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

4406 lines
160KB
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 "../DistrhoPluginUtils.hpp"

  19. #include "../extra/ScopedPointer.hpp"

  20. 

  21. #if DISTRHO_PLUGIN_HAS_UI && ! DISTRHO_PLUGIN_HAS_EMBED_UI

  22. # undef DISTRHO_PLUGIN_HAS_UI

  23. # define DISTRHO_PLUGIN_HAS_UI 0

  24. #endif

  25. 

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

  27. # undef DISTRHO_PLUGIN_HAS_UI

  28. # define DISTRHO_PLUGIN_HAS_UI 0

  29. #endif

  30. 

  31. #if DISTRHO_PLUGIN_HAS_UI == 1 && DISTRHO_PLUGIN_WANT_DIRECT_ACCESS == 0

  32. # define DPF_VST3_USES_SEPARATE_CONTROLLER

  33. #endif

  34. 

  35. #define DPF_VST3_MAX_BUFFER_SIZE 32768

  36. #define DPF_VST3_MAX_SAMPLE_RATE 384000

  37. #define DPF_VST3_MAX_LATENCY     DPF_VST3_MAX_SAMPLE_RATE * 10

  38. 

  39. #if DISTRHO_PLUGIN_HAS_UI

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

  41. #endif

  42. 

  43. #include "travesty/audio_processor.h"

  44. #include "travesty/component.h"

  45. #include "travesty/edit_controller.h"

  46. #include "travesty/factory.h"

  47. #include "travesty/host.h"

  48. 

  49. #ifdef DISTRHO_PROPER_CPP11_SUPPORT

  50. # include <atomic>

  51. #else

  52. // quick and dirty std::atomic replacement for the things we need

  53. namespace std {

  54.     struct atomic_int {

  55.         volatile int value;

  56.         explicit atomic_int(volatile int v) noexcept : value(v) {}

  57.         int operator++() volatile noexcept { return __atomic_add_fetch(&value, 1, __ATOMIC_RELAXED); }

  58.         int operator--() volatile noexcept { return __atomic_sub_fetch(&value, 1, __ATOMIC_RELAXED); }

  59.         operator int() volatile noexcept { return __atomic_load_n(&value, __ATOMIC_RELAXED); }

  60.     };

  61. }

  62. #endif

  63. 

  64. #include <map>

  65. #include <string>

  66. #include <vector>

  67. 

  68. /* TODO items:

  69.  * == parameters

  70.  * - test parameter triggers

  71.  * - have parameter outputs host-provided UI working in at least 1 host

  72.  * - parameter groups via unit ids

  73.  * - test parameter changes from DSP (aka requestParameterValueChange)

  74.  * - how to hide parameter outputs?

  75.  * - how to hide program parameter?

  76.  * - test receiving midi CC

  77.  * - implement getParameterNormalized/setParameterNormalized for MIDI CC params ?

  78.  * - fully implemented parameter stuff and verify

  79.  * - float to int safe casting

  80.  * - verify that latency changes works (with and without DPF_VST3_USES_SEPARATE_CONTROLLER)

  81.  * == MIDI

  82.  * - MIDI CC changes (need to store value to give to the host?)

  83.  * - MIDI program changes

  84.  * - MIDI sysex

  85.  * - append MIDI input events in a sorted way

  86.  * == BUSES

  87.  * - bus arrangements

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

  89.  * - routing info, do we care?

  90.  * - set sidechain bus name from port group

  91.  * == CV

  92.  * - cv scaling to -1/+1

  93.  * - test in at least 1 host

  94.  * == INFO

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

  96.  * - do something with set_io_mode?

  97.  */

  98. 

  99. START_NAMESPACE_DISTRHO

  100. 

  101. // --------------------------------------------------------------------------------------------------------------------

  102. 

  103. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  104. static constexpr const writeMidiFunc writeMidiCallback = nullptr;

  105. #endif

  106. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  107. static constexpr const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  108. #endif

  109. 

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

  111. 

  112. // --------------------------------------------------------------------------------------------------------------------

  113. // custom v3_tuid compatible type

  114. 

  115. typedef uint32_t dpf_tuid[4];

  116. #ifdef DISTRHO_PROPER_CPP11_SUPPORT

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

  118. #endif

  119. 

  120. // --------------------------------------------------------------------------------------------------------------------

  121. // custom, constant uids related to DPF

  122. 

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

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

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

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

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

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

  129. 

  130. // --------------------------------------------------------------------------------------------------------------------

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

  132. 

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

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

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

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

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

  138. 

  139. // --------------------------------------------------------------------------------------------------------------------

  140. // Utility functions

  141. 

  142. const char* tuid2str(const v3_tuid iid)

  143. {

  144.     static constexpr const struct {

  145.         v3_tuid iid;

  146.         const char* name;

  147.     } extra_known_iids[] = {

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

  149.         // edit-controller

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

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

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

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

  154.         { V3_ID(0xB7F8F859,0x41234872,0x91169581,0x4F3721A3), "{v3_edit_controller_note_expression_controller|NOT}" },

  155.         // units

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

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

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

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

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

  161.         // misc

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

  163.     };

  164. 

  165.     if (v3_tuid_match(iid, v3_audio_processor_iid))

  166.         return "{v3_audio_processor}";

  167.     if (v3_tuid_match(iid, v3_attribute_list_iid))

  168.         return "{v3_attribute_list_iid}";

  169.     if (v3_tuid_match(iid, v3_bstream_iid))

  170.         return "{v3_bstream}";

  171.     if (v3_tuid_match(iid, v3_component_iid))

  172.         return "{v3_component}";

  173.     if (v3_tuid_match(iid, v3_component_handler_iid))

  174.         return "{v3_component_handler}";

  175.     if (v3_tuid_match(iid, v3_connection_point_iid))

  176.         return "{v3_connection_point_iid}";

  177.     if (v3_tuid_match(iid, v3_edit_controller_iid))

  178.         return "{v3_edit_controller}";

  179.     if (v3_tuid_match(iid, v3_event_handler_iid))

  180.         return "{v3_event_handler_iid}";

  181.     if (v3_tuid_match(iid, v3_event_list_iid))

  182.         return "{v3_event_list}";

  183.     if (v3_tuid_match(iid, v3_funknown_iid))

  184.         return "{v3_funknown}";

  185.     if (v3_tuid_match(iid, v3_host_application_iid))

  186.         return "{v3_host_application_iid}";

  187.     if (v3_tuid_match(iid, v3_message_iid))

  188.         return "{v3_message_iid}";

  189.     if (v3_tuid_match(iid, v3_midi_mapping_iid))

  190.         return "{v3_midi_mapping_iid}";

  191.     if (v3_tuid_match(iid, v3_param_value_queue_iid))

  192.         return "{v3_param_value_queue}";

  193.     if (v3_tuid_match(iid, v3_param_changes_iid))

  194.         return "{v3_param_changes}";

  195.     if (v3_tuid_match(iid, v3_plugin_base_iid))

  196.         return "{v3_plugin_base}";

  197.     if (v3_tuid_match(iid, v3_plugin_factory_iid))

  198.         return "{v3_plugin_factory}";

  199.     if (v3_tuid_match(iid, v3_plugin_factory_2_iid))

  200.         return "{v3_plugin_factory_2}";

  201.     if (v3_tuid_match(iid, v3_plugin_factory_3_iid))

  202.         return "{v3_plugin_factory_3}";

  203.     if (v3_tuid_match(iid, v3_plugin_frame_iid))

  204.         return "{v3_plugin_frame}";

  205.     if (v3_tuid_match(iid, v3_plugin_view_iid))

  206.         return "{v3_plugin_view}";

  207.     if (v3_tuid_match(iid, v3_plugin_view_content_scale_iid))

  208.         return "{v3_plugin_view_content_scale_iid}";

  209.     if (v3_tuid_match(iid, v3_plugin_view_parameter_finder_iid))

  210.         return "{v3_plugin_view_parameter_finder}";

  211.     if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  212.         return "{v3_process_context_requirements}";

  213.     if (v3_tuid_match(iid, v3_run_loop_iid))

  214.         return "{v3_run_loop_iid}";

  215.     if (v3_tuid_match(iid, v3_timer_handler_iid))

  216.         return "{v3_timer_handler_iid}";

  217. 

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

  219.         return "{dpf_tuid_class}";

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

  221.         return "{dpf_tuid_component}";

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

  223.         return "{dpf_tuid_controller}";

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

  225.         return "{dpf_tuid_processor}";

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

  227.         return "{dpf_tuid_view}";

  228. 

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

  230.     {

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

  232.             return extra_known_iids[i].name;

  233.     }

  234. 

  235.     static char buf[46];

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

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

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

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

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

  241.     return buf;

  242. }

  243. 

  244. // --------------------------------------------------------------------------------------------------------------------

  245. 

  246. static bool strcmp_utf16(const int16_t* const str16, const char* const str8)

  247. {

  248.     size_t i = 0;

  249.     for (; str8[i] != '\0'; ++i)

  250.     {

  251.         const uint8_t char8 = static_cast<uint8_t>(str8[i]);

  252. 

  253.         // skip non-ascii chars, unsupported

  254.         if (char8 >= 0x80)

  255.             return false;

  256. 

  257.         if (str16[i] != char8)

  258.             return false;

  259.     }

  260. 

  261.     return str16[i] == str8[i];

  262. }

  263. 

  264. // --------------------------------------------------------------------------------------------------------------------

  265. 

  266. static size_t strlen_utf16(const int16_t* const str)

  267. {

  268.     size_t i = 0;

  269. 

  270.     while (str[i] != 0)

  271.         ++i;

  272. 

  273.     return i;

  274. }

  275. 

  276. // --------------------------------------------------------------------------------------------------------------------

  277. 

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

  279. {

  280.     DISTRHO_SAFE_ASSERT_RETURN(length > 0,);

  281. 

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

  283.     {

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

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

  286.     }

  287.     else

  288.     {

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

  290.     }

  291. }

  292. 

  293. void strncpy_utf8(char* const dst, const int16_t* const src, const size_t length)

  294. {

  295.     DISTRHO_SAFE_ASSERT_RETURN(length > 0,);

  296. 

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

  298.     {

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

  300.         {

  301.             // skip non-ascii chars, unsupported

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

  303.                 continue;

  304. 

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

  306.         }

  307.         dst[len] = 0;

  308.     }

  309.     else

  310.     {

  311.         dst[0] = 0;

  312.     }

  313. }

  314. 

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

  316. {

  317.     DISTRHO_SAFE_ASSERT_RETURN(length > 0,);

  318. 

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

  320.     {

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

  322.         {

  323.             // skip non-ascii chars, unsupported

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

  325.                 continue;

  326. 

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

  328.         }

  329.         dst[len] = 0;

  330.     }

  331.     else

  332.     {

  333.         dst[0] = 0;

  334.     }

  335. }

  336. 

  337. // --------------------------------------------------------------------------------------------------------------------

  338. 

  339. template<typename T>

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

  341. {

  342.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

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

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

  345. }

  346. 

  347. template<typename T>

  348. static void snprintf_utf16_t(int16_t* const dst, const T value, const char* const format, const size_t size)

  349. {

  350.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  351. 

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

  353.     DISTRHO_SAFE_ASSERT_RETURN(tmpbuf != nullptr,);

  354. 

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

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

  357. 

  358.     strncpy_utf16(dst, tmpbuf, size);

  359.     std::free(tmpbuf);

  360. }

  361. 

  362. static inline

  363. void snprintf_u32(char* const dst, const uint32_t value, const size_t size)

  364. {

  365.     return snprintf_t<uint32_t>(dst, value, "%u", size);

  366. }

  367. 

  368. static inline

  369. void snprintf_f32_utf16(int16_t* const dst, const float value, const size_t size)

  370. {

  371.     return snprintf_utf16_t<float>(dst, value, "%f", size);

  372. }

  373. 

  374. static inline

  375. void snprintf_i32_utf16(int16_t* const dst, const int value, const size_t size)

  376. {

  377.     return snprintf_utf16_t<int>(dst, value, "%d", size);

  378. }

  379. 

  380. // --------------------------------------------------------------------------------------------------------------------

  381. // handy way to create a utf16 string from a utf8 one on the current function scope, used for message strings

  382. 

  383. struct ScopedUTF16String {

  384.     int16_t* str;

  385.     ScopedUTF16String(const char* const s) noexcept;

  386.     ~ScopedUTF16String() noexcept;

  387.     operator const int16_t*() const noexcept;

  388. };

  389. 

  390. // --------------------------------------------------------------------------------------------------------------------

  391. 

  392. ScopedUTF16String::ScopedUTF16String(const char* const s) noexcept

  393.     : str(nullptr)

  394. {

  395.     const size_t len = std::strlen(s);

  396.     str = static_cast<int16_t*>(std::malloc(sizeof(int16_t) * (len + 1)));

  397.     DISTRHO_SAFE_ASSERT_RETURN(str != nullptr,);

  398.     strncpy_utf16(str, s, len + 1);

  399. }

  400. 

  401. ScopedUTF16String::~ScopedUTF16String() noexcept

  402. {

  403.     std::free(str);

  404. }

  405. 

  406. ScopedUTF16String::operator const int16_t*() const noexcept

  407. {

  408.     return str;

  409. }

  410. 

  411. // --------------------------------------------------------------------------------------------------------------------

  412. // handy way to create a utf8 string from a utf16 one on the current function scope

  413. 

  414. struct ScopedUTF8String {

  415.     char str[128];

  416. 

  417.     ScopedUTF8String(const int16_t* const s) noexcept

  418.     {

  419.         strncpy_utf8(str, s, 128);

  420.     }

  421. 

  422.     operator const char*() const noexcept

  423.     {

  424.         return str;

  425.     }

  426. };

  427. 

  428. // --------------------------------------------------------------------------------------------------------------------

  429. // dpf_plugin_view_create (implemented on UI side)

  430. 

  431. v3_plugin_view** dpf_plugin_view_create(v3_host_application** host, void* instancePointer, double sampleRate);

  432. 

  433. // --------------------------------------------------------------------------------------------------------------------

  434. 

  435. /**

  436.  * VST3 DSP class.

  437.  *

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

  439.  * The DSP is created during the "initialize" component event, and destroyed during "terminate".

  440.  *

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

  442.  */

  443. class PluginVst3

  444. {

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

  446.      * Main audio comes first, if available.

  447.      * Then sidechain, also if available.

  448.      * And finally each CV port individually.

  449.      *

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

  451.      */

  452.     struct BusInfo {

  453.         uint8_t audio;     // either 0 or 1

  454.         uint8_t sidechain; // either 0 or 1

  455.         uint32_t numMainAudio;

  456.         uint32_t numSidechain;

  457.         uint32_t numCV;

  458. 

  459.         BusInfo()

  460.           : audio(0),

  461.             sidechain(0),

  462.             numMainAudio(0),

  463.             numSidechain(0),

  464.             numCV(0) {}

  465.     } inputBuses, outputBuses;

  466. 

  467. public:

  468.     PluginVst3(v3_host_application** const host)

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

  470.           fComponentHandler(nullptr),

  471. #if DISTRHO_PLUGIN_HAS_UI

  472. # ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  473.           fConnectionFromCompToCtrl(nullptr),

  474. # endif

  475.           fConnectionFromCtrlToView(nullptr),

  476.           fHostApplication(host),

  477. #endif

  478.           fParameterCount(fPlugin.getParameterCount()),

  479.           fVst3ParameterCount(fParameterCount + kVst3InternalParameterCount),

  480.           fCachedParameterValues(nullptr),

  481.           fParameterValuesChangedDuringProcessing(nullptr)

  482. #if DISTRHO_PLUGIN_HAS_UI

  483.         , fParameterValueChangesForUI(nullptr)

  484.         , fConnectedToUI(false)

  485. #endif

  486. #if DISTRHO_PLUGIN_WANT_LATENCY

  487.         , fLastKnownLatency(fPlugin.getLatency())

  488. #endif

  489. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  490.         , fHostEventOutputHandle(nullptr)

  491. #endif

  492. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  493.         , fCurrentProgram(0)

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

  495. #endif

  496.     {

  497. #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  499.         {

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

  501. 

  502.             if (hints & kAudioPortIsCV)

  503.                 ++inputBuses.numCV;

  504.             else

  505.                 ++inputBuses.numMainAudio;

  506. 

  507.             if (hints & kAudioPortIsSidechain)

  508.                 ++inputBuses.numSidechain;

  509.         }

  510. 

  511.         if (inputBuses.numMainAudio != 0)

  512.             inputBuses.audio = 1;

  513.         if (inputBuses.numSidechain != 0)

  514.             inputBuses.sidechain = 1;

  515. 

  516.         uint32_t cvInputBusId = 0;

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

  518.         {

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

  520. 

  521.             if (port.hints & kAudioPortIsCV)

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

  523.             else if (port.hints & kAudioPortIsSidechain)

  524.                 port.busId = inputBuses.audio;

  525.             else

  526.                 port.busId = 0;

  527.         }

  528. #endif

  529. #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  531.         {

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

  533. 

  534.             if (hints & kAudioPortIsCV)

  535.                 ++outputBuses.numCV;

  536.             else

  537.                 ++outputBuses.numMainAudio;

  538. 

  539.             if (hints & kAudioPortIsSidechain)

  540.                 ++outputBuses.numSidechain;

  541.         }

  542. 

  543.         if (outputBuses.numMainAudio != 0)

  544.             outputBuses.audio = 1;

  545.         if (outputBuses.numSidechain != 0)

  546.             outputBuses.sidechain = 1;

  547. 

  548.         uint32_t cvOutputBusId = 0;

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

  550.         {

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

  552. 

  553.             if (port.hints & kAudioPortIsCV)

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

  555.             else if (port.hints & kAudioPortIsSidechain)

  556.                 port.busId = outputBuses.audio;

  557.             else

  558.                 port.busId = 0;

  559.         }

  560. #endif

  561. 

  562.         if (const uint32_t extraParameterCount = fParameterCount + kVst3InternalParameterBaseCount)

  563.         {

  564.             fCachedParameterValues = new float[extraParameterCount];

  565. 

  566.             fCachedParameterValues[kVst3InternalParameterActive]     = 0.0f;

  567.             fCachedParameterValues[kVst3InternalParameterBufferSize] = fPlugin.getBufferSize();

  568.             fCachedParameterValues[kVst3InternalParameterSampleRate] = fPlugin.getSampleRate();

  569.            #if DISTRHO_PLUGIN_WANT_LATENCY

  570.             fCachedParameterValues[kVst3InternalParameterLatency]    = fLastKnownLatency;

  571.            #endif

  572.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  573.             fCachedParameterValues[kVst3InternalParameterProgram]    = 0.0f;

  574.            #endif

  575. 

  576.             for (uint32_t i=0; i < fParameterCount; ++i)

  577.                 fCachedParameterValues[kVst3InternalParameterBaseCount + i] = fPlugin.getParameterDefault(i);

  578. 

  579.             fParameterValuesChangedDuringProcessing = new bool[extraParameterCount];

  580.             std::memset(fParameterValuesChangedDuringProcessing, 0, sizeof(bool)*extraParameterCount);

  581. 

  582.            #if DISTRHO_PLUGIN_HAS_UI

  583.             fParameterValueChangesForUI = new bool[extraParameterCount];

  584.             std::memset(fParameterValueChangesForUI, 0, sizeof(bool)*extraParameterCount);

  585.            #endif

  586.         }

  587. 

  588. #if DISTRHO_PLUGIN_WANT_STATE

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

  590.         {

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

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

  593.         }

  594. #endif

  595. 

  596. #if !DISTRHO_PLUGIN_HAS_UI

  597.         // unused

  598.         return; (void)host;

  599. #endif

  600.     }

  601. 

  602.     ~PluginVst3()

  603.     {

  604.         if (fCachedParameterValues != nullptr)

  605.         {

  606.             delete[] fCachedParameterValues;

  607.             fCachedParameterValues = nullptr;

  608.         }

  609. 

  610.         if (fParameterValuesChangedDuringProcessing != nullptr)

  611.         {

  612.             delete[] fParameterValuesChangedDuringProcessing;

  613.             fParameterValuesChangedDuringProcessing = nullptr;

  614.         }

  615. 

  616.        #if DISTRHO_PLUGIN_HAS_UI

  617.         if (fParameterValueChangesForUI != nullptr)

  618.         {

  619.             delete[] fParameterValueChangesForUI;

  620.             fParameterValueChangesForUI = nullptr;

  621.         }

  622.        #endif

  623.     }

  624. 

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

  626.     // utilities and common code

  627. 

  628.     void setNormalizedPluginParameterValue(const uint32_t index, const float normalized)

  629.     {

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

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

  632.         float value = ranges.getUnnormalizedValue(normalized);

  633. 

  634.         if (hints & kParameterIsBoolean)

  635.         {

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

  637.             value = value > midRange ? ranges.max : ranges.min;

  638.         }

  639.         else if (hints & kParameterIsInteger)

  640.         {

  641.             value = std::round(value);

  642.         }

  643. 

  644.         fCachedParameterValues[kVst3InternalParameterBaseCount + index] = value;

  645. #if DISTRHO_PLUGIN_HAS_UI

  646.         fParameterValueChangesForUI[kVst3InternalParameterBaseCount + index] = true;

  647. #endif

  648.         fPlugin.setParameterValue(index, value);

  649.     }

  650. 

  651.     // ----------------------------------------------------------------------------------------------------------------

  652.     // stuff called for UI creation

  653. 

  654.     void* getInstancePointer() const noexcept

  655.     {

  656.         return fPlugin.getInstancePointer();

  657.     }

  658. 

  659.     double getSampleRate() const noexcept

  660.     {

  661.         return fPlugin.getSampleRate();

  662.     }

  663. 

  664.     // ----------------------------------------------------------------------------------------------------------------

  665.     // v3_component interface calls

  666. 

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

  668.     {

  669.         switch (mediaType)

  670.         {

  671.         case V3_AUDIO:

  672.             if (busDirection == V3_INPUT)

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

  674.             if (busDirection == V3_OUTPUT)

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

  676.             break;

  677.         case V3_EVENT:

  678. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  679.             if (busDirection == V3_INPUT)

  680.                 return 1;

  681. #endif

  682. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  683.             if (busDirection == V3_OUTPUT)

  684.                 return 1;

  685. #endif

  686.             break;

  687.         }

  688. 

  689.         return 0;

  690.     }

  691. 

  692.     v3_result getBusInfo(const int32_t mediaType,

  693.                          const int32_t busDirection,

  694.                          const int32_t busIndex,

  695.                          v3_bus_info* const info) const

  696.     {

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

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

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

  700. 

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

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

  703. #endif

  704. 

  705.         if (mediaType == V3_AUDIO)

  706.         {

  707.            #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  708.             int32_t numChannels;

  709.             v3_bus_flags flags;

  710.             v3_bus_types busType;

  711.             v3_str_128 busName = {};

  712. 

  713.             if (busDirection == V3_INPUT)

  714.             {

  715.                #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  716.                 switch (busId)

  717.                 {

  718.                 case 0:

  719.                     if (inputBuses.audio)

  720.                     {

  721.                         numChannels = inputBuses.numMainAudio;

  722.                         busType = V3_MAIN;

  723.                         flags = V3_DEFAULT_ACTIVE;

  724.                         break;

  725.                     }

  726.                 // fall-through

  727.                 case 1:

  728.                     if (inputBuses.sidechain)

  729.                     {

  730.                         numChannels = inputBuses.numSidechain;

  731.                         busType = V3_AUX;

  732.                         flags = static_cast<v3_bus_flags>(0);

  733.                         break;

  734.                     }

  735.                 // fall-through

  736.                 default:

  737.                     numChannels = 1;

  738.                     busType = V3_AUX;

  739.                     flags = V3_IS_CONTROL_VOLTAGE;

  740.                     break;

  741.                 }

  742. 

  743.                 if (busType == V3_MAIN)

  744.                 {

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

  746.                 }

  747.                 else

  748.                 {

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

  750.                     {

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

  752. 

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

  754.                         if (port.busId == busId)

  755.                         {

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

  757.                             break;

  758.                         }

  759.                     }

  760.                 }

  761.                #else

  762.                 d_stdout("invalid bus %d", busId);

  763.                 return V3_INVALID_ARG;

  764.                #endif // DISTRHO_PLUGIN_NUM_INPUTS

  765.             }

  766.             else

  767.             {

  768.                #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  769.                 switch (busId)

  770.                 {

  771.                 case 0:

  772.                     if (outputBuses.audio)

  773.                     {

  774.                         numChannels = outputBuses.numMainAudio;

  775.                         busType = V3_MAIN;

  776.                         flags = V3_DEFAULT_ACTIVE;

  777.                         break;

  778.                     }

  779.                 // fall-through

  780.                 case 1:

  781.                     if (outputBuses.sidechain)

  782.                     {

  783.                         numChannels = outputBuses.numSidechain;

  784.                         busType = V3_AUX;

  785.                         flags = static_cast<v3_bus_flags>(0);

  786.                         break;

  787.                     }

  788.                 // fall-through

  789.                 default:

  790.                     numChannels = 1;

  791.                     busType = V3_AUX;

  792.                     flags = V3_IS_CONTROL_VOLTAGE;

  793.                     break;

  794.                 }

  795. 

  796.                 if (busType == V3_MAIN)

  797.                 {

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

  799.                 }

  800.                 else

  801.                 {

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

  803.                     {

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

  805. 

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

  807.                         if (port.busId == busId)

  808.                         {

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

  810.                             break;

  811.                         }

  812.                     }

  813.                 }

  814.                #else

  815.                 d_stdout("invalid bus %d", busId);

  816.                 return V3_INVALID_ARG;

  817.                #endif // DISTRHO_PLUGIN_NUM_OUTPUTS

  818.             }

  819. 

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

  821.             info->media_type = V3_AUDIO;

  822.             info->direction = busDirection;

  823.             info->channel_count = numChannels;

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

  825.             info->bus_type = busType;

  826.             info->flags = flags;

  827.             return V3_OK;

  828.            #else

  829.             d_stdout("invalid bus, line %d", __LINE__);

  830.             return V3_INVALID_ARG;

  831.            #endif // DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS

  832.         }

  833.         else

  834.         {

  835.             if (busDirection == V3_INPUT)

  836.             {

  837.                #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  839.                #else

  840.                 d_stdout("invalid bus, line %d", __LINE__);

  841.                 return V3_INVALID_ARG;

  842.                #endif

  843.             }

  844.             else

  845.             {

  846.                #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  848.                #else

  849.                 d_stdout("invalid bus, line %d", __LINE__);

  850.                 return V3_INVALID_ARG;

  851.                #endif

  852.             }

  853.             info->media_type = V3_EVENT;

  854.             info->direction = busDirection;

  855.             info->channel_count = 1;

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

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

  858.             info->bus_type = V3_MAIN;

  859.             info->flags = V3_DEFAULT_ACTIVE;

  860.             return V3_OK;

  861.         }

  862.     }

  863. 

  864.     v3_result getRoutingInfo(v3_routing_info*, v3_routing_info*)

  865.     {

  866.         // TODO

  867.         return V3_NOT_IMPLEMENTED;

  868.     }

  869. 

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

  871.                           const int32_t /* busDirection */,

  872.                           const int32_t /* busIndex */,

  873.                           const bool /* state */)

  874.     {

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

  876.         return V3_OK;

  877.     }

  878. 

  879.     v3_result setActive(const bool active)

  880.     {

  881.         if (active)

  882.             fPlugin.activate();

  883.         else

  884.             fPlugin.deactivateIfNeeded();

  885. 

  886.         return V3_OK;

  887.     }

  888. 

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

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

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

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

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

  894.      */

  895.     v3_result setState(v3_bstream** const stream)

  896.     {

  897.        #if DISTRHO_PLUGIN_HAS_UI

  898.         const bool connectedToUI = fConnectionFromCtrlToView != nullptr && fConnectedToUI;

  899.        #endif

  900.         String key, value;

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

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

  903. 

  904.         char buffer[512], orig;

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

  906.         v3_result res;

  907. 

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

  909.         {

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

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

  912. 

  913.             if (read == 0)

  914.                 return V3_OK;

  915. 

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

  917. 

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

  919.             {

  920.                 // found terminator, stop here

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

  922.                 {

  923.                     term = 1;

  924.                     break;

  925.                 }

  926. 

  927.                 // store character at read position

  928.                 orig = buffer[read];

  929. 

  930.                 // place null character to create valid string

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

  932. 

  933.                 // append to temporary vars

  934.                 if (fillingKey)

  935.                     key += buffer + i;

  936.                 else

  937.                     value += buffer + i;

  938. 

  939.                 // increase buffer offset by length of string

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

  941. 

  942.                 // restore read character

  943.                 buffer[read] = orig;

  944. 

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

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

  947.                 {

  948.                     // special keys

  949.                     if (key == "__dpf_state_begin__")

  950.                     {

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

  952.                                                        queryingType, V3_INTERNAL_ERR);

  953.                         queryingType = 's';

  954.                         key.clear();

  955.                         value.clear();

  956.                         continue;

  957.                     }

  958.                     if (key == "__dpf_state_end__")

  959.                     {

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

  961.                         queryingType = 'n';

  962.                         key.clear();

  963.                         value.clear();

  964.                         continue;

  965.                     }

  966.                     if (key == "__dpf_parameters_begin__")

  967.                     {

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

  969.                                                        queryingType, V3_INTERNAL_ERR);

  970.                         queryingType = 'p';

  971.                         key.clear();

  972.                         value.clear();

  973.                         continue;

  974.                     }

  975.                     if (key == "__dpf_parameters_end__")

  976.                     {

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

  978.                         queryingType = 'x';

  979.                         key.clear();

  980.                         value.clear();

  981.                         continue;

  982.                     }

  983. 

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

  985.                     fillingKey = !fillingKey;

  986. 

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

  988.                     if (value.isEmpty())

  989.                         continue;

  990. 

  991.                     if (key == "__dpf_program__")

  992.                     {

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

  994.                         queryingType = 'n';

  995. 

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

  997. 

  998. #if DISTRHO_PLUGIN_WANT_PROGRAMS

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

  1000.                         DISTRHO_SAFE_ASSERT_CONTINUE(program >= 0);

  1001. 

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

  1003.                         fPlugin.loadProgram(fCurrentProgram);

  1004. 

  1005. # if DISTRHO_PLUGIN_HAS_UI

  1006.                         if (connectedToUI)

  1007.                         {

  1008.                             fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  1009.                             sendParameterSetToUI(kVst3InternalParameterProgram, program);

  1010.                         }

  1011. # endif

  1012. #endif

  1013.                     }

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

  1015.                     {

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

  1017. 

  1018. #if DISTRHO_PLUGIN_WANT_STATE

  1019.                         if (fPlugin.wantStateKey(key))

  1020.                         {

  1021.                             fStateMap[key] = value;

  1022.                             fPlugin.setState(key, value);

  1023. 

  1024. # if DISTRHO_PLUGIN_HAS_UI

  1025.                             if (connectedToUI)

  1026.                                 sendStateSetToUI(key, value);

  1027. # endif

  1028.                         }

  1029. #endif

  1030.                     }

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

  1032.                     {

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

  1034.                         float fvalue;

  1035. 

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

  1037.                         for (uint32_t j=0; j < fParameterCount; ++j)

  1038.                         {

  1039.                             if (fPlugin.isParameterOutputOrTrigger(j))

  1040.                                 continue;

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

  1042.                                 continue;

  1043. 

  1044.                             if (fPlugin.getParameterHints(j) & kParameterIsInteger)

  1045.                                 fvalue = std::atoi(value.buffer());

  1046.                             else

  1047.                                 fvalue = std::atof(value.buffer());

  1048. 

  1049.                             // TODO atoi if integer

  1050.                             fCachedParameterValues[kVst3InternalParameterBaseCount + j] = fvalue;

  1051. #if DISTRHO_PLUGIN_HAS_UI

  1052.                             if (connectedToUI)

  1053.                             {

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

  1055.                                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + j] = true;

  1056.                             }

  1057. #endif

  1058.                             fPlugin.setParameterValue(j, fvalue);

  1059.                             break;

  1060.                         }

  1061. 

  1062.                     }

  1063. 

  1064.                     key.clear();

  1065.                     value.clear();

  1066.                 }

  1067.             }

  1068.         }

  1069. 

  1070.         if (fComponentHandler != nullptr)

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

  1072. 

  1073. #if DISTRHO_PLUGIN_HAS_UI

  1074.         if (connectedToUI)

  1075.         {

  1076.             for (uint32_t i=0; i<fParameterCount; ++i)

  1077.             {

  1078.                 if (fPlugin.isParameterOutputOrTrigger(i))

  1079.                     continue;

  1080.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  1081.                 sendParameterSetToUI(kVst3InternalParameterBaseCount + i,

  1082.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  1083.             }

  1084.         }

  1085. #endif

  1086. 

  1087.         return V3_OK;

  1088.     }

  1089. 

  1090.     v3_result getState(v3_bstream** const stream)

  1091.     {

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

  1093. #if DISTRHO_PLUGIN_WANT_STATE

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

  1095. #else

  1096.         const uint32_t stateCount = 0;

  1097. #endif

  1098. 

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

  1100.         {

  1101.             char buffer = '\0';

  1102.             int32_t ignored;

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

  1104.         }

  1105. 

  1106. #if DISTRHO_PLUGIN_WANT_FULL_STATE

  1107.         // Update current state

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

  1109.         {

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

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

  1112.         }

  1113. #endif

  1114. 

  1115.         String state;

  1116. 

  1117. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1118.         {

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

  1120.             tmpStr += String(fCurrentProgram);

  1121.             tmpStr += "\xff";

  1122. 

  1123.             state += tmpStr;

  1124.         }

  1125. #endif

  1126. 

  1127. #if DISTRHO_PLUGIN_WANT_STATE

  1128.         if (stateCount != 0)

  1129.         {

  1130.             state += "__dpf_state_begin__\xff";

  1131. 

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

  1133.             {

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

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

  1136. 

  1137.                 // join key and value

  1138.                 String tmpStr;

  1139.                 tmpStr  = key;

  1140.                 tmpStr += "\xff";

  1141.                 tmpStr += value;

  1142.                 tmpStr += "\xff";

  1143. 

  1144.                 state += tmpStr;

  1145.             }

  1146. 

  1147.             state += "__dpf_state_end__\xff";

  1148.         }

  1149. #endif

  1150. 

  1151.         if (paramCount != 0)

  1152.         {

  1153.             state += "__dpf_parameters_begin__\xff";

  1154. 

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

  1156.             {

  1157.                 if (fPlugin.isParameterOutputOrTrigger(i))

  1158.                     continue;

  1159. 

  1160.                 // join key and value

  1161.                 String tmpStr;

  1162.                 tmpStr  = fPlugin.getParameterSymbol(i);

  1163.                 tmpStr += "\xff";

  1164.                 // TODO cast to integer if needed

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

  1166.                 tmpStr += "\xff";

  1167. 

  1168.                 state += tmpStr;

  1169.             }

  1170. 

  1171.             state += "__dpf_parameters_end__\xff";

  1172.         }

  1173. 

  1174.         // terminator

  1175.         state += "\xfe";

  1176. 

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

  1178. 

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

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

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

  1182.         v3_result res;

  1183. 

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

  1185.         {

  1186.             wrtn = 0;

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

  1188. 

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

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

  1191.         }

  1192. 

  1193.         return V3_OK;

  1194.     }

  1195. 

  1196.     // ----------------------------------------------------------------------------------------------------------------

  1197.     // v3_audio_processor interface calls

  1198. 

  1199.     v3_result setBusArrangements(v3_speaker_arrangement* /*inputs*/, const int32_t /*numInputs*/,

  1200.                                  v3_speaker_arrangement* /*outputs*/, const int32_t /*numOutputs*/)

  1201.     {

  1202.         // TODO

  1203.         return V3_NOT_IMPLEMENTED;

  1204.     }

  1205. 

  1206.     v3_result getBusArrangement(const int32_t direction, const int32_t /*idx*/, v3_speaker_arrangement*)

  1207.     {

  1208.         switch (direction)

  1209.         {

  1210.         case V3_INPUT:

  1211.         case V3_OUTPUT:

  1212.             // TODO

  1213.             return V3_NOT_IMPLEMENTED;

  1214.         }

  1215. 

  1216.         return V3_INVALID_ARG;

  1217.     }

  1218. 

  1219.     uint32_t getLatencySamples() const noexcept

  1220.     {

  1221. #if DISTRHO_PLUGIN_WANT_LATENCY

  1222.         return fPlugin.getLatency();

  1223. #else

  1224.         return 0;

  1225. #endif

  1226.     }

  1227. 

  1228.     v3_result setupProcessing(v3_process_setup* const setup)

  1229.     {

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

  1231. 

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

  1233.         fPlugin.deactivateIfNeeded();

  1234. 

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

  1236. 

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

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

  1239. 

  1240.         fCachedParameterValues[kVst3InternalParameterBufferSize] = setup->max_block_size;

  1241.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterBufferSize] = true;

  1242. 

  1243.         fCachedParameterValues[kVst3InternalParameterSampleRate] = setup->sample_rate;

  1244.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterSampleRate] = true;

  1245.        #if DISTRHO_PLUGIN_HAS_UI

  1246.         fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = true;

  1247.        #endif

  1248. 

  1249.         if (active)

  1250.             fPlugin.activate();

  1251. 

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

  1253. 

  1254.         return V3_OK;

  1255.     }

  1256. 

  1257.     v3_result setProcessing(const bool processing)

  1258.     {

  1259.         if (processing)

  1260.         {

  1261.             if (! fPlugin.isActive())

  1262.                 fPlugin.activate();

  1263.         }

  1264.         else

  1265.         {

  1266.             fPlugin.deactivateIfNeeded();

  1267.         }

  1268. 

  1269.         fCachedParameterValues[kVst3InternalParameterActive] = processing ? 1.0f : 0.0f;

  1270.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterActive] = true;

  1271.         return V3_OK;

  1272.     }

  1273. 

  1274.     v3_result process(v3_process_data* const data)

  1275.     {

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

  1277.         // d_stdout("process %i", data->symbolic_sample_size);

  1278. 

  1279.         // activate plugin if not done yet

  1280.         if (! fPlugin.isActive())

  1281.             fPlugin.activate();

  1282. 

  1283. #if DISTRHO_PLUGIN_WANT_TIMEPOS

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

  1285.         {

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

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

  1288. 

  1289.             // ticksPerBeat is not possible with VST3

  1290.             fTimePosition.bbt.ticksPerBeat = 1920.0;

  1291. 

  1292.             if (ctx->state & V3_PROCESS_CTX_CONT_TIME_VALID)

  1293.                 fTimePosition.frame = ctx->continuous_time_in_samples;

  1294.             else

  1295.                 fTimePosition.frame = ctx->project_time_in_samples;

  1296. 

  1297.             if (ctx->state & V3_PROCESS_CTX_TEMPO_VALID)

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

  1299.             else

  1300.                 fTimePosition.bbt.beatsPerMinute = 120.0;

  1301. 

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

  1303.             {

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

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

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

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

  1308. 

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

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

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

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

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

  1314. 

  1315.                 if (ctx->project_time_quarters < 0.0)

  1316.                 {

  1317.                     --fTimePosition.bbt.bar;

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

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

  1320.                 }

  1321.             }

  1322.             else

  1323.             {

  1324.                 fTimePosition.bbt.bar         = 1;

  1325.                 fTimePosition.bbt.beat        = 1;

  1326.                 fTimePosition.bbt.tick        = 0.0;

  1327.                 fTimePosition.bbt.beatsPerBar = 4.0f;

  1328.                 fTimePosition.bbt.beatType    = 4.0f;

  1329.             }

  1330. 

  1331.             fTimePosition.bbt.barStartTick = fTimePosition.bbt.ticksPerBeat*

  1332.                                              fTimePosition.bbt.beatsPerBar*

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

  1334. 

  1335.             fPlugin.setTimePosition(fTimePosition);

  1336.         }

  1337. #endif

  1338. 

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

  1340.         {

  1341.             updateParametersFromProcessing(data->output_params, 0);

  1342.             return V3_OK;

  1343.         }

  1344. 

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

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

  1347. 

  1348.         {

  1349.             int32_t i = 0;

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

  1351.             {

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

  1353.                 {

  1354.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_INPUTS, i);

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

  1356.                 }

  1357.             }

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

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

  1360.         }

  1361. 

  1362.         {

  1363.             int32_t i = 0;

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

  1365.             {

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

  1367.                 {

  1368.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_OUTPUTS, i);

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

  1370.                 }

  1371.             }

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

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

  1374.         }

  1375. 

  1376. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1377.         fHostEventOutputHandle = data->output_events;

  1378. #endif

  1379. 

  1380. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1381.         uint32_t midiEventCount = 0;

  1382. 

  1383. # if DISTRHO_PLUGIN_HAS_UI

  1384.         while (fNotesRingBuffer.isDataAvailableForReading())

  1385.         {

  1386.             uint8_t midiData[3];

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

  1388.                 break;

  1389. 

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

  1391.             midiEvent.frame = 0;

  1392.             midiEvent.size  = 3;

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

  1394. 

  1395.             if (midiEventCount == kMaxMidiEvents)

  1396.                 break;

  1397.         }

  1398. # endif

  1399. 

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

  1401.         {

  1402.             v3_event event;

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

  1404.             {

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

  1406.                     break;

  1407. 

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

  1409.                 switch (event.type)

  1410.                 {

  1411.                 case V3_EVENT_NOTE_ON:

  1412.                 case V3_EVENT_NOTE_OFF:

  1413.                 // case V3_EVENT_DATA:

  1414.                 case V3_EVENT_POLY_PRESSURE:

  1415.                     break;

  1416.                 // case V3_EVENT_NOTE_EXP_VALUE:

  1417.                 // case V3_EVENT_NOTE_EXP_TEXT:

  1418.                 // case V3_EVENT_CHORD:

  1419.                 // case V3_EVENT_SCALE:

  1420.                 // case V3_EVENT_LEGACY_MIDI_CC_OUT:

  1421.                 default:

  1422.                     continue;

  1423.                 }

  1424. 

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

  1426.                 midiEvent.frame = event.sample_offset;

  1427. 

  1428.                 // encode event as MIDI

  1429.                 switch (event.type)

  1430.                 {

  1431.                 case V3_EVENT_NOTE_ON:

  1432.                     midiEvent.size = 3;

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

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

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

  1436.                     midiEvent.data[3] = 0;

  1437.                     break;

  1438.                 case V3_EVENT_NOTE_OFF:

  1439.                     midiEvent.size = 3;

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

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

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

  1443.                     midiEvent.data[3] = 0;

  1444.                     break;

  1445.                 case V3_EVENT_POLY_PRESSURE:

  1446.                     midiEvent.size = 3;

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

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

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

  1450.                     midiEvent.data[3] = 0;

  1451.                     break;

  1452.                 default:

  1453.                     midiEvent.size = 0;

  1454.                     break;

  1455.                 }

  1456. 

  1457.                 if (midiEventCount == kMaxMidiEvents)

  1458.                     break;

  1459.             }

  1460.         }

  1461. 

  1462.         // TODO append parameter MIDI events in a sorted way

  1463.         /*

  1464. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1465.         if (rindex == 0)

  1466.             continue;

  1467.         --rindex;

  1468. #endif

  1469. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  1471.           midiEvent.frame = offset;

  1472.           midiEvent.size = 3;

  1473.           midiEvent.data[0] = (rindex / 130) & 0xf;

  1474. 

  1475.           switch (rindex)

  1476.           {

  1477.           case 128: // channel pressure

  1478.               midiEvent.data[0] |= 0xD0;

  1479.               midiEvent.data[1] = std::max(0, std::min(127, (int)(value * 127)));

  1480.               midiEvent.data[2] = 0;

  1481.               midiEvent.data[3] = 0;

  1482.               break;

  1483.           case 129: // pitchbend

  1484.               midiEvent.data[0] |= 0xE0;

  1485.               midiEvent.data[1] = std::max(0, std::min(16384, (int)(value * 16384))) & 0x7f;

  1486.               midiEvent.data[2] = std::max(0, std::min(16384, (int)(value * 16384))) >> 7;

  1487.               midiEvent.data[3] = 0;

  1488.               break;

  1489.           default:

  1490.               midiEvent.data[0] |= 0xB0;

  1491.               midiEvent.data[1] = rindex % 130;

  1492.               midiEvent.data[2] = std::max(0, std::min(127, (int)(value * 127)));

  1493.               midiEvent.data[3] = 0;

  1494.               break;

  1495.           }

  1496. 

  1497.           if (midiEventCount == kMaxMidiEvents)

  1498.               break;

  1499.       }

  1500. #endif

  1501.       */

  1502. #endif

  1503. 

  1504.         // if there are any parameter changes at frame 0, set them here

  1505.         if (v3_param_changes** const inparamsptr = data->input_params)

  1506.         {

  1507.             int32_t offset;

  1508.             double value;

  1509. 

  1510.             for (int32_t i = 0, count = v3_cpp_obj(inparamsptr)->get_param_count(inparamsptr); i < count; ++i)

  1511.             {

  1512.                 v3_param_value_queue** const queue = v3_cpp_obj(inparamsptr)->get_param_data(inparamsptr, i);

  1513.                 DISTRHO_SAFE_ASSERT_BREAK(queue != nullptr);

  1514. 

  1515.                 const v3_param_id rindex = v3_cpp_obj(queue)->get_param_id(queue);

  1516.                 DISTRHO_SAFE_ASSERT_UINT_BREAK(rindex < fVst3ParameterCount, rindex);

  1517. 

  1518.                 if (rindex < kVst3InternalParameterCount)

  1519.                     continue;

  1520. 

  1521.                 if (v3_cpp_obj(queue)->get_point_count(queue) <= 0)

  1522.                     continue;

  1523. 

  1524.                 if (v3_cpp_obj(queue)->get_point(queue, 0, &offset, &value) != V3_OK)

  1525.                     break;

  1526. 

  1527.                 if (offset != 0)

  1528.                     continue;

  1529. 

  1530.                 const uint32_t index = rindex - kVst3InternalParameterCount;

  1531.                 setNormalizedPluginParameterValue(index, value);

  1532.             }

  1533.         }

  1534. 

  1535. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  1537. #else

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

  1539. #endif

  1540. 

  1541. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1542.         fHostEventOutputHandle = nullptr;

  1543. #endif

  1544. 

  1545.         // if there are any parameter changes after frame 0, set them here

  1546.         if (v3_param_changes** const inparamsptr = data->input_params)

  1547.         {

  1548.             int32_t offset;

  1549.             double value;

  1550. 

  1551.             for (int32_t i = 0, count = v3_cpp_obj(inparamsptr)->get_param_count(inparamsptr); i < count; ++i)

  1552.             {

  1553.                 v3_param_value_queue** const queue = v3_cpp_obj(inparamsptr)->get_param_data(inparamsptr, i);

  1554.                 DISTRHO_SAFE_ASSERT_BREAK(queue != nullptr);

  1555. 

  1556.                 const v3_param_id rindex = v3_cpp_obj(queue)->get_param_id(queue);

  1557.                 DISTRHO_SAFE_ASSERT_UINT_BREAK(rindex < fVst3ParameterCount, rindex);

  1558. 

  1559.                 if (rindex < kVst3InternalParameterCount)

  1560.                     continue;

  1561. 

  1562.                 const int32_t pcount = v3_cpp_obj(queue)->get_point_count(queue);

  1563. 

  1564.                 if (pcount <= 0)

  1565.                     continue;

  1566. 

  1567.                 if (v3_cpp_obj(queue)->get_point(queue, pcount - 1, &offset, &value) != V3_OK)

  1568.                     break;

  1569. 

  1570.                 if (offset == 0)

  1571.                     continue;

  1572. 

  1573.                 const uint32_t index = rindex - kVst3InternalParameterCount;

  1574.                 setNormalizedPluginParameterValue(index, value);

  1575.             }

  1576.         }

  1577. 

  1578.         updateParametersFromProcessing(data->output_params, data->nframes - 1);

  1579.         return V3_OK;

  1580.     }

  1581. 

  1582.     uint32_t getTailSamples() const noexcept

  1583.     {

  1584.         return 0;

  1585.     }

  1586. 

  1587.     // ----------------------------------------------------------------------------------------------------------------

  1588.     // v3_edit_controller interface calls

  1589. 

  1590.     int32_t getParameterCount() const noexcept

  1591.     {

  1592.         return fVst3ParameterCount;

  1593.     }

  1594. 

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

  1596.     {

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

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

  1599. 

  1600.         // TODO hash the parameter symbol

  1601.         info->param_id = rindex;

  1602. 

  1603.         switch (rindex)

  1604.         {

  1605.         case kVst3InternalParameterActive:

  1606.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

  1607.             info->step_count = 1;

  1608.             strncpy_utf16(info->title, "Active", 128);

  1609.             strncpy_utf16(info->short_title, "Active", 128);

  1610.             return V3_OK;

  1611.         case kVst3InternalParameterBufferSize:

  1612.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

  1613.             info->step_count = DPF_VST3_MAX_BUFFER_SIZE - 1;

  1614.             strncpy_utf16(info->title, "Buffer Size", 128);

  1615.             strncpy_utf16(info->short_title, "Buffer Size", 128);

  1616.             strncpy_utf16(info->units, "frames", 128);

  1617.             return V3_OK;

  1618.         case kVst3InternalParameterSampleRate:

  1619.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

  1620.             strncpy_utf16(info->title, "Sample Rate", 128);

  1621.             strncpy_utf16(info->short_title, "Sample Rate", 128);

  1622.             strncpy_utf16(info->units, "frames", 128);

  1623.             return V3_OK;

  1624.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1625.         case kVst3InternalParameterLatency:

  1626.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

  1627.             strncpy_utf16(info->title, "Latency", 128);

  1628.             strncpy_utf16(info->short_title, "Latency", 128);

  1629.             strncpy_utf16(info->units, "frames", 128);

  1630.             return V3_OK;

  1631.        #endif

  1632.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1633.         case kVst3InternalParameterProgram:

  1634.             info->flags = V3_PARAM_CAN_AUTOMATE | V3_PARAM_IS_LIST | V3_PARAM_PROGRAM_CHANGE | V3_PARAM_IS_HIDDEN;

  1635.             info->step_count = fProgramCountMinusOne;

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

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

  1638.             return V3_OK;

  1639.        #endif

  1640.         }

  1641. 

  1642. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1643.         if (rindex < kVst3InternalParameterCount)

  1644.         {

  1645.             const uint32_t index = static_cast<uint32_t>(rindex - kVst3InternalParameterMidiCC_start);

  1646.             info->flags = V3_PARAM_CAN_AUTOMATE | V3_PARAM_IS_HIDDEN;

  1647.             info->step_count = 127;

  1648.             char ccstr[24];

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

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

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

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

  1653.             return V3_OK;

  1654.         }

  1655. #endif

  1656. 

  1657.         const uint32_t index = static_cast<uint32_t>(rindex - kVst3InternalParameterCount);

  1658.         DISTRHO_SAFE_ASSERT_UINT_RETURN(index < fParameterCount, index, V3_INVALID_ARG);

  1659. 

  1660.         // set up flags

  1661.         int32_t flags = 0;

  1662. 

  1663.         const ParameterEnumerationValues& enumValues(fPlugin.getParameterEnumValues(index));

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

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

  1666. 

  1667.         switch (fPlugin.getParameterDesignation(index))

  1668.         {

  1669.         case kParameterDesignationNull:

  1670.             break;

  1671.         case kParameterDesignationBypass:

  1672.             flags |= V3_PARAM_IS_BYPASS;

  1673.             break;

  1674.         }

  1675. 

  1676.         if (hints & kParameterIsAutomatable)

  1677.             flags |= V3_PARAM_CAN_AUTOMATE;

  1678.         if (hints & kParameterIsOutput)

  1679.             flags |= V3_PARAM_READ_ONLY;

  1680. 

  1681.         // set up step_count

  1682.         int32_t step_count = 0;

  1683. 

  1684.         if (hints & kParameterIsBoolean)

  1685.             step_count = 1;

  1686.         else if (hints & kParameterIsInteger)

  1687.             step_count = ranges.max - ranges.min;

  1688. 

  1689.         if (enumValues.count >= 2 && enumValues.restrictedMode)

  1690.         {

  1691.             flags |= V3_PARAM_IS_LIST;

  1692.             step_count = enumValues.count - 1;

  1693.         }

  1694. 

  1695.         info->flags = flags;

  1696.         info->step_count = step_count;

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

  1698.         // int32_t unit_id;

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

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

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

  1702.         return V3_OK;

  1703.     }

  1704. 

  1705.     v3_result getParameterStringForValue(const v3_param_id rindex, const double normalized, v3_str_128 output)

  1706.     {

  1707.         DISTRHO_SAFE_ASSERT_RETURN(normalized >= 0.0 && normalized <= 1.0, V3_INVALID_ARG);

  1708. 

  1709.         switch (rindex)

  1710.         {

  1711.         case kVst3InternalParameterActive:

  1712.             strncpy_utf16(output, normalized > 0.5 ? "On" : "Off", 128);

  1713.             return V3_OK;

  1714.         case kVst3InternalParameterBufferSize:

  1715.             snprintf_i32_utf16(output, static_cast<int>(normalized * DPF_VST3_MAX_BUFFER_SIZE + 0.5), 128);

  1716.             return V3_OK;

  1717.         case kVst3InternalParameterSampleRate:

  1718.             snprintf_f32_utf16(output, std::round(normalized * DPF_VST3_MAX_SAMPLE_RATE), 128);

  1719.             return V3_OK;

  1720.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1721.         case kVst3InternalParameterLatency:

  1722.             snprintf_f32_utf16(output, std::round(normalized * DPF_VST3_MAX_LATENCY), 128);

  1723.             return V3_OK;

  1724.        #endif

  1725.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1726.         case kVst3InternalParameterProgram:

  1727.             const uint32_t program = std::round(normalized * fProgramCountMinusOne);

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

  1729.             return V3_OK;

  1730.        #endif

  1731.         }

  1732. 

  1733.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1734.         if (rindex < kVst3InternalParameterCount)

  1735.         {

  1736.             snprintf_f32_utf16(output, std::round(normalized * 127), 128);

  1737.             return V3_OK;

  1738.         }

  1739.        #endif

  1740. 

  1741.         const uint32_t index = static_cast<uint32_t>(rindex - kVst3InternalParameterCount);

  1742.         DISTRHO_SAFE_ASSERT_UINT_RETURN(index < fParameterCount, index, V3_INVALID_ARG);

  1743. 

  1744.         const ParameterEnumerationValues& enumValues(fPlugin.getParameterEnumValues(index));

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

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

  1747.         float value = ranges.getUnnormalizedValue(normalized);

  1748. 

  1749.         if (hints & kParameterIsBoolean)

  1750.         {

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

  1752.             value = value > midRange ? ranges.max : ranges.min;

  1753.         }

  1754.         else if (hints & kParameterIsInteger)

  1755.         {

  1756.             value = std::round(value);

  1757.         }

  1758. 

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

  1760.         {

  1761.             if (d_isEqual(enumValues.values[i].value, value))

  1762.             {

  1763.                 strncpy_utf16(output, enumValues.values[i].label, 128);

  1764.                 return V3_OK;

  1765.             }

  1766.         }

  1767. 

  1768.         if (hints & kParameterIsInteger)

  1769.             snprintf_i32_utf16(output, value, 128);

  1770.         else

  1771.             snprintf_f32_utf16(output, value, 128);

  1772. 

  1773.         return V3_OK;

  1774.     }

  1775. 

  1776.     v3_result getParameterValueForString(const v3_param_id rindex, int16_t* const input, double* const output)

  1777.     {

  1778.         switch (rindex)

  1779.         {

  1780.         case kVst3InternalParameterActive:

  1781.             *output = strcmp_utf16(input, "On") ? 1.0 : 0.0;

  1782.             return V3_OK;

  1783.         case kVst3InternalParameterBufferSize:

  1784.             *output = static_cast<double>(std::atoi(ScopedUTF8String(input))) / DPF_VST3_MAX_BUFFER_SIZE;

  1785.             return V3_OK;

  1786.         case kVst3InternalParameterSampleRate:

  1787.             *output = std::atof(ScopedUTF8String(input)) / DPF_VST3_MAX_SAMPLE_RATE;

  1788.             return V3_OK;

  1789.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1790.         case kVst3InternalParameterLatency:

  1791.             *output = std::atof(ScopedUTF8String(input)) / DPF_VST3_MAX_LATENCY;

  1792.             return V3_OK;

  1793.        #endif

  1794.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1795.         case kVst3InternalParameterProgram:

  1796.             for (uint32_t i=0, count=fPlugin.getProgramCount(); i < count; ++i)

  1797.             {

  1798.                 if (strcmp_utf16(input, fPlugin.getProgramName(i)))

  1799.                 {

  1800.                     *output = static_cast<double>(i) / static_cast<double>(fProgramCountMinusOne);

  1801.                     return V3_OK;

  1802.                 }

  1803.             }

  1804.             return V3_INVALID_ARG;

  1805.        #endif

  1806.         }

  1807. 

  1808.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1809.         if (rindex < kVst3InternalParameterCount)

  1810.         {

  1811.             // TODO find CC/channel based on name

  1812.             return V3_NOT_IMPLEMENTED;

  1813.         }

  1814.        #endif

  1815. 

  1816.         const uint32_t index = static_cast<uint32_t>(rindex - kVst3InternalParameterCount);

  1817.         DISTRHO_SAFE_ASSERT_UINT_RETURN(index < fParameterCount, index, V3_INVALID_ARG);

  1818. 

  1819.         const ParameterEnumerationValues& enumValues(fPlugin.getParameterEnumValues(index));

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

  1821. 

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

  1823.         {

  1824.             if (strcmp_utf16(input, enumValues.values[i].label))

  1825.             {

  1826.                 *output = ranges.getNormalizedValue(enumValues.values[i].value);

  1827.                 return V3_OK;

  1828.             }

  1829.         }

  1830. 

  1831.         const ScopedUTF8String input8(input);

  1832. 

  1833.         float value;

  1834.         if (fPlugin.getParameterHints(index) & kParameterIsInteger)

  1835.             value = std::atoi(input8);

  1836.         else

  1837.             value = std::atof(input8);

  1838. 

  1839.         *output = ranges.getNormalizedValue(value);

  1840.         return V3_OK;

  1841.     }

  1842. 

  1843.     double normalizedParameterToPlain(const v3_param_id rindex, const double normalized)

  1844.     {

  1845.         DISTRHO_SAFE_ASSERT_RETURN(normalized >= 0.0 && normalized <= 1.0, 0.0);

  1846. 

  1847.         switch (rindex)

  1848.         {

  1849.         case kVst3InternalParameterActive:

  1850.             return normalized > 0.5 ? 1.0 : 0.0;

  1851.         case kVst3InternalParameterBufferSize:

  1852.             return std::round(normalized * DPF_VST3_MAX_BUFFER_SIZE);

  1853.         case kVst3InternalParameterSampleRate:

  1854.             return normalized * DPF_VST3_MAX_SAMPLE_RATE;

  1855.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1856.         case kVst3InternalParameterLatency:

  1857.             return normalized * DPF_VST3_MAX_LATENCY;

  1858.        #endif

  1859.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1860.         case kVst3InternalParameterProgram:

  1861.             return std::round(normalized * fProgramCountMinusOne);

  1862.        #endif

  1863.         }

  1864. 

  1865.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1866.         if (rindex < kVst3InternalParameterCount)

  1867.             return std::round(normalized * 127);

  1868.        #endif

  1869. 

  1870.         const uint32_t index = static_cast<uint32_t>(rindex - kVst3InternalParameterCount);

  1871.         DISTRHO_SAFE_ASSERT_UINT2_RETURN(index < fParameterCount, index, fParameterCount, 0.0);

  1872. 

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

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

  1875.         float value = ranges.getUnnormalizedValue(normalized);

  1876. 

  1877.         if (hints & kParameterIsBoolean)

  1878.         {

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

  1880.             value = value > midRange ? ranges.max : ranges.min;

  1881.         }

  1882.         else if (hints & kParameterIsInteger)

  1883.         {

  1884.             value = std::round(value);

  1885.         }

  1886. 

  1887.         return value;

  1888.     }

  1889. 

  1890.     double plainParameterToNormalized(const v3_param_id rindex, const double plain)

  1891.     {

  1892.         switch (rindex)

  1893.         {

  1894.         case kVst3InternalParameterActive:

  1895.             return plain;

  1896.         case kVst3InternalParameterBufferSize:

  1897.             return std::max(0.0, std::min(1.0, plain / DPF_VST3_MAX_BUFFER_SIZE));

  1898.         case kVst3InternalParameterSampleRate:

  1899.             return std::max(0.0, std::min(1.0, plain / DPF_VST3_MAX_SAMPLE_RATE));

  1900.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1901.         case kVst3InternalParameterLatency:

  1902.             return std::max(0.0, std::min(1.0, plain / DPF_VST3_MAX_LATENCY));

  1903.        #endif

  1904.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1905.         case kVst3InternalParameterProgram:

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

  1907.        #endif

  1908.         }

  1909. 

  1910.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1911.         if (rindex < kVst3InternalParameterCount)

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

  1913.        #endif

  1914. 

  1915.         const uint32_t index = static_cast<uint32_t>(rindex - kVst3InternalParameterCount);

  1916.         DISTRHO_SAFE_ASSERT_UINT2_RETURN(index < fParameterCount, index, fParameterCount, 0.0);

  1917. 

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

  1919.         return ranges.getNormalizedValue(plain);

  1920.     }

  1921. 

  1922.     double getParameterNormalized(const v3_param_id rindex)

  1923.     {

  1924.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1925.         // TODO something to do here?

  1926.         if (rindex >= kVst3InternalParameterMidiCC_start && rindex <= kVst3InternalParameterMidiCC_end)

  1927.             return 0.0;

  1928.        #endif

  1929. 

  1930.         switch (rindex)

  1931.         {

  1932.         case kVst3InternalParameterActive:

  1933.         case kVst3InternalParameterBufferSize:

  1934.         case kVst3InternalParameterSampleRate:

  1935.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1936.         case kVst3InternalParameterLatency:

  1937.        #endif

  1938.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1939.         case kVst3InternalParameterProgram:

  1940.        #endif

  1941.             return plainParameterToNormalized(rindex, fCachedParameterValues[rindex]);

  1942.         }

  1943. 

  1944.         const uint32_t index = static_cast<uint32_t>(rindex - kVst3InternalParameterCount);

  1945.         DISTRHO_SAFE_ASSERT_UINT2_RETURN(index < fParameterCount, index, fParameterCount, 0.0);

  1946. 

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

  1948.         return ranges.getNormalizedValue(fCachedParameterValues[kVst3InternalParameterBaseCount + index]);

  1949.     }

  1950. 

  1951.     v3_result setParameterNormalized(const v3_param_id rindex, const double normalized)

  1952.     {

  1953.         DISTRHO_SAFE_ASSERT_RETURN(normalized >= 0.0 && normalized <= 1.0, V3_INVALID_ARG);

  1954. 

  1955.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1956.         // TODO something to do here?

  1957.         if (rindex >= kVst3InternalParameterMidiCC_start && rindex <= kVst3InternalParameterMidiCC_end)

  1958.             return V3_INVALID_ARG;

  1959.        #endif

  1960. 

  1961.         if (rindex < kVst3InternalParameterBaseCount)

  1962.         {

  1963.             fCachedParameterValues[rindex] = normalizedParameterToPlain(rindex, normalized);

  1964.             int flags = 0;

  1965. 

  1966.             switch (rindex)

  1967.             {

  1968.             case kVst3InternalParameterActive:

  1969.                 if (fCachedParameterValues[rindex] > 0.5f)

  1970.                 {

  1971.                     if (! fPlugin.isActive())

  1972.                         fPlugin.activate();

  1973.                 }

  1974.                 else

  1975.                 {

  1976.                     fPlugin.deactivateIfNeeded();

  1977.                 }

  1978.                 break;

  1979.             case kVst3InternalParameterBufferSize:

  1980.                 fPlugin.setBufferSize(fCachedParameterValues[rindex], true);

  1981.                 break;

  1982.             case kVst3InternalParameterSampleRate:

  1983.                 fPlugin.setSampleRate(fCachedParameterValues[rindex], true);

  1984.                 break;

  1985.            #if DISTRHO_PLUGIN_WANT_LATENCY

  1986.             case kVst3InternalParameterLatency:

  1987.                 flags = V3_RESTART_LATENCY_CHANGED;

  1988.                 break;

  1989.            #endif

  1990.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1991.             case kVst3InternalParameterProgram:

  1992.                 flags = V3_RESTART_PARAM_VALUES_CHANGED;

  1993.                 fCurrentProgram = fCachedParameterValues[rindex];

  1994.                 fPlugin.loadProgram(fCurrentProgram);

  1995. 

  1996.                 for (uint32_t i=0; i<fParameterCount; ++i)

  1997.                 {

  1998.                     if (fPlugin.isParameterOutputOrTrigger(i))

  1999.                         continue;

  2000.                     fCachedParameterValues[kVst3InternalParameterCount + i] = fPlugin.getParameterValue(i);

  2001.                 }

  2002. 

  2003.                #if DISTRHO_PLUGIN_HAS_UI

  2004.                 fParameterValueChangesForUI[kVst3InternalParameterProgram] = true;

  2005.                #endif

  2006.                 break;

  2007.            #endif

  2008.             }

  2009. 

  2010.             if (fComponentHandler != nullptr && flags != 0)

  2011.                 v3_cpp_obj(fComponentHandler)->restart_component(fComponentHandler, flags);

  2012. 

  2013.             return V3_OK;

  2014.         }

  2015. 

  2016.         const uint32_t index = static_cast<uint32_t>(rindex - kVst3InternalParameterCount);

  2017.         DISTRHO_SAFE_ASSERT_UINT2_RETURN(index < fParameterCount, index, fParameterCount, V3_INVALID_ARG);

  2018. 

  2019.         setNormalizedPluginParameterValue(index, normalized);

  2020.         return V3_OK;

  2021.     }

  2022. 

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

  2024.     {

  2025.         fComponentHandler = handler;

  2026.         return V3_OK;

  2027.     }

  2028. 

  2029. #if DISTRHO_PLUGIN_HAS_UI

  2030.     // ----------------------------------------------------------------------------------------------------------------

  2031.     // v3_connection_point interface calls

  2032. 

  2033.    #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  2034.     void comp2ctrl_connect(v3_connection_point** const other)

  2035.     {

  2036.         fConnectionFromCompToCtrl = other;

  2037.     }

  2038. 

  2039.     void comp2ctrl_disconnect()

  2040.     {

  2041.         fConnectionFromCompToCtrl = nullptr;

  2042.     }

  2043. 

  2044.     v3_result comp2ctrl_notify(v3_message** const message)

  2045.     {

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

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

  2048. 

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

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

  2051. 

  2052.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  2054.             return notify_midi(attrs);

  2055.        #endif

  2056. 

  2057.        #if DISTRHO_PLUGIN_WANT_STATE

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

  2059.             return notify_state(attrs);

  2060.        #endif

  2061. 

  2062.         d_stdout("comp2ctrl_notify received unknown msg '%s'", msgid);

  2063. 

  2064.         return V3_NOT_IMPLEMENTED;

  2065.     }

  2066.    #endif // DPF_VST3_USES_SEPARATE_CONTROLLER

  2067. 

  2068.     // ----------------------------------------------------------------------------------------------------------------

  2069. 

  2070.     void ctrl2view_connect(v3_connection_point** const other)

  2071.     {

  2072.         DISTRHO_SAFE_ASSERT(fConnectedToUI == false);

  2073. 

  2074.         fConnectionFromCtrlToView = other;

  2075.         fConnectedToUI = false;

  2076.     }

  2077. 

  2078.     void ctrl2view_disconnect()

  2079.     {

  2080.         fConnectedToUI = false;

  2081. 

  2082.         if (fConnectionFromCtrlToView != nullptr)

  2083.         {

  2084.             v3_cpp_obj_unref(fConnectionFromCtrlToView);

  2085.             fConnectionFromCtrlToView = nullptr;

  2086.         }

  2087.     }

  2088. 

  2089.     v3_result ctrl2view_notify(v3_message** const message)

  2090.     {

  2091.         DISTRHO_SAFE_ASSERT_RETURN(fConnectionFromCtrlToView != nullptr, V3_INTERNAL_ERR);

  2092. 

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

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

  2095. 

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

  2097.         {

  2098.             fConnectedToUI = true;

  2099. 

  2100.             fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = false;

  2101.             sendParameterSetToUI(kVst3InternalParameterSampleRate,

  2102.                                  fCachedParameterValues[kVst3InternalParameterSampleRate]);

  2103. 

  2104.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2105.             fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  2106.             sendParameterSetToUI(kVst3InternalParameterProgram, fCurrentProgram);

  2107.            #endif

  2108. 

  2109.            #if DISTRHO_PLUGIN_WANT_FULL_STATE

  2110.             // Update current state from plugin side

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

  2112.             {

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

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

  2115.             }

  2116.            #endif

  2117. 

  2118.            #if DISTRHO_PLUGIN_WANT_STATE

  2119.             // Set state

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

  2121.             {

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

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

  2124. 

  2125.                 sendStateSetToUI(key, value);

  2126.             }

  2127.            #endif

  2128. 

  2129.             for (uint32_t i=0; i<fParameterCount; ++i)

  2130.             {

  2131.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  2132.                 sendParameterSetToUI(kVst3InternalParameterBaseCount + i,

  2133.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  2134.             }

  2135. 

  2136.             sendReadyToUI();

  2137.             return V3_OK;

  2138.         }

  2139. 

  2140.         DISTRHO_SAFE_ASSERT_RETURN(fConnectedToUI, V3_INTERNAL_ERR);

  2141. 

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

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

  2144. 

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

  2146.         {

  2147.             if (fParameterValueChangesForUI[kVst3InternalParameterSampleRate])

  2148.             {

  2149.                 fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = false;

  2150.                 sendParameterSetToUI(kVst3InternalParameterSampleRate,

  2151.                                      fCachedParameterValues[kVst3InternalParameterSampleRate]);

  2152.             }

  2153. 

  2154.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2155.             if (fParameterValueChangesForUI[kVst3InternalParameterProgram])

  2156.             {

  2157.                 fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  2158.                 sendParameterSetToUI(kVst3InternalParameterProgram, fCurrentProgram);

  2159.             }

  2160.            #endif

  2161. 

  2162.             for (uint32_t i=0; i<fParameterCount; ++i)

  2163.             {

  2164.                 if (! fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i])

  2165.                     continue;

  2166. 

  2167.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  2168.                 sendParameterSetToUI(kVst3InternalParameterBaseCount + i,

  2169.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  2170.             }

  2171. 

  2172.             sendReadyToUI();

  2173.             return V3_OK;

  2174.         }

  2175. 

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

  2177.         {

  2178.             ctrl2view_disconnect();

  2179.             return V3_OK;

  2180.         }

  2181. 

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

  2183.         {

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

  2185. 

  2186.             int64_t rindex;

  2187.             int64_t started;

  2188.             v3_result res;

  2189. 

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

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

  2192.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex >= kVst3InternalParameterCount,

  2193.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2194.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex < kVst3InternalParameterCount + fParameterCount,

  2195.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2196. 

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

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

  2199.             DISTRHO_SAFE_ASSERT_INT_RETURN(started == 0 || started == 1, started, V3_INTERNAL_ERR);

  2200. 

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

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

  2203.         }

  2204. 

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

  2206.         {

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

  2208. 

  2209.             int64_t rindex;

  2210.             double value;

  2211.             v3_result res;

  2212. 

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

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

  2215.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex >= kVst3InternalParameterCount,

  2216.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2217.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex < kVst3InternalParameterCount + fParameterCount,

  2218.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2219. 

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

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

  2222. 

  2223.             const uint32_t index = rindex - kVst3InternalParameterCount;

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

  2225. 

  2226.             return v3_cpp_obj(fComponentHandler)->perform_edit(fComponentHandler, rindex, normalized);

  2227.         }

  2228. 

  2229.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  2231.         {

  2232.            #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  2233.             DISTRHO_SAFE_ASSERT_RETURN(fConnectionFromCompToCtrl != nullptr, V3_INTERNAL_ERR);

  2234.             return v3_cpp_obj(fConnectionFromCompToCtrl)->notify(fConnectionFromCompToCtrl, message);

  2235.            #else

  2236.             return notify_midi(attrs);

  2237.            #endif

  2238.         }

  2239.        #endif

  2240. 

  2241.        #if DISTRHO_PLUGIN_WANT_STATE

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

  2243.         {

  2244.            #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  2245.             DISTRHO_SAFE_ASSERT_RETURN(fConnectionFromCompToCtrl != nullptr, V3_INTERNAL_ERR);

  2246.             return v3_cpp_obj(fConnectionFromCompToCtrl)->notify(fConnectionFromCompToCtrl, message);

  2247.            #else

  2248.             return notify_state(attrs);

  2249.            #endif

  2250.         }

  2251.        #endif

  2252. 

  2253.         d_stdout("ctrl2view_notify received unknown msg '%s'", msgid);

  2254. 

  2255.         return V3_NOT_IMPLEMENTED;

  2256.     }

  2257. 

  2258.    #if DISTRHO_PLUGIN_WANT_STATE

  2259.     v3_result notify_state(v3_attribute_list** const attrs)

  2260.     {

  2261.         int64_t keyLength = -1;

  2262.         int64_t valueLength = -1;

  2263.         v3_result res;

  2264. 

  2265.         res = v3_cpp_obj(attrs)->get_int(attrs, "key:length", &keyLength);

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

  2267.         DISTRHO_SAFE_ASSERT_INT_RETURN(keyLength >= 0, keyLength, V3_INTERNAL_ERR);

  2268. 

  2269.         res = v3_cpp_obj(attrs)->get_int(attrs, "value:length", &valueLength);

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

  2271.         DISTRHO_SAFE_ASSERT_INT_RETURN(valueLength >= 0, valueLength, V3_INTERNAL_ERR);

  2272. 

  2273.         int16_t* const key16 = (int16_t*)std::malloc(sizeof(int16_t)*(keyLength + 1));

  2274.         DISTRHO_SAFE_ASSERT_RETURN(key16 != nullptr, V3_NOMEM);

  2275. 

  2276.         int16_t* const value16 = (int16_t*)std::malloc(sizeof(int16_t)*(valueLength + 1));

  2277.         DISTRHO_SAFE_ASSERT_RETURN(value16 != nullptr, V3_NOMEM);

  2278. 

  2279.         res = v3_cpp_obj(attrs)->get_string(attrs, "key", key16, sizeof(int16_t)*keyLength);

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

  2281. 

  2282.         res = v3_cpp_obj(attrs)->get_string(attrs, "value", value16, sizeof(int16_t)*valueLength);

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

  2284. 

  2285.         // do cheap inline conversion

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

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

  2288. 

  2289.         for (int64_t i=0; i<keyLength; ++i)

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

  2291.         for (int64_t i=0; i<valueLength; ++i)

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

  2293. 

  2294.         key[keyLength] = '\0';

  2295.         value[valueLength] = '\0';

  2296. 

  2297.         fPlugin.setState(key, value);

  2298. 

  2299.         // save this key as needed

  2300.         if (fPlugin.wantStateKey(key))

  2301.         {

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

  2303.             {

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

  2305. 

  2306.                 if (dkey == key)

  2307.                 {

  2308.                     it->second = value;

  2309.                     std::free(key16);

  2310.                     std::free(value16);

  2311.                     return V3_OK;

  2312.                 }

  2313.             }

  2314. 

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

  2316.         }

  2317. 

  2318.         std::free(key16);

  2319.         std::free(value16);

  2320.         return V3_OK;

  2321.     }

  2322.    #endif // DISTRHO_PLUGIN_WANT_STATE

  2323. 

  2324.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2325.     v3_result notify_midi(v3_attribute_list** const attrs)

  2326.     {

  2327.         uint8_t* data;

  2328.         uint32_t size;

  2329.         v3_result res;

  2330. 

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

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

  2333. 

  2334.         // known maximum size

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

  2336. 

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

  2338.     }

  2339.    #endif // DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2340. #endif

  2341. 

  2342.     // ----------------------------------------------------------------------------------------------------------------

  2343. 

  2344. private:

  2345.     // Plugin

  2346.     PluginExporter fPlugin;

  2347. 

  2348.     // VST3 stuff

  2349.     v3_component_handler** fComponentHandler;

  2350. #if DISTRHO_PLUGIN_HAS_UI

  2351.    #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  2352.     v3_connection_point** fConnectionFromCompToCtrl;

  2353.    #endif

  2354.     v3_connection_point** fConnectionFromCtrlToView;

  2355.     v3_host_application** const fHostApplication;

  2356. #endif

  2357. 

  2358.     // Temporary data

  2359.     const uint32_t fParameterCount;

  2360.     const uint32_t fVst3ParameterCount; // full offset + real

  2361.     float* fCachedParameterValues; // basic offset + real

  2362.     bool* fParameterValuesChangedDuringProcessing; // basic offset + real

  2363. #if DISTRHO_PLUGIN_HAS_UI

  2364.     bool* fParameterValueChangesForUI; // basic offset + real

  2365.     bool fConnectedToUI;

  2366. #endif

  2367. #if DISTRHO_PLUGIN_WANT_LATENCY

  2368.     uint32_t fLastKnownLatency;

  2369. #endif

  2370. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2371.     MidiEvent fMidiEvents[kMaxMidiEvents];

  2372. # if DISTRHO_PLUGIN_HAS_UI

  2373.     SmallStackRingBuffer fNotesRingBuffer;

  2374. # endif

  2375. #endif

  2376. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2377.     v3_event_list** fHostEventOutputHandle;

  2378. #endif

  2379. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2380.     uint32_t fCurrentProgram;

  2381.     const uint32_t fProgramCountMinusOne;

  2382. #endif

  2383. #if DISTRHO_PLUGIN_WANT_STATE

  2384.     StringMap fStateMap;

  2385. #endif

  2386. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  2387.     TimePosition fTimePosition;

  2388. #endif

  2389. 

  2390.     // ----------------------------------------------------------------------------------------------------------------

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

  2392. 

  2393.     void updateParametersFromProcessing(v3_param_changes** const outparamsptr, const int32_t offset)

  2394.     {

  2395.         DISTRHO_SAFE_ASSERT_RETURN(outparamsptr != nullptr,);

  2396. 

  2397.         v3_param_id paramId;

  2398.         float curValue;

  2399. 

  2400.         for (v3_param_id i=kVst3InternalParameterActive; i<=kVst3InternalParameterSampleRate; ++i)

  2401.         {

  2402.             if (! fParameterValuesChangedDuringProcessing[i])

  2403.                 continue;

  2404. 

  2405.             curValue = plainParameterToNormalized(i, fCachedParameterValues[i]);

  2406.             fParameterValuesChangedDuringProcessing[i] = false;

  2407.             addParameterDataToHostOutputEvents(outparamsptr, i, curValue);

  2408.         }

  2409. 

  2410.         for (uint32_t i=0; i<fParameterCount; ++i)

  2411.         {

  2412.             if (fPlugin.isParameterOutput(i))

  2413.             {

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

  2415.                 curValue = fPlugin.getParameterValue(i);

  2416. 

  2417.                 if (d_isEqual(curValue, fCachedParameterValues[kVst3InternalParameterBaseCount + i]))

  2418.                     continue;

  2419.             }

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

  2421.             {

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

  2423.                 curValue = fPlugin.getParameterValue(i);

  2424. 

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

  2426.                     continue;

  2427. 

  2428.                 fPlugin.setParameterValue(i, curValue);

  2429.             }

  2430.             else if (fParameterValuesChangedDuringProcessing[kVst3InternalParameterBaseCount + i])

  2431.             {

  2432.                 fParameterValuesChangedDuringProcessing[kVst3InternalParameterBaseCount + i] = false;

  2433.                 curValue = fPlugin.getParameterValue(i);

  2434.             }

  2435.             else

  2436.             {

  2437.                 continue;

  2438.             }

  2439. 

  2440.             fCachedParameterValues[kVst3InternalParameterBaseCount + i] = curValue;

  2441. #if DISTRHO_PLUGIN_HAS_UI

  2442.             fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = true;

  2443. #endif

  2444. 

  2445.             paramId = kVst3InternalParameterCount + i;

  2446.             curValue = fPlugin.getParameterRanges(i).getNormalizedValue(curValue);

  2447. 

  2448.             if (! addParameterDataToHostOutputEvents(outparamsptr, paramId, curValue, offset))

  2449.                 break;

  2450.         }

  2451. 

  2452. #if DISTRHO_PLUGIN_WANT_LATENCY

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

  2454. 

  2455.         if (fLastKnownLatency != latency)

  2456.         {

  2457.             fLastKnownLatency = latency;

  2458. 

  2459.             curValue = plainParameterToNormalized(kVst3InternalParameterLatency,

  2460.                                                   fCachedParameterValues[kVst3InternalParameterLatency]);

  2461.             addParameterDataToHostOutputEvents(outparamsptr, kVst3InternalParameterLatency, curValue);

  2462.         }

  2463. #endif

  2464.     }

  2465. 

  2466.     bool addParameterDataToHostOutputEvents(v3_param_changes** const outparamsptr,

  2467.                                             v3_param_id paramId,

  2468.                                             const float curValue,

  2469.                                             const int32_t offset = 0)

  2470.     {

  2471.         int32_t index = 0;

  2472.         v3_param_value_queue** const queue = v3_cpp_obj(outparamsptr)->add_param_data(outparamsptr,

  2473.                                                                                       &paramId, &index);

  2474.         DISTRHO_SAFE_ASSERT_RETURN(queue != nullptr, false);

  2475.         DISTRHO_SAFE_ASSERT_RETURN(v3_cpp_obj(queue)->add_point(queue, 0, curValue, &index) == V3_OK, false);

  2476. 

  2477.         if (offset != 0)

  2478.             v3_cpp_obj(queue)->add_point(queue, offset, curValue, &index);

  2479. 

  2480.         return true;

  2481.     }

  2482. 

  2483. #if DISTRHO_PLUGIN_HAS_UI

  2484.     // ----------------------------------------------------------------------------------------------------------------

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

  2486. 

  2487.     v3_message** createMessage(const char* const id) const

  2488.     {

  2489.         DISTRHO_SAFE_ASSERT_RETURN(fHostApplication != nullptr, nullptr);

  2490. 

  2491.         v3_tuid iid;

  2492.         memcpy(iid, v3_message_iid, sizeof(v3_tuid));

  2493.         v3_message** msg = nullptr;

  2494.         const v3_result res = v3_cpp_obj(fHostApplication)->create_instance(fHostApplication, iid, iid, (void**)&msg);

  2495.         DISTRHO_SAFE_ASSERT_INT_RETURN(res == V3_TRUE, res, nullptr);

  2496.         DISTRHO_SAFE_ASSERT_RETURN(msg != nullptr, nullptr);

  2497. 

  2498.         v3_cpp_obj(msg)->set_message_id(msg, id);

  2499.         return msg;

  2500.     }

  2501. 

  2502.     void sendParameterSetToUI(const v3_param_id rindex, const double value) const

  2503.     {

  2504.         v3_message** const message = createMessage("parameter-set");

  2505.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2506. 

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

  2508.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  2509. 

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

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

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

  2513.         v3_cpp_obj(fConnectionFromCtrlToView)->notify(fConnectionFromCtrlToView, message);

  2514. 

  2515.         v3_cpp_obj_unref(message);

  2516.     }

  2517. 

  2518.     void sendStateSetToUI(const char* const key, const char* const value) const

  2519.     {

  2520.         v3_message** const message = createMessage("state-set");

  2521.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2522. 

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

  2524.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  2525. 

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

  2527.         v3_cpp_obj(attrlist)->set_int(attrlist, "key:length", std::strlen(key));

  2528.         v3_cpp_obj(attrlist)->set_int(attrlist, "value:length", std::strlen(value));

  2529.         v3_cpp_obj(attrlist)->set_string(attrlist, "key", ScopedUTF16String(key));

  2530.         v3_cpp_obj(attrlist)->set_string(attrlist, "value", ScopedUTF16String(value));

  2531.         v3_cpp_obj(fConnectionFromCtrlToView)->notify(fConnectionFromCtrlToView, message);

  2532. 

  2533.         v3_cpp_obj_unref(message);

  2534.     }

  2535. 

  2536.     void sendReadyToUI() const

  2537.     {

  2538.         v3_message** const message = createMessage("ready");

  2539.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2540. 

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

  2542.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  2543. 

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

  2545.         v3_cpp_obj(fConnectionFromCtrlToView)->notify(fConnectionFromCtrlToView, message);

  2546. 

  2547.         v3_cpp_obj_unref(message);

  2548.     }

  2549. #endif

  2550. 

  2551.     // ----------------------------------------------------------------------------------------------------------------

  2552.     // DPF callbacks

  2553. 

  2554.     bool requestParameterValueChange(const uint32_t index, float)

  2555.     {

  2556.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterBaseCount + index] = true;

  2557.         return true;

  2558.     }

  2559. 

  2560. #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

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

  2562.     {

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

  2564.     }

  2565. #endif

  2566. 

  2567. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2568.     bool writeMidi(const MidiEvent& midiEvent)

  2569.     {

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

  2571. 

  2572.         v3_event event;

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

  2574.         event.sample_offset = midiEvent.frame;

  2575. 

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

  2577. 

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

  2579.         {

  2580.         case 0x80:

  2581.             event.type = V3_EVENT_NOTE_OFF;

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

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

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

  2585.             // int32_t note_id;

  2586.             // float tuning;

  2587.             break;

  2588.         case 0x90:

  2589.             event.type = V3_EVENT_NOTE_ON;

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

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

  2592.             // float tuning;

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

  2594.             // int32_t length;

  2595.             // int32_t note_id;

  2596.             break;

  2597.         case 0xA0:

  2598.             event.type = V3_EVENT_POLY_PRESSURE;

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

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

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

  2602.             // int32_t note_id;

  2603.             break;

  2604.         case 0xB0:

  2605.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

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

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

  2609.             if (midiEvent.size == 4)

  2610.                 event.midi_cc_out.value2 = midiEvent.size == 4;

  2611.             break;

  2612.         /* TODO how do we deal with program changes??

  2613.         case 0xC0:

  2614.             break;

  2615.         */

  2616.         case 0xD0:

  2617.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

  2619.             event.midi_cc_out.cc_number = 128;

  2620.             event.midi_cc_out.value = data[1];

  2621.             break;

  2622.         case 0xE0:

  2623.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

  2625.             event.midi_cc_out.cc_number = 129;

  2626.             event.midi_cc_out.value = data[1];

  2627.             event.midi_cc_out.value2 = data[2];

  2628.             break;

  2629.         default:

  2630.             return true;

  2631.         }

  2632. 

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

  2634.     }

  2635. 

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

  2637.     {

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

  2639.     }

  2640. #endif

  2641. 

  2642. };

  2643. 

  2644. // --------------------------------------------------------------------------------------------------------------------

  2645. 

  2646. /**

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

  2648.  */

  2649. 

  2650. // --------------------------------------------------------------------------------------------------------------------

  2651. // v3_funknown for static instances

  2652. 

  2653. static uint32_t V3_API dpf_static_ref(void*) { return 1; }

  2654. static uint32_t V3_API dpf_static_unref(void*) { return 0; }

  2655. 

  2656. // --------------------------------------------------------------------------------------------------------------------

  2657. // v3_funknown for classes with a single instance

  2658. 

  2659. template<class T>

  2660. static uint32_t V3_API dpf_single_instance_ref(void* const self)

  2661. {

  2662.     return ++(*static_cast<T**>(self))->refcounter;

  2663. }

  2664. 

  2665. template<class T>

  2666. static uint32_t V3_API dpf_single_instance_unref(void* const self)

  2667. {

  2668.     return --(*static_cast<T**>(self))->refcounter;

  2669. }

  2670. 

  2671. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  2672. // --------------------------------------------------------------------------------------------------------------------

  2673. // dpf_comp2ctrl_connection_point

  2674. 

  2675. struct dpf_comp2ctrl_connection_point : v3_connection_point_cpp {

  2676.     std::atomic_int refcounter;

  2677.     ScopedPointer<PluginVst3>& vst3;

  2678.     v3_connection_point** other;

  2679. 

  2680.     dpf_comp2ctrl_connection_point(ScopedPointer<PluginVst3>& v)

  2681.         : refcounter(1),

  2682.           vst3(v),

  2683.           other(nullptr)

  2684.     {

  2685.         // v3_funknown, single instance

  2686.         query_interface = query_interface_connection_point;

  2687.         ref = dpf_single_instance_ref<dpf_comp2ctrl_connection_point>;

  2688.         unref = dpf_single_instance_unref<dpf_comp2ctrl_connection_point>;

  2689. 

  2690.         // v3_connection_point

  2691.         point.connect = connect;

  2692.         point.disconnect = disconnect;

  2693.         point.notify = notify;

  2694.     }

  2695. 

  2696.     // ----------------------------------------------------------------------------------------------------------------

  2697.     // v3_funknown

  2698. 

  2699.     static v3_result V3_API query_interface_connection_point(void* const self, const v3_tuid iid, void** const iface)

  2700.     {

  2701.         dpf_comp2ctrl_connection_point* const point = *static_cast<dpf_comp2ctrl_connection_point**>(self);

  2702. 

  2703.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  2704.             v3_tuid_match(iid, v3_connection_point_iid))

  2705.         {

  2706.             d_stdout("dpf_comp2ctrl_connection_point => %p %s %p | OK", self, tuid2str(iid), iface);

  2707.             ++point->refcounter;

  2708.             *iface = self;

  2709.             return V3_OK;

  2710.         }

  2711. 

  2712.         d_stdout("dpf_comp2ctrl_connection_point => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  2713. 

  2714.         *iface = nullptr;

  2715.         return V3_NO_INTERFACE;

  2716.     }

  2717. 

  2718.     // ----------------------------------------------------------------------------------------------------------------

  2719.     // v3_connection_point

  2720. 

  2721.     static v3_result V3_API connect(void* const self, v3_connection_point** const other)

  2722.     {

  2723.         d_stdout("dpf_comp2ctrl_connection_point::connect => %p %p", self, other);

  2724.         dpf_comp2ctrl_connection_point* const point = *static_cast<dpf_comp2ctrl_connection_point**>(self);

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

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

  2727. 

  2728.         point->other = other;

  2729. 

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

  2731.             vst3->comp2ctrl_connect(other);

  2732. 

  2733.         return V3_OK;

  2734.     }

  2735. 

  2736.     static v3_result V3_API disconnect(void* const self, v3_connection_point** const other)

  2737.     {

  2738.         d_stdout("dpf_comp2ctrl_connection_point => %p %p", self, other);

  2739.         dpf_comp2ctrl_connection_point* const point = *static_cast<dpf_comp2ctrl_connection_point**>(self);

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

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

  2742. 

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

  2744.             vst3->comp2ctrl_disconnect();

  2745. 

  2746.         point->other = nullptr;

  2747. 

  2748.         return V3_OK;

  2749.     }

  2750. 

  2751.     static v3_result V3_API notify(void* const self, v3_message** const message)

  2752.     {

  2753.         dpf_comp2ctrl_connection_point* const point = *static_cast<dpf_comp2ctrl_connection_point**>(self);

  2754. 

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

  2756.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  2757. 

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

  2759.         DISTRHO_SAFE_ASSERT_RETURN(other != nullptr, V3_NOT_INITIALIZED);

  2760. 

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

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

  2763. 

  2764.         int64_t target = 0;

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

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

  2767.         DISTRHO_SAFE_ASSERT_INT_RETURN(target == 1, target, V3_INTERNAL_ERR);

  2768. 

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

  2770.         return vst3->comp2ctrl_notify(message);

  2771.     }

  2772. };

  2773. #endif // DPF_VST3_USES_SEPARATE_CONTROLLER

  2774. 

  2775. #if DISTRHO_PLUGIN_HAS_UI

  2776. // --------------------------------------------------------------------------------------------------------------------

  2777. // dpf_comp2ctrl_connection_point

  2778. 

  2779. struct dpf_ctrl2view_connection_point : v3_connection_point_cpp {

  2780.     std::atomic_int refcounter;

  2781.     ScopedPointer<PluginVst3>& vst3;

  2782.     v3_connection_point** other;

  2783. 

  2784.     dpf_ctrl2view_connection_point(ScopedPointer<PluginVst3>& v)

  2785.         : refcounter(1),

  2786.           vst3(v),

  2787.           other(nullptr)

  2788.     {

  2789.         // v3_funknown, single instance

  2790.         query_interface = query_interface_connection_point;

  2791.         ref = dpf_single_instance_ref<dpf_ctrl2view_connection_point>;

  2792.         unref = dpf_single_instance_unref<dpf_ctrl2view_connection_point>;

  2793. 

  2794.         // v3_connection_point

  2795.         point.connect = connect;

  2796.         point.disconnect = disconnect;

  2797.         point.notify = notify;

  2798.     }

  2799. 

  2800.     // ----------------------------------------------------------------------------------------------------------------

  2801.     // v3_funknown

  2802. 

  2803.     static v3_result V3_API query_interface_connection_point(void* const self, const v3_tuid iid, void** const iface)

  2804.     {

  2805.         dpf_ctrl2view_connection_point* const point = *static_cast<dpf_ctrl2view_connection_point**>(self);

  2806. 

  2807.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  2808.             v3_tuid_match(iid, v3_connection_point_iid))

  2809.         {

  2810.             d_stdout("dpf_ctrl2view_connection_point => %p %s %p | OK", self, tuid2str(iid), iface);

  2811.             ++point->refcounter;

  2812.             *iface = self;

  2813.             return V3_OK;

  2814.         }

  2815. 

  2816.         d_stdout("dpf_ctrl2view_connection_point => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  2817. 

  2818.         *iface = nullptr;

  2819.         return V3_NO_INTERFACE;

  2820.     }

  2821. 

  2822.     // ----------------------------------------------------------------------------------------------------------------

  2823.     // v3_connection_point

  2824. 

  2825.     static v3_result V3_API connect(void* const self, v3_connection_point** const other)

  2826.     {

  2827.         d_stdout("dpf_ctrl2view_connection_point::connect => %p %p", self, other);

  2828.         dpf_ctrl2view_connection_point* const point = *static_cast<dpf_ctrl2view_connection_point**>(self);

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

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

  2831. 

  2832.         point->other = other;

  2833. 

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

  2835.             vst3->ctrl2view_connect(other);

  2836. 

  2837.         return V3_OK;

  2838.     }

  2839. 

  2840.     static v3_result V3_API disconnect(void* const self, v3_connection_point** const other)

  2841.     {

  2842.         d_stdout("dpf_ctrl2view_connection_point::disconnect => %p %p", self, other);

  2843.         dpf_ctrl2view_connection_point* const point = *static_cast<dpf_ctrl2view_connection_point**>(self);

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

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

  2846. 

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

  2848.             vst3->ctrl2view_disconnect();

  2849. 

  2850.         point->other = nullptr;

  2851. 

  2852.         return V3_OK;

  2853.     }

  2854. 

  2855.     static v3_result V3_API notify(void* const self, v3_message** const message)

  2856.     {

  2857.         dpf_ctrl2view_connection_point* const point = *static_cast<dpf_ctrl2view_connection_point**>(self);

  2858. 

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

  2860.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  2861. 

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

  2863.         DISTRHO_SAFE_ASSERT_RETURN(other != nullptr, V3_NOT_INITIALIZED);

  2864. 

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

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

  2867. 

  2868.         int64_t target = 0;

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

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

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

  2872. 

  2873.         if (target == 1)

  2874.         {

  2875.             // view -> edit controller

  2876.             return vst3->ctrl2view_notify(message);

  2877.         }

  2878.         else

  2879.         {

  2880.             // edit controller -> view

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

  2882.         }

  2883.     }

  2884. };

  2885. #endif // DISTRHO_PLUGIN_HAS_UI

  2886. 

  2887. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2888. // --------------------------------------------------------------------------------------------------------------------

  2889. // dpf_midi_mapping

  2890. 

  2891. struct dpf_midi_mapping : v3_midi_mapping_cpp {

  2892.     dpf_midi_mapping()

  2893.     {

  2894.         // v3_funknown, static

  2895.         query_interface = query_interface_midi_mapping;

  2896.         ref = dpf_static_ref;

  2897.         unref = dpf_static_unref;

  2898. 

  2899.         // v3_midi_mapping

  2900.         map.get_midi_controller_assignment = get_midi_controller_assignment;

  2901.     }

  2902. 

  2903.     // ----------------------------------------------------------------------------------------------------------------

  2904.     // v3_funknown

  2905. 

  2906.     static v3_result V3_API query_interface_midi_mapping(void* const self, const v3_tuid iid, void** const iface)

  2907.     {

  2908.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  2909.             v3_tuid_match(iid, v3_midi_mapping_iid))

  2910.         {

  2911.             d_stdout("query_interface_midi_mapping => %p %s %p | OK", self, tuid2str(iid), iface);

  2912.             *iface = self;

  2913.             return V3_OK;

  2914.         }

  2915. 

  2916.         d_stdout("query_interface_midi_mapping => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  2917. 

  2918.         *iface = nullptr;

  2919.         return V3_NO_INTERFACE;

  2920.     }

  2921. 

  2922.     // ----------------------------------------------------------------------------------------------------------------

  2923.     // v3_midi_mapping

  2924. 

  2925.     static v3_result V3_API get_midi_controller_assignment(void*, const int32_t bus, const int16_t channel, const int16_t cc, v3_param_id* const id)

  2926.     {

  2927.         DISTRHO_SAFE_ASSERT_INT_RETURN(bus == 0, bus, V3_FALSE);

  2928.         DISTRHO_SAFE_ASSERT_INT_RETURN(channel >= 0 && channel < 16, channel, V3_FALSE);

  2929.         DISTRHO_SAFE_ASSERT_INT_RETURN(cc >= 0 && cc < 130, cc, V3_FALSE);

  2930. 

  2931.         *id = kVst3InternalParameterMidiCC_start + channel * 130 + cc;

  2932.         return V3_TRUE;

  2933.     }

  2934. 

  2935.     DISTRHO_PREVENT_HEAP_ALLOCATION

  2936. };

  2937. #endif // DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2938. 

  2939. // --------------------------------------------------------------------------------------------------------------------

  2940. // dpf_edit_controller

  2941. 

  2942. struct dpf_edit_controller : v3_edit_controller_cpp {

  2943.     std::atomic_int refcounter;

  2944. #if DISTRHO_PLUGIN_HAS_UI

  2945.     ScopedPointer<dpf_ctrl2view_connection_point> connectionCtrl2View;

  2946. #endif

  2947. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  2948.     ScopedPointer<dpf_comp2ctrl_connection_point> connectionComp2Ctrl;

  2949.     ScopedPointer<PluginVst3> vst3;

  2950. #else

  2951.     ScopedPointer<PluginVst3>& vst3;

  2952.     bool initialized;

  2953. #endif

  2954.     // cached values

  2955.     v3_component_handler** handler;

  2956.     v3_host_application** const hostApplicationFromFactory;

  2957.     v3_host_application** hostApplicationFromInitialize;

  2958. 

  2959. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  2960.     dpf_edit_controller(v3_host_application** const host)

  2961.         : refcounter(1),

  2962.           vst3(nullptr),

  2963. #else

  2964.     dpf_edit_controller(ScopedPointer<PluginVst3>& v, v3_host_application** const host)

  2965.         : refcounter(1),

  2966.           vst3(v),

  2967.           initialized(false),

  2968. #endif

  2969.           handler(nullptr),

  2970.           hostApplicationFromFactory(host),

  2971.           hostApplicationFromInitialize(nullptr)

  2972.     {

  2973.         d_stdout("dpf_edit_controller() with hostApplication %p", hostApplicationFromFactory);

  2974. 

  2975.         // make sure host application is valid through out this controller lifetime

  2976.         if (hostApplicationFromFactory != nullptr)

  2977.             v3_cpp_obj_ref(hostApplicationFromFactory);

  2978. 

  2979.         // v3_funknown, everything custom

  2980.         query_interface = query_interface_edit_controller;

  2981.         ref = ref_edit_controller;

  2982.         unref = unref_edit_controller;

  2983. 

  2984.         // v3_plugin_base

  2985.         base.initialize = initialize;

  2986.         base.terminate = terminate;

  2987. 

  2988.         // v3_edit_controller

  2989.         ctrl.set_component_state = set_component_state;

  2990.         ctrl.set_state = set_state;

  2991.         ctrl.get_state = get_state;

  2992.         ctrl.get_parameter_count = get_parameter_count;

  2993.         ctrl.get_parameter_info = get_parameter_info;

  2994.         ctrl.get_parameter_string_for_value = get_parameter_string_for_value;

  2995.         ctrl.get_parameter_value_for_string = get_parameter_value_for_string;

  2996.         ctrl.normalised_parameter_to_plain = normalised_parameter_to_plain;

  2997.         ctrl.plain_parameter_to_normalised = plain_parameter_to_normalised;

  2998.         ctrl.get_parameter_normalised = get_parameter_normalised;

  2999.         ctrl.set_parameter_normalised = set_parameter_normalised;

  3000.         ctrl.set_component_handler = set_component_handler;

  3001.         ctrl.create_view = create_view;

  3002.     }

  3003. 

  3004.     ~dpf_edit_controller()

  3005.     {

  3006.         d_stdout("~dpf_edit_controller()");

  3007. #if DISTRHO_PLUGIN_HAS_UI

  3008.         connectionCtrl2View = nullptr;

  3009. #endif

  3010. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3011.         connectionComp2Ctrl = nullptr;

  3012.         vst3 = nullptr;

  3013. #endif

  3014. 

  3015.         if (hostApplicationFromFactory != nullptr)

  3016.             v3_cpp_obj_unref(hostApplicationFromFactory);

  3017.     }

  3018. 

  3019.     // ----------------------------------------------------------------------------------------------------------------

  3020.     // v3_funknown

  3021. 

  3022.     static v3_result V3_API query_interface_edit_controller(void* const self, const v3_tuid iid, void** const iface)

  3023.     {

  3024.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3025. 

  3026.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  3027.             v3_tuid_match(iid, v3_plugin_base_iid) ||

  3028.             v3_tuid_match(iid, v3_edit_controller_iid))

  3029.         {

  3030.             d_stdout("query_interface_edit_controller => %p %s %p | OK", self, tuid2str(iid), iface);

  3031.             ++controller->refcounter;

  3032.             *iface = self;

  3033.             return V3_OK;

  3034.         }

  3035. 

  3036. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  3037.         if (v3_tuid_match(iid, v3_midi_mapping_iid))

  3038.         {

  3039.             d_stdout("query_interface_edit_controller => %p %s %p | OK convert static", self, tuid2str(iid), iface);

  3040.             static dpf_midi_mapping midi_mapping;

  3041.             static dpf_midi_mapping* midi_mapping_ptr = &midi_mapping;

  3042.             *iface = &midi_mapping_ptr;

  3043.             return V3_OK;

  3044.         }

  3045. #endif

  3046. 

  3047. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3048.         if (v3_tuid_match(iid, v3_connection_point_iid))

  3049.         {

  3050.             d_stdout("query_interface_edit_controller => %p %s %p | OK convert %p",

  3051.                      self, tuid2str(iid), iface, controller->connectionComp2Ctrl.get());

  3052. 

  3053.             if (controller->connectionComp2Ctrl == nullptr)

  3054.                 controller->connectionComp2Ctrl = new dpf_comp2ctrl_connection_point(controller->vst3);

  3055.             else

  3056.                 ++controller->connectionComp2Ctrl->refcounter;

  3057.             *iface = &controller->connectionComp2Ctrl;

  3058.             return V3_OK;

  3059.         }

  3060. #endif

  3061. 

  3062.         d_stdout("query_interface_edit_controller => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  3063. 

  3064.         *iface = nullptr;

  3065.         return V3_NO_INTERFACE;

  3066.     }

  3067. 

  3068.     static uint32_t V3_API ref_edit_controller(void* const self)

  3069.     {

  3070.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3071.         const int refcount = ++controller->refcounter;

  3072.         d_stdout("dpf_edit_controller::ref => %p | refcount %i", self, refcount);

  3073.         return refcount;

  3074.     }

  3075. 

  3076.     static uint32_t V3_API unref_edit_controller(void* const self)

  3077.     {

  3078.         dpf_edit_controller** const controllerptr = static_cast<dpf_edit_controller**>(self);

  3079.         dpf_edit_controller* const controller = *controllerptr;

  3080. 

  3081.         if (const int refcount = --controller->refcounter)

  3082.         {

  3083.             d_stdout("dpf_edit_controller::unref => %p | refcount %i", self, refcount);

  3084.             return refcount;

  3085.         }

  3086. 

  3087. #if DISTRHO_PLUGIN_HAS_UI

  3088.         if (dpf_ctrl2view_connection_point* const point = controller->connectionCtrl2View)

  3089.         {

  3090.             if (const int refcount = point->refcounter)

  3091.             {

  3092.                 d_stderr("DPF warning: asked to delete controller while view connection point still active (refcount %d)", refcount);

  3093.             }

  3094.         }

  3095. #endif

  3096. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3097.         if (dpf_comp2ctrl_connection_point* const point = controller->connectionComp2Ctrl)

  3098.         {

  3099.             if (const int refcount = point->refcounter)

  3100.             {

  3101.                 d_stderr("DPF warning: asked to delete controller while component connection point still active (refcount %d)", refcount);

  3102.             }

  3103.         }

  3104. #endif

  3105. 

  3106.         d_stdout("dpf_edit_controller::unref => %p | refcount is zero, deleting everything now!", self);

  3107. 

  3108.         delete controller;

  3109.         delete controllerptr;

  3110.         return 0;

  3111.     }

  3112. 

  3113.     // ----------------------------------------------------------------------------------------------------------------

  3114.     // v3_plugin_base

  3115. 

  3116.     static v3_result V3_API initialize(void* const self, v3_plugin_base::v3_funknown** const context)

  3117.     {

  3118.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3119. 

  3120.         // check if already initialized

  3121. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3122.         DISTRHO_SAFE_ASSERT_RETURN(controller->vst3 == nullptr, V3_INVALID_ARG);

  3123. #else

  3124.         DISTRHO_SAFE_ASSERT_RETURN(! controller->initialized, V3_INVALID_ARG);

  3125. #endif

  3126. 

  3127.         // query for host application

  3128.         v3_host_application** hostApplication = nullptr;

  3129.         if (context != nullptr)

  3130.             v3_cpp_obj_query_interface(context, v3_host_application_iid, &hostApplication);

  3131. 

  3132.         d_stdout("dpf_edit_controller::initialize => %p %p | host %p", self, context, hostApplication);

  3133. 

  3134.         // save it for later so we can unref it

  3135.         controller->hostApplicationFromInitialize = hostApplication;

  3136. 

  3137. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3138.         // provide the factory application to the plugin if this new one is missing

  3139.         if (hostApplication == nullptr)

  3140.             hostApplication = controller->hostApplicationFromFactory;

  3141. 

  3142.         // default early values

  3143.         if (d_nextBufferSize == 0)

  3144.             d_nextBufferSize = 1024;

  3145.         if (d_nextSampleRate <= 0.0)

  3146.             d_nextSampleRate = 44100.0;

  3147. 

  3148.         d_nextCanRequestParameterValueChanges = true;

  3149. 

  3150.         // create the actual plugin

  3151.         controller->vst3 = new PluginVst3(hostApplication);

  3152. 

  3153.         // set connection point if needed

  3154.         if (dpf_comp2ctrl_connection_point* const point = controller->connectionComp2Ctrl)

  3155.         {

  3156.             if (point->other != nullptr)

  3157.                 controller->vst3->comp2ctrl_connect(point->other);

  3158.         }

  3159. #else

  3160.         // mark as initialized

  3161.         controller->initialized = true;

  3162. #endif

  3163. 

  3164.         return V3_OK;

  3165.     }

  3166. 

  3167.     static v3_result V3_API terminate(void* self)

  3168.     {

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

  3170.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3171. 

  3172. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3173.         // check if already terminated

  3174.         DISTRHO_SAFE_ASSERT_RETURN(controller->vst3 != nullptr, V3_INVALID_ARG);

  3175. 

  3176.         // delete actual plugin

  3177.         controller->vst3 = nullptr;

  3178. #else

  3179.         // check if already terminated

  3180.         DISTRHO_SAFE_ASSERT_RETURN(controller->initialized, V3_INVALID_ARG);

  3181. 

  3182.         // mark as uninitialzed

  3183.         controller->initialized = false;

  3184. #endif

  3185. 

  3186.         // unref host application received during initialize

  3187.         if (controller->hostApplicationFromInitialize != nullptr)

  3188.         {

  3189.             v3_cpp_obj_unref(controller->hostApplicationFromInitialize);

  3190.             controller->hostApplicationFromInitialize = nullptr;

  3191.         }

  3192. 

  3193.         return V3_OK;

  3194.     }

  3195. 

  3196.     // ----------------------------------------------------------------------------------------------------------------

  3197.     // v3_edit_controller

  3198. 

  3199.     static v3_result V3_API set_component_state(void* const self, v3_bstream** const stream)

  3200.     {

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

  3202. 

  3203. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3204.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3205. 

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

  3207.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3208. 

  3209.         return vst3->setState(stream);

  3210. #else

  3211.         return V3_OK;

  3212. 

  3213.         // unused

  3214.         (void)self;

  3215.         (void)stream;

  3216. #endif

  3217.     }

  3218. 

  3219.     static v3_result V3_API set_state(void* const self, v3_bstream** const stream)

  3220.     {

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

  3222.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3223. 

  3224. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3225.         DISTRHO_SAFE_ASSERT_RETURN(controller->vst3 != nullptr, V3_NOT_INITIALIZED);

  3226. #else

  3227.         DISTRHO_SAFE_ASSERT_RETURN(controller->initialized, V3_INVALID_ARG);

  3228. #endif

  3229. 

  3230.         return V3_NOT_IMPLEMENTED;

  3231. 

  3232.         // unused

  3233.         (void)stream;

  3234.     }

  3235. 

  3236.     static v3_result V3_API get_state(void* const self, v3_bstream** const stream)

  3237.     {

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

  3239.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3240. 

  3241. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3242.         DISTRHO_SAFE_ASSERT_RETURN(controller->vst3 != nullptr, V3_NOT_INITIALIZED);

  3243. #else

  3244.         DISTRHO_SAFE_ASSERT_RETURN(controller->initialized, V3_INVALID_ARG);

  3245. #endif

  3246. 

  3247.         return V3_NOT_IMPLEMENTED;

  3248. 

  3249.         // unused

  3250.         (void)stream;

  3251.     }

  3252. 

  3253.     static int32_t V3_API get_parameter_count(void* self)

  3254.     {

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

  3256.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3257. 

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

  3259.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3260. 

  3261.         return vst3->getParameterCount();

  3262.     }

  3263. 

  3264.     static v3_result V3_API get_parameter_info(void* self, int32_t param_idx, v3_param_info* param_info)

  3265.     {

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

  3267.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3268. 

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

  3270.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3271. 

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

  3273.     }

  3274. 

  3275.     static v3_result V3_API get_parameter_string_for_value(void* self, v3_param_id index, double normalised, v3_str_128 output)

  3276.     {

  3277.         // NOTE very noisy, called many times

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

  3279.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3280. 

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

  3282.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3283. 

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

  3285.     }

  3286. 

  3287.     static v3_result V3_API get_parameter_value_for_string(void* self, v3_param_id index, int16_t* input, double* output)

  3288.     {

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

  3290.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3291. 

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

  3293.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3294. 

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

  3296.     }

  3297. 

  3298.     static double V3_API normalised_parameter_to_plain(void* self, v3_param_id index, double normalised)

  3299.     {

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

  3301.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3302. 

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

  3304.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3305. 

  3306.         return vst3->normalizedParameterToPlain(index, normalised);

  3307.     }

  3308. 

  3309.     static double V3_API plain_parameter_to_normalised(void* self, v3_param_id index, double plain)

  3310.     {

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

  3312.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3313. 

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

  3315.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3316. 

  3317.         return vst3->plainParameterToNormalized(index, plain);

  3318.     }

  3319. 

  3320.     static double V3_API get_parameter_normalised(void* self, v3_param_id index)

  3321.     {

  3322.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3323. 

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

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

  3326. 

  3327.         return vst3->getParameterNormalized(index);

  3328.     }

  3329. 

  3330.     static v3_result V3_API set_parameter_normalised(void* const self, const v3_param_id index, const double normalised)

  3331.     {

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

  3333.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3334. 

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

  3336.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3337. 

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

  3339.     }

  3340. 

  3341.     static v3_result V3_API set_component_handler(void* self, v3_component_handler** handler)

  3342.     {

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

  3344.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3345. 

  3346.         controller->handler = handler;

  3347. 

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

  3349.             return vst3->setComponentHandler(handler);

  3350. 

  3351.         return V3_NOT_INITIALIZED;

  3352.     }

  3353. 

  3354.     static v3_plugin_view** V3_API create_view(void* self, const char* name)

  3355.     {

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

  3357.         dpf_edit_controller* const controller = *static_cast<dpf_edit_controller**>(self);

  3358. 

  3359.         d_stdout("create_view has contexts %p %p",

  3360.                  controller->hostApplicationFromFactory, controller->hostApplicationFromInitialize);

  3361. 

  3362. #if DISTRHO_PLUGIN_HAS_UI

  3363.         // plugin must be initialized

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

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

  3366. 

  3367.         d_stdout("dpf_edit_controller::create_view => %p %s | edit-ctrl %p, factory %p",

  3368.                  self, name,

  3369.                  controller->hostApplicationFromInitialize,

  3370.                  controller->hostApplicationFromFactory);

  3371. 

  3372.         // we require a host application for message creation

  3373.         v3_host_application** const host = controller->hostApplicationFromInitialize != nullptr

  3374.                                          ? controller->hostApplicationFromInitialize

  3375.                                          : controller->hostApplicationFromFactory;

  3376.         DISTRHO_SAFE_ASSERT_RETURN(host != nullptr, nullptr);

  3377. 

  3378.         v3_plugin_view** const view = dpf_plugin_view_create(host,

  3379.                                                              vst3->getInstancePointer(),

  3380.                                                              vst3->getSampleRate());

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

  3382. 

  3383.         v3_connection_point** uiconn = nullptr;

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

  3385.         {

  3386.             d_stdout("view connection query ok %p", uiconn);

  3387.             controller->connectionCtrl2View = new dpf_ctrl2view_connection_point(controller->vst3);

  3388. 

  3389.             v3_connection_point** const ctrlconn = (v3_connection_point**)&controller->connectionCtrl2View;

  3390. 

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

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

  3393.         }

  3394.         else

  3395.         {

  3396.             controller->connectionCtrl2View = nullptr;

  3397.         }

  3398. 

  3399.         return view;

  3400. #else

  3401.         return nullptr;

  3402. #endif

  3403.     }

  3404. };

  3405. 

  3406. // --------------------------------------------------------------------------------------------------------------------

  3407. // dpf_process_context_requirements

  3408. 

  3409. struct dpf_process_context_requirements : v3_process_context_requirements_cpp {

  3410.     dpf_process_context_requirements()

  3411.     {

  3412.         // v3_funknown, static

  3413.         query_interface = query_interface_process_context_requirements;

  3414.         ref = dpf_static_ref;

  3415.         unref = dpf_static_unref;

  3416. 

  3417.         // v3_process_context_requirements

  3418.         req.get_process_context_requirements = get_process_context_requirements;

  3419.     }

  3420. 

  3421.     // ----------------------------------------------------------------------------------------------------------------

  3422.     // v3_funknown

  3423. 

  3424.     static v3_result V3_API query_interface_process_context_requirements(void* const self, const v3_tuid iid, void** const iface)

  3425.     {

  3426.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  3427.             v3_tuid_match(iid, v3_process_context_requirements_iid))

  3428.         {

  3429.             d_stdout("query_interface_process_context_requirements => %p %s %p | OK", self, tuid2str(iid), iface);

  3430.             *iface = self;

  3431.             return V3_OK;

  3432.         }

  3433. 

  3434.         d_stdout("query_interface_process_context_requirements => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  3435. 

  3436.         *iface = nullptr;

  3437.         return V3_NO_INTERFACE;

  3438.     }

  3439. 

  3440.     // ----------------------------------------------------------------------------------------------------------------

  3441.     // v3_process_context_requirements

  3442. 

  3443.     static uint32_t V3_API get_process_context_requirements(void*)

  3444.     {

  3445. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  3446.         return 0x0

  3447.             | V3_PROCESS_CTX_NEED_CONTINUOUS_TIME  // V3_PROCESS_CTX_CONT_TIME_VALID

  3448.             | V3_PROCESS_CTX_NEED_PROJECT_TIME     // V3_PROCESS_CTX_PROJECT_TIME_VALID

  3449.             | V3_PROCESS_CTX_NEED_TEMPO            // V3_PROCESS_CTX_TEMPO_VALID

  3450.             | V3_PROCESS_CTX_NEED_TIME_SIG         // V3_PROCESS_CTX_TIME_SIG_VALID

  3451.             | V3_PROCESS_CTX_NEED_TRANSPORT_STATE; // V3_PROCESS_CTX_PLAYING

  3452. #else

  3453.         return 0x0;

  3454. #endif

  3455.     }

  3456. 

  3457.     DISTRHO_PREVENT_HEAP_ALLOCATION

  3458. };

  3459. 

  3460. // --------------------------------------------------------------------------------------------------------------------

  3461. // dpf_audio_processor

  3462. 

  3463. struct dpf_audio_processor : v3_audio_processor_cpp {

  3464.     std::atomic_int refcounter;

  3465.     ScopedPointer<PluginVst3>& vst3;

  3466. 

  3467.     dpf_audio_processor(ScopedPointer<PluginVst3>& v)

  3468.         : refcounter(1),

  3469.           vst3(v)

  3470.     {

  3471.         // v3_funknown, single instance

  3472.         query_interface = query_interface_audio_processor;

  3473.         ref = dpf_single_instance_ref<dpf_audio_processor>;

  3474.         unref = dpf_single_instance_unref<dpf_audio_processor>;

  3475. 

  3476.         // v3_audio_processor

  3477.         proc.set_bus_arrangements = set_bus_arrangements;

  3478.         proc.get_bus_arrangement = get_bus_arrangement;

  3479.         proc.can_process_sample_size = can_process_sample_size;

  3480.         proc.get_latency_samples = get_latency_samples;

  3481.         proc.setup_processing = setup_processing;

  3482.         proc.set_processing = set_processing;

  3483.         proc.process = process;

  3484.         proc.get_tail_samples = get_tail_samples;

  3485.     }

  3486. 

  3487.     // ----------------------------------------------------------------------------------------------------------------

  3488.     // v3_funknown

  3489. 

  3490.     static v3_result V3_API query_interface_audio_processor(void* const self, const v3_tuid iid, void** const iface)

  3491.     {

  3492.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3493. 

  3494.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  3495.             v3_tuid_match(iid, v3_audio_processor_iid))

  3496.         {

  3497.             d_stdout("query_interface_audio_processor => %p %s %p | OK", self, tuid2str(iid), iface);

  3498.             ++processor->refcounter;

  3499.             *iface = self;

  3500.             return V3_OK;

  3501.         }

  3502. 

  3503.         if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  3504.         {

  3505.             d_stdout("query_interface_audio_processor => %p %s %p | OK convert static", self, tuid2str(iid), iface);

  3506.             static dpf_process_context_requirements context_req;

  3507.             static dpf_process_context_requirements* context_req_ptr = &context_req;

  3508.             *iface = &context_req_ptr;

  3509.             return V3_OK;

  3510.         }

  3511. 

  3512.         d_stdout("query_interface_audio_processor => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  3513. 

  3514.         *iface = nullptr;

  3515.         return V3_NO_INTERFACE;

  3516.     }

  3517. 

  3518.     // ----------------------------------------------------------------------------------------------------------------

  3519.     // v3_audio_processor

  3520. 

  3521.     static v3_result V3_API set_bus_arrangements(void* const self,

  3522.                                                  v3_speaker_arrangement* const inputs, const int32_t num_inputs,

  3523.                                                  v3_speaker_arrangement* const outputs, const int32_t num_outputs)

  3524.     {

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

  3526.         // d_stdout("dpf_audio_processor::set_bus_arrangements => %p %p %i %p %i",

  3527.         //          self, inputs, num_inputs, outputs, num_outputs);

  3528.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3529. 

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

  3531.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3532. 

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

  3534.     }

  3535. 

  3536.     static v3_result V3_API get_bus_arrangement(void* const self, const int32_t bus_direction,

  3537.                                                 const int32_t idx, v3_speaker_arrangement* const arr)

  3538.     {

  3539.         d_stdout("dpf_audio_processor::get_bus_arrangement => %p %s %p",

  3540.                  self, v3_bus_direction_str(bus_direction), idx, arr);

  3541.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3542. 

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

  3544.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3545. 

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

  3547.     }

  3548. 

  3549.     static v3_result V3_API can_process_sample_size(void*, const int32_t symbolic_sample_size)

  3550.     {

  3551.         // NOTE runs during RT

  3552.         // d_stdout("dpf_audio_processor::can_process_sample_size => %i", symbolic_sample_size);

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

  3554.     }

  3555. 

  3556.     static uint32_t V3_API get_latency_samples(void* const self)

  3557.     {

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

  3559.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3560. 

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

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

  3563. 

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

  3565.     }

  3566. 

  3567.     static v3_result V3_API setup_processing(void* const self, v3_process_setup* const setup)

  3568.     {

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

  3570.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3571. 

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

  3573.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3574. 

  3575.         d_nextBufferSize = setup->max_block_size;

  3576.         d_nextSampleRate = setup->sample_rate;

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

  3578.     }

  3579. 

  3580.     static v3_result V3_API set_processing(void* const self, const v3_bool state)

  3581.     {

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

  3583.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3584. 

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

  3586.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3587. 

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

  3589.     }

  3590. 

  3591.     static v3_result V3_API process(void* const self, v3_process_data* const data)

  3592.     {

  3593.         // NOTE runs during RT

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

  3595.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3596. 

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

  3598.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3599. 

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

  3601.     }

  3602. 

  3603.     static uint32_t V3_API get_tail_samples(void* const self)

  3604.     {

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

  3606.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3607. 

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

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

  3610. 

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

  3612.     }

  3613. };

  3614. 

  3615. // --------------------------------------------------------------------------------------------------------------------

  3616. // Store components that we can't delete properly, to be cleaned up on module unload

  3617. 

  3618. struct dpf_component;

  3619. 

  3620. std::vector<dpf_component**> gComponentGarbage;

  3621. 

  3622. static v3_result handleUncleanComponent(dpf_component** const componentptr)

  3623. {

  3624.     gComponentGarbage.push_back(componentptr);

  3625.     return V3_INVALID_ARG;

  3626. }

  3627. 

  3628. // --------------------------------------------------------------------------------------------------------------------

  3629. // dpf_component

  3630. 

  3631. struct dpf_component : v3_component_cpp {

  3632.     std::atomic_int refcounter;

  3633.     ScopedPointer<dpf_audio_processor> processor;

  3634. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3635.     ScopedPointer<dpf_comp2ctrl_connection_point> connectionComp2Ctrl;

  3636. #else

  3637.     ScopedPointer<dpf_edit_controller> controller;

  3638. #endif

  3639.     ScopedPointer<PluginVst3> vst3;

  3640.     v3_host_application** const hostApplicationFromFactory;

  3641.     v3_host_application** hostApplicationFromInitialize;

  3642. 

  3643.     dpf_component(v3_host_application** const host)

  3644.         : refcounter(1),

  3645.           hostApplicationFromFactory(host),

  3646.           hostApplicationFromInitialize(nullptr)

  3647.     {

  3648.         d_stdout("dpf_component() with hostApplication %p", hostApplicationFromFactory);

  3649. 

  3650.         // make sure host application is valid through out this component lifetime

  3651.         if (hostApplicationFromFactory != nullptr)

  3652.             v3_cpp_obj_ref(hostApplicationFromFactory);

  3653. 

  3654.         // v3_funknown, everything custom

  3655.         query_interface = query_interface_component;

  3656.         ref = ref_component;

  3657.         unref = unref_component;

  3658. 

  3659.         // v3_plugin_base

  3660.         base.initialize = initialize;

  3661.         base.terminate = terminate;

  3662. 

  3663.         // v3_component

  3664.         comp.get_controller_class_id = get_controller_class_id;

  3665.         comp.set_io_mode = set_io_mode;

  3666.         comp.get_bus_count = get_bus_count;

  3667.         comp.get_bus_info = get_bus_info;

  3668.         comp.get_routing_info = get_routing_info;

  3669.         comp.activate_bus = activate_bus;

  3670.         comp.set_active = set_active;

  3671.         comp.set_state = set_state;

  3672.         comp.get_state = get_state;

  3673.     }

  3674. 

  3675.     ~dpf_component()

  3676.     {

  3677.         d_stdout("~dpf_component()");

  3678.         processor = nullptr;

  3679. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3680.         connectionComp2Ctrl = nullptr;

  3681. #else

  3682.         controller = nullptr;

  3683. #endif

  3684.         vst3 = nullptr;

  3685. 

  3686.         if (hostApplicationFromFactory != nullptr)

  3687.             v3_cpp_obj_unref(hostApplicationFromFactory);

  3688.     }

  3689. 

  3690.     // ----------------------------------------------------------------------------------------------------------------

  3691.     // v3_funknown

  3692. 

  3693.     static v3_result V3_API query_interface_component(void* const self, const v3_tuid iid, void** const iface)

  3694.     {

  3695.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3696. 

  3697.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  3698.             v3_tuid_match(iid, v3_plugin_base_iid) ||

  3699.             v3_tuid_match(iid, v3_component_iid))

  3700.         {

  3701.             d_stdout("query_interface_component => %p %s %p | OK", self, tuid2str(iid), iface);

  3702.             ++component->refcounter;

  3703.             *iface = self;

  3704.             return V3_OK;

  3705.         }

  3706. 

  3707. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  3708.         if (v3_tuid_match(iid, v3_midi_mapping_iid))

  3709.         {

  3710.             d_stdout("query_interface_component => %p %s %p | OK convert static", self, tuid2str(iid), iface);

  3711.             static dpf_midi_mapping midi_mapping;

  3712.             static dpf_midi_mapping* midi_mapping_ptr = &midi_mapping;

  3713.             *iface = &midi_mapping_ptr;

  3714.             return V3_OK;

  3715.         }

  3716. #endif

  3717. 

  3718.         if (v3_tuid_match(iid, v3_audio_processor_iid))

  3719.         {

  3720.             d_stdout("query_interface_component => %p %s %p | OK convert %p",

  3721.                      self, tuid2str(iid), iface, component->processor.get());

  3722. 

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

  3724.                 component->processor = new dpf_audio_processor(component->vst3);

  3725.             else

  3726.                 ++component->processor->refcounter;

  3727.             *iface = &component->processor;

  3728.             return V3_OK;

  3729.         }

  3730. 

  3731. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3732.         if (v3_tuid_match(iid, v3_connection_point_iid))

  3733.         {

  3734.             d_stdout("query_interface_component => %p %s %p | OK convert %p",

  3735.                      self, tuid2str(iid), iface, component->connectionComp2Ctrl.get());

  3736. 

  3737.             if (component->connectionComp2Ctrl == nullptr)

  3738.                 component->connectionComp2Ctrl = new dpf_comp2ctrl_connection_point(component->vst3);

  3739.             else

  3740.                 ++component->connectionComp2Ctrl->refcounter;

  3741.             *iface = &component->connectionComp2Ctrl;

  3742.             return V3_OK;

  3743.         }

  3744. #else

  3745.         if (v3_tuid_match(iid, v3_edit_controller_iid))

  3746.         {

  3747.             d_stdout("query_interface_component => %p %s %p | OK convert %p",

  3748.                      self, tuid2str(iid), iface, component->controller.get());

  3749. 

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

  3751.                 component->controller = new dpf_edit_controller(component->vst3,

  3752.                                                                 component->hostApplicationFromFactory);

  3753.             else

  3754.                 ++component->controller->refcounter;

  3755.             *iface = &component->controller;

  3756.             return V3_OK;

  3757.         }

  3758. #endif

  3759. 

  3760.         d_stdout("query_interface_component => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  3761. 

  3762.         *iface = nullptr;

  3763.         return V3_NO_INTERFACE;

  3764.     }

  3765. 

  3766.     static uint32_t V3_API ref_component(void* const self)

  3767.     {

  3768.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3769.         const int refcount = ++component->refcounter;

  3770.         d_stdout("dpf_component::ref => %p | refcount %i", self, refcount);

  3771.         return refcount;

  3772.     }

  3773. 

  3774.     static uint32_t V3_API unref_component(void* const self)

  3775.     {

  3776.         dpf_component** const componentptr = static_cast<dpf_component**>(self);

  3777.         dpf_component* const component = *componentptr;

  3778. 

  3779.         if (const int refcount = --component->refcounter)

  3780.         {

  3781.             d_stdout("dpf_component::unref => %p | refcount %i", self, refcount);

  3782.             return refcount;

  3783.         }

  3784. 

  3785.         /**

  3786.          * Some hosts will have unclean instances of a few of the component child classes at this point.

  3787.          * We check for those here, going through the whole possible chain to see if it is safe to delete.

  3788.          * If not, we add this component to the `gComponentGarbage` global which will take care of it during unload.

  3789.          */

  3790. 

  3791.         bool unclean = false;

  3792.         if (dpf_audio_processor* const proc = component->processor)

  3793.         {

  3794.             if (const int refcount = proc->refcounter)

  3795.             {

  3796.                 unclean = true;

  3797.                 d_stderr("DPF warning: asked to delete component while audio processor still active (refcount %d)", refcount);

  3798.             }

  3799.         }

  3800. 

  3801. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3802.         if (dpf_comp2ctrl_connection_point* const point = component->connectionComp2Ctrl)

  3803.         {

  3804.             if (const int refcount = point->refcounter)

  3805.             {

  3806.                 unclean = true;

  3807.                 d_stderr("DPF warning: asked to delete component while connection point still active (refcount %d)", refcount);

  3808.             }

  3809.         }

  3810. #else

  3811.         if (dpf_edit_controller* const controller = component->controller)

  3812.         {

  3813.             if (const int refcount = controller->refcounter)

  3814.             {

  3815.                 unclean = true;

  3816.                 d_stderr("DPF warning: asked to delete component while edit controller still active (refcount %d)", refcount);

  3817.             }

  3818. 

  3819. # if DISTRHO_PLUGIN_HAS_UI

  3820.             if (dpf_dsp_connection_point* const controller = ctrl->connectionCtrl2View)

  3821.             {

  3822.                 if (const int refcount = controller->refcounter)

  3823.                 {

  3824.                     unclean = true;

  3825.                     d_stderr("DPF warning: asked to delete component while view connection point still active (refcount %d)", refcount);

  3826.                 }

  3827.             }

  3828. # endif

  3829.         }

  3830. #endif

  3831. 

  3832.         if (unclean)

  3833.             return handleUncleanComponent(componentptr);

  3834. 

  3835.         d_stdout("dpf_component::unref => %p | refcount is zero, deleting everything now!", self);

  3836. 

  3837.         delete component;

  3838.         delete componentptr;

  3839.         return 0;

  3840.     }

  3841. 

  3842.     // ----------------------------------------------------------------------------------------------------------------

  3843.     // v3_plugin_base

  3844. 

  3845.     static v3_result V3_API initialize(void* const self, v3_plugin_base::v3_funknown** const context)

  3846.     {

  3847.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3848. 

  3849.         // check if already initialized

  3850.         DISTRHO_SAFE_ASSERT_RETURN(component->vst3 == nullptr, V3_INVALID_ARG);

  3851. 

  3852.         // query for host application

  3853.         v3_host_application** hostApplication = nullptr;

  3854.         if (context != nullptr)

  3855.             v3_cpp_obj_query_interface(context, v3_host_application_iid, &hostApplication);

  3856. 

  3857.         d_stdout("dpf_component::initialize => %p %p | hostApplication %p", self, context, hostApplication);

  3858. 

  3859.         // save it for later so we can unref it

  3860.         component->hostApplicationFromInitialize = hostApplication;

  3861. 

  3862.         // provide the factory application to the plugin if this new one is missing

  3863.         if (hostApplication == nullptr)

  3864.             hostApplication = component->hostApplicationFromFactory;

  3865. 

  3866.         // default early values

  3867.         if (d_nextBufferSize == 0)

  3868.             d_nextBufferSize = 1024;

  3869.         if (d_nextSampleRate <= 0.0)

  3870.             d_nextSampleRate = 44100.0;

  3871. 

  3872.         d_nextCanRequestParameterValueChanges = true;

  3873. 

  3874.         // create the actual plugin

  3875.         component->vst3 = new PluginVst3(hostApplication);

  3876. 

  3877.        #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  3878.         // set connection point if needed

  3879.         if (dpf_comp2ctrl_connection_point* const point = component->connectionComp2Ctrl)

  3880.         {

  3881.             if (point->other != nullptr)

  3882.                 component->vst3->comp2ctrl_connect(point->other);

  3883.         }

  3884.        #endif

  3885. 

  3886.         return V3_OK;

  3887.     }

  3888. 

  3889.     static v3_result V3_API terminate(void* const self)

  3890.     {

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

  3892.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3893. 

  3894.         // check if already terminated

  3895.         DISTRHO_SAFE_ASSERT_RETURN(component->vst3 != nullptr, V3_INVALID_ARG);

  3896. 

  3897.         // delete actual plugin

  3898.         component->vst3 = nullptr;

  3899. 

  3900.         // unref host application received during initialize

  3901.         if (component->hostApplicationFromInitialize != nullptr)

  3902.         {

  3903.             v3_cpp_obj_unref(component->hostApplicationFromInitialize);

  3904.             component->hostApplicationFromInitialize = nullptr;

  3905.         }

  3906. 

  3907.         return V3_OK;

  3908.     }

  3909. 

  3910.     // ----------------------------------------------------------------------------------------------------------------

  3911.     // v3_component

  3912. 

  3913.     static v3_result V3_API get_controller_class_id(void*, v3_tuid class_id)

  3914.     {

  3915.         d_stdout("dpf_component::get_controller_class_id => %p", class_id);

  3916. 

  3917.         std::memcpy(class_id, dpf_tuid_controller, sizeof(v3_tuid));

  3918.         return V3_OK;

  3919.     }

  3920. 

  3921.     static v3_result V3_API set_io_mode(void* const self, const int32_t io_mode)

  3922.     {

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

  3924. 

  3925.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3926. 

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

  3928.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3929. 

  3930.         // TODO

  3931.         return V3_NOT_IMPLEMENTED;

  3932.     }

  3933. 

  3934.     static int32_t V3_API get_bus_count(void* const self, const int32_t media_type, const int32_t bus_direction)

  3935.     {

  3936.         // NOTE runs during RT

  3937.         // d_stdout("dpf_component::get_bus_count => %p %s %s",

  3938.         //          self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction));

  3939.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3940. 

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

  3942.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3943. 

  3944.         const int32_t ret = vst3->getBusCount(media_type, bus_direction);

  3945.         // d_stdout("dpf_component::get_bus_count returns %i", ret);

  3946.         return ret;

  3947.     }

  3948. 

  3949.     static v3_result V3_API get_bus_info(void* const self, const int32_t media_type, const int32_t bus_direction,

  3950.                                          const int32_t bus_idx, v3_bus_info* const info)

  3951.     {

  3952.         d_stdout("dpf_component::get_bus_info => %p %s %s %i %p",

  3953.                  self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction), bus_idx, info);

  3954.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3955. 

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

  3957.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3958. 

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

  3960.     }

  3961. 

  3962.     static v3_result V3_API get_routing_info(void* const self, v3_routing_info* const input, v3_routing_info* const output)

  3963.     {

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

  3965.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3966. 

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

  3968.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3969. 

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

  3971.     }

  3972. 

  3973.     static v3_result V3_API activate_bus(void* const self, const int32_t media_type, const int32_t bus_direction,

  3974.                                          const int32_t bus_idx, const v3_bool state)

  3975.     {

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

  3977.         // d_stdout("dpf_component::activate_bus => %p %s %s %i %u",

  3978.         //          self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction), bus_idx, state);

  3979.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3980. 

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

  3982.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3983. 

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

  3985.     }

  3986. 

  3987.     static v3_result V3_API set_active(void* const self, const v3_bool state)

  3988.     {

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

  3990.         dpf_component* const component = *static_cast<dpf_component**>(self);

  3991. 

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

  3993.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  3994. 

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

  3996.     }

  3997. 

  3998.     static v3_result V3_API set_state(void* const self, v3_bstream** const stream)

  3999.     {

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

  4001.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4002. 

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

  4004.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4005. 

  4006.         return vst3->setState(stream);

  4007.     }

  4008. 

  4009.     static v3_result V3_API get_state(void* const self, v3_bstream** const stream)

  4010.     {

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

  4012.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4013. 

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

  4015.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4016. 

  4017.         return vst3->getState(stream);

  4018.     }

  4019. };

  4020. 

  4021. // --------------------------------------------------------------------------------------------------------------------

  4022. // Dummy plugin to get data from

  4023. 

  4024. static const PluginExporter& _getPluginInfo()

  4025. {

  4026.     d_nextBufferSize = 1024;

  4027.     d_nextSampleRate = 44100.0;

  4028.     d_nextPluginIsDummy = true;

  4029.     d_nextCanRequestParameterValueChanges = true;

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

  4031.     d_nextBufferSize = 0;

  4032.     d_nextSampleRate = 0.0;

  4033.     d_nextPluginIsDummy = false;

  4034.     d_nextCanRequestParameterValueChanges = false;

  4035. 

  4036.     return gPluginInfo;

  4037. }

  4038. 

  4039. static const PluginExporter& getPluginInfo()

  4040. {

  4041.     static const PluginExporter& info(_getPluginInfo());

  4042.     return info;

  4043. }

  4044. 

  4045. static const char* getPluginCategories()

  4046. {

  4047.     static String categories;

  4048.     static bool firstInit = true;

  4049. 

  4050.     if (firstInit)

  4051.     {

  4052. #ifdef DISTRHO_PLUGIN_VST3_CATEGORIES

  4053.         categories = DISTRHO_PLUGIN_VST3_CATEGORIES;

  4054. #elif DISTRHO_PLUGIN_IS_SYNTH

  4055.         categories = "Instrument";

  4056. #endif

  4057. #if (DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_INPUTS == 1) && DISTRHO_PLUGIN_NUM_OUTPUTS == 1

  4058.         if (categories.isNotEmpty())

  4059.             categories += "|";

  4060.         categories += "Mono";

  4061. #elif (DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_INPUTS == 2) && DISTRHO_PLUGIN_NUM_OUTPUTS == 2

  4062.         if (categories.isNotEmpty())

  4063.             categories += "|";

  4064.         categories += "Stereo";

  4065. #endif

  4066.         firstInit = false;

  4067.     }

  4068. 

  4069.     return categories.buffer();

  4070. }

  4071. 

  4072. static const char* getPluginVersion()

  4073. {

  4074.     static String version;

  4075. 

  4076.     if (version.isEmpty())

  4077.     {

  4078.         const uint32_t versionNum = getPluginInfo().getVersion();

  4079. 

  4080.         char versionBuf[64];

  4081.         snprintf(versionBuf, sizeof(versionBuf)-1, "%d.%d.%d",

  4082.                  (versionNum >> 16) & 0xff,

  4083.                  (versionNum >>  8) & 0xff,

  4084.                  (versionNum >>  0) & 0xff);

  4085.         versionBuf[sizeof(versionBuf)-1] = '\0';

  4086.         version = versionBuf;

  4087.     }

  4088. 

  4089.     return version.buffer();

  4090. }

  4091. 

  4092. // --------------------------------------------------------------------------------------------------------------------

  4093. // dpf_factory

  4094. 

  4095. struct dpf_factory : v3_plugin_factory_cpp {

  4096.     std::atomic_int refcounter;

  4097. 

  4098.     // cached values

  4099.     v3_funknown** hostContext;

  4100. 

  4101.     dpf_factory()

  4102.         : refcounter(1),

  4103.           hostContext(nullptr)

  4104.     {

  4105.         // v3_funknown, static

  4106.         query_interface = query_interface_factory;

  4107.         ref = ref_factory;

  4108.         unref = unref_factory;

  4109. 

  4110.         // v3_plugin_factory

  4111.         v1.get_factory_info = get_factory_info;

  4112.         v1.num_classes = num_classes;

  4113.         v1.get_class_info = get_class_info;

  4114.         v1.create_instance = create_instance;

  4115. 

  4116.         // v3_plugin_factory_2

  4117.         v2.get_class_info_2 = get_class_info_2;

  4118. 

  4119.         // v3_plugin_factory_3

  4120.         v3.get_class_info_utf16 = get_class_info_utf16;

  4121.         v3.set_host_context = set_host_context;

  4122.     }

  4123. 

  4124.     ~dpf_factory()

  4125.     {

  4126.         // unref old context if there is one

  4127.         if (hostContext != nullptr)

  4128.             v3_cpp_obj_unref(hostContext);

  4129. 

  4130.         if (gComponentGarbage.size() == 0)

  4131.             return;

  4132. 

  4133.         d_stdout("DPF notice: cleaning up previously undeleted components now");

  4134. 

  4135.         for (std::vector<dpf_component**>::iterator it = gComponentGarbage.begin();

  4136.             it != gComponentGarbage.end(); ++it)

  4137.         {

  4138.             dpf_component** const componentptr = *it;

  4139.             dpf_component* const component = *componentptr;

  4140.             delete component;

  4141.             delete componentptr;

  4142.         }

  4143. 

  4144.         gComponentGarbage.clear();

  4145.     }

  4146. 

  4147.     // ----------------------------------------------------------------------------------------------------------------

  4148.     // v3_funknown

  4149. 

  4150.     static v3_result V3_API query_interface_factory(void* const self, const v3_tuid iid, void** const iface)

  4151.     {

  4152.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4153. 

  4154.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  4155.             v3_tuid_match(iid, v3_plugin_factory_iid) ||

  4156.             v3_tuid_match(iid, v3_plugin_factory_2_iid) ||

  4157.             v3_tuid_match(iid, v3_plugin_factory_3_iid))

  4158.         {

  4159.             d_stdout("query_interface_factory => %p %s %p | OK", self, tuid2str(iid), iface);

  4160.             ++factory->refcounter;

  4161.             *iface = self;

  4162.             return V3_OK;

  4163.         }

  4164. 

  4165.         d_stdout("query_interface_factory => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  4166. 

  4167.         *iface = nullptr;

  4168.         return V3_NO_INTERFACE;

  4169.     }

  4170. 

  4171.     static uint32_t V3_API ref_factory(void* const self)

  4172.     {

  4173.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4174.         const int refcount = ++factory->refcounter;

  4175.         d_stdout("ref_factory::ref => %p | refcount %i", self, refcount);

  4176.         return refcount;

  4177.     }

  4178. 

  4179.     static uint32_t V3_API unref_factory(void* const self)

  4180.     {

  4181.         dpf_factory** const factoryptr = static_cast<dpf_factory**>(self);

  4182.         dpf_factory* const factory = *factoryptr;

  4183. 

  4184.         if (const int refcount = --factory->refcounter)

  4185.         {

  4186.             d_stdout("unref_factory::unref => %p | refcount %i", self, refcount);

  4187.             return refcount;

  4188.         }

  4189. 

  4190.         d_stdout("unref_factory::unref => %p | refcount is zero, deleting factory", self);

  4191. 

  4192.         delete factory;

  4193.         delete factoryptr;

  4194.         return 0;

  4195.     }

  4196. 

  4197.     // ----------------------------------------------------------------------------------------------------------------

  4198.     // v3_plugin_factory

  4199. 

  4200.     static v3_result V3_API get_factory_info(void*, v3_factory_info* const info)

  4201.     {

  4202.         d_stdout("dpf_factory::get_factory_info => %p", info);

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

  4204. 

  4205.         info->flags = 0x10;

  4206.         DISTRHO_NAMESPACE::strncpy(info->vendor, getPluginInfo().getMaker(), ARRAY_SIZE(info->vendor));

  4207.         DISTRHO_NAMESPACE::strncpy(info->url, getPluginInfo().getHomePage(), ARRAY_SIZE(info->url));

  4208.         // DISTRHO_NAMESPACE::strncpy(info->email, "", ARRAY_SIZE(info->email)); // TODO

  4209.         return V3_OK;

  4210.     }

  4211. 

  4212.     static int32_t V3_API num_classes(void*)

  4213.     {

  4214.         d_stdout("dpf_factory::num_classes");

  4215.         return 1;

  4216.     }

  4217. 

  4218.     static v3_result V3_API get_class_info(void*, const int32_t idx, v3_class_info* const info)

  4219.     {

  4220.         d_stdout("dpf_factory::get_class_info => %i %p", idx, info);

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

  4222.         DISTRHO_SAFE_ASSERT_RETURN(idx == 0, V3_INVALID_ARG);

  4223. 

  4224.         info->cardinality = 0x7FFFFFFF;

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

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

  4227.         DISTRHO_NAMESPACE::strncpy(info->name, getPluginInfo().getName(), ARRAY_SIZE(info->name));

  4228.         return V3_OK;

  4229.     }

  4230. 

  4231.     static v3_result V3_API create_instance(void* self, const v3_tuid class_id, const v3_tuid iid, void** const instance)

  4232.     {

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

  4234.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4235. 

  4236.         // query for host application

  4237.         v3_host_application** hostApplication = nullptr;

  4238.         if (factory->hostContext != nullptr)

  4239.             v3_cpp_obj_query_interface(factory->hostContext, v3_host_application_iid, &hostApplication);

  4240. 

  4241.         // create component

  4242.         if (v3_tuid_match(class_id, *(const v3_tuid*)&dpf_tuid_class) && v3_tuid_match(iid, v3_component_iid))

  4243.         {

  4244.             dpf_component** const componentptr = new dpf_component*;

  4245.             *componentptr = new dpf_component(hostApplication);

  4246.             *instance = static_cast<void*>(componentptr);

  4247.             return V3_OK;

  4248.         }

  4249. 

  4250.        #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  4251.         // create edit controller

  4252.         if (v3_tuid_match(class_id, *(const v3_tuid*)&dpf_tuid_controller) && v3_tuid_match(iid, v3_edit_controller_iid))

  4253.         {

  4254.             dpf_edit_controller** const controllerptr = new dpf_edit_controller*;

  4255.             *controllerptr = new dpf_edit_controller(hostApplication);

  4256.             *instance = static_cast<void*>(controllerptr);

  4257.             return V3_OK;

  4258.         }

  4259.        #endif

  4260. 

  4261.         // unsupported, roll back host application

  4262.         if (hostApplication != nullptr)

  4263.             v3_cpp_obj_unref(hostApplication);

  4264. 

  4265.         return V3_NO_INTERFACE;

  4266.     }

  4267. 

  4268.     // ----------------------------------------------------------------------------------------------------------------

  4269.     // v3_plugin_factory_2

  4270. 

  4271.     static v3_result V3_API get_class_info_2(void*, const int32_t idx, v3_class_info_2* const info)

  4272.     {

  4273.         d_stdout("dpf_factory::get_class_info_2 => %i %p", idx, info);

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

  4275.         DISTRHO_SAFE_ASSERT_RETURN(idx == 0, V3_INVALID_ARG);

  4276. 

  4277.         info->cardinality = 0x7FFFFFFF;

  4278.         // TODO FIXME

  4279. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  4280.         info->class_flags = V3_DISTRIBUTABLE;

  4281. #endif

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

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

  4284.         DISTRHO_NAMESPACE::strncpy(info->sub_categories, getPluginCategories(), ARRAY_SIZE(info->sub_categories));

  4285.         DISTRHO_NAMESPACE::strncpy(info->name, getPluginInfo().getName(), ARRAY_SIZE(info->name));

  4286.         DISTRHO_NAMESPACE::strncpy(info->vendor, getPluginInfo().getMaker(), ARRAY_SIZE(info->vendor));

  4287.         DISTRHO_NAMESPACE::strncpy(info->version, getPluginVersion(), ARRAY_SIZE(info->version));

  4288.         DISTRHO_NAMESPACE::strncpy(info->sdk_version, "Travesty", ARRAY_SIZE(info->sdk_version));

  4289.         return V3_OK;

  4290.     }

  4291. 

  4292.     // ------------------------------------------------------------------------------------------------------------

  4293.     // v3_plugin_factory_3

  4294. 

  4295.     static v3_result V3_API get_class_info_utf16(void*, const int32_t idx, v3_class_info_3* const info)

  4296.     {

  4297.         d_stdout("dpf_factory::get_class_info_utf16 => %i %p", idx, info);

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

  4299.         DISTRHO_SAFE_ASSERT_RETURN(idx == 0, V3_INVALID_ARG);

  4300. 

  4301.         info->cardinality = 0x7FFFFFFF;

  4302.         // TODO FIXME

  4303. #ifdef DPF_VST3_USES_SEPARATE_CONTROLLER

  4304.         info->class_flags = V3_DISTRIBUTABLE;

  4305. #endif

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

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

  4308.         DISTRHO_NAMESPACE::strncpy(info->sub_categories, getPluginCategories(), ARRAY_SIZE(info->sub_categories));

  4309.         DISTRHO_NAMESPACE::strncpy_utf16(info->name, getPluginInfo().getName(), ARRAY_SIZE(info->name));

  4310.         DISTRHO_NAMESPACE::strncpy_utf16(info->vendor, getPluginInfo().getMaker(), ARRAY_SIZE(info->vendor));

  4311.         DISTRHO_NAMESPACE::strncpy_utf16(info->version, getPluginVersion(), ARRAY_SIZE(info->version));

  4312.         DISTRHO_NAMESPACE::strncpy_utf16(info->sdk_version, "Travesty", ARRAY_SIZE(info->sdk_version));

  4313.         return V3_OK;

  4314.     }

  4315. 

  4316.     static v3_result V3_API set_host_context(void* const self, v3_funknown** const context)

  4317.     {

  4318.         d_stdout("dpf_factory::set_host_context => %p %p", self, context);

  4319.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4320. 

  4321.         // unref old context if there is one

  4322.         if (factory->hostContext != nullptr)

  4323.             v3_cpp_obj_unref(factory->hostContext);

  4324. 

  4325.         // store new context

  4326.         factory->hostContext = context;

  4327. 

  4328.         // make sure the object keeps being valid for a while

  4329.         if (context != nullptr)

  4330.             v3_cpp_obj_ref(context);

  4331. 

  4332.         return V3_OK;

  4333.     }

  4334. };

  4335. 

  4336. END_NAMESPACE_DISTRHO

  4337. 

  4338. // --------------------------------------------------------------------------------------------------------------------

  4339. // VST3 entry point

  4340. 

  4341. DISTRHO_PLUGIN_EXPORT

  4342. const void* GetPluginFactory(void);

  4343. 

  4344. const void* GetPluginFactory(void)

  4345. {

  4346.     USE_NAMESPACE_DISTRHO;

  4347.     dpf_factory** const factoryptr = new dpf_factory*;

  4348.     *factoryptr = new dpf_factory;

  4349.     return static_cast<void*>(factoryptr);

  4350. }

  4351. 

  4352. // --------------------------------------------------------------------------------------------------------------------

  4353. // OS specific module load

  4354. 

  4355. #if defined(DISTRHO_OS_MAC)

  4356. # define ENTRYFNNAME bundleEntry

  4357. # define EXITFNNAME bundleExit

  4358. #elif defined(DISTRHO_OS_WINDOWS)

  4359. # define ENTRYFNNAME InitDll

  4360. # define EXITFNNAME ExitDll

  4361. #else

  4362. # define ENTRYFNNAME ModuleEntry

  4363. # define EXITFNNAME ModuleExit

  4364. #endif

  4365. 

  4366. DISTRHO_PLUGIN_EXPORT

  4367. bool ENTRYFNNAME(void*);

  4368. 

  4369. bool ENTRYFNNAME(void*)

  4370. {

  4371.     USE_NAMESPACE_DISTRHO;

  4372. 

  4373.     // find plugin bundle

  4374.     static String bundlePath;

  4375.     if (bundlePath.isEmpty())

  4376.     {

  4377.         String tmpPath(getBinaryFilename());

  4378.         tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  4379.         tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  4380.         DISTRHO_SAFE_ASSERT_RETURN(tmpPath.endsWith("/Contents"), true);

  4381. 

  4382.         tmpPath.truncate(tmpPath.rfind('/'));

  4383.         bundlePath = tmpPath;

  4384.         d_nextBundlePath = bundlePath.buffer();

  4385.     }

  4386. 

  4387.     // init dummy plugin and set uniqueId

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

  4389.         = dpf_tuid_processor[2] = dpf_tuid_view[2] = getPluginInfo().getUniqueId();

  4390. 

  4391.     return true;

  4392. }

  4393. 

  4394. DISTRHO_PLUGIN_EXPORT

  4395. bool EXITFNNAME(void);

  4396. 

  4397. bool EXITFNNAME(void)

  4398. {

  4399.     return true;

  4400. }

  4401. 

  4402. #undef ENTRYFNNAME

  4403. #undef EXITFNNAME

  4404. 

  4405. // --------------------------------------------------------------------------------------------------------------------