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

4896 lines
182KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Plugin Framework (DPF)

  3.  * Copyright (C) 2012-2022 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. #define DPF_VST3_MAX_BUFFER_SIZE 32768

  22. #define DPF_VST3_MAX_SAMPLE_RATE 384000

  23. #define DPF_VST3_MAX_LATENCY     DPF_VST3_MAX_SAMPLE_RATE * 10

  24. 

  25. #if DISTRHO_PLUGIN_HAS_UI

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

  27. #endif

  28. 

  29. #include "travesty/audio_processor.h"

  30. #include "travesty/component.h"

  31. #include "travesty/edit_controller.h"

  32. #include "travesty/factory.h"

  33. #include "travesty/host.h"

  34. 

  35. #include <map>

  36. #include <string>

  37. #include <vector>

  38. 

  39. /* TODO items:

  40.  * == parameters

  41.  * - test parameter triggers

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

  43.  * - parameter groups via unit ids

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

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

  46.  * - fully implemented parameter stuff and verify

  47.  * - float to int safe casting

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

  49.  * == MIDI

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

  51.  * - MIDI program changes

  52.  * - MIDI sysex

  53.  * == BUSES

  54.  * - routing info, do we care?

  55.  * == CV

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

  57.  * - test in at least 1 host

  58.  * == INFO

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

  60.  * - do something with set_io_mode?

  61.  */

  62. 

  63. START_NAMESPACE_DISTRHO

  64. 

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

  66. 

  67. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  68. static constexpr const writeMidiFunc writeMidiCallback = nullptr;

  69. #endif

  70. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  71. static constexpr const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  72. #endif

  73. 

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

  75. 

  76. // --------------------------------------------------------------------------------------------------------------------

  77. // custom v3_tuid compatible type

  78. 

  79. typedef uint32_t dpf_tuid[4];

  80. #ifdef DISTRHO_PROPER_CPP11_SUPPORT

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

  82. #endif

  83. 

  84. // --------------------------------------------------------------------------------------------------------------------

  85. // custom, constant uids related to DPF

  86. 

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

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

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

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

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

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

  93. 

  94. // --------------------------------------------------------------------------------------------------------------------

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

  96. 

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

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

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

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

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

  102. 

  103. // --------------------------------------------------------------------------------------------------------------------

  104. // Utility functions

  105. 

  106. const char* tuid2str(const v3_tuid iid)

  107. {

  108.     static constexpr const struct {

  109.         v3_tuid iid;

  110.         const char* name;

  111.     } extra_known_iids[] = {

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

  113.         // edit-controller

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

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

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

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

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

  119.         // units

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

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

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

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

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

  125.         // misc

  126.         { V3_ID(0x309ECE78,0xEB7D4FAE,0x8B2225D9,0x09FD08B6), "{v3_audio_presentation_latency|NOT}" },

  127.         { V3_ID(0xB4E8287F,0x1BB346AA,0x83A46667,0x68937BAB), "{v3_automation_state|NOT}" },

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

  129.         { V3_ID(0x6D21E1DC,0x91199D4B,0xA2A02FEF,0x6C1AE55C), "{v3_parameter_function_name|NOT}" },

  130.         { V3_ID(0x8AE54FDA,0xE93046B9,0xA28555BC,0xDC98E21E), "{v3_prefetchable_support|NOT}" },

  131.         { V3_ID(0xA81A0471,0x48C34DC4,0xAC30C9E1,0x3C8393D5), "{v3_xml_representation_stream|NOT}" },

  132.         /*

  133.         // seen in the wild but unknown, related to component

  134.         { V3_ID(0x6548D671,0x997A4EA5,0x9B336A6F,0xB3E93B50), "{v3_|NOT}" },

  135.         { V3_ID(0xC2B7896B,0x069844D5,0x8F06E937,0x33A35FF7), "{v3_|NOT}" },

  136.         { V3_ID(0xE123DE93,0xE0F642A4,0xAE53867E,0x53F059EE), "{v3_|NOT}" },

  137.         { V3_ID(0x83850D7B,0xC12011D8,0xA143000A,0x959B31C6), "{v3_|NOT}" },

  138.         { V3_ID(0x9598D418,0xA00448AC,0x9C6D8248,0x065B2E5C), "{v3_|NOT}" },

  139.         { V3_ID(0xBD386132,0x45174BAD,0xA324390B,0xFD297506), "{v3_|NOT}" },

  140.         { V3_ID(0xD7296A84,0x23B1419C,0xAAD0FAA3,0x53BB16B7), "{v3_|NOT}" },

  141.         { V3_ID(0x181A0AF6,0xA10947BA,0x8A6F7C7C,0x3FF37129), "{v3_|NOT}" },

  142.         { V3_ID(0xC2B7896B,0x69A844D5,0x8F06E937,0x33A35FF7), "{v3_|NOT}" },

  143.         // seen in the wild but unknown, related to edit controller

  144.         { V3_ID(0x1F2F76D3,0xBFFB4B96,0xB99527A5,0x5EBCCEF4), "{v3_|NOT}" },

  145.         { V3_ID(0x6B2449CC,0x419740B5,0xAB3C79DA,0xC5FE5C86), "{v3_|NOT}" },

  146.         { V3_ID(0x67800560,0x5E784D90,0xB97BAB4C,0x8DC5BAA3), "{v3_|NOT}" },

  147.         { V3_ID(0xDB51DA00,0x8FD5416D,0xB84894D8,0x7FDE73E4), "{v3_|NOT}" },

  148.         { V3_ID(0xE90FC54F,0x76F24235,0x8AF8BD15,0x68C663D6), "{v3_|NOT}" },

  149.         { V3_ID(0x07938E89,0xBA0D4CA8,0x8C7286AB,0xA9DDA95B), "{v3_|NOT}" },

  150.         { V3_ID(0x42879094,0xA2F145ED,0xAC90E82A,0x99458870), "{v3_|NOT}" },

  151.         { V3_ID(0xC3B17BC0,0x2C174494,0x80293402,0xFBC4BBF8), "{v3_|NOT}" },

  152.         { V3_ID(0x31E29A7A,0xE55043AD,0x8B95B9B8,0xDA1FBE1E), "{v3_|NOT}" },

  153.         { V3_ID(0x8E3C292C,0x95924F9D,0xB2590B1E,0x100E4198), "{v3_|NOT}" },

  154.         { V3_ID(0x50553FD9,0x1D2C4C24,0xB410F484,0xC5FB9F3F), "{v3_|NOT}" },

  155.         { V3_ID(0xF185556C,0x5EE24FC7,0x92F28754,0xB7759EA8), "{v3_|NOT}" },

  156.         { V3_ID(0xD2CE9317,0xF24942C9,0x9742E82D,0xB10CCC52), "{v3_|NOT}" },

  157.         { V3_ID(0xDA57E6D1,0x1F3242D1,0xAD9C1A82,0xFDB95695), "{v3_|NOT}" },

  158.         { V3_ID(0x3ABDFC3E,0x4B964A66,0xFCD86F10,0x0D554023), "{v3_|NOT}" },

  159.         // seen in the wild but unknown, related to view

  160.         { V3_ID(0xAA3E50FF,0xB78840EE,0xADCD48E8,0x094CEDB7), "{v3_|NOT}" },

  161.         { V3_ID(0x2CAE14DB,0x4DE04C6E,0x8BD2E611,0x1B31A9C2), "{v3_|NOT}" },

  162.         { V3_ID(0xD868D61D,0x20F445F4,0x947D069E,0xC811D1E4), "{v3_|NOT}" },

  163.         { V3_ID(0xEE49E3CA,0x6FCB44FB,0xAEBEE6C3,0x48625122), "{v3_|NOT}" },

  164.         */

  165.     };

  166. 

  167.     if (v3_tuid_match(iid, v3_audio_processor_iid))

  168.         return "{v3_audio_processor}";

  169.     if (v3_tuid_match(iid, v3_attribute_list_iid))

  170.         return "{v3_attribute_list_iid}";

  171.     if (v3_tuid_match(iid, v3_bstream_iid))

  172.         return "{v3_bstream}";

  173.     if (v3_tuid_match(iid, v3_component_iid))

  174.         return "{v3_component}";

  175.     if (v3_tuid_match(iid, v3_component_handler_iid))

  176.         return "{v3_component_handler}";

  177.     if (v3_tuid_match(iid, v3_connection_point_iid))

  178.         return "{v3_connection_point_iid}";

  179.     if (v3_tuid_match(iid, v3_edit_controller_iid))

  180.         return "{v3_edit_controller}";

  181.     if (v3_tuid_match(iid, v3_event_handler_iid))

  182.         return "{v3_event_handler_iid}";

  183.     if (v3_tuid_match(iid, v3_event_list_iid))

  184.         return "{v3_event_list}";

  185.     if (v3_tuid_match(iid, v3_funknown_iid))

  186.         return "{v3_funknown}";

  187.     if (v3_tuid_match(iid, v3_host_application_iid))

  188.         return "{v3_host_application_iid}";

  189.     if (v3_tuid_match(iid, v3_message_iid))

  190.         return "{v3_message_iid}";

  191.     if (v3_tuid_match(iid, v3_midi_mapping_iid))

  192.         return "{v3_midi_mapping_iid}";

  193.     if (v3_tuid_match(iid, v3_param_value_queue_iid))

  194.         return "{v3_param_value_queue}";

  195.     if (v3_tuid_match(iid, v3_param_changes_iid))

  196.         return "{v3_param_changes}";

  197.     if (v3_tuid_match(iid, v3_plugin_base_iid))

  198.         return "{v3_plugin_base}";

  199.     if (v3_tuid_match(iid, v3_plugin_factory_iid))

  200.         return "{v3_plugin_factory}";

  201.     if (v3_tuid_match(iid, v3_plugin_factory_2_iid))

  202.         return "{v3_plugin_factory_2}";

  203.     if (v3_tuid_match(iid, v3_plugin_factory_3_iid))

  204.         return "{v3_plugin_factory_3}";

  205.     if (v3_tuid_match(iid, v3_plugin_frame_iid))

  206.         return "{v3_plugin_frame}";

  207.     if (v3_tuid_match(iid, v3_plugin_view_iid))

  208.         return "{v3_plugin_view}";

  209.     if (v3_tuid_match(iid, v3_plugin_view_content_scale_iid))

  210.         return "{v3_plugin_view_content_scale_iid}";

  211.     if (v3_tuid_match(iid, v3_plugin_view_parameter_finder_iid))

  212.         return "{v3_plugin_view_parameter_finder}";

  213.     if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  214.         return "{v3_process_context_requirements}";

  215.     if (v3_tuid_match(iid, v3_run_loop_iid))

  216.         return "{v3_run_loop_iid}";

  217.     if (v3_tuid_match(iid, v3_timer_handler_iid))

  218.         return "{v3_timer_handler_iid}";

  219. 

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

  221.         return "{dpf_tuid_class}";

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

  223.         return "{dpf_tuid_component}";

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

  225.         return "{dpf_tuid_controller}";

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

  227.         return "{dpf_tuid_processor}";

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

  229.         return "{dpf_tuid_view}";

  230. 

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

  232.     {

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

  234.             return extra_known_iids[i].name;

  235.     }

  236. 

  237.     static char buf[46];

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

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

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

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

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

  243.     return buf;

  244. }

  245. 

  246. // --------------------------------------------------------------------------------------------------------------------

  247. // dpf_plugin_view_create (implemented on UI side)

  248. 

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

  250. 

  251. // --------------------------------------------------------------------------------------------------------------------

  252. 

  253. /**

  254.  * VST3 DSP class.

  255.  *

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

  257.  * This class is created during the "initialize" component event, and destroyed during "terminate".

  258.  *

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

  260.  */

  261. class PluginVst3

  262. {

  263.     /* Buses: count possible buses we can provide to the host, in case they are not yet defined by the developer.

  264.      * These values are only used if port groups aren't set.

  265.      *

  266.      * When port groups are not in use:

  267.      * - 1 bus is provided for the main audio (if there is any)

  268.      * - 1 for sidechain

  269.      * - 1 for each cv port

  270.      * So basically:

  271.      * Main audio is used as first bus, if available.

  272.      * Then sidechain, also if available.

  273.      * And finally each CV port individually.

  274.      *

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

  276.      */

  277.     struct BusInfo {

  278.         uint8_t audio;     // either 0 or 1

  279.         uint8_t sidechain; // either 0 or 1

  280.         uint32_t groups;

  281.         uint32_t audioPorts;

  282.         uint32_t sidechainPorts;

  283.         uint32_t groupPorts;

  284.         uint32_t cvPorts;

  285. 

  286.         BusInfo()

  287.           : audio(0),

  288.             sidechain(0),

  289.             groups(0),

  290.             audioPorts(0),

  291.             sidechainPorts(0),

  292.             groupPorts(0),

  293.             cvPorts(0) {}

  294.     } inputBuses, outputBuses;

  295. 

  296.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  297.     /* Handy class for storing and sorting VST3 events and MIDI CC parameters.

  298.      * It will only store events for which a MIDI conversion is possible.

  299.      */

  300.     struct InputEventList {

  301.         enum Type {

  302.             NoteOn,

  303.             NoteOff,

  304.             SysexData,

  305.             PolyPressure,

  306.             CC_Normal,

  307.             CC_ChannelPressure,

  308.             CC_Pitchbend,

  309.             UI_MIDI // event from UI

  310.         };

  311.         struct InputEventStorage {

  312.             Type type;

  313.             union {

  314.                 v3_event_note_on noteOn;

  315.                 v3_event_note_off noteOff;

  316.                 v3_event_data sysexData;

  317.                 v3_event_poly_pressure polyPressure;

  318.                 uint8_t midi[3];

  319.             };

  320.         } eventListStorage[kMaxMidiEvents];

  321. 

  322.         struct InputEvent {

  323.             int32_t sampleOffset;

  324.             const InputEventStorage* storage;

  325.             InputEvent* next;

  326.         } eventList[kMaxMidiEvents];

  327. 

  328.         uint16_t numUsed;

  329.         int32_t firstSampleOffset;

  330.         int32_t lastSampleOffset;

  331.         InputEvent* firstEvent;

  332.         InputEvent* lastEvent;

  333. 

  334.         void init()

  335.         {

  336.             numUsed = 0;

  337.             firstSampleOffset = lastSampleOffset = 0;

  338.             firstEvent = nullptr;

  339.         }

  340. 

  341.         uint32_t convert(MidiEvent midiEvents[kMaxMidiEvents]) const noexcept

  342.         {

  343.             uint32_t count = 0;

  344. 

  345.             for (const InputEvent* event = firstEvent; event != nullptr; event = event->next)

  346.             {

  347.                 MidiEvent& midiEvent(midiEvents[count++]);

  348.                 midiEvent.frame = event->sampleOffset;

  349. 

  350.                 const InputEventStorage& eventStorage(*event->storage);

  351. 

  352.                 switch (eventStorage.type)

  353.                 {

  354.                 case NoteOn:

  355.                     midiEvent.size = 3;

  356.                     midiEvent.data[0] = 0x90 | (eventStorage.noteOn.channel & 0xf);

  357.                     midiEvent.data[1] = eventStorage.noteOn.pitch;

  358.                     midiEvent.data[2] = std::max(0, std::min(127, (int)(eventStorage.noteOn.velocity * 127)));

  359.                     midiEvent.data[3] = 0;

  360.                     break;

  361.                 case NoteOff:

  362.                     midiEvent.size = 3;

  363.                     midiEvent.data[0] = 0x80 | (eventStorage.noteOff.channel & 0xf);

  364.                     midiEvent.data[1] = eventStorage.noteOff.pitch;

  365.                     midiEvent.data[2] = std::max(0, std::min(127, (int)(eventStorage.noteOff.velocity * 127)));

  366.                     midiEvent.data[3] = 0;

  367.                     break;

  368.                 /* TODO

  369.                 case SysexData:

  370.                     break;

  371.                 */

  372.                 case PolyPressure:

  373.                     midiEvent.size = 3;

  374.                     midiEvent.data[0] = 0xA0 | (eventStorage.polyPressure.channel & 0xf);

  375.                     midiEvent.data[1] = eventStorage.polyPressure.pitch;

  376.                     midiEvent.data[2] = std::max(0, std::min(127, (int)(eventStorage.polyPressure.pressure * 127)));

  377.                     midiEvent.data[3] = 0;

  378.                     break;

  379.                 case CC_Normal:

  380.                     midiEvent.size = 3;

  381.                     midiEvent.data[0] = 0xB0 | (eventStorage.midi[0] & 0xf);

  382.                     midiEvent.data[1] = eventStorage.midi[1];

  383.                     midiEvent.data[2] = eventStorage.midi[2];

  384.                     break;

  385.                 case CC_ChannelPressure:

  386.                     midiEvent.size = 2;

  387.                     midiEvent.data[0] = 0xD0 | (eventStorage.midi[0] & 0xf);

  388.                     midiEvent.data[1] = eventStorage.midi[1];

  389.                     midiEvent.data[2] = 0;

  390.                     break;

  391.                 case CC_Pitchbend:

  392.                     midiEvent.size = 3;

  393.                     midiEvent.data[0] = 0xE0 | (eventStorage.midi[0] & 0xf);

  394.                     midiEvent.data[1] = eventStorage.midi[1];

  395.                     midiEvent.data[2] = eventStorage.midi[2];

  396.                     break;

  397.                 case UI_MIDI:

  398.                     midiEvent.size = 3;

  399.                     midiEvent.data[0] = eventStorage.midi[0];

  400.                     midiEvent.data[1] = eventStorage.midi[1];

  401.                     midiEvent.data[2] = eventStorage.midi[2];

  402.                     break;

  403.                 default:

  404.                     midiEvent.size = 0;

  405.                     break;

  406.                 }

  407.             }

  408. 

  409.             return count;

  410.         }

  411. 

  412.         bool appendEvent(const v3_event& event) noexcept

  413.         {

  414.             // only save events that can be converted directly into MIDI

  415.             switch (event.type)

  416.             {

  417.             case V3_EVENT_NOTE_ON:

  418.             case V3_EVENT_NOTE_OFF:

  419.             // case V3_EVENT_DATA:

  420.             case V3_EVENT_POLY_PRESSURE:

  421.                 break;

  422.             default:

  423.                 return false;

  424.             }

  425. 

  426.             InputEventStorage& eventStorage(eventListStorage[numUsed]);

  427. 

  428.             switch (event.type)

  429.             {

  430.             case V3_EVENT_NOTE_ON:

  431.                 eventStorage.type = NoteOn;

  432.                 eventStorage.noteOn = event.note_on;

  433.                 break;

  434.             case V3_EVENT_NOTE_OFF:

  435.                 eventStorage.type = NoteOff;

  436.                 eventStorage.noteOff = event.note_off;

  437.                 break;

  438.             case V3_EVENT_DATA:

  439.                 eventStorage.type = SysexData;

  440.                 eventStorage.sysexData = event.data;

  441.                 break;

  442.             case V3_EVENT_POLY_PRESSURE:

  443.                 eventStorage.type = PolyPressure;

  444.                 eventStorage.polyPressure = event.poly_pressure;

  445.                 break;

  446.             default:

  447.                 return false;

  448.             }

  449. 

  450.             eventList[numUsed].sampleOffset = event.sample_offset;

  451.             eventList[numUsed].storage = &eventStorage;

  452. 

  453.             return placeSorted(event.sample_offset);

  454.         }

  455. 

  456.         bool appendCC(const int32_t sampleOffset, v3_param_id paramId, const double value) noexcept

  457.         {

  458.             InputEventStorage& eventStorage(eventListStorage[numUsed]);

  459. 

  460.             paramId -= kVst3InternalParameterMidiCC_start;

  461. 

  462.             const uint8_t cc = paramId % 130;

  463. 

  464.             switch (cc)

  465.             {

  466.             case 128:

  467.                 eventStorage.type = CC_ChannelPressure;

  468.                 eventStorage.midi[1] = std::max(0, std::min(127, (int)(value * 127)));

  469.                 eventStorage.midi[2] = 0;

  470.                 break;

  471.             case 129:

  472.                 eventStorage.type = CC_Pitchbend;

  473.                 eventStorage.midi[1] = std::max(0, std::min(16384, (int)(value * 16384))) & 0x7f;

  474.                 eventStorage.midi[2] = std::max(0, std::min(16384, (int)(value * 16384))) >> 7;

  475.                 break;

  476.             default:

  477.                 eventStorage.type = CC_Normal;

  478.                 eventStorage.midi[1] = cc;

  479.                 eventStorage.midi[2] = std::max(0, std::min(127, (int)(value * 127)));

  480.                 break;

  481.             }

  482. 

  483.             eventStorage.midi[0] = paramId / 130;

  484. 

  485.             eventList[numUsed].sampleOffset = sampleOffset;

  486.             eventList[numUsed].storage = &eventStorage;

  487. 

  488.             return placeSorted(sampleOffset);

  489.         }

  490. 

  491.        #if DISTRHO_PLUGIN_HAS_UI

  492.         // NOTE always runs first

  493.         bool appendFromUI(const uint8_t midiData[3])

  494.         {

  495.             InputEventStorage& eventStorage(eventListStorage[numUsed]);

  496. 

  497.             eventStorage.type = UI_MIDI;

  498.             std::memcpy(eventStorage.midi, midiData, sizeof(uint8_t)*3);

  499. 

  500.             InputEvent* const event = &eventList[numUsed];

  501. 

  502.             event->sampleOffset = 0;

  503.             event->storage = &eventStorage;

  504.             event->next = nullptr;

  505. 

  506.             if (numUsed == 0)

  507.             {

  508.                 firstEvent = lastEvent = event;

  509.             }

  510.             else

  511.             {

  512.                 lastEvent->next = event;

  513.                 lastEvent = event;

  514.             }

  515. 

  516.             return ++numUsed == kMaxMidiEvents;

  517.         }

  518.        #endif

  519. 

  520.     private:

  521.         bool placeSorted(const int32_t sampleOffset) noexcept

  522.         {

  523.             InputEvent* const event = &eventList[numUsed];

  524. 

  525.             // initialize

  526.             if (numUsed == 0)

  527.             {

  528.                 firstSampleOffset = lastSampleOffset = sampleOffset;

  529.                 firstEvent = lastEvent = event;

  530.                 event->next = nullptr;

  531.             }

  532.             // push to the back

  533.             else if (sampleOffset >= lastSampleOffset)

  534.             {

  535.                 lastSampleOffset = sampleOffset;

  536.                 lastEvent->next = event;

  537.                 lastEvent = event;

  538.                 event->next = nullptr;

  539.             }

  540.             // push to the front

  541.             else if (sampleOffset < firstSampleOffset)

  542.             {

  543.                 firstSampleOffset = sampleOffset;

  544.                 event->next = firstEvent;

  545.                 firstEvent = event;

  546.             }

  547.             // find place in between events

  548.             else

  549.             {

  550.                 // keep reference out of the loop so we can check validity afterwards

  551.                 InputEvent* event2 = firstEvent;

  552. 

  553.                 // iterate all events

  554.                 for (; event2 != nullptr; event2 = event2->next)

  555.                 {

  556.                     // if offset is higher than iterated event, stop and insert in-between

  557.                     if (sampleOffset > event2->sampleOffset)

  558.                         break;

  559. 

  560.                     // if offset matches, find the last event with the same offset so we can push after it

  561.                     if (sampleOffset == event2->sampleOffset)

  562.                     {

  563.                         event2 = event2->next;

  564.                         for (; event2 != nullptr && sampleOffset == event2->sampleOffset; event2 = event2->next) {}

  565.                         break;

  566.                     }

  567.                 }

  568. 

  569.                 DISTRHO_SAFE_ASSERT_RETURN(event2 != nullptr, true);

  570. 

  571.                 event->next = event2->next;

  572.                 event2->next = event;

  573.             }

  574. 

  575.             return ++numUsed == kMaxMidiEvents;

  576.         }

  577.     } inputEventList;

  578.    #endif // DISTRHO_PLUGIN_WANT_MIDI_INPUT

  579. 

  580. public:

  581.     PluginVst3(v3_host_application** const host)

  582.         : fPlugin(this, writeMidiCallback, requestParameterValueChangeCallback, nullptr),

  583.           fComponentHandler(nullptr),

  584.         #if DISTRHO_PLUGIN_HAS_UI

  585.          #if DPF_VST3_USES_SEPARATE_CONTROLLER

  586.           fConnectionFromCompToCtrl(nullptr),

  587.          #endif

  588.           fConnectionFromCtrlToView(nullptr),

  589.           fHostApplication(host),

  590.         #endif

  591.           fParameterCount(fPlugin.getParameterCount()),

  592.           fVst3ParameterCount(fParameterCount + kVst3InternalParameterCount),

  593.           fCachedParameterValues(nullptr),

  594.           fDummyAudioBuffer(nullptr),

  595.           fParameterValuesChangedDuringProcessing(nullptr)

  596.        #if DISTRHO_PLUGIN_HAS_UI

  597.         , fParameterValueChangesForUI(nullptr)

  598.         , fConnectedToUI(false)

  599.        #endif

  600.        #if DISTRHO_PLUGIN_WANT_LATENCY

  601.         , fLastKnownLatency(fPlugin.getLatency())

  602.        #endif

  603.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  604.         , fHostEventOutputHandle(nullptr)

  605.        #endif

  606.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  607.         , fCurrentProgram(0)

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

  609.        #endif

  610.     {

  611.        #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  612.         std::memset(fEnabledInputs, 0, sizeof(fEnabledInputs));

  613.         fillInBusInfoDetails<true>();

  614.        #endif

  615.        #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  616.         std::memset(fEnabledOutputs, 0, sizeof(fEnabledOutputs));

  617.         fillInBusInfoDetails<false>();

  618.        #endif

  619. 

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

  621.         {

  622.             fCachedParameterValues = new float[extraParameterCount];

  623. 

  624.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  627.            #endif

  628.            #if DISTRHO_PLUGIN_WANT_LATENCY

  629.             fCachedParameterValues[kVst3InternalParameterLatency]    = fLastKnownLatency;

  630.            #endif

  631.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  632.             fCachedParameterValues[kVst3InternalParameterProgram]    = 0.0f;

  633.            #endif

  634. 

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

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

  637. 

  638.             fParameterValuesChangedDuringProcessing = new bool[extraParameterCount];

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

  640. 

  641.            #if DISTRHO_PLUGIN_HAS_UI

  642.             fParameterValueChangesForUI = new bool[extraParameterCount];

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

  644.            #endif

  645.         }

  646. 

  647.        #if DISTRHO_PLUGIN_WANT_STATE

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

  649.         {

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

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

  652.         }

  653.        #endif

  654. 

  655.        #if !DISTRHO_PLUGIN_HAS_UI

  656.         // unused

  657.         return; (void)host;

  658.        #endif

  659.     }

  660. 

  661.     ~PluginVst3()

  662.     {

  663.         if (fCachedParameterValues != nullptr)

  664.         {

  665.             delete[] fCachedParameterValues;

  666.             fCachedParameterValues = nullptr;

  667.         }

  668. 

  669.         if (fDummyAudioBuffer != nullptr)

  670.         {

  671.             delete[] fDummyAudioBuffer;

  672.             fDummyAudioBuffer = nullptr;

  673.         }

  674. 

  675.         if (fParameterValuesChangedDuringProcessing != nullptr)

  676.         {

  677.             delete[] fParameterValuesChangedDuringProcessing;

  678.             fParameterValuesChangedDuringProcessing = nullptr;

  679.         }

  680. 

  681.        #if DISTRHO_PLUGIN_HAS_UI

  682.         if (fParameterValueChangesForUI != nullptr)

  683.         {

  684.             delete[] fParameterValueChangesForUI;

  685.             fParameterValueChangesForUI = nullptr;

  686.         }

  687.        #endif

  688.     }

  689. 

  690.     // ----------------------------------------------------------------------------------------------------------------

  691.     // utilities and common code

  692. 

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

  694.     {

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

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

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

  698. 

  699.         if (hints & kParameterIsBoolean)

  700.         {

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

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

  703.         }

  704.         else if (hints & kParameterIsInteger)

  705.         {

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

  707.         }

  708. 

  709.         fCachedParameterValues[kVst3InternalParameterBaseCount + index] = value;

  710.        #if DISTRHO_PLUGIN_HAS_UI

  711.         fParameterValueChangesForUI[kVst3InternalParameterBaseCount + index] = true;

  712.        #endif

  713.         fPlugin.setParameterValue(index, value);

  714.     }

  715. 

  716.     // ----------------------------------------------------------------------------------------------------------------

  717.     // stuff called for UI creation

  718. 

  719.     void* getInstancePointer() const noexcept

  720.     {

  721.         return fPlugin.getInstancePointer();

  722.     }

  723. 

  724.     double getSampleRate() const noexcept

  725.     {

  726.         return fPlugin.getSampleRate();

  727.     }

  728. 

  729.     // ----------------------------------------------------------------------------------------------------------------

  730.     // v3_component interface calls

  731. 

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

  733.     {

  734.         switch (mediaType)

  735.         {

  736.         case V3_AUDIO:

  737.             if (busDirection == V3_INPUT)

  738.                 return inputBuses.audio + inputBuses.sidechain + inputBuses.groups + inputBuses.cvPorts;

  739.             if (busDirection == V3_OUTPUT)

  740.                 return outputBuses.audio + outputBuses.sidechain + outputBuses.groups + outputBuses.cvPorts;

  741.             break;

  742.         case V3_EVENT:

  743.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  744.             if (busDirection == V3_INPUT)

  745.                 return 1;

  746.            #endif

  747.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  748.             if (busDirection == V3_OUTPUT)

  749.                 return 1;

  750.            #endif

  751.             break;

  752.         }

  753. 

  754.         return 0;

  755.     }

  756. 

  757.     v3_result getBusInfo(const int32_t mediaType,

  758.                          const int32_t busDirection,

  759.                          const int32_t busIndex,

  760.                          v3_bus_info* const info) const

  761.     {

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

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

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

  765. 

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

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

  768.        #endif

  769. 

  770.         if (mediaType == V3_AUDIO)

  771.         {

  772.            #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  773.             if (busDirection == V3_INPUT)

  774.             {

  775.                #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  776.                 return getAudioBusInfo<true>(busId, info);

  777.                #else

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

  779.                 return V3_INVALID_ARG;

  780.                #endif // DISTRHO_PLUGIN_NUM_INPUTS

  781.             }

  782.             else

  783.             {

  784.                #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  785.                 return getAudioBusInfo<false>(busId, info);

  786.                #else

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

  788.                 return V3_INVALID_ARG;

  789.                #endif // DISTRHO_PLUGIN_NUM_OUTPUTS

  790.             }

  791.            #else

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

  793.             return V3_INVALID_ARG;

  794.            #endif // DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS

  795.         }

  796.         else

  797.         {

  798.             if (busDirection == V3_INPUT)

  799.             {

  800.                #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  802.                #else

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

  804.                 return V3_INVALID_ARG;

  805.                #endif

  806.             }

  807.             else

  808.             {

  809.                #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  811.                #else

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

  813.                 return V3_INVALID_ARG;

  814.                #endif

  815.             }

  816.             info->media_type = V3_EVENT;

  817.             info->direction = busDirection;

  818.             info->channel_count = 1;

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

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

  821.             info->bus_type = V3_MAIN;

  822.             info->flags = V3_DEFAULT_ACTIVE;

  823.             return V3_OK;

  824.         }

  825.     }

  826. 

  827.     v3_result getRoutingInfo(v3_routing_info*, v3_routing_info*)

  828.     {

  829.         /*

  830.         output->media_type = V3_AUDIO;

  831.         output->bus_idx = 0;

  832.         output->channel = -1;

  833.         d_stdout("getRoutingInfo %s %d %d",

  834.                  v3_media_type_str(input->media_type), input->bus_idx, input->channel);

  835.         */

  836.         return V3_NOT_IMPLEMENTED;

  837.     }

  838. 

  839.     v3_result activateBus(const int32_t mediaType,

  840.                           const int32_t busDirection,

  841.                           const int32_t busIndex,

  842.                           const bool state) noexcept

  843.     {

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

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

  846. 

  847.         if (mediaType == V3_AUDIO)

  848.         {

  849.            #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  851. 

  852.             if (busDirection == V3_INPUT)

  853.             {

  854.                #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  856.                 {

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

  858. 

  859.                     if (port.busId == busId)

  860.                         fEnabledInputs[i] = state;

  861.                 }

  862.                #endif

  863.             }

  864.             else

  865.             {

  866.                #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  868.                 {

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

  870. 

  871.                     if (port.busId == busId)

  872.                         fEnabledOutputs[i] = state;

  873.                 }

  874.                #endif

  875.             }

  876.            #endif

  877.         }

  878. 

  879.         return V3_OK;

  880. 

  881.        #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  882.         // unused

  883.         (void)state;

  884.        #endif

  885.     }

  886. 

  887.     v3_result setActive(const bool active)

  888.     {

  889.         if (active)

  890.             fPlugin.activate();

  891.         else

  892.             fPlugin.deactivateIfNeeded();

  893. 

  894.         return V3_OK;

  895.     }

  896. 

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

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

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

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

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

  902.      */

  903.     v3_result setState(v3_bstream** const stream)

  904.     {

  905.        #if DISTRHO_PLUGIN_HAS_UI

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

  907.        #endif

  908.         String key, value;

  909.         bool hasValue = false;

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

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

  912. 

  913.         char buffer[512], orig;

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

  915.         v3_result res;

  916. 

  917.         for (int32_t terminated = 0, read; terminated == 0;)

  918.         {

  919.             read = -1;

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

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

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

  923. 

  924.             if (read == 0)

  925.                 return V3_OK;

  926. 

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

  928.             {

  929.                 // found terminator, stop here

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

  931.                 {

  932.                     terminated = 1;

  933.                     break;

  934.                 }

  935. 

  936.                 // store character at read position

  937.                 orig = buffer[read];

  938. 

  939.                 // place null character to create valid string

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

  941. 

  942.                 // append to temporary vars

  943.                 if (fillingKey)

  944.                 {

  945.                     key += buffer + i;

  946.                 }

  947.                 else

  948.                 {

  949.                     value += buffer + i;

  950.                     hasValue = true;

  951.                 }

  952. 

  953.                 // increase buffer offset by length of string

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

  955. 

  956.                 // restore read character

  957.                 buffer[read] = orig;

  958. 

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

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

  961.                 {

  962.                     // special keys

  963.                     if (key == "__dpf_state_begin__")

  964.                     {

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

  966.                                                        queryingType, V3_INTERNAL_ERR);

  967.                         queryingType = 's';

  968.                         key.clear();

  969.                         value.clear();

  970.                         hasValue = false;

  971.                         continue;

  972.                     }

  973.                     if (key == "__dpf_state_end__")

  974.                     {

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

  976.                         queryingType = 'n';

  977.                         key.clear();

  978.                         value.clear();

  979.                         hasValue = false;

  980.                         continue;

  981.                     }

  982.                     if (key == "__dpf_parameters_begin__")

  983.                     {

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

  985.                                                        queryingType, V3_INTERNAL_ERR);

  986.                         queryingType = 'p';

  987.                         key.clear();

  988.                         value.clear();

  989.                         hasValue = false;

  990.                         continue;

  991.                     }

  992.                     if (key == "__dpf_parameters_end__")

  993.                     {

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

  995.                         queryingType = 'x';

  996.                         key.clear();

  997.                         value.clear();

  998.                         hasValue = false;

  999.                         continue;

  1000.                     }

  1001. 

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

  1003.                     fillingKey = !fillingKey;

  1004. 

  1005.                     // if there is no value yet keep reading until we have one

  1006.                     if (! hasValue)

  1007.                         continue;

  1008. 

  1009.                     if (key == "__dpf_program__")

  1010.                     {

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

  1012.                         queryingType = 'n';

  1013. 

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

  1015. 

  1016.                       #if DISTRHO_PLUGIN_WANT_PROGRAMS

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

  1018.                         DISTRHO_SAFE_ASSERT_CONTINUE(program >= 0);

  1019. 

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

  1021.                         fPlugin.loadProgram(fCurrentProgram);

  1022. 

  1023.                        #if DISTRHO_PLUGIN_HAS_UI

  1024.                         if (connectedToUI)

  1025.                         {

  1026.                             fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  1027.                             sendParameterSetToUI(kVst3InternalParameterProgram, program);

  1028.                         }

  1029.                        #endif

  1030.                       #endif

  1031.                     }

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

  1033.                     {

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

  1035. 

  1036.                        #if DISTRHO_PLUGIN_WANT_STATE

  1037.                         if (fPlugin.wantStateKey(key))

  1038.                         {

  1039.                             fStateMap[key] = value;

  1040.                             fPlugin.setState(key, value);

  1041. 

  1042.                            #if DISTRHO_PLUGIN_HAS_UI

  1043.                             if (connectedToUI)

  1044.                                 sendStateSetToUI(key, value);

  1045.                            #endif

  1046.                         }

  1047.                        #endif

  1048.                     }

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

  1050.                     {

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

  1052.                         float fvalue;

  1053. 

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

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

  1056.                         {

  1057.                             if (fPlugin.isParameterOutputOrTrigger(j))

  1058.                                 continue;

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

  1060.                                 continue;

  1061. 

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

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

  1064.                             else

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

  1066. 

  1067.                             fCachedParameterValues[kVst3InternalParameterBaseCount + j] = fvalue;

  1068.                            #if DISTRHO_PLUGIN_HAS_UI

  1069.                             if (connectedToUI)

  1070.                             {

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

  1072.                                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + j] = true;

  1073.                             }

  1074.                            #endif

  1075.                             fPlugin.setParameterValue(j, fvalue);

  1076.                             break;

  1077.                         }

  1078.                     }

  1079. 

  1080.                     key.clear();

  1081.                     value.clear();

  1082.                     hasValue = false;

  1083.                 }

  1084.             }

  1085.         }

  1086. 

  1087.         if (fComponentHandler != nullptr)

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

  1089. 

  1090.        #if DISTRHO_PLUGIN_HAS_UI

  1091.         if (connectedToUI)

  1092.         {

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

  1094.             {

  1095.                 if (fPlugin.isParameterOutputOrTrigger(i))

  1096.                     continue;

  1097.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  1098.                 sendParameterSetToUI(kVst3InternalParameterBaseCount + i,

  1099.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  1100.             }

  1101.         }

  1102.        #endif

  1103. 

  1104.         return V3_OK;

  1105.     }

  1106. 

  1107.     v3_result getState(v3_bstream** const stream)

  1108.     {

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

  1110.        #if DISTRHO_PLUGIN_WANT_STATE

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

  1112.        #else

  1113.         const uint32_t stateCount = 0;

  1114.        #endif

  1115. 

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

  1117.         {

  1118.             char buffer = '\0';

  1119.             int32_t ignored;

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

  1121.         }

  1122. 

  1123.        #if DISTRHO_PLUGIN_WANT_FULL_STATE

  1124.         // Update current state

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

  1126.         {

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

  1128.             fStateMap[key] = fPlugin.getStateValue(key);

  1129.         }

  1130.        #endif

  1131. 

  1132.         String state;

  1133. 

  1134.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1135.         {

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

  1137.             tmpStr += String(fCurrentProgram);

  1138.             tmpStr += "\xff";

  1139. 

  1140.             state += tmpStr;

  1141.         }

  1142.        #endif

  1143. 

  1144.        #if DISTRHO_PLUGIN_WANT_STATE

  1145.         if (stateCount != 0)

  1146.         {

  1147.             state += "__dpf_state_begin__\xff";

  1148. 

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

  1150.             {

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

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

  1153. 

  1154.                 // join key and value

  1155.                 String tmpStr;

  1156.                 tmpStr  = key;

  1157.                 tmpStr += "\xff";

  1158.                 tmpStr += value;

  1159.                 tmpStr += "\xff";

  1160. 

  1161.                 state += tmpStr;

  1162.             }

  1163. 

  1164.             state += "__dpf_state_end__\xff";

  1165.         }

  1166.        #endif

  1167. 

  1168.         if (paramCount != 0)

  1169.         {

  1170.             state += "__dpf_parameters_begin__\xff";

  1171. 

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

  1173.             {

  1174.                 if (fPlugin.isParameterOutputOrTrigger(i))

  1175.                     continue;

  1176. 

  1177.                 // join key and value

  1178.                 String tmpStr;

  1179.                 tmpStr  = fPlugin.getParameterSymbol(i);

  1180.                 tmpStr += "\xff";

  1181.                 if (fPlugin.getParameterHints(i) & kParameterIsInteger)

  1182.                     tmpStr += String(static_cast<int>(std::round(fPlugin.getParameterValue(i))));

  1183.                 else

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

  1185.                 tmpStr += "\xff";

  1186. 

  1187.                 state += tmpStr;

  1188.             }

  1189. 

  1190.             state += "__dpf_parameters_end__\xff";

  1191.         }

  1192. 

  1193.         // terminator

  1194.         state += "\xfe";

  1195. 

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

  1197. 

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

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

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

  1201.         v3_result res;

  1202. 

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

  1204.         {

  1205.             wrtn = 0;

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

  1207. 

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

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

  1210.         }

  1211. 

  1212.         return V3_OK;

  1213.     }

  1214. 

  1215.     // ----------------------------------------------------------------------------------------------------------------

  1216.     // v3_audio_processor interface calls

  1217. 

  1218.     v3_result setBusArrangements(v3_speaker_arrangement* const inputs, const int32_t numInputs,

  1219.                                  v3_speaker_arrangement* const outputs, const int32_t numOutputs)

  1220.     {

  1221.        #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  1222.         DISTRHO_SAFE_ASSERT_RETURN(numInputs >= 0, V3_INVALID_ARG);

  1223.         if (!setAudioBusArrangement<true>(inputs, static_cast<uint32_t>(numInputs)))

  1224.             return V3_INTERNAL_ERR;

  1225.        #else

  1226.         DISTRHO_SAFE_ASSERT_RETURN(numInputs == 0, V3_INVALID_ARG);

  1227.         // unused

  1228.         (void)inputs;

  1229.        #endif

  1230. 

  1231.        #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  1232.         DISTRHO_SAFE_ASSERT_RETURN(numOutputs >= 0, V3_INVALID_ARG);

  1233.         if (!setAudioBusArrangement<false>(outputs, static_cast<uint32_t>(numOutputs)))

  1234.             return V3_INTERNAL_ERR;

  1235.        #else

  1236.         DISTRHO_SAFE_ASSERT_RETURN(numOutputs == 0, V3_INVALID_ARG);

  1237.         // unused

  1238.         (void)outputs;

  1239.        #endif

  1240. 

  1241.         return V3_OK;

  1242.     }

  1243. 

  1244.     v3_result getBusArrangement(const int32_t busDirection, const int32_t busIndex, v3_speaker_arrangement* const speaker) const noexcept

  1245.     {

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

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

  1248.         DISTRHO_SAFE_ASSERT_RETURN(speaker != nullptr, V3_INVALID_ARG);

  1249. 

  1250.        #if DISTRHO_PLUGIN_NUM_INPUTS > 0 || DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  1252.        #endif

  1253. 

  1254.         if (busDirection == V3_INPUT)

  1255.         {

  1256.            #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  1257.             if (getAudioBusArrangement<true>(busId, speaker))

  1258.                 return V3_OK;

  1259.            #endif

  1260.             d_stdout("invalid input bus arrangement %d", busIndex);

  1261.             return V3_INVALID_ARG;

  1262.         }

  1263.         else

  1264.         {

  1265.            #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  1266.             if (getAudioBusArrangement<false>(busId, speaker))

  1267.                 return V3_OK;

  1268.            #endif

  1269.             d_stdout("invalid output bus arrangement %d", busIndex);

  1270.             return V3_INVALID_ARG;

  1271.         }

  1272.     }

  1273. 

  1274.     uint32_t getLatencySamples() const noexcept

  1275.     {

  1276.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1277.         return fPlugin.getLatency();

  1278.        #else

  1279.         return 0;

  1280.        #endif

  1281.     }

  1282. 

  1283.     v3_result setupProcessing(v3_process_setup* const setup)

  1284.     {

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

  1286. 

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

  1288.         fPlugin.deactivateIfNeeded();

  1289. 

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

  1291. 

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

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

  1294. 

  1295.       #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  1297.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterBufferSize] = true;

  1298. 

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

  1300.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterSampleRate] = true;

  1301.        #if DISTRHO_PLUGIN_HAS_UI

  1302.         fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = true;

  1303.        #endif

  1304.       #endif

  1305. 

  1306.         if (active)

  1307.             fPlugin.activate();

  1308. 

  1309.         delete[] fDummyAudioBuffer;

  1310.         fDummyAudioBuffer = new float[setup->max_block_size];

  1311. 

  1312.         return V3_OK;

  1313.     }

  1314. 

  1315.     v3_result setProcessing(const bool processing)

  1316.     {

  1317.         if (processing)

  1318.         {

  1319.             if (! fPlugin.isActive())

  1320.                 fPlugin.activate();

  1321.         }

  1322.         else

  1323.         {

  1324.             fPlugin.deactivateIfNeeded();

  1325.         }

  1326. 

  1327.         return V3_OK;

  1328.     }

  1329. 

  1330.     v3_result process(v3_process_data* const data)

  1331.     {

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

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

  1334. 

  1335.         // activate plugin if not done yet

  1336.         if (! fPlugin.isActive())

  1337.             fPlugin.activate();

  1338. 

  1339.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

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

  1341.         {

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

  1343. 

  1344.             // ticksPerBeat is not possible with VST3

  1345.             fTimePosition.bbt.ticksPerBeat = 1920.0;

  1346. 

  1347.             if (ctx->state & V3_PROCESS_CTX_CONT_TIME_VALID)

  1348.                 fTimePosition.frame = ctx->continuous_time_in_samples;

  1349.             else

  1350.                 fTimePosition.frame = ctx->project_time_in_samples;

  1351. 

  1352.             if (ctx->state & V3_PROCESS_CTX_TEMPO_VALID)

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

  1354.             else

  1355.                 fTimePosition.bbt.beatsPerMinute = 120.0;

  1356. 

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

  1358.             {

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

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

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

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

  1363. 

  1364.                 fTimePosition.bbt.valid       = true;

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

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

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

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

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

  1370. 

  1371.                 if (ctx->project_time_quarters < 0.0)

  1372.                 {

  1373.                     --fTimePosition.bbt.bar;

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

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

  1376.                 }

  1377.             }

  1378.             else

  1379.             {

  1380.                 fTimePosition.bbt.valid       = false;

  1381.                 fTimePosition.bbt.bar         = 1;

  1382.                 fTimePosition.bbt.beat        = 1;

  1383.                 fTimePosition.bbt.tick        = 0.0;

  1384.                 fTimePosition.bbt.beatsPerBar = 4.0f;

  1385.                 fTimePosition.bbt.beatType    = 4.0f;

  1386.             }

  1387. 

  1388.             fTimePosition.bbt.barStartTick = fTimePosition.bbt.ticksPerBeat*

  1389.                                              fTimePosition.bbt.beatsPerBar*

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

  1391. 

  1392.             fPlugin.setTimePosition(fTimePosition);

  1393.         }

  1394.        #endif

  1395. 

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

  1397.         {

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

  1399.             return V3_OK;

  1400.         }

  1401. 

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

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

  1404. 

  1405.         std::memset(fDummyAudioBuffer, 0, sizeof(float)*data->nframes);

  1406. 

  1407.         {

  1408.             int32_t i = 0;

  1409.            #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  1411.             {

  1412.                 for (int32_t j = 0; j < data->inputs->num_channels; ++j)

  1413.                 {

  1414.                     while (!fEnabledInputs[i] && i < DISTRHO_PLUGIN_NUM_INPUTS)

  1415.                         inputs[i++] = fDummyAudioBuffer;

  1416. 

  1417.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_INPUTS, i);

  1418.                     inputs[i++] = data->inputs->channel_buffers_32[j];

  1419.                 }

  1420.             }

  1421.            #endif

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

  1423.                 inputs[i] = fDummyAudioBuffer;

  1424.         }

  1425. 

  1426.         {

  1427.             int32_t i = 0;

  1428.            #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  1430.             {

  1431.                 for (int32_t j = 0; j < data->outputs->num_channels; ++j)

  1432.                 {

  1433.                     while (!fEnabledOutputs[i] && i < DISTRHO_PLUGIN_NUM_OUTPUTS)

  1434.                         outputs[i++] = fDummyAudioBuffer;

  1435. 

  1436.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_OUTPUTS, i);

  1437.                     outputs[i++] = data->outputs->channel_buffers_32[j];

  1438.                 }

  1439.             }

  1440.            #endif

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

  1442.                 outputs[i] = fDummyAudioBuffer;

  1443.         }

  1444. 

  1445.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1446.         fHostEventOutputHandle = data->output_events;

  1447.        #endif

  1448. 

  1449.       #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1450.         bool canAppendMoreEvents = true;

  1451.         inputEventList.init();

  1452. 

  1453.        #if DISTRHO_PLUGIN_HAS_UI

  1454.         while (fNotesRingBuffer.isDataAvailableForReading())

  1455.         {

  1456.             uint8_t midiData[3];

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

  1458.                 break;

  1459. 

  1460.             if (inputEventList.appendFromUI(midiData))

  1461.             {

  1462.                 canAppendMoreEvents = false;

  1463.                 break;

  1464.             }

  1465.         }

  1466.        #endif

  1467. 

  1468.         if (canAppendMoreEvents)

  1469.         {

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

  1471.             {

  1472.                 v3_event event;

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

  1474.                 {

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

  1476.                         break;

  1477. 

  1478.                     if (inputEventList.appendEvent(event))

  1479.                     {

  1480.                         canAppendMoreEvents = false;

  1481.                         break;

  1482.                     }

  1483.                 }

  1484.             }

  1485.         }

  1486.       #endif

  1487. 

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

  1489.         {

  1490.             int32_t offset;

  1491.             double value;

  1492. 

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

  1494.             {

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

  1496.                 DISTRHO_SAFE_ASSERT_BREAK(queue != nullptr);

  1497. 

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

  1499.                 DISTRHO_SAFE_ASSERT_UINT_BREAK(rindex < fVst3ParameterCount, rindex);

  1500. 

  1501.                #if DPF_VST3_HAS_INTERNAL_PARAMETERS

  1502.                 if (rindex < kVst3InternalParameterCount)

  1503.                 {

  1504.                    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1505.                     // if there are any MIDI CC events as parameter changes, handle them here

  1506.                     if (canAppendMoreEvents && rindex >= kVst3InternalParameterMidiCC_start && rindex <= kVst3InternalParameterMidiCC_end)

  1507.                     {

  1508.                         for (int32_t j = 0, pcount = v3_cpp_obj(queue)->get_point_count(queue); j < pcount; ++j)

  1509.                         {

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

  1511.                                 break;

  1512. 

  1513.                             if (inputEventList.appendCC(offset, rindex, value))

  1514.                             {

  1515.                                 canAppendMoreEvents = false;

  1516.                                 break;

  1517.                             }

  1518.                         }

  1519.                     }

  1520.                    #endif

  1521.                     continue;

  1522.                 }

  1523.                #endif

  1524. 

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

  1526.                     continue;

  1527. 

  1528.                 // if there are any parameter changes at frame 0, handle them here

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

  1530.                     break;

  1531. 

  1532.                 if (offset != 0)

  1533.                     continue;

  1534. 

  1535.                 const uint32_t index = rindex - kVst3InternalParameterCount;

  1536.                 setNormalizedPluginParameterValue(index, value);

  1537.             }

  1538.         }

  1539. 

  1540.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1541.         const uint32_t midiEventCount = inputEventList.convert(fMidiEvents);

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

  1543.        #else

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

  1545.        #endif

  1546. 

  1547.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1548.         fHostEventOutputHandle = nullptr;

  1549.        #endif

  1550. 

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

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

  1553.         {

  1554.             int32_t offset;

  1555.             double value;

  1556. 

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

  1558.             {

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

  1560.                 DISTRHO_SAFE_ASSERT_BREAK(queue != nullptr);

  1561. 

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

  1563.                 DISTRHO_SAFE_ASSERT_UINT_BREAK(rindex < fVst3ParameterCount, rindex);

  1564. 

  1565.                #if DPF_VST3_HAS_INTERNAL_PARAMETERS

  1566.                 if (rindex < kVst3InternalParameterCount)

  1567.                     continue;

  1568.                #endif

  1569. 

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

  1571. 

  1572.                 if (pcount <= 0)

  1573.                     continue;

  1574. 

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

  1576.                     break;

  1577. 

  1578.                 if (offset == 0)

  1579.                     continue;

  1580. 

  1581.                 const uint32_t index = rindex - kVst3InternalParameterCount;

  1582.                 setNormalizedPluginParameterValue(index, value);

  1583.             }

  1584.         }

  1585. 

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

  1587.         return V3_OK;

  1588.     }

  1589. 

  1590.     uint32_t getTailSamples() const noexcept

  1591.     {

  1592.         return 0;

  1593.     }

  1594. 

  1595.     // ----------------------------------------------------------------------------------------------------------------

  1596.     // v3_edit_controller interface calls

  1597. 

  1598.     int32_t getParameterCount() const noexcept

  1599.     {

  1600.         return fVst3ParameterCount;

  1601.     }

  1602. 

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

  1604.     {

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

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

  1607. 

  1608.         // TODO hash the parameter symbol

  1609.         info->param_id = rindex;

  1610. 

  1611.         switch (rindex)

  1612.         {

  1613.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1614.         case kVst3InternalParameterBufferSize:

  1615.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

  1616.             info->step_count = DPF_VST3_MAX_BUFFER_SIZE - 1;

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

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

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

  1620.             return V3_OK;

  1621.         case kVst3InternalParameterSampleRate:

  1622.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

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

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

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

  1626.             return V3_OK;

  1627.        #endif

  1628.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1629.         case kVst3InternalParameterLatency:

  1630.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

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

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

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

  1634.             return V3_OK;

  1635.        #endif

  1636.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1637.         case kVst3InternalParameterProgram:

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

  1639.             info->step_count = fProgramCountMinusOne;

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

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

  1642.             return V3_OK;

  1643.        #endif

  1644.         }

  1645. 

  1646.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1647.         if (rindex < kVst3InternalParameterCount)

  1648.         {

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

  1650.             info->flags = V3_PARAM_CAN_AUTOMATE | V3_PARAM_IS_HIDDEN;

  1651.             info->step_count = 127;

  1652.             char ccstr[24];

  1653.             snprintf(ccstr, sizeof(ccstr), "MIDI Ch. %d CC %d", static_cast<uint8_t>(index / 130) + 1, index % 130);

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

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

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

  1657.             return V3_OK;

  1658.         }

  1659.        #endif

  1660. 

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

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

  1663. 

  1664.         // set up flags

  1665.         int32_t flags = 0;

  1666. 

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

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

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

  1670. 

  1671.         switch (fPlugin.getParameterDesignation(index))

  1672.         {

  1673.         case kParameterDesignationNull:

  1674.             break;

  1675.         case kParameterDesignationBypass:

  1676.             flags |= V3_PARAM_IS_BYPASS;

  1677.             break;

  1678.         }

  1679. 

  1680.         if (hints & kParameterIsAutomatable)

  1681.             flags |= V3_PARAM_CAN_AUTOMATE;

  1682.         if (hints & kParameterIsOutput)

  1683.             flags |= V3_PARAM_READ_ONLY;

  1684. 

  1685.         // set up step_count

  1686.         int32_t step_count = 0;

  1687. 

  1688.         if (hints & kParameterIsBoolean)

  1689.             step_count = 1;

  1690.         else if (hints & kParameterIsInteger)

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

  1692. 

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

  1694.         {

  1695.             flags |= V3_PARAM_IS_LIST;

  1696.             step_count = enumValues.count - 1;

  1697.         }

  1698. 

  1699.         info->flags = flags;

  1700.         info->step_count = step_count;

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

  1702.         // int32_t unit_id;

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

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

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

  1706.         return V3_OK;

  1707.     }

  1708. 

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

  1710.     {

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

  1712. 

  1713.         switch (rindex)

  1714.         {

  1715.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1716.         case kVst3InternalParameterBufferSize:

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

  1718.             return V3_OK;

  1719.         case kVst3InternalParameterSampleRate:

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

  1721.             return V3_OK;

  1722.        #endif

  1723.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1724.         case kVst3InternalParameterLatency:

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

  1726.             return V3_OK;

  1727.        #endif

  1728.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1729.         case kVst3InternalParameterProgram:

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

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

  1732.             return V3_OK;

  1733.        #endif

  1734.         }

  1735. 

  1736.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1737.         if (rindex < kVst3InternalParameterCount)

  1738.         {

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

  1740.             return V3_OK;

  1741.         }

  1742.        #endif

  1743. 

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

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

  1746. 

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

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

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

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

  1751. 

  1752.         if (hints & kParameterIsBoolean)

  1753.         {

  1754.             const float midRange = ranges.min + (ranges.max - ranges.min) * 0.5f;

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

  1756.         }

  1757.         else if (hints & kParameterIsInteger)

  1758.         {

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

  1760.         }

  1761. 

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

  1763.         {

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

  1765.             {

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

  1767.                 return V3_OK;

  1768.             }

  1769.         }

  1770. 

  1771.         if (hints & kParameterIsInteger)

  1772.             snprintf_i32_utf16(output, value, 128);

  1773.         else

  1774.             snprintf_f32_utf16(output, value, 128);

  1775. 

  1776.         return V3_OK;

  1777.     }

  1778. 

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

  1780.     {

  1781.         switch (rindex)

  1782.         {

  1783.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1784.         case kVst3InternalParameterBufferSize:

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

  1786.             return V3_OK;

  1787.         case kVst3InternalParameterSampleRate:

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

  1789.             return V3_OK;

  1790.        #endif

  1791.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1792.         case kVst3InternalParameterLatency:

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

  1794.             return V3_OK;

  1795.        #endif

  1796.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1797.         case kVst3InternalParameterProgram:

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

  1799.             {

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

  1801.                 {

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

  1803.                     return V3_OK;

  1804.                 }

  1805.             }

  1806.             return V3_INVALID_ARG;

  1807.        #endif

  1808.         }

  1809. 

  1810.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1811.         if (rindex < kVst3InternalParameterCount)

  1812.         {

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

  1814.             return V3_NOT_IMPLEMENTED;

  1815.         }

  1816.        #endif

  1817. 

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

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

  1820. 

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

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

  1823. 

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

  1825.         {

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

  1827.             {

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

  1829.                 return V3_OK;

  1830.             }

  1831.         }

  1832. 

  1833.         const ScopedUTF8String input8(input);

  1834. 

  1835.         float value;

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

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

  1838.         else

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

  1840. 

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

  1842.         return V3_OK;

  1843.     }

  1844. 

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

  1846.     {

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

  1848. 

  1849.         switch (rindex)

  1850.         {

  1851.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1852.         case kVst3InternalParameterBufferSize:

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

  1854.         case kVst3InternalParameterSampleRate:

  1855.             return normalized * DPF_VST3_MAX_SAMPLE_RATE;

  1856.        #endif

  1857.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1858.         case kVst3InternalParameterLatency:

  1859.             return normalized * DPF_VST3_MAX_LATENCY;

  1860.        #endif

  1861.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1862.         case kVst3InternalParameterProgram:

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

  1864.        #endif

  1865.         }

  1866. 

  1867.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1868.         if (rindex < kVst3InternalParameterCount)

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

  1870.        #endif

  1871. 

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

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

  1874. 

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

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

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

  1878. 

  1879.         if (hints & kParameterIsBoolean)

  1880.         {

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

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

  1883.         }

  1884.         else if (hints & kParameterIsInteger)

  1885.         {

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

  1887.         }

  1888. 

  1889.         return value;

  1890.     }

  1891. 

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

  1893.     {

  1894.         switch (rindex)

  1895.         {

  1896.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1897.         case kVst3InternalParameterBufferSize:

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

  1899.         case kVst3InternalParameterSampleRate:

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

  1901.        #endif

  1902.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1903.         case kVst3InternalParameterLatency:

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

  1905.        #endif

  1906.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1907.         case kVst3InternalParameterProgram:

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

  1909.        #endif

  1910.         }

  1911. 

  1912.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1913.         if (rindex < kVst3InternalParameterCount)

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

  1915.        #endif

  1916. 

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

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

  1919. 

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

  1921.         return ranges.getNormalizedValue(plain);

  1922.     }

  1923. 

  1924.     double getParameterNormalized(const v3_param_id rindex)

  1925.     {

  1926.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1927.         // TODO something to do here?

  1928.         if (

  1929.            #if !DPF_VST3_PURE_MIDI_INTERNAL_PARAMETERS

  1930.             rindex >= kVst3InternalParameterMidiCC_start &&

  1931.            #endif

  1932.             rindex <= kVst3InternalParameterMidiCC_end)

  1933.             return 0.0;

  1934.        #endif

  1935. 

  1936.        #if DPF_VST3_USES_SEPARATE_CONTROLLER || DISTRHO_PLUGIN_WANT_LATENCY || DISTRHO_PLUGIN_WANT_PROGRAMS

  1937.         switch (rindex)

  1938.         {

  1939.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1940.         case kVst3InternalParameterBufferSize:

  1941.         case kVst3InternalParameterSampleRate:

  1942.        #endif

  1943.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1944.         case kVst3InternalParameterLatency:

  1945.        #endif

  1946.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1947.         case kVst3InternalParameterProgram:

  1948.        #endif

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

  1950.         }

  1951.        #endif

  1952. 

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

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

  1955. 

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

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

  1958.     }

  1959. 

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

  1961.     {

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

  1963. 

  1964.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1965.         // TODO something to do here?

  1966.         if (

  1967.            #if !DPF_VST3_PURE_MIDI_INTERNAL_PARAMETERS

  1968.             rindex >= kVst3InternalParameterMidiCC_start &&

  1969.            #endif

  1970.             rindex <= kVst3InternalParameterMidiCC_end)

  1971.             return V3_INVALID_ARG;

  1972.        #endif

  1973. 

  1974.        #if DPF_VST3_HAS_INTERNAL_PARAMETERS && !DPF_VST3_PURE_MIDI_INTERNAL_PARAMETERS

  1975.         if (rindex < kVst3InternalParameterBaseCount)

  1976.         {

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

  1978.             int flags = 0;

  1979. 

  1980.             switch (rindex)

  1981.             {

  1982.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1983.             case kVst3InternalParameterBufferSize:

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

  1985.                 break;

  1986.             case kVst3InternalParameterSampleRate:

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

  1988.                 break;

  1989.            #endif

  1990.            #if DISTRHO_PLUGIN_WANT_LATENCY

  1991.             case kVst3InternalParameterLatency:

  1992.                 flags = V3_RESTART_LATENCY_CHANGED;

  1993.                 break;

  1994.            #endif

  1995.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1996.             case kVst3InternalParameterProgram:

  1997.                 flags = V3_RESTART_PARAM_VALUES_CHANGED;

  1998.                 fCurrentProgram = fCachedParameterValues[rindex];

  1999.                 fPlugin.loadProgram(fCurrentProgram);

  2000. 

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

  2002.                 {

  2003.                     if (fPlugin.isParameterOutputOrTrigger(i))

  2004.                         continue;

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

  2006.                 }

  2007. 

  2008.                #if DISTRHO_PLUGIN_HAS_UI

  2009.                 fParameterValueChangesForUI[kVst3InternalParameterProgram] = true;

  2010.                #endif

  2011.                 break;

  2012.            #endif

  2013.             }

  2014. 

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

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

  2017. 

  2018.             return V3_OK;

  2019.         }

  2020.        #endif

  2021. 

  2022.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  2025. 

  2026.         setNormalizedPluginParameterValue(index, normalized);

  2027.        #endif

  2028.         return V3_OK;

  2029. 

  2030.        #if !DPF_VST3_HAS_INTERNAL_PARAMETERS

  2031.         // unused

  2032.         (void)rindex;

  2033.        #endif

  2034.     }

  2035. 

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

  2037.     {

  2038.         fComponentHandler = handler;

  2039.         return V3_OK;

  2040.     }

  2041. 

  2042. #if DISTRHO_PLUGIN_HAS_UI

  2043.     // ----------------------------------------------------------------------------------------------------------------

  2044.     // v3_connection_point interface calls

  2045. 

  2046.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2047.     void comp2ctrl_connect(v3_connection_point** const other)

  2048.     {

  2049.         fConnectionFromCompToCtrl = other;

  2050.     }

  2051. 

  2052.     void comp2ctrl_disconnect()

  2053.     {

  2054.         fConnectionFromCompToCtrl = nullptr;

  2055.     }

  2056. 

  2057.     v3_result comp2ctrl_notify(v3_message** const message)

  2058.     {

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

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

  2061. 

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

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

  2064. 

  2065.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  2067.             return notify_midi(attrs);

  2068.        #endif

  2069. 

  2070.        #if DISTRHO_PLUGIN_WANT_STATE

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

  2072.             return notify_state(attrs);

  2073.        #endif

  2074. 

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

  2076. 

  2077.         return V3_NOT_IMPLEMENTED;

  2078.     }

  2079.    #endif // DPF_VST3_USES_SEPARATE_CONTROLLER

  2080. 

  2081.     // ----------------------------------------------------------------------------------------------------------------

  2082. 

  2083.     void ctrl2view_connect(v3_connection_point** const other)

  2084.     {

  2085.         DISTRHO_SAFE_ASSERT(fConnectedToUI == false);

  2086. 

  2087.         fConnectionFromCtrlToView = other;

  2088.         fConnectedToUI = false;

  2089.     }

  2090. 

  2091.     void ctrl2view_disconnect()

  2092.     {

  2093.         fConnectedToUI = false;

  2094.         fConnectionFromCtrlToView = nullptr;

  2095.     }

  2096. 

  2097.     v3_result ctrl2view_notify(v3_message** const message)

  2098.     {

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

  2100. 

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

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

  2103. 

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

  2105.         {

  2106.             fConnectedToUI = true;

  2107. 

  2108.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2109.             fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = false;

  2110.             sendParameterSetToUI(kVst3InternalParameterSampleRate,

  2111.                                  fCachedParameterValues[kVst3InternalParameterSampleRate]);

  2112.            #endif

  2113. 

  2114.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2115.             fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  2116.             sendParameterSetToUI(kVst3InternalParameterProgram, fCurrentProgram);

  2117.            #endif

  2118. 

  2119.            #if DISTRHO_PLUGIN_WANT_FULL_STATE

  2120.             // Update current state from plugin side

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

  2122.             {

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

  2124.                 fStateMap[key] = fPlugin.getStateValue(key);

  2125.             }

  2126.            #endif

  2127. 

  2128.            #if DISTRHO_PLUGIN_WANT_STATE

  2129.             // Set state

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

  2131.             {

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

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

  2134. 

  2135.                 sendStateSetToUI(key, value);

  2136.             }

  2137.            #endif

  2138. 

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

  2140.             {

  2141.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  2142.                 sendParameterSetToUI(kVst3InternalParameterBaseCount + i,

  2143.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  2144.             }

  2145. 

  2146.             sendReadyToUI();

  2147.             return V3_OK;

  2148.         }

  2149. 

  2150.         DISTRHO_SAFE_ASSERT_RETURN(fConnectedToUI, V3_INTERNAL_ERR);

  2151. 

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

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

  2154. 

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

  2156.         {

  2157.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2158.             if (fParameterValueChangesForUI[kVst3InternalParameterSampleRate])

  2159.             {

  2160.                 fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = false;

  2161.                 sendParameterSetToUI(kVst3InternalParameterSampleRate,

  2162.                                      fCachedParameterValues[kVst3InternalParameterSampleRate]);

  2163.             }

  2164.            #endif

  2165. 

  2166.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2167.             if (fParameterValueChangesForUI[kVst3InternalParameterProgram])

  2168.             {

  2169.                 fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  2170.                 sendParameterSetToUI(kVst3InternalParameterProgram, fCurrentProgram);

  2171.             }

  2172.            #endif

  2173. 

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

  2175.             {

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

  2177.                     continue;

  2178. 

  2179.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  2180.                 sendParameterSetToUI(kVst3InternalParameterBaseCount + i,

  2181.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  2182.             }

  2183. 

  2184.             sendReadyToUI();

  2185.             return V3_OK;

  2186.         }

  2187. 

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

  2189.         {

  2190.             fConnectedToUI = false;

  2191.             return V3_OK;

  2192.         }

  2193. 

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

  2195.         {

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

  2197. 

  2198.             int64_t rindex;

  2199.             int64_t started;

  2200.             v3_result res;

  2201. 

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

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

  2204.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex >= kVst3InternalParameterCount,

  2205.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2206.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex < kVst3InternalParameterCount + fParameterCount,

  2207.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2208. 

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

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

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

  2212. 

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

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

  2215.         }

  2216. 

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

  2218.         {

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

  2220. 

  2221.             int64_t rindex;

  2222.             double value;

  2223.             v3_result res;

  2224. 

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

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

  2227.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex >= kVst3InternalParameterCount,

  2228.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2229.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex < kVst3InternalParameterCount + fParameterCount,

  2230.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2231. 

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

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

  2234. 

  2235.             const uint32_t index = rindex - kVst3InternalParameterCount;

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

  2237. 

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

  2239.         }

  2240. 

  2241.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  2243.         {

  2244.            #if 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_midi(attrs);

  2249.            #endif

  2250.         }

  2251.        #endif

  2252. 

  2253.        #if DISTRHO_PLUGIN_WANT_STATE

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

  2255.         {

  2256.             const v3_result res = notify_state(attrs);

  2257. 

  2258.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2259.             if (res != V3_OK)

  2260.                 return res;

  2261. 

  2262.             // notify component of the change

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

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

  2265.            #else

  2266.             return res;

  2267.            #endif

  2268.         }

  2269.        #endif

  2270. 

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

  2272. 

  2273.         return V3_NOT_IMPLEMENTED;

  2274.     }

  2275. 

  2276.    #if DISTRHO_PLUGIN_WANT_STATE

  2277.     v3_result notify_state(v3_attribute_list** const attrs)

  2278.     {

  2279.         int64_t keyLength = -1;

  2280.         int64_t valueLength = -1;

  2281.         v3_result res;

  2282. 

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

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

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

  2286. 

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

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

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

  2290. 

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

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

  2293. 

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

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

  2296. 

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

  2298.         DISTRHO_SAFE_ASSERT_INT2_RETURN(res == V3_OK, res, keyLength, res);

  2299. 

  2300.         if (valueLength != 0)

  2301.         {

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

  2303.             DISTRHO_SAFE_ASSERT_INT2_RETURN(res == V3_OK, res, valueLength, res);

  2304.         }

  2305. 

  2306.         // do cheap inline conversion

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

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

  2309. 

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

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

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

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

  2314. 

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

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

  2317. 

  2318.         fPlugin.setState(key, value);

  2319. 

  2320.         // save this key as needed

  2321.         if (fPlugin.wantStateKey(key))

  2322.         {

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

  2324.             {

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

  2326. 

  2327.                 if (dkey == key)

  2328.                 {

  2329.                     it->second = value;

  2330.                     std::free(key16);

  2331.                     std::free(value16);

  2332.                     return V3_OK;

  2333.                 }

  2334.             }

  2335. 

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

  2337.         }

  2338. 

  2339.         std::free(key16);

  2340.         std::free(value16);

  2341.         return V3_OK;

  2342.     }

  2343.    #endif // DISTRHO_PLUGIN_WANT_STATE

  2344. 

  2345.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2346.     v3_result notify_midi(v3_attribute_list** const attrs)

  2347.     {

  2348.         uint8_t* data;

  2349.         uint32_t size;

  2350.         v3_result res;

  2351. 

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

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

  2354. 

  2355.         // known maximum size

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

  2357. 

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

  2359.     }

  2360.    #endif // DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2361. #endif

  2362. 

  2363.     // ----------------------------------------------------------------------------------------------------------------

  2364. 

  2365. private:

  2366.     // Plugin

  2367.     PluginExporter fPlugin;

  2368. 

  2369.     // VST3 stuff

  2370.     v3_component_handler** fComponentHandler;

  2371.   #if DISTRHO_PLUGIN_HAS_UI

  2372.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2373.     v3_connection_point** fConnectionFromCompToCtrl;

  2374.    #endif

  2375.     v3_connection_point** fConnectionFromCtrlToView;

  2376.     v3_host_application** const fHostApplication;

  2377.   #endif

  2378. 

  2379.     // Temporary data

  2380.     const uint32_t fParameterCount;

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

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

  2383.     float* fDummyAudioBuffer;

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

  2385.    #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  2386.     bool fEnabledInputs[DISTRHO_PLUGIN_NUM_INPUTS];

  2387.    #endif

  2388.    #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2389.     bool fEnabledOutputs[DISTRHO_PLUGIN_NUM_OUTPUTS];

  2390.    #endif

  2391.    #if DISTRHO_PLUGIN_HAS_UI

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

  2393.     bool fConnectedToUI;

  2394.    #endif

  2395.    #if DISTRHO_PLUGIN_WANT_LATENCY

  2396.     uint32_t fLastKnownLatency;

  2397.    #endif

  2398.   #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2399.     MidiEvent fMidiEvents[kMaxMidiEvents];

  2400.    #if DISTRHO_PLUGIN_HAS_UI

  2401.     SmallStackRingBuffer fNotesRingBuffer;

  2402.    #endif

  2403.   #endif

  2404.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2405.     v3_event_list** fHostEventOutputHandle;

  2406.    #endif

  2407.    #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2408.     uint32_t fCurrentProgram;

  2409.     const uint32_t fProgramCountMinusOne;

  2410.    #endif

  2411.    #if DISTRHO_PLUGIN_WANT_STATE

  2412.     StringMap fStateMap;

  2413.    #endif

  2414.    #if DISTRHO_PLUGIN_WANT_TIMEPOS

  2415.     TimePosition fTimePosition;

  2416.    #endif

  2417. 

  2418.     // ----------------------------------------------------------------------------------------------------------------

  2419.     // helper functions for dealing with buses

  2420. 

  2421.    #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2422.     template<bool isInput>

  2423.     void fillInBusInfoDetails()

  2424.     {

  2425.         constexpr const uint32_t numPorts = isInput ? DISTRHO_PLUGIN_NUM_INPUTS : DISTRHO_PLUGIN_NUM_OUTPUTS;

  2426.         BusInfo& busInfo(isInput ? inputBuses : outputBuses);

  2427.         bool* const enabledPorts = isInput

  2428.                                 #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  2429.                                  ? fEnabledInputs

  2430.                                 #else

  2431.                                  ? nullptr

  2432.                                 #endif

  2433.                                 #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2434.                                  : fEnabledOutputs;

  2435.                                 #else

  2436.                                  : nullptr;

  2437.                                 #endif

  2438. 

  2439.         std::vector<uint32_t> visitedPortGroups;

  2440.         for (uint32_t i=0; i<numPorts; ++i)

  2441.         {

  2442.             const AudioPortWithBusId& port(fPlugin.getAudioPort(isInput, i));

  2443. 

  2444.             if (port.groupId != kPortGroupNone)

  2445.             {

  2446.                 const std::vector<uint32_t>::iterator end = visitedPortGroups.end();

  2447.                 if (std::find(visitedPortGroups.begin(), end, port.groupId) == end)

  2448.                 {

  2449.                     visitedPortGroups.push_back(port.groupId);

  2450.                     ++busInfo.groups;

  2451.                 }

  2452.                 ++busInfo.groupPorts;

  2453.                 continue;

  2454.             }

  2455. 

  2456.             if (port.hints & kAudioPortIsCV)

  2457.                 ++busInfo.cvPorts;

  2458.             else if (port.hints & kAudioPortIsSidechain)

  2459.                 ++busInfo.sidechainPorts;

  2460.             else

  2461.                 ++busInfo.audioPorts;

  2462.         }

  2463. 

  2464.         if (busInfo.audioPorts != 0)

  2465.             busInfo.audio = 1;

  2466.         if (busInfo.sidechainPorts != 0)

  2467.             busInfo.sidechain = 1;

  2468. 

  2469.         uint32_t busIdForCV = 0;

  2470.         const std::vector<uint32_t>::iterator vpgStart = visitedPortGroups.begin();

  2471.         const std::vector<uint32_t>::iterator vpgEnd = visitedPortGroups.end();

  2472. 

  2473.         for (uint32_t i=0; i<numPorts; ++i)

  2474.         {

  2475.             AudioPortWithBusId& port(fPlugin.getAudioPort(isInput, i));

  2476. 

  2477.             if (port.groupId != kPortGroupNone)

  2478.             {

  2479.                 port.busId = std::find(vpgStart, vpgEnd, port.groupId) - vpgStart;

  2480. 

  2481.                 if (busInfo.audio == 0 && (port.hints & kAudioPortIsSidechain) == 0x0)

  2482.                     enabledPorts[i] = true;

  2483.             }

  2484.             else

  2485.             {

  2486.                 if (port.hints & kAudioPortIsCV)

  2487.                 {

  2488.                     port.busId = busInfo.audio + busInfo.sidechain + busIdForCV++;

  2489.                 }

  2490.                 else if (port.hints & kAudioPortIsSidechain)

  2491.                 {

  2492.                     port.busId = busInfo.audio;

  2493.                 }

  2494.                 else

  2495.                 {

  2496.                     port.busId = 0;

  2497.                     enabledPorts[i] = true;

  2498.                 }

  2499. 

  2500.                 port.busId += busInfo.groups;

  2501.             }

  2502.         }

  2503.     }

  2504. 

  2505.     template<bool isInput>

  2506.     v3_result getAudioBusInfo(uint32_t busId, v3_bus_info* const info) const

  2507.     {

  2508.         constexpr const uint32_t numPorts = isInput ? DISTRHO_PLUGIN_NUM_INPUTS : DISTRHO_PLUGIN_NUM_OUTPUTS;

  2509.         const BusInfo& busInfo(isInput ? inputBuses : outputBuses);

  2510. 

  2511.         int32_t numChannels;

  2512.         uint32_t flags;

  2513.         v3_bus_types busType;

  2514.         v3_str_128 busName = {};

  2515. 

  2516.         if (busId < busInfo.groups)

  2517.         {

  2518.             numChannels = 0;

  2519. 

  2520.             for (uint32_t i=0; i<numPorts; ++i)

  2521.             {

  2522.                 const AudioPortWithBusId& port(fPlugin.getAudioPort(isInput, i));

  2523. 

  2524.                 if (port.busId == busId)

  2525.                 {

  2526.                     const PortGroupWithId& group(fPlugin.getPortGroupById(port.groupId));

  2527. 

  2528.                     switch (port.groupId)

  2529.                     {

  2530.                     case kPortGroupStereo:

  2531.                     case kPortGroupMono:

  2532.                         strncpy_utf16(busName, isInput ? "Audio Input" : "Audio Output", 128);

  2533.                         break;

  2534.                     default:

  2535.                         if (group.name.isNotEmpty())

  2536.                             strncpy_utf16(busName, group.name, 128);

  2537.                         else

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

  2539.                         break;

  2540.                     }

  2541. 

  2542.                     numChannels = fPlugin.getAudioPortCountWithGroupId(isInput, port.groupId);

  2543. 

  2544.                     if (busInfo.audio == 0 && (port.hints & kAudioPortIsSidechain) == 0x0)

  2545.                     {

  2546.                         busType = V3_MAIN;

  2547.                         flags = V3_DEFAULT_ACTIVE;

  2548.                     }

  2549.                     else

  2550.                     {

  2551.                         busType = V3_AUX;

  2552.                         flags = 0;

  2553.                     }

  2554.                     break;

  2555.                 }

  2556.             }

  2557. 

  2558.             DISTRHO_SAFE_ASSERT_RETURN(numChannels != 0, V3_INTERNAL_ERR);

  2559.         }

  2560.         else

  2561.         {

  2562.             busId -= busInfo.groups;

  2563. 

  2564.             switch (busId)

  2565.             {

  2566.             case 0:

  2567.                 if (busInfo.audio)

  2568.                 {

  2569.                     numChannels = busInfo.audioPorts;

  2570.                     busType = V3_MAIN;

  2571.                     flags = V3_DEFAULT_ACTIVE;

  2572.                     break;

  2573.                 }

  2574.             // fall-through

  2575.             case 1:

  2576.                 if (busInfo.sidechain)

  2577.                 {

  2578.                     numChannels = busInfo.sidechainPorts;

  2579.                     busType = V3_AUX;

  2580.                     flags = 0;

  2581.                     break;

  2582.                 }

  2583.             // fall-through

  2584.             default:

  2585.                 numChannels = 1;

  2586.                 busType = V3_AUX;

  2587.                 flags = V3_IS_CONTROL_VOLTAGE;

  2588.                 break;

  2589.             }

  2590. 

  2591.             if (busType == V3_MAIN)

  2592.             {

  2593.                 strncpy_utf16(busName, isInput ? "Audio Input" : "Audio Output", 128);

  2594.             }

  2595.             else

  2596.             {

  2597.                 for (uint32_t i=0; i<numPorts; ++i)

  2598.                 {

  2599.                     const AudioPortWithBusId& port(fPlugin.getAudioPort(isInput, i));

  2600. 

  2601.                     if (port.busId == busId)

  2602.                     {

  2603.                         const String& groupName(busInfo.groups ? fPlugin.getPortGroupById(port.groupId).name : port.name);

  2604.                         strncpy_utf16(busName, groupName, 128);

  2605.                         break;

  2606.                     }

  2607.                 }

  2608.             }

  2609.         }

  2610. 

  2611.         // d_stdout("getAudioBusInfo %d %d %d", (int)isInput, busId, numChannels);

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

  2613.         info->media_type = V3_AUDIO;

  2614.         info->direction = isInput ? V3_INPUT : V3_OUTPUT;

  2615.         info->channel_count = numChannels;

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

  2617.         info->bus_type = busType;

  2618.         info->flags = flags;

  2619.         return V3_OK;

  2620.     }

  2621. 

  2622.     template<bool isInput>

  2623.     v3_speaker_arrangement getSpeakerArrangementForAudioPort(const BusInfo& busInfo, const uint32_t portGroupId, uint32_t busId) const noexcept

  2624.     {

  2625.         switch (portGroupId)

  2626.         {

  2627.         case kPortGroupMono:

  2628.             return V3_SPEAKER_M;

  2629.         case kPortGroupStereo:

  2630.             return V3_SPEAKER_L | V3_SPEAKER_R;

  2631.         }

  2632. 

  2633.         v3_speaker_arrangement arr = 0x0;

  2634. 

  2635.         if (busId < busInfo.groups)

  2636.         {

  2637.             const uint32_t numPortsInBus = fPlugin.getAudioPortCountWithGroupId(isInput, busId);

  2638.             for (uint32_t j=0; j<numPortsInBus; ++j)

  2639.                 arr |= 1ull << (j + 33ull);

  2640.         }

  2641.         else

  2642.         {

  2643.             busId -= busInfo.groups;

  2644. 

  2645.             if (busInfo.audio != 0 && busId == 0)

  2646.             {

  2647.                 arr = 0x0;

  2648.                 for (uint32_t j=0; j<busInfo.audioPorts; ++j)

  2649.                     arr |= 1ull << (j + 33ull);

  2650.             }

  2651.             else if (busInfo.sidechain != 0 && busId == busInfo.audio)

  2652.             {

  2653.                 arr = 0x0;

  2654.                 for (uint32_t j=0; j<busInfo.sidechainPorts; ++j)

  2655.                     arr |= 1ull << (busInfo.audioPorts + j + 33ull);

  2656.             }

  2657.             else

  2658.             {

  2659.                 arr = 1ull << (busInfo.audioPorts + busInfo.sidechainPorts + busId + 33ull);

  2660.             }

  2661.         }

  2662. 

  2663.         return arr;

  2664.     }

  2665. 

  2666.     template<bool isInput>

  2667.     bool getAudioBusArrangement(uint32_t busId, v3_speaker_arrangement* const speaker) const

  2668.     {

  2669.         constexpr const uint32_t numPorts = isInput ? DISTRHO_PLUGIN_NUM_INPUTS : DISTRHO_PLUGIN_NUM_OUTPUTS;

  2670.         const BusInfo& busInfo(isInput ? inputBuses : outputBuses);

  2671.         const bool* const enabledPorts = isInput

  2672.                                       #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  2673.                                        ? fEnabledInputs

  2674.                                       #else

  2675.                                        ? nullptr

  2676.                                       #endif

  2677.                                       #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2678.                                        : fEnabledOutputs;

  2679.                                       #else

  2680.                                        : nullptr;

  2681.                                       #endif

  2682. 

  2683.         for (uint32_t i=0; i<numPorts; ++i)

  2684.         {

  2685.             const AudioPortWithBusId& port(fPlugin.getAudioPort(isInput, i));

  2686. 

  2687.             if (port.busId != busId)

  2688.             {

  2689.                 // d_stdout("port.busId != busId: %d %d", port.busId, busId);

  2690.                 continue;

  2691.             }

  2692. 

  2693.             if (!enabledPorts[i])

  2694.             {

  2695.                 *speaker = 0;

  2696.                 // d_stdout("getAudioBusArrangement %d %d not enabled", i, busId);

  2697.                 return true;

  2698.             }

  2699. 

  2700.             *speaker = getSpeakerArrangementForAudioPort<isInput>(busInfo, port.groupId, busId);

  2701.             // d_stdout("getAudioBusArrangement %d enabled by value %lx", busId, *speaker);

  2702.             return true;

  2703.         }

  2704. 

  2705.         return false;

  2706.     }

  2707. 

  2708.     template<bool isInput>

  2709.     bool setAudioBusArrangement(v3_speaker_arrangement* const speakers, const uint32_t numBuses)

  2710.     {

  2711.         constexpr const uint32_t numPorts = isInput ? DISTRHO_PLUGIN_NUM_INPUTS : DISTRHO_PLUGIN_NUM_OUTPUTS;

  2712.         BusInfo& busInfo(isInput ? inputBuses : outputBuses);

  2713.         bool* const enabledPorts = isInput

  2714.                                 #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  2715.                                  ? fEnabledInputs

  2716.                                 #else

  2717.                                  ? nullptr

  2718.                                 #endif

  2719.                                 #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2720.                                  : fEnabledOutputs;

  2721.                                 #else

  2722.                                  : nullptr;

  2723.                                 #endif

  2724. 

  2725.         bool ok = true;

  2726. 

  2727.         for (uint32_t busId=0; busId<numBuses; ++busId)

  2728.         {

  2729.             const v3_speaker_arrangement arr = speakers[busId];

  2730. 

  2731.             // d_stdout("setAudioBusArrangement %d %d | %d %lx", (int)isInput, numBuses, busId, arr);

  2732. 

  2733.             for (uint32_t i=0; i<numPorts; ++i)

  2734.             {

  2735.                 AudioPortWithBusId& port(fPlugin.getAudioPort(isInput, i));

  2736. 

  2737.                 if (port.busId != busId)

  2738.                 {

  2739.                     // d_stdout("setAudioBusArrangement port.busId != busId: %d %d", port.busId, busId);

  2740.                     continue;

  2741.                 }

  2742. 

  2743.                 // get the only valid speaker arrangement for this bus, assuming enabled

  2744.                 const v3_speaker_arrangement earr = getSpeakerArrangementForAudioPort<isInput>(busInfo, port.groupId, busId);

  2745. 

  2746.                 // fail if host tries to map it to anything else

  2747.                 if (earr != arr && arr != 0)

  2748.                 {

  2749.                     ok = false;

  2750.                     continue;

  2751.                 }

  2752. 

  2753.                 enabledPorts[i] = arr != 0;

  2754.             }

  2755.         }

  2756. 

  2757.         // disable any buses outside of the requested arrangement

  2758.         const uint32_t totalBuses = busInfo.audio + busInfo.sidechain + busInfo.groups + busInfo.cvPorts;

  2759. 

  2760.         for (uint32_t busId=numBuses; busId<totalBuses; ++busId)

  2761.         {

  2762.             for (uint32_t i=0; i<numPorts; ++i)

  2763.             {

  2764.                 const AudioPortWithBusId& port(fPlugin.getAudioPort(isInput, i));

  2765. 

  2766.                 if (port.busId == busId)

  2767.                 {

  2768.                     enabledPorts[i] = false;

  2769.                     break;

  2770.                 }

  2771.             }

  2772.         }

  2773. 

  2774.         return ok;

  2775.     }

  2776.    #endif

  2777. 

  2778.     // ----------------------------------------------------------------------------------------------------------------

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

  2780. 

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

  2782.     {

  2783.         DISTRHO_SAFE_ASSERT_RETURN(outparamsptr != nullptr,);

  2784. 

  2785.         v3_param_id paramId;

  2786.         float curValue;

  2787. 

  2788.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2789.         for (v3_param_id i=kVst3InternalParameterBufferSize; i<=kVst3InternalParameterSampleRate; ++i)

  2790.         {

  2791.             if (! fParameterValuesChangedDuringProcessing[i])

  2792.                 continue;

  2793. 

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

  2795.             fParameterValuesChangedDuringProcessing[i] = false;

  2796.             addParameterDataToHostOutputEvents(outparamsptr, i, curValue);

  2797.         }

  2798.        #endif

  2799. 

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

  2801.         {

  2802.             if (fPlugin.isParameterOutput(i))

  2803.             {

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

  2805.                 curValue = fPlugin.getParameterValue(i);

  2806. 

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

  2808.                     continue;

  2809.             }

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

  2811.             {

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

  2813.                 curValue = fPlugin.getParameterValue(i);

  2814. 

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

  2816.                     continue;

  2817. 

  2818.                 fPlugin.setParameterValue(i, curValue);

  2819.             }

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

  2821.             {

  2822.                 fParameterValuesChangedDuringProcessing[kVst3InternalParameterBaseCount + i] = false;

  2823.                 curValue = fPlugin.getParameterValue(i);

  2824.             }

  2825.             else

  2826.             {

  2827.                 continue;

  2828.             }

  2829. 

  2830.             fCachedParameterValues[kVst3InternalParameterBaseCount + i] = curValue;

  2831.            #if DISTRHO_PLUGIN_HAS_UI

  2832.             fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = true;

  2833.            #endif

  2834. 

  2835.             paramId = kVst3InternalParameterCount + i;

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

  2837. 

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

  2839.                 break;

  2840.         }

  2841. 

  2842.        #if DISTRHO_PLUGIN_WANT_LATENCY

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

  2844. 

  2845.         if (fLastKnownLatency != latency)

  2846.         {

  2847.             fLastKnownLatency = latency;

  2848. 

  2849.             curValue = plainParameterToNormalized(kVst3InternalParameterLatency,

  2850.                                                   fCachedParameterValues[kVst3InternalParameterLatency]);

  2851.             addParameterDataToHostOutputEvents(outparamsptr, kVst3InternalParameterLatency, curValue);

  2852.         }

  2853.        #endif

  2854.     }

  2855. 

  2856.     bool addParameterDataToHostOutputEvents(v3_param_changes** const outparamsptr,

  2857.                                             v3_param_id paramId,

  2858.                                             const float curValue,

  2859.                                             const int32_t offset = 0)

  2860.     {

  2861.         int32_t index = 0;

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

  2863.                                                                                       &paramId, &index);

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

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

  2866. 

  2867.         if (offset != 0)

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

  2869. 

  2870.         return true;

  2871.     }

  2872. 

  2873.    #if DISTRHO_PLUGIN_HAS_UI

  2874.     // ----------------------------------------------------------------------------------------------------------------

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

  2876. 

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

  2878.     {

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

  2880. 

  2881.         v3_tuid iid;

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

  2883.         v3_message** msg = nullptr;

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

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

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

  2887. 

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

  2889.         return msg;

  2890.     }

  2891. 

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

  2893.     {

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

  2895.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2896. 

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

  2898.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  2899. 

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

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

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

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

  2904. 

  2905.         v3_cpp_obj_unref(message);

  2906.     }

  2907. 

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

  2909.     {

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

  2911.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2912. 

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

  2914.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  2915. 

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

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

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

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

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

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

  2922. 

  2923.         v3_cpp_obj_unref(message);

  2924.     }

  2925. 

  2926.     void sendReadyToUI() const

  2927.     {

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

  2929.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2930. 

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

  2932.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  2933. 

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

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

  2936. 

  2937.         v3_cpp_obj_unref(message);

  2938.     }

  2939.    #endif

  2940. 

  2941.     // ----------------------------------------------------------------------------------------------------------------

  2942.     // DPF callbacks

  2943. 

  2944.    #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  2945.     bool requestParameterValueChange(const uint32_t index, float)

  2946.     {

  2947.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterBaseCount + index] = true;

  2948.         return true;

  2949.     }

  2950. 

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

  2952.     {

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

  2954.     }

  2955.    #endif

  2956. 

  2957.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2958.     bool writeMidi(const MidiEvent& midiEvent)

  2959.     {

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

  2961. 

  2962.         v3_event event;

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

  2964.         event.sample_offset = midiEvent.frame;

  2965. 

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

  2967. 

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

  2969.         {

  2970.         case 0x80:

  2971.             event.type = V3_EVENT_NOTE_OFF;

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

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

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

  2975.             // int32_t note_id;

  2976.             // float tuning;

  2977.             break;

  2978.         case 0x90:

  2979.             event.type = V3_EVENT_NOTE_ON;

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

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

  2982.             // float tuning;

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

  2984.             // int32_t length;

  2985.             // int32_t note_id;

  2986.             break;

  2987.         case 0xA0:

  2988.             event.type = V3_EVENT_POLY_PRESSURE;

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

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

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

  2992.             // int32_t note_id;

  2993.             break;

  2994.         case 0xB0:

  2995.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

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

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

  2999.             if (midiEvent.size == 4)

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

  3001.             break;

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

  3003.         case 0xC0:

  3004.             break;

  3005.         */

  3006.         case 0xD0:

  3007.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

  3009.             event.midi_cc_out.cc_number = 128;

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

  3011.             break;

  3012.         case 0xE0:

  3013.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

  3015.             event.midi_cc_out.cc_number = 129;

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

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

  3018.             break;

  3019.         default:

  3020.             return true;

  3021.         }

  3022. 

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

  3024.     }

  3025. 

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

  3027.     {

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

  3029.     }

  3030.    #endif

  3031. };

  3032. 

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

  3034. 

  3035. /**

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

  3037.  */

  3038. 

  3039. // --------------------------------------------------------------------------------------------------------------------

  3040. // v3_funknown for static instances

  3041. 

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

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

  3044. 

  3045. // --------------------------------------------------------------------------------------------------------------------

  3046. // v3_funknown for classes with a single instance

  3047. 

  3048. template<class T>

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

  3050. {

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

  3052. }

  3053. 

  3054. template<class T>

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

  3056. {

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

  3058. }

  3059. 

  3060. // --------------------------------------------------------------------------------------------------------------------

  3061. // Store components that we can't delete properly, to be cleaned up on module unload

  3062. 

  3063. struct dpf_component;

  3064. 

  3065. static std::vector<dpf_component**> gComponentGarbage;

  3066. 

  3067. static uint32_t handleUncleanComponent(dpf_component** const componentptr)

  3068. {

  3069.     gComponentGarbage.push_back(componentptr);

  3070.     return 0;

  3071. }

  3072. 

  3073. #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3074. // --------------------------------------------------------------------------------------------------------------------

  3075. // Store controllers that we can't delete properly, to be cleaned up on module unload

  3076. 

  3077. struct dpf_edit_controller;

  3078. 

  3079. static std::vector<dpf_edit_controller**> gControllerGarbage;

  3080. 

  3081. static uint32_t handleUncleanController(dpf_edit_controller** const controllerptr)

  3082. {

  3083.     gControllerGarbage.push_back(controllerptr);

  3084.     return 0;

  3085. }

  3086. 

  3087. // --------------------------------------------------------------------------------------------------------------------

  3088. // dpf_comp2ctrl_connection_point

  3089. 

  3090. struct dpf_comp2ctrl_connection_point : v3_connection_point_cpp {

  3091.     std::atomic_int refcounter;

  3092.     ScopedPointer<PluginVst3>& vst3;

  3093.     v3_connection_point** other;

  3094. 

  3095.     dpf_comp2ctrl_connection_point(ScopedPointer<PluginVst3>& v)

  3096.         : refcounter(1),

  3097.           vst3(v),

  3098.           other(nullptr)

  3099.     {

  3100.         // v3_funknown, single instance

  3101.         query_interface = query_interface_connection_point;

  3102.         ref = dpf_single_instance_ref<dpf_comp2ctrl_connection_point>;

  3103.         unref = dpf_single_instance_unref<dpf_comp2ctrl_connection_point>;

  3104. 

  3105.         // v3_connection_point

  3106.         point.connect = connect;

  3107.         point.disconnect = disconnect;

  3108.         point.notify = notify;

  3109.     }

  3110. 

  3111.     // ----------------------------------------------------------------------------------------------------------------

  3112.     // v3_funknown

  3113. 

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

  3115.     {

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

  3117. 

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

  3119.             v3_tuid_match(iid, v3_connection_point_iid))

  3120.         {

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

  3122.             ++point->refcounter;

  3123.             *iface = self;

  3124.             return V3_OK;

  3125.         }

  3126. 

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

  3128. 

  3129.         *iface = nullptr;

  3130.         return V3_NO_INTERFACE;

  3131.     }

  3132. 

  3133.     // ----------------------------------------------------------------------------------------------------------------

  3134.     // v3_connection_point

  3135. 

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

  3137.     {

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

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

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

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

  3142. 

  3143.         point->other = other;

  3144. 

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

  3146.             vst3->comp2ctrl_connect(other);

  3147. 

  3148.         return V3_OK;

  3149.     }

  3150. 

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

  3152.     {

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

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

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

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

  3157. 

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

  3159.             vst3->comp2ctrl_disconnect();

  3160. 

  3161.         point->other = nullptr;

  3162. 

  3163.         return V3_OK;

  3164.     }

  3165. 

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

  3167.     {

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

  3169. 

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

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

  3172. 

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

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

  3175. 

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

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

  3178. 

  3179.         int64_t target = 0;

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

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

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

  3183. 

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

  3185.         return vst3->comp2ctrl_notify(message);

  3186.     }

  3187. };

  3188. #endif // DPF_VST3_USES_SEPARATE_CONTROLLER

  3189. 

  3190. #if DISTRHO_PLUGIN_HAS_UI

  3191. // --------------------------------------------------------------------------------------------------------------------

  3192. // dpf_ctrl2view_connection_point

  3193. 

  3194. struct dpf_ctrl2view_connection_point : v3_connection_point_cpp {

  3195.     ScopedPointer<PluginVst3>& vst3;

  3196.     v3_connection_point** other;

  3197. 

  3198.     dpf_ctrl2view_connection_point(ScopedPointer<PluginVst3>& v)

  3199.         : vst3(v),

  3200.           other(nullptr)

  3201.     {

  3202.         // v3_funknown, single instance, used internally

  3203.         query_interface = nullptr;

  3204.         ref = nullptr;

  3205.         unref = nullptr;

  3206. 

  3207.         // v3_connection_point

  3208.         point.connect = connect;

  3209.         point.disconnect = disconnect;

  3210.         point.notify = notify;

  3211.     }

  3212. 

  3213.     // ----------------------------------------------------------------------------------------------------------------

  3214.     // v3_connection_point

  3215. 

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

  3217.     {

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

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

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

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

  3222. 

  3223.         point->other = other;

  3224. 

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

  3226.             vst3->ctrl2view_connect(other);

  3227. 

  3228.         return V3_OK;

  3229.     }

  3230. 

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

  3232.     {

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

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

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

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

  3237. 

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

  3239.             vst3->ctrl2view_disconnect();

  3240. 

  3241.         v3_cpp_obj_unref(point->other);

  3242.         point->other = nullptr;

  3243. 

  3244.         return V3_OK;

  3245.     }

  3246. 

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

  3248.     {

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

  3250. 

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

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

  3253. 

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

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

  3256. 

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

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

  3259. 

  3260.         int64_t target = 0;

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

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

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

  3264. 

  3265.         if (target == 1)

  3266.         {

  3267.             // view -> edit controller

  3268.             return vst3->ctrl2view_notify(message);

  3269.         }

  3270.         else

  3271.         {

  3272.             // edit controller -> view

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

  3274.         }

  3275.     }

  3276. };

  3277. #endif // DISTRHO_PLUGIN_HAS_UI

  3278. 

  3279. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  3280. // --------------------------------------------------------------------------------------------------------------------

  3281. // dpf_midi_mapping

  3282. 

  3283. struct dpf_midi_mapping : v3_midi_mapping_cpp {

  3284.     dpf_midi_mapping()

  3285.     {

  3286.         // v3_funknown, static

  3287.         query_interface = query_interface_midi_mapping;

  3288.         ref = dpf_static_ref;

  3289.         unref = dpf_static_unref;

  3290. 

  3291.         // v3_midi_mapping

  3292.         map.get_midi_controller_assignment = get_midi_controller_assignment;

  3293.     }

  3294. 

  3295.     // ----------------------------------------------------------------------------------------------------------------

  3296.     // v3_funknown

  3297. 

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

  3299.     {

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

  3301.             v3_tuid_match(iid, v3_midi_mapping_iid))

  3302.         {

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

  3304.             *iface = self;

  3305.             return V3_OK;

  3306.         }

  3307. 

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

  3309. 

  3310.         *iface = nullptr;

  3311.         return V3_NO_INTERFACE;

  3312.     }

  3313. 

  3314.     // ----------------------------------------------------------------------------------------------------------------

  3315.     // v3_midi_mapping

  3316. 

  3317.     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)

  3318.     {

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

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

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

  3322. 

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

  3324.         return V3_TRUE;

  3325.     }

  3326. 

  3327.     DISTRHO_PREVENT_HEAP_ALLOCATION

  3328. };

  3329. #endif // DISTRHO_PLUGIN_WANT_MIDI_INPUT

  3330. 

  3331. // --------------------------------------------------------------------------------------------------------------------

  3332. // dpf_edit_controller

  3333. 

  3334. struct dpf_edit_controller : v3_edit_controller_cpp {

  3335.     std::atomic_int refcounter;

  3336.    #if DISTRHO_PLUGIN_HAS_UI

  3337.     ScopedPointer<dpf_ctrl2view_connection_point> connectionCtrl2View;

  3338.    #endif

  3339.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3340.     ScopedPointer<dpf_comp2ctrl_connection_point> connectionComp2Ctrl;

  3341.     ScopedPointer<PluginVst3> vst3;

  3342.    #else

  3343.     ScopedPointer<PluginVst3>& vst3;

  3344.     bool initialized;

  3345.    #endif

  3346.     // cached values

  3347.     v3_component_handler** handler;

  3348.     v3_host_application** const hostApplicationFromFactory;

  3349.    #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3350.     v3_host_application** const hostApplicationFromComponent;

  3351.     v3_host_application** hostApplicationFromComponentInitialize;

  3352.    #endif

  3353.     v3_host_application** hostApplicationFromInitialize;

  3354. 

  3355.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3356.     dpf_edit_controller(v3_host_application** const hostApp)

  3357.         : refcounter(1),

  3358.           vst3(nullptr),

  3359.    #else

  3360.     dpf_edit_controller(ScopedPointer<PluginVst3>& v, v3_host_application** const hostApp, v3_host_application** const hostComp)

  3361.         : refcounter(1),

  3362.           vst3(v),

  3363.           initialized(false),

  3364.    #endif

  3365.           handler(nullptr),

  3366.           hostApplicationFromFactory(hostApp),

  3367.          #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3368.           hostApplicationFromComponent(hostComp),

  3369.           hostApplicationFromComponentInitialize(nullptr),

  3370.          #endif

  3371.           hostApplicationFromInitialize(nullptr)

  3372.     {

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

  3374. 

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

  3376.         if (hostApplicationFromFactory != nullptr)

  3377.             v3_cpp_obj_ref(hostApplicationFromFactory);

  3378.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3379.         if (hostApplicationFromComponent != nullptr)

  3380.             v3_cpp_obj_ref(hostApplicationFromComponent);

  3381.        #endif

  3382. 

  3383.         // v3_funknown, everything custom

  3384.         query_interface = query_interface_edit_controller;

  3385.         ref = ref_edit_controller;

  3386.         unref = unref_edit_controller;

  3387. 

  3388.         // v3_plugin_base

  3389.         base.initialize = initialize;

  3390.         base.terminate = terminate;

  3391. 

  3392.         // v3_edit_controller

  3393.         ctrl.set_component_state = set_component_state;

  3394.         ctrl.set_state = set_state;

  3395.         ctrl.get_state = get_state;

  3396.         ctrl.get_parameter_count = get_parameter_count;

  3397.         ctrl.get_parameter_info = get_parameter_info;

  3398.         ctrl.get_parameter_string_for_value = get_parameter_string_for_value;

  3399.         ctrl.get_parameter_value_for_string = get_parameter_value_for_string;

  3400.         ctrl.normalised_parameter_to_plain = normalised_parameter_to_plain;

  3401.         ctrl.plain_parameter_to_normalised = plain_parameter_to_normalised;

  3402.         ctrl.get_parameter_normalised = get_parameter_normalised;

  3403.         ctrl.set_parameter_normalised = set_parameter_normalised;

  3404.         ctrl.set_component_handler = set_component_handler;

  3405.         ctrl.create_view = create_view;

  3406.     }

  3407. 

  3408.     ~dpf_edit_controller()

  3409.     {

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

  3411.        #if DISTRHO_PLUGIN_HAS_UI

  3412.         connectionCtrl2View = nullptr;

  3413.        #endif

  3414.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3415.         connectionComp2Ctrl = nullptr;

  3416.         vst3 = nullptr;

  3417.        #endif

  3418. 

  3419.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3420.         if (hostApplicationFromComponent != nullptr)

  3421.             v3_cpp_obj_unref(hostApplicationFromComponent);

  3422.        #endif

  3423.         if (hostApplicationFromFactory != nullptr)

  3424.             v3_cpp_obj_unref(hostApplicationFromFactory);

  3425.     }

  3426. 

  3427.     // ----------------------------------------------------------------------------------------------------------------

  3428.     // v3_funknown

  3429. 

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

  3431.     {

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

  3433. 

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

  3435.             v3_tuid_match(iid, v3_plugin_base_iid) ||

  3436.             v3_tuid_match(iid, v3_edit_controller_iid))

  3437.         {

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

  3439.             ++controller->refcounter;

  3440.             *iface = self;

  3441.             return V3_OK;

  3442.         }

  3443. 

  3444.         if (v3_tuid_match(iid, v3_midi_mapping_iid))

  3445.         {

  3446.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  3448.             static dpf_midi_mapping midi_mapping;

  3449.             static dpf_midi_mapping* midi_mapping_ptr = &midi_mapping;

  3450.             *iface = &midi_mapping_ptr;

  3451.             return V3_OK;

  3452.            #else

  3453.             d_stdout("query_interface_edit_controller => %p %s %p | reject unused", self, tuid2str(iid), iface);

  3454.             *iface = nullptr;

  3455.             return V3_NO_INTERFACE;

  3456.            #endif

  3457.         }

  3458. 

  3459.         if (v3_tuid_match(iid, v3_connection_point_iid))

  3460.         {

  3461.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  3464. 

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

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

  3467.             else

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

  3469.             *iface = &controller->connectionComp2Ctrl;

  3470.             return V3_OK;

  3471.            #else

  3472.             d_stdout("query_interface_edit_controller => %p %s %p | reject unwanted", self, tuid2str(iid), iface);

  3473.             *iface = nullptr;

  3474.             return V3_NO_INTERFACE;

  3475.            #endif

  3476.         }

  3477. 

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

  3479.         *iface = nullptr;

  3480.         return V3_NO_INTERFACE;

  3481.     }

  3482. 

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

  3484.     {

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

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

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

  3488.         return refcount;

  3489.     }

  3490. 

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

  3492.     {

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

  3494.         dpf_edit_controller* const controller = *controllerptr;

  3495. 

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

  3497.         {

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

  3499.             return refcount;

  3500.         }

  3501. 

  3502.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3503.         /**

  3504.          * Some hosts will have unclean instances of a few of the controller child classes at this point.

  3505.          * We check for those here, going through the whole possible chain to see if it is safe to delete.

  3506.          * If not, we add this controller to the `gControllerGarbage` global which will take care of it during unload.

  3507.          */

  3508. 

  3509.         bool unclean = false;

  3510. 

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

  3512.         {

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

  3514.             {

  3515.                 unclean = true;

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

  3517.             }

  3518.         }

  3519. 

  3520.         if (unclean)

  3521.             return handleUncleanController(controllerptr);

  3522. 

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

  3524. 

  3525.         delete controller;

  3526.         delete controllerptr;

  3527.        #else

  3528.         d_stdout("dpf_edit_controller::unref => %p | refcount is zero, deletion will be done by component later", self);

  3529.        #endif

  3530.         return 0;

  3531.     }

  3532. 

  3533.     // ----------------------------------------------------------------------------------------------------------------

  3534.     // v3_plugin_base

  3535. 

  3536.     static v3_result V3_API initialize(void* const self, v3_funknown** const context)

  3537.     {

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

  3539. 

  3540.         // check if already initialized

  3541.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  3543.        #else

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

  3545.        #endif

  3546. 

  3547.         // query for host application

  3548.         v3_host_application** hostApplication = nullptr;

  3549.         if (context != nullptr)

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

  3551. 

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

  3553. 

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

  3555.         controller->hostApplicationFromInitialize = hostApplication;

  3556. 

  3557.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  3559.         if (hostApplication == nullptr)

  3560.             hostApplication = controller->hostApplicationFromFactory;

  3561. 

  3562.         // default early values

  3563.         if (d_nextBufferSize == 0)

  3564.             d_nextBufferSize = 1024;

  3565.         if (d_nextSampleRate <= 0.0)

  3566.             d_nextSampleRate = 44100.0;

  3567. 

  3568.         d_nextCanRequestParameterValueChanges = true;

  3569. 

  3570.         // create the actual plugin

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

  3572. 

  3573.         // set connection point if needed

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

  3575.         {

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

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

  3578.         }

  3579.        #else

  3580.         // mark as initialized

  3581.         controller->initialized = true;

  3582.        #endif

  3583. 

  3584.         return V3_OK;

  3585.     }

  3586. 

  3587.     static v3_result V3_API terminate(void* self)

  3588.     {

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

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

  3591. 

  3592.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3593.         // check if already terminated

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

  3595. 

  3596.         // delete actual plugin

  3597.         controller->vst3 = nullptr;

  3598.        #else

  3599.         // check if already terminated

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

  3601. 

  3602.         // mark as uninitialzed

  3603.         controller->initialized = false;

  3604.        #endif

  3605. 

  3606.         // unref host application received during initialize

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

  3608.         {

  3609.             v3_cpp_obj_unref(controller->hostApplicationFromInitialize);

  3610.             controller->hostApplicationFromInitialize = nullptr;

  3611.         }

  3612. 

  3613.         return V3_OK;

  3614.     }

  3615. 

  3616.     // ----------------------------------------------------------------------------------------------------------------

  3617.     // v3_edit_controller

  3618. 

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

  3620.     {

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

  3622. 

  3623.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  3625. 

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

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

  3628. 

  3629.         return vst3->setState(stream);

  3630.        #else

  3631.         return V3_OK;

  3632. 

  3633.         // unused

  3634.         (void)self;

  3635.         (void)stream;

  3636.        #endif

  3637.     }

  3638. 

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

  3640.     {

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

  3642. 

  3643.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  3646.        #endif

  3647. 

  3648.         return V3_NOT_IMPLEMENTED;

  3649. 

  3650.         // maybe unused

  3651.         (void)self;

  3652.         (void)stream;

  3653.     }

  3654. 

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

  3656.     {

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

  3658. 

  3659.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  3662.        #endif

  3663. 

  3664.         return V3_NOT_IMPLEMENTED;

  3665. 

  3666.         // maybe unused

  3667.         (void)self;

  3668.         (void)stream;

  3669.     }

  3670. 

  3671.     static int32_t V3_API get_parameter_count(void* self)

  3672.     {

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

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

  3675. 

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

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

  3678. 

  3679.         return vst3->getParameterCount();

  3680.     }

  3681. 

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

  3683.     {

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

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

  3686. 

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

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

  3689. 

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

  3691.     }

  3692. 

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

  3694.     {

  3695.         // NOTE very noisy, called many times

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

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

  3698. 

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

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

  3701. 

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

  3703.     }

  3704. 

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

  3706.     {

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

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

  3709. 

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

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

  3712. 

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

  3714.     }

  3715. 

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

  3717.     {

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

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

  3720. 

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

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

  3723. 

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

  3725.     }

  3726. 

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

  3728.     {

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

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

  3731. 

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

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

  3734. 

  3735.         return vst3->plainParameterToNormalized(index, plain);

  3736.     }

  3737. 

  3738.     static double V3_API get_parameter_normalised(void* self, v3_param_id index)

  3739.     {

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

  3741. 

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

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

  3744. 

  3745.         return vst3->getParameterNormalized(index);

  3746.     }

  3747. 

  3748.     static v3_result V3_API set_parameter_normalised(void* const self, const v3_param_id index, const double normalised)

  3749.     {

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

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

  3752. 

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

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

  3755. 

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

  3757.     }

  3758. 

  3759.     static v3_result V3_API set_component_handler(void* self, v3_component_handler** handler)

  3760.     {

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

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

  3763. 

  3764.         controller->handler = handler;

  3765. 

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

  3767.             return vst3->setComponentHandler(handler);

  3768. 

  3769.         return V3_NOT_INITIALIZED;

  3770.     }

  3771. 

  3772.     static v3_plugin_view** V3_API create_view(void* self, const char* name)

  3773.     {

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

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

  3776. 

  3777.         d_stdout("create_view has contexts %p %p",

  3778.                  controller->hostApplicationFromFactory, controller->hostApplicationFromInitialize);

  3779. 

  3780.        #if DISTRHO_PLUGIN_HAS_UI

  3781.         // plugin must be initialized

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

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

  3784. 

  3785.         d_stdout("dpf_edit_controller::create_view => %p %s | edit-ctrl %p, factory %p",

  3786.                  self, name,

  3787.                  controller->hostApplicationFromInitialize,

  3788.                  controller->hostApplicationFromFactory);

  3789. 

  3790.         // we require a host application for message creation

  3791.         v3_host_application** const host = controller->hostApplicationFromInitialize != nullptr

  3792.                                          ? controller->hostApplicationFromInitialize

  3793.                                         #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3794.                                          : controller->hostApplicationFromComponent != nullptr

  3795.                                          ? controller->hostApplicationFromComponent

  3796.                                          : controller->hostApplicationFromComponentInitialize != nullptr

  3797.                                          ? controller->hostApplicationFromComponentInitialize

  3798.                                         #endif

  3799.                                          : controller->hostApplicationFromFactory;

  3800.         DISTRHO_SAFE_ASSERT_RETURN(host != nullptr, nullptr);

  3801. 

  3802.         v3_plugin_view** const view = dpf_plugin_view_create(host,

  3803.                                                              vst3->getInstancePointer(),

  3804.                                                              vst3->getSampleRate());

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

  3806. 

  3807.         v3_connection_point** uiconn = nullptr;

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

  3809.         {

  3810.             d_stdout("view connection query ok %p", uiconn);

  3811.             controller->connectionCtrl2View = new dpf_ctrl2view_connection_point(controller->vst3);

  3812. 

  3813.             v3_connection_point** const ctrlconn = (v3_connection_point**)&controller->connectionCtrl2View;

  3814. 

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

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

  3817.         }

  3818.         else

  3819.         {

  3820.             controller->connectionCtrl2View = nullptr;

  3821.         }

  3822. 

  3823.         return view;

  3824.        #else

  3825.         return nullptr;

  3826.        #endif

  3827.     }

  3828. };

  3829. 

  3830. // --------------------------------------------------------------------------------------------------------------------

  3831. // dpf_process_context_requirements

  3832. 

  3833. struct dpf_process_context_requirements : v3_process_context_requirements_cpp {

  3834.     dpf_process_context_requirements()

  3835.     {

  3836.         // v3_funknown, static

  3837.         query_interface = query_interface_process_context_requirements;

  3838.         ref = dpf_static_ref;

  3839.         unref = dpf_static_unref;

  3840. 

  3841.         // v3_process_context_requirements

  3842.         req.get_process_context_requirements = get_process_context_requirements;

  3843.     }

  3844. 

  3845.     // ----------------------------------------------------------------------------------------------------------------

  3846.     // v3_funknown

  3847. 

  3848.     static v3_result V3_API query_interface_process_context_requirements(void* const self, const v3_tuid iid, void** const iface)

  3849.     {

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

  3851.             v3_tuid_match(iid, v3_process_context_requirements_iid))

  3852.         {

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

  3854.             *iface = self;

  3855.             return V3_OK;

  3856.         }

  3857. 

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

  3859. 

  3860.         *iface = nullptr;

  3861.         return V3_NO_INTERFACE;

  3862.     }

  3863. 

  3864.     // ----------------------------------------------------------------------------------------------------------------

  3865.     // v3_process_context_requirements

  3866. 

  3867.     static uint32_t V3_API get_process_context_requirements(void*)

  3868.     {

  3869.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  3870.         return 0x0

  3871.             | V3_PROCESS_CTX_NEED_CONTINUOUS_TIME  // V3_PROCESS_CTX_CONT_TIME_VALID

  3872.             | V3_PROCESS_CTX_NEED_PROJECT_TIME     // V3_PROCESS_CTX_PROJECT_TIME_VALID

  3873.             | V3_PROCESS_CTX_NEED_TEMPO            // V3_PROCESS_CTX_TEMPO_VALID

  3874.             | V3_PROCESS_CTX_NEED_TIME_SIG         // V3_PROCESS_CTX_TIME_SIG_VALID

  3875.             | V3_PROCESS_CTX_NEED_TRANSPORT_STATE; // V3_PROCESS_CTX_PLAYING

  3876.        #else

  3877.         return 0x0;

  3878.        #endif

  3879.     }

  3880. 

  3881.     DISTRHO_PREVENT_HEAP_ALLOCATION

  3882. };

  3883. 

  3884. // --------------------------------------------------------------------------------------------------------------------

  3885. // dpf_audio_processor

  3886. 

  3887. struct dpf_audio_processor : v3_audio_processor_cpp {

  3888.     std::atomic_int refcounter;

  3889.     ScopedPointer<PluginVst3>& vst3;

  3890. 

  3891.     dpf_audio_processor(ScopedPointer<PluginVst3>& v)

  3892.         : refcounter(1),

  3893.           vst3(v)

  3894.     {

  3895.         // v3_funknown, single instance

  3896.         query_interface = query_interface_audio_processor;

  3897.         ref = dpf_single_instance_ref<dpf_audio_processor>;

  3898.         unref = dpf_single_instance_unref<dpf_audio_processor>;

  3899. 

  3900.         // v3_audio_processor

  3901.         proc.set_bus_arrangements = set_bus_arrangements;

  3902.         proc.get_bus_arrangement = get_bus_arrangement;

  3903.         proc.can_process_sample_size = can_process_sample_size;

  3904.         proc.get_latency_samples = get_latency_samples;

  3905.         proc.setup_processing = setup_processing;

  3906.         proc.set_processing = set_processing;

  3907.         proc.process = process;

  3908.         proc.get_tail_samples = get_tail_samples;

  3909.     }

  3910. 

  3911.     // ----------------------------------------------------------------------------------------------------------------

  3912.     // v3_funknown

  3913. 

  3914.     static v3_result V3_API query_interface_audio_processor(void* const self, const v3_tuid iid, void** const iface)

  3915.     {

  3916.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3917. 

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

  3919.             v3_tuid_match(iid, v3_audio_processor_iid))

  3920.         {

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

  3922.             ++processor->refcounter;

  3923.             *iface = self;

  3924.             return V3_OK;

  3925.         }

  3926. 

  3927.         if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  3928.         {

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

  3930.             static dpf_process_context_requirements context_req;

  3931.             static dpf_process_context_requirements* context_req_ptr = &context_req;

  3932.             *iface = &context_req_ptr;

  3933.             return V3_OK;

  3934.         }

  3935. 

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

  3937. 

  3938.         *iface = nullptr;

  3939.         return V3_NO_INTERFACE;

  3940.     }

  3941. 

  3942.     // ----------------------------------------------------------------------------------------------------------------

  3943.     // v3_audio_processor

  3944. 

  3945.     static v3_result V3_API set_bus_arrangements(void* const self,

  3946.                                                  v3_speaker_arrangement* const inputs, const int32_t num_inputs,

  3947.                                                  v3_speaker_arrangement* const outputs, const int32_t num_outputs)

  3948.     {

  3949.         // NOTE this is called a bunch of times in JUCE hosts

  3950.         d_stdout("dpf_audio_processor::set_bus_arrangements => %p %p %i %p %i",

  3951.                  self, inputs, num_inputs, outputs, num_outputs);

  3952.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3953. 

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

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

  3956. 

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

  3958.     }

  3959. 

  3960.     static v3_result V3_API get_bus_arrangement(void* const self, const int32_t bus_direction,

  3961.                                                 const int32_t idx, v3_speaker_arrangement* const arr)

  3962.     {

  3963.         d_stdout("dpf_audio_processor::get_bus_arrangement => %p %s %i %p",

  3964.                  self, v3_bus_direction_str(bus_direction), idx, arr);

  3965.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3966. 

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

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

  3969. 

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

  3971.     }

  3972. 

  3973.     static v3_result V3_API can_process_sample_size(void*, const int32_t symbolic_sample_size)

  3974.     {

  3975.         // NOTE runs during RT

  3976.         // d_stdout("dpf_audio_processor::can_process_sample_size => %i", symbolic_sample_size);

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

  3978.     }

  3979. 

  3980.     static uint32_t V3_API get_latency_samples(void* const self)

  3981.     {

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

  3983.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3984. 

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

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

  3987. 

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

  3989.     }

  3990. 

  3991.     static v3_result V3_API setup_processing(void* const self, v3_process_setup* const setup)

  3992.     {

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

  3994.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3995. 

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

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

  3998. 

  3999.         d_stdout("dpf_audio_processor::setup_processing => %p %p | %d %f", self, setup, setup->max_block_size, setup->sample_rate);

  4000. 

  4001.         d_nextBufferSize = setup->max_block_size;

  4002.         d_nextSampleRate = setup->sample_rate;

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

  4004.     }

  4005. 

  4006.     static v3_result V3_API set_processing(void* const self, const v3_bool state)

  4007.     {

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

  4009.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4010. 

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

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

  4013. 

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

  4015.     }

  4016. 

  4017.     static v3_result V3_API process(void* const self, v3_process_data* const data)

  4018.     {

  4019.         // NOTE runs during RT

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

  4021.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4022. 

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

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

  4025. 

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

  4027.     }

  4028. 

  4029.     static uint32_t V3_API get_tail_samples(void* const self)

  4030.     {

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

  4032.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4033. 

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

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

  4036. 

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

  4038.     }

  4039. };

  4040. 

  4041. // --------------------------------------------------------------------------------------------------------------------

  4042. // dpf_component

  4043. 

  4044. struct dpf_component : v3_component_cpp {

  4045.     std::atomic_int refcounter;

  4046.     ScopedPointer<dpf_audio_processor> processor;

  4047.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4048.     ScopedPointer<dpf_comp2ctrl_connection_point> connectionComp2Ctrl;

  4049.    #else

  4050.     ScopedPointer<dpf_edit_controller> controller;

  4051.    #endif

  4052.     ScopedPointer<PluginVst3> vst3;

  4053.     v3_host_application** const hostApplicationFromFactory;

  4054.     v3_host_application** hostApplicationFromInitialize;

  4055. 

  4056.     dpf_component(v3_host_application** const host)

  4057.         : refcounter(1),

  4058.           hostApplicationFromFactory(host),

  4059.           hostApplicationFromInitialize(nullptr)

  4060.     {

  4061.         d_stdout("dpf_component() with hostApplication %p", hostApplicationFromFactory);

  4062. 

  4063.         // make sure host application is valid through out this component lifetime

  4064.         if (hostApplicationFromFactory != nullptr)

  4065.             v3_cpp_obj_ref(hostApplicationFromFactory);

  4066. 

  4067.         // v3_funknown, everything custom

  4068.         query_interface = query_interface_component;

  4069.         ref = ref_component;

  4070.         unref = unref_component;

  4071. 

  4072.         // v3_plugin_base

  4073.         base.initialize = initialize;

  4074.         base.terminate = terminate;

  4075. 

  4076.         // v3_component

  4077.         comp.get_controller_class_id = get_controller_class_id;

  4078.         comp.set_io_mode = set_io_mode;

  4079.         comp.get_bus_count = get_bus_count;

  4080.         comp.get_bus_info = get_bus_info;

  4081.         comp.get_routing_info = get_routing_info;

  4082.         comp.activate_bus = activate_bus;

  4083.         comp.set_active = set_active;

  4084.         comp.set_state = set_state;

  4085.         comp.get_state = get_state;

  4086.     }

  4087. 

  4088.     ~dpf_component()

  4089.     {

  4090.         d_stdout("~dpf_component()");

  4091.         processor = nullptr;

  4092.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4093.         connectionComp2Ctrl = nullptr;

  4094.        #else

  4095.         controller = nullptr;

  4096.        #endif

  4097.         vst3 = nullptr;

  4098. 

  4099.         if (hostApplicationFromFactory != nullptr)

  4100.             v3_cpp_obj_unref(hostApplicationFromFactory);

  4101.     }

  4102. 

  4103.     // ----------------------------------------------------------------------------------------------------------------

  4104.     // v3_funknown

  4105. 

  4106.     static v3_result V3_API query_interface_component(void* const self, const v3_tuid iid, void** const iface)

  4107.     {

  4108.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4109. 

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

  4111.             v3_tuid_match(iid, v3_plugin_base_iid) ||

  4112.             v3_tuid_match(iid, v3_component_iid))

  4113.         {

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

  4115.             ++component->refcounter;

  4116.             *iface = self;

  4117.             return V3_OK;

  4118.         }

  4119. 

  4120.         if (v3_tuid_match(iid, v3_midi_mapping_iid))

  4121.         {

  4122.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  4124.             static dpf_midi_mapping midi_mapping;

  4125.             static dpf_midi_mapping* midi_mapping_ptr = &midi_mapping;

  4126.             *iface = &midi_mapping_ptr;

  4127.             return V3_OK;

  4128.            #else

  4129.             d_stdout("query_interface_component => %p %s %p | reject unused", self, tuid2str(iid), iface);

  4130.             *iface = nullptr;

  4131.             return V3_NO_INTERFACE;

  4132.            #endif

  4133.         }

  4134. 

  4135.         if (v3_tuid_match(iid, v3_audio_processor_iid))

  4136.         {

  4137.             d_stdout("query_interface_component => %p %s %p | OK convert %p",

  4138.                      self, tuid2str(iid), iface, component->processor.get());

  4139. 

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

  4141.                 component->processor = new dpf_audio_processor(component->vst3);

  4142.             else

  4143.                 ++component->processor->refcounter;

  4144.             *iface = &component->processor;

  4145.             return V3_OK;

  4146.         }

  4147. 

  4148.         if (v3_tuid_match(iid, v3_connection_point_iid))

  4149.         {

  4150.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4151.             d_stdout("query_interface_component => %p %s %p | OK convert %p",

  4152.                      self, tuid2str(iid), iface, component->connectionComp2Ctrl.get());

  4153. 

  4154.             if (component->connectionComp2Ctrl == nullptr)

  4155.                 component->connectionComp2Ctrl = new dpf_comp2ctrl_connection_point(component->vst3);

  4156.             else

  4157.                 ++component->connectionComp2Ctrl->refcounter;

  4158.             *iface = &component->connectionComp2Ctrl;

  4159.             return V3_OK;

  4160.            #else

  4161.             d_stdout("query_interface_component => %p %s %p | reject unwanted", self, tuid2str(iid), iface);

  4162.             *iface = nullptr;

  4163.             return V3_NO_INTERFACE;

  4164.            #endif

  4165.         }

  4166. 

  4167.         if (v3_tuid_match(iid, v3_edit_controller_iid))

  4168.         {

  4169.            #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  4170.             d_stdout("query_interface_component => %p %s %p | OK convert %p",

  4171.                      self, tuid2str(iid), iface, component->controller.get());

  4172. 

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

  4174.                 component->controller = new dpf_edit_controller(component->vst3,

  4175.                                                                 component->hostApplicationFromFactory,

  4176.                                                                 component->hostApplicationFromInitialize);

  4177.             else

  4178.                 ++component->controller->refcounter;

  4179.             *iface = &component->controller;

  4180.             return V3_OK;

  4181.            #else

  4182.             d_stdout("query_interface_component => %p %s %p | reject unwanted", self, tuid2str(iid), iface);

  4183.             *iface = nullptr;

  4184.             return V3_NO_INTERFACE;

  4185.            #endif

  4186.         }

  4187. 

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

  4189.         *iface = nullptr;

  4190.         return V3_NO_INTERFACE;

  4191.     }

  4192. 

  4193.     static uint32_t V3_API ref_component(void* const self)

  4194.     {

  4195.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4196.         const int refcount = ++component->refcounter;

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

  4198.         return refcount;

  4199.     }

  4200. 

  4201.     static uint32_t V3_API unref_component(void* const self)

  4202.     {

  4203.         dpf_component** const componentptr = static_cast<dpf_component**>(self);

  4204.         dpf_component* const component = *componentptr;

  4205. 

  4206.         if (const int refcount = --component->refcounter)

  4207.         {

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

  4209.             return refcount;

  4210.         }

  4211. 

  4212.         /**

  4213.          * Some hosts will have unclean instances of a few of the component child classes at this point.

  4214.          * We check for those here, going through the whole possible chain to see if it is safe to delete.

  4215.          * If not, we add this component to the `gComponentGarbage` global which will take care of it during unload.

  4216.          */

  4217. 

  4218.         bool unclean = false;

  4219. 

  4220.         if (dpf_audio_processor* const proc = component->processor)

  4221.         {

  4222.             if (const int refcount = proc->refcounter)

  4223.             {

  4224.                 unclean = true;

  4225.                 d_stderr("DPF warning: asked to delete component while audio processor still active (refcount %d)", refcount);

  4226.             }

  4227.         }

  4228. 

  4229.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4230.         if (dpf_comp2ctrl_connection_point* const point = component->connectionComp2Ctrl)

  4231.         {

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

  4233.             {

  4234.                 unclean = true;

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

  4236.             }

  4237.         }

  4238.        #else

  4239.         if (dpf_edit_controller* const controller = component->controller)

  4240.         {

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

  4242.             {

  4243.                 unclean = true;

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

  4245.             }

  4246.         }

  4247.        #endif

  4248. 

  4249.         if (unclean)

  4250.             return handleUncleanComponent(componentptr);

  4251. 

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

  4253. 

  4254.         delete component;

  4255.         delete componentptr;

  4256.         return 0;

  4257.     }

  4258. 

  4259.     // ----------------------------------------------------------------------------------------------------------------

  4260.     // v3_plugin_base

  4261. 

  4262.     static v3_result V3_API initialize(void* const self, v3_funknown** const context)

  4263.     {

  4264.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4265. 

  4266.         // check if already initialized

  4267.         DISTRHO_SAFE_ASSERT_RETURN(component->vst3 == nullptr, V3_INVALID_ARG);

  4268. 

  4269.         // query for host application

  4270.         v3_host_application** hostApplication = nullptr;

  4271.         if (context != nullptr)

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

  4273. 

  4274.         d_stdout("dpf_component::initialize => %p %p | hostApplication %p", self, context, hostApplication);

  4275. 

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

  4277.         component->hostApplicationFromInitialize = hostApplication;

  4278. 

  4279.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  4280.         // save it in edit controller too, needed for some hosts

  4281.         if (component->controller != nullptr)

  4282.             component->controller->hostApplicationFromComponentInitialize = hostApplication;

  4283.        #endif

  4284. 

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

  4286.         if (hostApplication == nullptr)

  4287.             hostApplication = component->hostApplicationFromFactory;

  4288. 

  4289.         // default early values

  4290.         if (d_nextBufferSize == 0)

  4291.             d_nextBufferSize = 1024;

  4292.         if (d_nextSampleRate <= 0.0)

  4293.             d_nextSampleRate = 44100.0;

  4294. 

  4295.         d_nextCanRequestParameterValueChanges = true;

  4296. 

  4297.         // create the actual plugin

  4298.         component->vst3 = new PluginVst3(hostApplication);

  4299. 

  4300.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4301.         // set connection point if needed

  4302.         if (dpf_comp2ctrl_connection_point* const point = component->connectionComp2Ctrl)

  4303.         {

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

  4305.                 component->vst3->comp2ctrl_connect(point->other);

  4306.         }

  4307.        #endif

  4308. 

  4309.         return V3_OK;

  4310.     }

  4311. 

  4312.     static v3_result V3_API terminate(void* const self)

  4313.     {

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

  4315.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4316. 

  4317.         // check if already terminated

  4318.         DISTRHO_SAFE_ASSERT_RETURN(component->vst3 != nullptr, V3_INVALID_ARG);

  4319. 

  4320.         // delete actual plugin

  4321.         component->vst3 = nullptr;

  4322. 

  4323.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  4324.         // remove previous host application saved during initialize

  4325.         if (component->controller != nullptr)

  4326.             component->controller->hostApplicationFromComponentInitialize = nullptr;

  4327.        #endif

  4328. 

  4329.         // unref host application received during initialize

  4330.         if (component->hostApplicationFromInitialize != nullptr)

  4331.         {

  4332.             v3_cpp_obj_unref(component->hostApplicationFromInitialize);

  4333.             component->hostApplicationFromInitialize = nullptr;

  4334.         }

  4335. 

  4336.         return V3_OK;

  4337.     }

  4338. 

  4339.     // ----------------------------------------------------------------------------------------------------------------

  4340.     // v3_component

  4341. 

  4342.     static v3_result V3_API get_controller_class_id(void*, v3_tuid class_id)

  4343.     {

  4344.         d_stdout("dpf_component::get_controller_class_id => %p", class_id);

  4345. 

  4346.         std::memcpy(class_id, dpf_tuid_controller, sizeof(v3_tuid));

  4347.         return V3_OK;

  4348.     }

  4349. 

  4350.     static v3_result V3_API set_io_mode(void* const self, const int32_t io_mode)

  4351.     {

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

  4353. 

  4354.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4355. 

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

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

  4358. 

  4359.         // TODO

  4360.         return V3_NOT_IMPLEMENTED;

  4361.     }

  4362. 

  4363.     static int32_t V3_API get_bus_count(void* const self, const int32_t media_type, const int32_t bus_direction)

  4364.     {

  4365.         // NOTE runs during RT

  4366.         // d_stdout("dpf_component::get_bus_count => %p %s %s",

  4367.         //          self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction));

  4368.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4369. 

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

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

  4372. 

  4373.         const int32_t ret = vst3->getBusCount(media_type, bus_direction);

  4374.         // d_stdout("dpf_component::get_bus_count returns %i", ret);

  4375.         return ret;

  4376.     }

  4377. 

  4378.     static v3_result V3_API get_bus_info(void* const self, const int32_t media_type, const int32_t bus_direction,

  4379.                                          const int32_t bus_idx, v3_bus_info* const info)

  4380.     {

  4381.         d_stdout("dpf_component::get_bus_info => %p %s %s %i %p",

  4382.                  self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction), bus_idx, info);

  4383.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4384. 

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

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

  4387. 

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

  4389.     }

  4390. 

  4391.     static v3_result V3_API get_routing_info(void* const self, v3_routing_info* const input, v3_routing_info* const output)

  4392.     {

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

  4394.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4395. 

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

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

  4398. 

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

  4400.     }

  4401. 

  4402.     static v3_result V3_API activate_bus(void* const self, const int32_t media_type, const int32_t bus_direction,

  4403.                                          const int32_t bus_idx, const v3_bool state)

  4404.     {

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

  4406.         // d_stdout("dpf_component::activate_bus => %p %s %s %i %u",

  4407.         //          self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction), bus_idx, state);

  4408.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4409. 

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

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

  4412. 

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

  4414.     }

  4415. 

  4416.     static v3_result V3_API set_active(void* const self, const v3_bool state)

  4417.     {

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

  4419.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4420. 

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

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

  4423. 

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

  4425.     }

  4426. 

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

  4428.     {

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

  4430.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4431. 

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

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

  4434. 

  4435.         return vst3->setState(stream);

  4436.     }

  4437. 

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

  4439.     {

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

  4441.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4442. 

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

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

  4445. 

  4446.         return vst3->getState(stream);

  4447.     }

  4448. };

  4449. 

  4450. // --------------------------------------------------------------------------------------------------------------------

  4451. // Dummy plugin to get data from

  4452. 

  4453. static const PluginExporter& _getPluginInfo()

  4454. {

  4455.     d_nextBufferSize = 1024;

  4456.     d_nextSampleRate = 44100.0;

  4457.     d_nextPluginIsDummy = true;

  4458.     d_nextCanRequestParameterValueChanges = true;

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

  4460.     d_nextBufferSize = 0;

  4461.     d_nextSampleRate = 0.0;

  4462.     d_nextPluginIsDummy = false;

  4463.     d_nextCanRequestParameterValueChanges = false;

  4464. 

  4465.     return gPluginInfo;

  4466. }

  4467. 

  4468. static const PluginExporter& getPluginInfo()

  4469. {

  4470.     static const PluginExporter& info(_getPluginInfo());

  4471.     return info;

  4472. }

  4473. 

  4474. static const char* getPluginCategories()

  4475. {

  4476.     static String categories;

  4477.     static bool firstInit = true;

  4478. 

  4479.     if (firstInit)

  4480.     {

  4481. #ifdef DISTRHO_PLUGIN_VST3_CATEGORIES

  4482.         categories = DISTRHO_PLUGIN_VST3_CATEGORIES;

  4483. #elif DISTRHO_PLUGIN_IS_SYNTH

  4484.         categories = "Instrument";

  4485. #endif

  4486. #if (DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_INPUTS == 1) && DISTRHO_PLUGIN_NUM_OUTPUTS == 1

  4487.         if (categories.isNotEmpty())

  4488.             categories += "|";

  4489.         categories += "Mono";

  4490. #elif (DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_INPUTS == 2) && DISTRHO_PLUGIN_NUM_OUTPUTS == 2

  4491.         if (categories.isNotEmpty())

  4492.             categories += "|";

  4493.         categories += "Stereo";

  4494. #endif

  4495.         firstInit = false;

  4496.     }

  4497. 

  4498.     return categories.buffer();

  4499. }

  4500. 

  4501. static const char* getPluginVersion()

  4502. {

  4503.     static String version;

  4504. 

  4505.     if (version.isEmpty())

  4506.     {

  4507.         const uint32_t versionNum = getPluginInfo().getVersion();

  4508. 

  4509.         char versionBuf[64];

  4510.         std::snprintf(versionBuf, sizeof(versionBuf)-1, "%d.%d.%d",

  4511.                       (versionNum >> 16) & 0xff,

  4512.                       (versionNum >>  8) & 0xff,

  4513.                       (versionNum >>  0) & 0xff);

  4514.         versionBuf[sizeof(versionBuf)-1] = '\0';

  4515.         version = versionBuf;

  4516.     }

  4517. 

  4518.     return version.buffer();

  4519. }

  4520. 

  4521. // --------------------------------------------------------------------------------------------------------------------

  4522. // dpf_factory

  4523. 

  4524. struct dpf_factory : v3_plugin_factory_cpp {

  4525.     std::atomic_int refcounter;

  4526. 

  4527.     // cached values

  4528.     v3_funknown** hostContext;

  4529. 

  4530.     dpf_factory()

  4531.         : refcounter(1),

  4532.           hostContext(nullptr)

  4533.     {

  4534.         // v3_funknown, static

  4535.         query_interface = query_interface_factory;

  4536.         ref = ref_factory;

  4537.         unref = unref_factory;

  4538. 

  4539.         // v3_plugin_factory

  4540.         v1.get_factory_info = get_factory_info;

  4541.         v1.num_classes = num_classes;

  4542.         v1.get_class_info = get_class_info;

  4543.         v1.create_instance = create_instance;

  4544. 

  4545.         // v3_plugin_factory_2

  4546.         v2.get_class_info_2 = get_class_info_2;

  4547. 

  4548.         // v3_plugin_factory_3

  4549.         v3.get_class_info_utf16 = get_class_info_utf16;

  4550.         v3.set_host_context = set_host_context;

  4551.     }

  4552. 

  4553.     ~dpf_factory()

  4554.     {

  4555.         // unref old context if there is one

  4556.         if (hostContext != nullptr)

  4557.             v3_cpp_obj_unref(hostContext);

  4558. 

  4559.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4560.         if (gControllerGarbage.size() != 0)

  4561.         {

  4562.             d_stdout("DPF notice: cleaning up previously undeleted controllers now");

  4563. 

  4564.             for (std::vector<dpf_edit_controller**>::iterator it = gControllerGarbage.begin();

  4565.                 it != gControllerGarbage.end(); ++it)

  4566.             {

  4567.                 dpf_edit_controller** const controllerptr = *it;

  4568.                 dpf_edit_controller* const controller = *controllerptr;

  4569.                 delete controller;

  4570.                 delete controllerptr;

  4571.             }

  4572. 

  4573.             gControllerGarbage.clear();

  4574.         }

  4575.        #endif

  4576. 

  4577.         if (gComponentGarbage.size() != 0)

  4578.         {

  4579.             d_stdout("DPF notice: cleaning up previously undeleted components now");

  4580. 

  4581.             for (std::vector<dpf_component**>::iterator it = gComponentGarbage.begin();

  4582.                 it != gComponentGarbage.end(); ++it)

  4583.             {

  4584.                 dpf_component** const componentptr = *it;

  4585.                 dpf_component* const component = *componentptr;

  4586.                 delete component;

  4587.                 delete componentptr;

  4588.             }

  4589. 

  4590.             gComponentGarbage.clear();

  4591.         }

  4592.     }

  4593. 

  4594.     // ----------------------------------------------------------------------------------------------------------------

  4595.     // v3_funknown

  4596. 

  4597.     static v3_result V3_API query_interface_factory(void* const self, const v3_tuid iid, void** const iface)

  4598.     {

  4599.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4600. 

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

  4602.             v3_tuid_match(iid, v3_plugin_factory_iid) ||

  4603.             v3_tuid_match(iid, v3_plugin_factory_2_iid) ||

  4604.             v3_tuid_match(iid, v3_plugin_factory_3_iid))

  4605.         {

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

  4607.             ++factory->refcounter;

  4608.             *iface = self;

  4609.             return V3_OK;

  4610.         }

  4611. 

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

  4613. 

  4614.         *iface = nullptr;

  4615.         return V3_NO_INTERFACE;

  4616.     }

  4617. 

  4618.     static uint32_t V3_API ref_factory(void* const self)

  4619.     {

  4620.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4621.         const int refcount = ++factory->refcounter;

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

  4623.         return refcount;

  4624.     }

  4625. 

  4626.     static uint32_t V3_API unref_factory(void* const self)

  4627.     {

  4628.         dpf_factory** const factoryptr = static_cast<dpf_factory**>(self);

  4629.         dpf_factory* const factory = *factoryptr;

  4630. 

  4631.         if (const int refcount = --factory->refcounter)

  4632.         {

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

  4634.             return refcount;

  4635.         }

  4636. 

  4637.         d_stdout("unref_factory::unref => %p | refcount is zero, deleting factory", self);

  4638. 

  4639.         delete factory;

  4640.         delete factoryptr;

  4641.         return 0;

  4642.     }

  4643. 

  4644.     // ----------------------------------------------------------------------------------------------------------------

  4645.     // v3_plugin_factory

  4646. 

  4647.     static v3_result V3_API get_factory_info(void*, v3_factory_info* const info)

  4648.     {

  4649.         d_stdout("dpf_factory::get_factory_info => %p", info);

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

  4651. 

  4652.         info->flags = 0x10; // unicode

  4653.         DISTRHO_NAMESPACE::strncpy(info->vendor, getPluginInfo().getMaker(), ARRAY_SIZE(info->vendor));

  4654.         DISTRHO_NAMESPACE::strncpy(info->url, getPluginInfo().getHomePage(), ARRAY_SIZE(info->url));

  4655.         // DISTRHO_NAMESPACE::strncpy(info->email, "", ARRAY_SIZE(info->email)); // TODO

  4656.         return V3_OK;

  4657.     }

  4658. 

  4659.     static int32_t V3_API num_classes(void*)

  4660.     {

  4661.         d_stdout("dpf_factory::num_classes");

  4662.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4663.         return 2; // factory can create component and edit-controller

  4664.        #else

  4665.         return 1; // factory can only create component, edit-controller must be casted

  4666.        #endif

  4667.     }

  4668. 

  4669.     static v3_result V3_API get_class_info(void*, const int32_t idx, v3_class_info* const info)

  4670.     {

  4671.         d_stdout("dpf_factory::get_class_info => %i %p", idx, info);

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

  4673.         DISTRHO_SAFE_ASSERT_RETURN(idx <= 2, V3_INVALID_ARG);

  4674. 

  4675.         info->cardinality = 0x7FFFFFFF;

  4676.         DISTRHO_NAMESPACE::strncpy(info->name, getPluginInfo().getName(), ARRAY_SIZE(info->name));

  4677. 

  4678.         if (idx == 0)

  4679.         {

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

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

  4682.         }

  4683.         else

  4684.         {

  4685.             std::memcpy(info->class_id, dpf_tuid_controller, sizeof(v3_tuid));

  4686.             DISTRHO_NAMESPACE::strncpy(info->category, "Component Controller Class", ARRAY_SIZE(info->category));

  4687.         }

  4688. 

  4689.         return V3_OK;

  4690.     }

  4691. 

  4692.     static v3_result V3_API create_instance(void* self, const v3_tuid class_id, const v3_tuid iid, void** const instance)

  4693.     {

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

  4695.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4696. 

  4697.         // query for host application

  4698.         v3_host_application** hostApplication = nullptr;

  4699.         if (factory->hostContext != nullptr)

  4700.             v3_cpp_obj_query_interface(factory->hostContext, v3_host_application_iid, &hostApplication);

  4701. 

  4702.         // create component

  4703.         if (v3_tuid_match(class_id, *(const v3_tuid*)&dpf_tuid_class) && (v3_tuid_match(iid, v3_component_iid) ||

  4704.                                                                           v3_tuid_match(iid, v3_funknown_iid)))

  4705.         {

  4706.             dpf_component** const componentptr = new dpf_component*;

  4707.             *componentptr = new dpf_component(hostApplication);

  4708.             *instance = static_cast<void*>(componentptr);

  4709.             return V3_OK;

  4710.         }

  4711. 

  4712.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4713.         // create edit controller

  4714.         if (v3_tuid_match(class_id, *(const v3_tuid*)&dpf_tuid_controller) && (v3_tuid_match(iid, v3_edit_controller_iid) ||

  4715.                                                                                v3_tuid_match(iid, v3_funknown_iid)))

  4716.         {

  4717.             dpf_edit_controller** const controllerptr = new dpf_edit_controller*;

  4718.             *controllerptr = new dpf_edit_controller(hostApplication);

  4719.             *instance = static_cast<void*>(controllerptr);

  4720.             return V3_OK;

  4721.         }

  4722.        #endif

  4723. 

  4724.         // unsupported, roll back host application

  4725.         if (hostApplication != nullptr)

  4726.             v3_cpp_obj_unref(hostApplication);

  4727. 

  4728.         return V3_NO_INTERFACE;

  4729.     }

  4730. 

  4731.     // ----------------------------------------------------------------------------------------------------------------

  4732.     // v3_plugin_factory_2

  4733. 

  4734.     static v3_result V3_API get_class_info_2(void*, const int32_t idx, v3_class_info_2* const info)

  4735.     {

  4736.         d_stdout("dpf_factory::get_class_info_2 => %i %p", idx, info);

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

  4738.         DISTRHO_SAFE_ASSERT_RETURN(idx <= 2, V3_INVALID_ARG);

  4739. 

  4740.         info->cardinality = 0x7FFFFFFF;

  4741.        #if DPF_VST3_USES_SEPARATE_CONTROLLER || !DISTRHO_PLUGIN_HAS_UI

  4742.         info->class_flags = V3_DISTRIBUTABLE;

  4743.        #endif

  4744.         DISTRHO_NAMESPACE::strncpy(info->sub_categories, getPluginCategories(), ARRAY_SIZE(info->sub_categories));

  4745.         DISTRHO_NAMESPACE::strncpy(info->name, getPluginInfo().getName(), ARRAY_SIZE(info->name));

  4746.         DISTRHO_NAMESPACE::strncpy(info->vendor, getPluginInfo().getMaker(), ARRAY_SIZE(info->vendor));

  4747.         DISTRHO_NAMESPACE::strncpy(info->version, getPluginVersion(), ARRAY_SIZE(info->version));

  4748.         DISTRHO_NAMESPACE::strncpy(info->sdk_version, "Travesty 3.7.4", ARRAY_SIZE(info->sdk_version));

  4749. 

  4750.         if (idx == 0)

  4751.         {

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

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

  4754.         }

  4755.         else

  4756.         {

  4757.             std::memcpy(info->class_id, dpf_tuid_controller, sizeof(v3_tuid));

  4758.             DISTRHO_NAMESPACE::strncpy(info->category, "Component Controller Class", ARRAY_SIZE(info->category));

  4759.         }

  4760. 

  4761.         return V3_OK;

  4762.     }

  4763. 

  4764.     // ------------------------------------------------------------------------------------------------------------

  4765.     // v3_plugin_factory_3

  4766. 

  4767.     static v3_result V3_API get_class_info_utf16(void*, const int32_t idx, v3_class_info_3* const info)

  4768.     {

  4769.         d_stdout("dpf_factory::get_class_info_utf16 => %i %p", idx, info);

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

  4771.         DISTRHO_SAFE_ASSERT_RETURN(idx <= 2, V3_INVALID_ARG);

  4772. 

  4773.         info->cardinality = 0x7FFFFFFF;

  4774.        #if DPF_VST3_USES_SEPARATE_CONTROLLER || !DISTRHO_PLUGIN_HAS_UI

  4775.         info->class_flags = V3_DISTRIBUTABLE;

  4776.        #endif

  4777.         DISTRHO_NAMESPACE::strncpy(info->sub_categories, getPluginCategories(), ARRAY_SIZE(info->sub_categories));

  4778.         DISTRHO_NAMESPACE::strncpy_utf16(info->name, getPluginInfo().getName(), ARRAY_SIZE(info->name));

  4779.         DISTRHO_NAMESPACE::strncpy_utf16(info->vendor, getPluginInfo().getMaker(), ARRAY_SIZE(info->vendor));

  4780.         DISTRHO_NAMESPACE::strncpy_utf16(info->version, getPluginVersion(), ARRAY_SIZE(info->version));

  4781.         DISTRHO_NAMESPACE::strncpy_utf16(info->sdk_version, "Travesty 3.7.4", ARRAY_SIZE(info->sdk_version));

  4782. 

  4783.         if (idx == 0)

  4784.         {

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

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

  4787.         }

  4788.         else

  4789.         {

  4790.             std::memcpy(info->class_id, dpf_tuid_controller, sizeof(v3_tuid));

  4791.             DISTRHO_NAMESPACE::strncpy(info->category, "Component Controller Class", ARRAY_SIZE(info->category));

  4792.         }

  4793. 

  4794.         return V3_OK;

  4795.     }

  4796. 

  4797.     static v3_result V3_API set_host_context(void* const self, v3_funknown** const context)

  4798.     {

  4799.         d_stdout("dpf_factory::set_host_context => %p %p", self, context);

  4800.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4801. 

  4802.         // unref old context if there is one

  4803.         if (factory->hostContext != nullptr)

  4804.             v3_cpp_obj_unref(factory->hostContext);

  4805. 

  4806.         // store new context

  4807.         factory->hostContext = context;

  4808. 

  4809.         // make sure the object keeps being valid for a while

  4810.         if (context != nullptr)

  4811.             v3_cpp_obj_ref(context);

  4812. 

  4813.         return V3_OK;

  4814.     }

  4815. };

  4816. 

  4817. END_NAMESPACE_DISTRHO

  4818. 

  4819. // --------------------------------------------------------------------------------------------------------------------

  4820. // VST3 entry point

  4821. 

  4822. DISTRHO_PLUGIN_EXPORT

  4823. const void* GetPluginFactory(void);

  4824. 

  4825. const void* GetPluginFactory(void)

  4826. {

  4827.     USE_NAMESPACE_DISTRHO;

  4828.     dpf_factory** const factoryptr = new dpf_factory*;

  4829.     *factoryptr = new dpf_factory;

  4830.     return static_cast<void*>(factoryptr);

  4831. }

  4832. 

  4833. // --------------------------------------------------------------------------------------------------------------------

  4834. // OS specific module load

  4835. 

  4836. #if defined(DISTRHO_OS_MAC)

  4837. # define ENTRYFNNAME bundleEntry

  4838. # define ENTRYFNNAMEARGS void*

  4839. # define EXITFNNAME bundleExit

  4840. #elif defined(DISTRHO_OS_WINDOWS)

  4841. # define ENTRYFNNAME InitDll

  4842. # define ENTRYFNNAMEARGS void

  4843. # define EXITFNNAME ExitDll

  4844. #else

  4845. # define ENTRYFNNAME ModuleEntry

  4846. # define ENTRYFNNAMEARGS void*

  4847. # define EXITFNNAME ModuleExit

  4848. #endif

  4849. 

  4850. DISTRHO_PLUGIN_EXPORT

  4851. bool ENTRYFNNAME(ENTRYFNNAMEARGS);

  4852. 

  4853. bool ENTRYFNNAME(ENTRYFNNAMEARGS)

  4854. {

  4855.     USE_NAMESPACE_DISTRHO;

  4856. 

  4857.     // find plugin bundle

  4858.     static String bundlePath;

  4859.     if (bundlePath.isEmpty())

  4860.     {

  4861.         String tmpPath(getBinaryFilename());

  4862.         tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  4863.         tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  4864. 

  4865.         if (tmpPath.endsWith(DISTRHO_OS_SEP_STR "Contents"))

  4866.         {

  4867.             tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  4868.             bundlePath = tmpPath;

  4869.             d_nextBundlePath = bundlePath.buffer();

  4870.         }

  4871.         else

  4872.         {

  4873.             bundlePath = "error";

  4874.         }

  4875.     }

  4876. 

  4877.     // init dummy plugin and set uniqueId

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

  4879.         = dpf_tuid_processor[2] = dpf_tuid_view[2] = getPluginInfo().getUniqueId();

  4880. 

  4881.     return true;

  4882. }

  4883. 

  4884. DISTRHO_PLUGIN_EXPORT

  4885. bool EXITFNNAME(void);

  4886. 

  4887. bool EXITFNNAME(void)

  4888. {

  4889.     return true;

  4890. }

  4891. 

  4892. #undef ENTRYFNNAME

  4893. #undef EXITFNNAME

  4894. 

  4895. // --------------------------------------------------------------------------------------------------------------------