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

4972 lines
185KB
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. /* TODO items:

  18.  * == parameters

  19.  * - test parameter triggers

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

  21.  * - parameter groups via unit ids

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

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

  24.  * - float to int safe casting

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

  26.  * == MIDI

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

  28.  * - MIDI program changes

  29.  * - MIDI sysex

  30.  * == BUSES

  31.  * - routing info, do we care?

  32.  * == CV

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

  34.  * - test in at least 1 host

  35.  * == INFO

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

  37.  * - do something with set_io_mode?

  38.  */

  39. 

  40. #include "DistrhoPluginInternal.hpp"

  41. #include "../DistrhoPluginUtils.hpp"

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

  43. 

  44. #define DPF_VST3_MAX_BUFFER_SIZE 32768

  45. #define DPF_VST3_MAX_SAMPLE_RATE 384000

  46. #define DPF_VST3_MAX_LATENCY     DPF_VST3_MAX_SAMPLE_RATE * 10

  47. 

  48. #if DISTRHO_PLUGIN_HAS_UI

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

  50. #endif

  51. 

  52. #include "travesty/audio_processor.h"

  53. #include "travesty/component.h"

  54. #include "travesty/edit_controller.h"

  55. #include "travesty/factory.h"

  56. #include "travesty/host.h"

  57. 

  58. #include <map>

  59. #include <string>

  60. #include <vector>

  61. 

  62. START_NAMESPACE_DISTRHO

  63. 

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

  65. 

  66. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  67. static constexpr const writeMidiFunc writeMidiCallback = nullptr;

  68. #endif

  69. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  70. static constexpr const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  71. #endif

  72. 

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

  74. 

  75. // --------------------------------------------------------------------------------------------------------------------

  76. // custom v3_tuid compatible type

  77. 

  78. typedef uint32_t dpf_tuid[4];

  79. #ifdef DISTRHO_PROPER_CPP11_SUPPORT

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

  81. #endif

  82. 

  83. // --------------------------------------------------------------------------------------------------------------------

  84. // custom, constant uids related to DPF

  85. 

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

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

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

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

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

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

  92. 

  93. // --------------------------------------------------------------------------------------------------------------------

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

  95. 

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

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

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

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

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

  101. 

  102. // --------------------------------------------------------------------------------------------------------------------

  103. // Utility functions

  104. 

  105. const char* tuid2str(const v3_tuid iid)

  106. {

  107.     static constexpr const struct {

  108.         v3_tuid iid;

  109.         const char* name;

  110.     } extra_known_iids[] = {

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

  112.         // edit-controller

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

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

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

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

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

  118.         // units

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

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

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

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

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

  124.         // misc

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

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

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

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

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

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

  131.         /*

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  163.         */

  164.     };

  165. 

  166.     if (v3_tuid_match(iid, v3_audio_processor_iid))

  167.         return "{v3_audio_processor}";

  168.     if (v3_tuid_match(iid, v3_attribute_list_iid))

  169.         return "{v3_attribute_list_iid}";

  170.     if (v3_tuid_match(iid, v3_bstream_iid))

  171.         return "{v3_bstream}";

  172.     if (v3_tuid_match(iid, v3_component_iid))

  173.         return "{v3_component}";

  174.     if (v3_tuid_match(iid, v3_component_handler_iid))

  175.         return "{v3_component_handler}";

  176.     if (v3_tuid_match(iid, v3_connection_point_iid))

  177.         return "{v3_connection_point_iid}";

  178.     if (v3_tuid_match(iid, v3_edit_controller_iid))

  179.         return "{v3_edit_controller}";

  180.     if (v3_tuid_match(iid, v3_event_handler_iid))

  181.         return "{v3_event_handler_iid}";

  182.     if (v3_tuid_match(iid, v3_event_list_iid))

  183.         return "{v3_event_list}";

  184.     if (v3_tuid_match(iid, v3_funknown_iid))

  185.         return "{v3_funknown}";

  186.     if (v3_tuid_match(iid, v3_host_application_iid))

  187.         return "{v3_host_application_iid}";

  188.     if (v3_tuid_match(iid, v3_message_iid))

  189.         return "{v3_message_iid}";

  190.     if (v3_tuid_match(iid, v3_midi_mapping_iid))

  191.         return "{v3_midi_mapping_iid}";

  192.     if (v3_tuid_match(iid, v3_param_value_queue_iid))

  193.         return "{v3_param_value_queue}";

  194.     if (v3_tuid_match(iid, v3_param_changes_iid))

  195.         return "{v3_param_changes}";

  196.     if (v3_tuid_match(iid, v3_plugin_base_iid))

  197.         return "{v3_plugin_base}";

  198.     if (v3_tuid_match(iid, v3_plugin_factory_iid))

  199.         return "{v3_plugin_factory}";

  200.     if (v3_tuid_match(iid, v3_plugin_factory_2_iid))

  201.         return "{v3_plugin_factory_2}";

  202.     if (v3_tuid_match(iid, v3_plugin_factory_3_iid))

  203.         return "{v3_plugin_factory_3}";

  204.     if (v3_tuid_match(iid, v3_plugin_frame_iid))

  205.         return "{v3_plugin_frame}";

  206.     if (v3_tuid_match(iid, v3_plugin_view_iid))

  207.         return "{v3_plugin_view}";

  208.     if (v3_tuid_match(iid, v3_plugin_view_content_scale_iid))

  209.         return "{v3_plugin_view_content_scale_iid}";

  210.     if (v3_tuid_match(iid, v3_plugin_view_parameter_finder_iid))

  211.         return "{v3_plugin_view_parameter_finder}";

  212.     if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  213.         return "{v3_process_context_requirements}";

  214.     if (v3_tuid_match(iid, v3_run_loop_iid))

  215.         return "{v3_run_loop_iid}";

  216.     if (v3_tuid_match(iid, v3_timer_handler_iid))

  217.         return "{v3_timer_handler_iid}";

  218. 

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

  220.         return "{dpf_tuid_class}";

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

  222.         return "{dpf_tuid_component}";

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

  224.         return "{dpf_tuid_controller}";

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

  226.         return "{dpf_tuid_processor}";

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

  228.         return "{dpf_tuid_view}";

  229. 

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

  231.     {

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

  233.             return extra_known_iids[i].name;

  234.     }

  235. 

  236.     static char buf[46];

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

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

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

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

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

  242.     return buf;

  243. }

  244. 

  245. // --------------------------------------------------------------------------------------------------------------------

  246. // dpf_plugin_view_create (implemented on UI side)

  247. 

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

  249. 

  250. // --------------------------------------------------------------------------------------------------------------------

  251. 

  252. /**

  253.  * VST3 DSP class.

  254.  *

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

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

  257.  *

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

  259.  */

  260. class PluginVst3

  261. {

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

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

  264.      *

  265.      * When port groups are not in use:

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

  267.      * - 1 for sidechain

  268.      * - 1 for each cv port

  269.      * So basically:

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

  271.      * Then sidechain, also if available.

  272.      * And finally each CV port individually.

  273.      *

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

  275.      */

  276.     struct BusInfo {

  277.         uint8_t audio;     // either 0 or 1

  278.         uint8_t sidechain; // either 0 or 1

  279.         uint32_t groups;

  280.         uint32_t audioPorts;

  281.         uint32_t sidechainPorts;

  282.         uint32_t groupPorts;

  283.         uint32_t cvPorts;

  284. 

  285.         BusInfo()

  286.           : audio(0),

  287.             sidechain(0),

  288.             groups(0),

  289.             audioPorts(0),

  290.             sidechainPorts(0),

  291.             groupPorts(0),

  292.             cvPorts(0) {}

  293.     } inputBuses, outputBuses;

  294. 

  295.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

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

  298.      */

  299.     struct InputEventList {

  300.         enum Type {

  301.             NoteOn,

  302.             NoteOff,

  303.             SysexData,

  304.             PolyPressure,

  305.             CC_Normal,

  306.             CC_ChannelPressure,

  307.             CC_Pitchbend,

  308.             UI_MIDI // event from UI

  309.         };

  310.         struct InputEventStorage {

  311.             Type type;

  312.             union {

  313.                 v3_event_note_on noteOn;

  314.                 v3_event_note_off noteOff;

  315.                 v3_event_data sysexData;

  316.                 v3_event_poly_pressure polyPressure;

  317.                 uint8_t midi[3];

  318.             };

  319.         } eventListStorage[kMaxMidiEvents];

  320. 

  321.         struct InputEvent {

  322.             int32_t sampleOffset;

  323.             const InputEventStorage* storage;

  324.             InputEvent* next;

  325.         } eventList[kMaxMidiEvents];

  326. 

  327.         uint16_t numUsed;

  328.         int32_t firstSampleOffset;

  329.         int32_t lastSampleOffset;

  330.         InputEvent* firstEvent;

  331.         InputEvent* lastEvent;

  332. 

  333.         void init()

  334.         {

  335.             numUsed = 0;

  336.             firstSampleOffset = lastSampleOffset = 0;

  337.             firstEvent = nullptr;

  338.         }

  339. 

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

  341.         {

  342.             uint32_t count = 0;

  343. 

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

  345.             {

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

  347.                 midiEvent.frame = event->sampleOffset;

  348. 

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

  350. 

  351.                 switch (eventStorage.type)

  352.                 {

  353.                 case NoteOn:

  354.                     midiEvent.size = 3;

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

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

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

  358.                     midiEvent.data[3] = 0;

  359.                     break;

  360.                 case NoteOff:

  361.                     midiEvent.size = 3;

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

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

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

  365.                     midiEvent.data[3] = 0;

  366.                     break;

  367.                 /* TODO

  368.                 case SysexData:

  369.                     break;

  370.                 */

  371.                 case PolyPressure:

  372.                     midiEvent.size = 3;

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

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

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

  376.                     midiEvent.data[3] = 0;

  377.                     break;

  378.                 case CC_Normal:

  379.                     midiEvent.size = 3;

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

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

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

  383.                     break;

  384.                 case CC_ChannelPressure:

  385.                     midiEvent.size = 2;

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

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

  388.                     midiEvent.data[2] = 0;

  389.                     break;

  390.                 case CC_Pitchbend:

  391.                     midiEvent.size = 3;

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

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

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

  395.                     break;

  396.                 case UI_MIDI:

  397.                     midiEvent.size = 3;

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

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

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

  401.                     break;

  402.                 default:

  403.                     midiEvent.size = 0;

  404.                     break;

  405.                 }

  406.             }

  407. 

  408.             return count;

  409.         }

  410. 

  411.         bool appendEvent(const v3_event& event) noexcept

  412.         {

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

  414.             switch (event.type)

  415.             {

  416.             case V3_EVENT_NOTE_ON:

  417.             case V3_EVENT_NOTE_OFF:

  418.             // case V3_EVENT_DATA:

  419.             case V3_EVENT_POLY_PRESSURE:

  420.                 break;

  421.             default:

  422.                 return false;

  423.             }

  424. 

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

  426. 

  427.             switch (event.type)

  428.             {

  429.             case V3_EVENT_NOTE_ON:

  430.                 eventStorage.type = NoteOn;

  431.                 eventStorage.noteOn = event.note_on;

  432.                 break;

  433.             case V3_EVENT_NOTE_OFF:

  434.                 eventStorage.type = NoteOff;

  435.                 eventStorage.noteOff = event.note_off;

  436.                 break;

  437.             case V3_EVENT_DATA:

  438.                 eventStorage.type = SysexData;

  439.                 eventStorage.sysexData = event.data;

  440.                 break;

  441.             case V3_EVENT_POLY_PRESSURE:

  442.                 eventStorage.type = PolyPressure;

  443.                 eventStorage.polyPressure = event.poly_pressure;

  444.                 break;

  445.             default:

  446.                 return false;

  447.             }

  448. 

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

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

  451. 

  452.             return placeSorted(event.sample_offset);

  453.         }

  454. 

  455.         bool appendCC(const int32_t sampleOffset, v3_param_id paramId, const double normalized) noexcept

  456.         {

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

  458. 

  459.             paramId -= kVst3InternalParameterMidiCC_start;

  460. 

  461.             const uint8_t cc = paramId % 130;

  462. 

  463.             switch (cc)

  464.             {

  465.             case 128:

  466.                 eventStorage.type = CC_ChannelPressure;

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

  468.                 eventStorage.midi[2] = 0;

  469.                 break;

  470.             case 129:

  471.                 eventStorage.type = CC_Pitchbend;

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

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

  474.                 break;

  475.             default:

  476.                 eventStorage.type = CC_Normal;

  477.                 eventStorage.midi[1] = cc;

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

  479.                 break;

  480.             }

  481. 

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

  483. 

  484.             eventList[numUsed].sampleOffset = sampleOffset;

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

  486. 

  487.             return placeSorted(sampleOffset);

  488.         }

  489. 

  490.        #if DISTRHO_PLUGIN_HAS_UI

  491.         // NOTE always runs first

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

  493.         {

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

  495. 

  496.             eventStorage.type = UI_MIDI;

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

  498. 

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

  500. 

  501.             event->sampleOffset = 0;

  502.             event->storage = &eventStorage;

  503.             event->next = nullptr;

  504. 

  505.             if (numUsed == 0)

  506.             {

  507.                 firstEvent = lastEvent = event;

  508.             }

  509.             else

  510.             {

  511.                 lastEvent->next = event;

  512.                 lastEvent = event;

  513.             }

  514. 

  515.             return ++numUsed == kMaxMidiEvents;

  516.         }

  517.        #endif

  518. 

  519.     private:

  520.         bool placeSorted(const int32_t sampleOffset) noexcept

  521.         {

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

  523. 

  524.             // initialize

  525.             if (numUsed == 0)

  526.             {

  527.                 firstSampleOffset = lastSampleOffset = sampleOffset;

  528.                 firstEvent = lastEvent = event;

  529.                 event->next = nullptr;

  530.             }

  531.             // push to the back

  532.             else if (sampleOffset >= lastSampleOffset)

  533.             {

  534.                 lastSampleOffset = sampleOffset;

  535.                 lastEvent->next = event;

  536.                 lastEvent = event;

  537.                 event->next = nullptr;

  538.             }

  539.             // push to the front

  540.             else if (sampleOffset < firstSampleOffset)

  541.             {

  542.                 firstSampleOffset = sampleOffset;

  543.                 event->next = firstEvent;

  544.                 firstEvent = event;

  545.             }

  546.             // find place in between events

  547.             else

  548.             {

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

  550.                 InputEvent* event2 = firstEvent;

  551. 

  552.                 // iterate all events

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

  554.                 {

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

  556.                     if (sampleOffset > event2->sampleOffset)

  557.                         break;

  558. 

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

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

  561.                     {

  562.                         event2 = event2->next;

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

  564.                         break;

  565.                     }

  566.                 }

  567. 

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

  569. 

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

  571.                 event2->next = event;

  572.             }

  573. 

  574.             return ++numUsed == kMaxMidiEvents;

  575.         }

  576.     } inputEventList;

  577.    #endif // DISTRHO_PLUGIN_WANT_MIDI_INPUT

  578. 

  579. public:

  580.     PluginVst3(v3_host_application** const host, const bool isComponent)

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

  582.           fComponentHandler(nullptr),

  583.         #if DISTRHO_PLUGIN_HAS_UI

  584.          #if DPF_VST3_USES_SEPARATE_CONTROLLER

  585.           fConnectionFromCompToCtrl(nullptr),

  586.          #endif

  587.           fConnectionFromCtrlToView(nullptr),

  588.           fHostApplication(host),

  589.         #endif

  590.           fParameterCount(fPlugin.getParameterCount()),

  591.           fVst3ParameterCount(fParameterCount + kVst3InternalParameterCount),

  592.           fCachedParameterValues(nullptr),

  593.           fDummyAudioBuffer(nullptr),

  594.           fParameterValuesChangedDuringProcessing(nullptr)

  595.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  596.         , fIsComponent(isComponent)

  597.        #endif

  598.        #if DISTRHO_PLUGIN_HAS_UI

  599.         , fParameterValueChangesForUI(nullptr)

  600.         , fConnectedToUI(false)

  601.        #endif

  602.        #if DISTRHO_PLUGIN_WANT_LATENCY

  603.         , fLastKnownLatency(fPlugin.getLatency())

  604.        #endif

  605.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  606.         , fHostEventOutputHandle(nullptr)

  607.        #endif

  608.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  609.         , fCurrentProgram(0)

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

  611.        #endif

  612.     {

  613.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  614.         DISTRHO_SAFE_ASSERT(isComponent);

  615.        #endif

  616. 

  617.        #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  619.         fillInBusInfoDetails<true>();

  620.        #endif

  621.        #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  623.         fillInBusInfoDetails<false>();

  624.        #endif

  625. 

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

  627.         {

  628.             fCachedParameterValues = new float[extraParameterCount];

  629. 

  630.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  633.            #endif

  634.            #if DISTRHO_PLUGIN_WANT_LATENCY

  635.             fCachedParameterValues[kVst3InternalParameterLatency]    = fLastKnownLatency;

  636.            #endif

  637.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  638.             fCachedParameterValues[kVst3InternalParameterProgram]    = 0.0f;

  639.            #endif

  640. 

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

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

  643. 

  644.             fParameterValuesChangedDuringProcessing = new bool[extraParameterCount];

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

  646. 

  647.            #if DISTRHO_PLUGIN_HAS_UI

  648.             fParameterValueChangesForUI = new bool[extraParameterCount];

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

  650.            #endif

  651.         }

  652. 

  653.        #if DISTRHO_PLUGIN_WANT_STATE

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

  655.         {

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

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

  658.         }

  659.        #endif

  660. 

  661.        #if !DISTRHO_PLUGIN_HAS_UI

  662.         // unused

  663.         return; (void)host;

  664.        #endif

  665.     }

  666. 

  667.     ~PluginVst3()

  668.     {

  669.         if (fCachedParameterValues != nullptr)

  670.         {

  671.             delete[] fCachedParameterValues;

  672.             fCachedParameterValues = nullptr;

  673.         }

  674. 

  675.         if (fDummyAudioBuffer != nullptr)

  676.         {

  677.             delete[] fDummyAudioBuffer;

  678.             fDummyAudioBuffer = nullptr;

  679.         }

  680. 

  681.         if (fParameterValuesChangedDuringProcessing != nullptr)

  682.         {

  683.             delete[] fParameterValuesChangedDuringProcessing;

  684.             fParameterValuesChangedDuringProcessing = nullptr;

  685.         }

  686. 

  687.        #if DISTRHO_PLUGIN_HAS_UI

  688.         if (fParameterValueChangesForUI != nullptr)

  689.         {

  690.             delete[] fParameterValueChangesForUI;

  691.             fParameterValueChangesForUI = nullptr;

  692.         }

  693.        #endif

  694.     }

  695. 

  696.     // ----------------------------------------------------------------------------------------------------------------

  697.     // utilities and common code

  698. 

  699.     double _getNormalizedParameterValue(const uint32_t index, const double plain)

  700.     {

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

  702.         return ranges.getFixedAndNormalizedValue(plain);

  703.     }

  704. 

  705.     void _setNormalizedPluginParameterValue(const uint32_t index, const double normalized)

  706.     {

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

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

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

  710. 

  711.         // convert as needed as check for changes

  712.         if (hints & kParameterIsBoolean)

  713.         {

  714.             const float midRange = ranges.min + (ranges.max - ranges.min) / 2.f;

  715.             const bool isHigh = value > midRange;

  716. 

  717.             if (isHigh == (fCachedParameterValues[kVst3InternalParameterBaseCount + index] > midRange))

  718.                 return;

  719. 

  720.             value = isHigh ? ranges.max : ranges.min;

  721.         }

  722.         else if (hints & kParameterIsInteger)

  723.         {

  724.             const int ivalue = static_cast<int>(std::round(value));

  725. 

  726.             if (static_cast<int>(fCachedParameterValues[kVst3InternalParameterBaseCount + index]) == ivalue)

  727.                 return;

  728. 

  729.             value = ivalue;

  730.         }

  731.         else

  732.         {

  733.             // deal with low resolution of some hosts, which convert double to float internally and lose precision

  734.             if (std::abs(ranges.getNormalizedValue(static_cast<double>(fCachedParameterValues[kVst3InternalParameterBaseCount + index])) - normalized) < 0.0000001)

  735.                 return;

  736.         }

  737. 

  738.         fCachedParameterValues[kVst3InternalParameterBaseCount + index] = value;

  739. 

  740.       #if DISTRHO_PLUGIN_HAS_UI

  741.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  742.         if (!fIsComponent)

  743.        #endif

  744.         {

  745.             fParameterValueChangesForUI[kVst3InternalParameterBaseCount + index] = true;

  746.         }

  747.       #endif

  748. 

  749.         if (!fPlugin.isParameterOutputOrTrigger(index))

  750.             fPlugin.setParameterValue(index, value);

  751.     }

  752. 

  753.     // ----------------------------------------------------------------------------------------------------------------

  754.     // stuff called for UI creation

  755. 

  756.     void* getInstancePointer() const noexcept

  757.     {

  758.         return fPlugin.getInstancePointer();

  759.     }

  760. 

  761.     double getSampleRate() const noexcept

  762.     {

  763.         return fPlugin.getSampleRate();

  764.     }

  765. 

  766.     // ----------------------------------------------------------------------------------------------------------------

  767.     // v3_component interface calls

  768. 

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

  770.     {

  771.         switch (mediaType)

  772.         {

  773.         case V3_AUDIO:

  774.             if (busDirection == V3_INPUT)

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

  776.             if (busDirection == V3_OUTPUT)

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

  778.             break;

  779.         case V3_EVENT:

  780.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  781.             if (busDirection == V3_INPUT)

  782.                 return 1;

  783.            #endif

  784.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  785.             if (busDirection == V3_OUTPUT)

  786.                 return 1;

  787.            #endif

  788.             break;

  789.         }

  790. 

  791.         return 0;

  792.     }

  793. 

  794.     v3_result getBusInfo(const int32_t mediaType,

  795.                          const int32_t busDirection,

  796.                          const int32_t busIndex,

  797.                          v3_bus_info* const info) const

  798.     {

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

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

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

  802. 

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

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

  805.        #endif

  806. 

  807.         if (mediaType == V3_AUDIO)

  808.         {

  809.            #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  810.             if (busDirection == V3_INPUT)

  811.             {

  812.                #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  814.                #else

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

  816.                 return V3_INVALID_ARG;

  817.                #endif // DISTRHO_PLUGIN_NUM_INPUTS

  818.             }

  819.             else

  820.             {

  821.                #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  823.                #else

  824.                 d_stderr("invalid output bus %d", busId);

  825.                 return V3_INVALID_ARG;

  826.                #endif // DISTRHO_PLUGIN_NUM_OUTPUTS

  827.             }

  828.            #else

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

  830.             return V3_INVALID_ARG;

  831.            #endif // DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS

  832.         }

  833.         else

  834.         {

  835.             if (busDirection == V3_INPUT)

  836.             {

  837.                #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  839.                #else

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

  841.                 return V3_INVALID_ARG;

  842.                #endif

  843.             }

  844.             else

  845.             {

  846.                #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  848.                #else

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

  850.                 return V3_INVALID_ARG;

  851.                #endif

  852.             }

  853.             info->media_type = V3_EVENT;

  854.             info->direction = busDirection;

  855.             info->channel_count = 1;

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

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

  858.             info->bus_type = V3_MAIN;

  859.             info->flags = V3_DEFAULT_ACTIVE;

  860.             return V3_OK;

  861.         }

  862.     }

  863. 

  864.     v3_result getRoutingInfo(v3_routing_info*, v3_routing_info*)

  865.     {

  866.         /*

  867.         output->media_type = V3_AUDIO;

  868.         output->bus_idx = 0;

  869.         output->channel = -1;

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

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

  872.         */

  873.         return V3_NOT_IMPLEMENTED;

  874.     }

  875. 

  876.     v3_result activateBus(const int32_t mediaType,

  877.                           const int32_t busDirection,

  878.                           const int32_t busIndex,

  879.                           const bool state) noexcept

  880.     {

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

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

  883. 

  884.         if (mediaType == V3_AUDIO)

  885.         {

  886.            #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  888. 

  889.             if (busDirection == V3_INPUT)

  890.             {

  891.                #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  893.                 {

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

  895. 

  896.                     if (port.busId == busId)

  897.                         fEnabledInputs[i] = state;

  898.                 }

  899.                #endif

  900.             }

  901.             else

  902.             {

  903.                #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  905.                 {

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

  907. 

  908.                     if (port.busId == busId)

  909.                         fEnabledOutputs[i] = state;

  910.                 }

  911.                #endif

  912.             }

  913.            #endif

  914.         }

  915. 

  916.         return V3_OK;

  917. 

  918.        #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  919.         // unused

  920.         (void)state;

  921.        #endif

  922.     }

  923. 

  924.     v3_result setActive(const bool active)

  925.     {

  926.         if (active)

  927.             fPlugin.activate();

  928.         else

  929.             fPlugin.deactivateIfNeeded();

  930. 

  931.         return V3_OK;

  932.     }

  933. 

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

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

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

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

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

  939.      */

  940.     v3_result setState(v3_bstream** const stream)

  941.     {

  942.        #if DISTRHO_PLUGIN_HAS_UI

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

  944.        #endif

  945.         String key, value;

  946.         bool hasValue = false;

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

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

  949. 

  950.         char buffer[512], orig;

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

  952.         v3_result res;

  953. 

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

  955.         {

  956.             read = -1;

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

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

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

  960. 

  961.             if (read == 0)

  962.                 return V3_OK;

  963. 

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

  965.             {

  966.                 // found terminator, stop here

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

  968.                 {

  969.                     terminated = 1;

  970.                     break;

  971.                 }

  972. 

  973.                 // store character at read position

  974.                 orig = buffer[read];

  975. 

  976.                 // place null character to create valid string

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

  978. 

  979.                 // append to temporary vars

  980.                 if (fillingKey)

  981.                 {

  982.                     key += buffer + i;

  983.                 }

  984.                 else

  985.                 {

  986.                     value += buffer + i;

  987.                     hasValue = true;

  988.                 }

  989. 

  990.                 // increase buffer offset by length of string

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

  992. 

  993.                 // restore read character

  994.                 buffer[read] = orig;

  995. 

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

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

  998.                 {

  999.                     // special keys

  1000.                     if (key == "__dpf_state_begin__")

  1001.                     {

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

  1003.                                                        queryingType, V3_INTERNAL_ERR);

  1004.                         queryingType = 's';

  1005.                         key.clear();

  1006.                         value.clear();

  1007.                         hasValue = false;

  1008.                         continue;

  1009.                     }

  1010.                     if (key == "__dpf_state_end__")

  1011.                     {

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

  1013.                         queryingType = 'n';

  1014.                         key.clear();

  1015.                         value.clear();

  1016.                         hasValue = false;

  1017.                         continue;

  1018.                     }

  1019.                     if (key == "__dpf_parameters_begin__")

  1020.                     {

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

  1022.                                                        queryingType, V3_INTERNAL_ERR);

  1023.                         queryingType = 'p';

  1024.                         key.clear();

  1025.                         value.clear();

  1026.                         hasValue = false;

  1027.                         continue;

  1028.                     }

  1029.                     if (key == "__dpf_parameters_end__")

  1030.                     {

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

  1032.                         queryingType = 'x';

  1033.                         key.clear();

  1034.                         value.clear();

  1035.                         hasValue = false;

  1036.                         continue;

  1037.                     }

  1038. 

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

  1040.                     fillingKey = !fillingKey;

  1041. 

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

  1043.                     if (! hasValue)

  1044.                         continue;

  1045. 

  1046.                     if (key == "__dpf_program__")

  1047.                     {

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

  1049.                         queryingType = 'n';

  1050. 

  1051.                         d_debug("found program '%s'", value.buffer());

  1052. 

  1053.                       #if DISTRHO_PLUGIN_WANT_PROGRAMS

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

  1055.                         DISTRHO_SAFE_ASSERT_CONTINUE(program >= 0);

  1056. 

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

  1058.                         fPlugin.loadProgram(fCurrentProgram);

  1059. 

  1060.                        #if DISTRHO_PLUGIN_HAS_UI

  1061.                         if (connectedToUI)

  1062.                         {

  1063.                             fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  1064.                             sendParameterSetToUI(kVst3InternalParameterProgram, program);

  1065.                         }

  1066.                        #endif

  1067.                       #endif

  1068.                     }

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

  1070.                     {

  1071.                         d_debug("found state '%s' '%s'", key.buffer(), value.buffer());

  1072. 

  1073.                        #if DISTRHO_PLUGIN_WANT_STATE

  1074.                         if (fPlugin.wantStateKey(key))

  1075.                         {

  1076.                             fStateMap[key] = value;

  1077.                             fPlugin.setState(key, value);

  1078. 

  1079.                            #if DISTRHO_PLUGIN_HAS_UI

  1080.                             if (connectedToUI)

  1081.                                 sendStateSetToUI(key, value);

  1082.                            #endif

  1083.                         }

  1084.                        #endif

  1085.                     }

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

  1087.                     {

  1088.                         d_debug("found parameter '%s' '%s'", key.buffer(), value.buffer());

  1089.                         float fvalue;

  1090. 

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

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

  1093.                         {

  1094.                             if (fPlugin.isParameterOutputOrTrigger(j))

  1095.                                 continue;

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

  1097.                                 continue;

  1098. 

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

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

  1101.                             else

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

  1103. 

  1104.                             fCachedParameterValues[kVst3InternalParameterBaseCount + j] = fvalue;

  1105.                            #if DISTRHO_PLUGIN_HAS_UI

  1106.                             if (connectedToUI)

  1107.                             {

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

  1109.                                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + j] = true;

  1110.                             }

  1111.                            #endif

  1112.                             fPlugin.setParameterValue(j, fvalue);

  1113.                             break;

  1114.                         }

  1115.                     }

  1116. 

  1117.                     key.clear();

  1118.                     value.clear();

  1119.                     hasValue = false;

  1120.                 }

  1121.             }

  1122.         }

  1123. 

  1124.         if (fComponentHandler != nullptr)

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

  1126. 

  1127.        #if DISTRHO_PLUGIN_HAS_UI

  1128.         if (connectedToUI)

  1129.         {

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

  1131.             {

  1132.                 if (fPlugin.isParameterOutputOrTrigger(i))

  1133.                     continue;

  1134.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  1135.                 sendParameterSetToUI(kVst3InternalParameterCount + i,

  1136.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  1137.             }

  1138.         }

  1139.        #endif

  1140. 

  1141.         return V3_OK;

  1142.     }

  1143. 

  1144.     v3_result getState(v3_bstream** const stream)

  1145.     {

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

  1147.        #if DISTRHO_PLUGIN_WANT_STATE

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

  1149.        #else

  1150.         const uint32_t stateCount = 0;

  1151.        #endif

  1152. 

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

  1154.         {

  1155.             char buffer = '\0';

  1156.             int32_t ignored;

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

  1158.         }

  1159. 

  1160.        #if DISTRHO_PLUGIN_WANT_FULL_STATE

  1161.         // Update current state

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

  1163.         {

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

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

  1166.         }

  1167.        #endif

  1168. 

  1169.         String state;

  1170. 

  1171.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1172.         {

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

  1174.             tmpStr += String(fCurrentProgram);

  1175.             tmpStr += "\xff";

  1176. 

  1177.             state += tmpStr;

  1178.         }

  1179.        #endif

  1180. 

  1181.        #if DISTRHO_PLUGIN_WANT_STATE

  1182.         if (stateCount != 0)

  1183.         {

  1184.             state += "__dpf_state_begin__\xff";

  1185. 

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

  1187.             {

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

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

  1190. 

  1191.                 // join key and value

  1192.                 String tmpStr;

  1193.                 tmpStr  = key;

  1194.                 tmpStr += "\xff";

  1195.                 tmpStr += value;

  1196.                 tmpStr += "\xff";

  1197. 

  1198.                 state += tmpStr;

  1199.             }

  1200. 

  1201.             state += "__dpf_state_end__\xff";

  1202.         }

  1203.        #endif

  1204. 

  1205.         if (paramCount != 0)

  1206.         {

  1207.             state += "__dpf_parameters_begin__\xff";

  1208. 

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

  1210.             {

  1211.                 if (fPlugin.isParameterOutputOrTrigger(i))

  1212.                     continue;

  1213. 

  1214.                 // join key and value

  1215.                 String tmpStr;

  1216.                 tmpStr  = fPlugin.getParameterSymbol(i);

  1217.                 tmpStr += "\xff";

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

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

  1220.                 else

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

  1222.                 tmpStr += "\xff";

  1223. 

  1224.                 state += tmpStr;

  1225.             }

  1226. 

  1227.             state += "__dpf_parameters_end__\xff";

  1228.         }

  1229. 

  1230.         // terminator

  1231.         state += "\xfe";

  1232. 

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

  1234. 

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

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

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

  1238.         v3_result res;

  1239. 

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

  1241.         {

  1242.             wrtn = 0;

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

  1244. 

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

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

  1247.         }

  1248. 

  1249.         return V3_OK;

  1250.     }

  1251. 

  1252.     // ----------------------------------------------------------------------------------------------------------------

  1253.     // v3_audio_processor interface calls

  1254. 

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

  1256.                                  v3_speaker_arrangement* const outputs, const int32_t numOutputs)

  1257.     {

  1258.        #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

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

  1261.             return V3_INTERNAL_ERR;

  1262.        #else

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

  1264.         // unused

  1265.         (void)inputs;

  1266.        #endif

  1267. 

  1268.        #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

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

  1271.             return V3_INTERNAL_ERR;

  1272.        #else

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

  1274.         // unused

  1275.         (void)outputs;

  1276.        #endif

  1277. 

  1278.         return V3_OK;

  1279.     }

  1280. 

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

  1282.     {

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

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

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

  1286. 

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

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

  1289.        #endif

  1290. 

  1291.         if (busDirection == V3_INPUT)

  1292.         {

  1293.            #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  1295.                 return V3_OK;

  1296.            #endif

  1297.             d_stderr("invalid input bus arrangement %d, line %d", busIndex, __LINE__);

  1298.             return V3_INVALID_ARG;

  1299.         }

  1300.         else

  1301.         {

  1302.            #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  1304.                 return V3_OK;

  1305.            #endif

  1306.             d_stderr("invalid output bus arrangement %d, line %d", busIndex, __LINE__);

  1307.             return V3_INVALID_ARG;

  1308.         }

  1309.     }

  1310. 

  1311.     uint32_t getLatencySamples() const noexcept

  1312.     {

  1313.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1314.         return fPlugin.getLatency();

  1315.        #else

  1316.         return 0;

  1317.        #endif

  1318.     }

  1319. 

  1320.     v3_result setupProcessing(v3_process_setup* const setup)

  1321.     {

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

  1323. 

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

  1325.         fPlugin.deactivateIfNeeded();

  1326. 

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

  1328. 

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

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

  1331. 

  1332.       #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  1334.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterBufferSize] = true;

  1335. 

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

  1337.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterSampleRate] = true;

  1338.        #if DISTRHO_PLUGIN_HAS_UI

  1339.         fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = true;

  1340.        #endif

  1341.       #endif

  1342. 

  1343.         if (active)

  1344.             fPlugin.activate();

  1345. 

  1346.         delete[] fDummyAudioBuffer;

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

  1348. 

  1349.         return V3_OK;

  1350.     }

  1351. 

  1352.     v3_result setProcessing(const bool processing)

  1353.     {

  1354.         if (processing)

  1355.         {

  1356.             if (! fPlugin.isActive())

  1357.                 fPlugin.activate();

  1358.         }

  1359.         else

  1360.         {

  1361.             fPlugin.deactivateIfNeeded();

  1362.         }

  1363. 

  1364.         return V3_OK;

  1365.     }

  1366. 

  1367.     v3_result process(v3_process_data* const data)

  1368.     {

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

  1370.         // d_debug("process %i", data->symbolic_sample_size);

  1371. 

  1372.         // activate plugin if not done yet

  1373.         if (! fPlugin.isActive())

  1374.             fPlugin.activate();

  1375. 

  1376.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

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

  1378.         {

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

  1380. 

  1381.             // ticksPerBeat is not possible with VST3

  1382.             fTimePosition.bbt.ticksPerBeat = 1920.0;

  1383. 

  1384.             if (ctx->state & V3_PROCESS_CTX_PROJECT_TIME_VALID)

  1385.                 fTimePosition.frame = ctx->project_time_in_samples;

  1386.             else if (ctx->state & V3_PROCESS_CTX_CONT_TIME_VALID)

  1387.                 fTimePosition.frame = ctx->continuous_time_in_samples;

  1388. 

  1389.             if (ctx->state & V3_PROCESS_CTX_TEMPO_VALID)

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

  1391.             else

  1392.                 fTimePosition.bbt.beatsPerMinute = 120.0;

  1393. 

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

  1395.             {

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

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

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

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

  1400. 

  1401.                 fTimePosition.bbt.valid       = true;

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

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

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

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

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

  1407. 

  1408.                 if (ctx->project_time_quarters < 0.0)

  1409.                 {

  1410.                     --fTimePosition.bbt.bar;

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

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

  1413.                 }

  1414.             }

  1415.             else

  1416.             {

  1417.                 fTimePosition.bbt.valid       = false;

  1418.                 fTimePosition.bbt.bar         = 1;

  1419.                 fTimePosition.bbt.beat        = 1;

  1420.                 fTimePosition.bbt.tick        = 0.0;

  1421.                 fTimePosition.bbt.beatsPerBar = 4.0f;

  1422.                 fTimePosition.bbt.beatType    = 4.0f;

  1423.             }

  1424. 

  1425.             fTimePosition.bbt.barStartTick = fTimePosition.bbt.ticksPerBeat*

  1426.                                              fTimePosition.bbt.beatsPerBar*

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

  1428. 

  1429.             fPlugin.setTimePosition(fTimePosition);

  1430.         }

  1431.        #endif

  1432. 

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

  1434.         {

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

  1436.             return V3_OK;

  1437.         }

  1438. 

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

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

  1441. 

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

  1443. 

  1444.         {

  1445.             int32_t i = 0;

  1446.            #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  1448.             {

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

  1450.                 {

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

  1452.                         inputs[i++] = fDummyAudioBuffer;

  1453. 

  1454.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_INPUTS, i);

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

  1456.                 }

  1457.             }

  1458.            #endif

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

  1460.                 inputs[i] = fDummyAudioBuffer;

  1461.         }

  1462. 

  1463.         {

  1464.             int32_t i = 0;

  1465.            #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  1467.             {

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

  1469.                 {

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

  1471.                         outputs[i++] = fDummyAudioBuffer;

  1472. 

  1473.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_OUTPUTS, i);

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

  1475.                 }

  1476.             }

  1477.            #endif

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

  1479.                 outputs[i] = fDummyAudioBuffer;

  1480.         }

  1481. 

  1482.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1483.         fHostEventOutputHandle = data->output_events;

  1484.        #endif

  1485. 

  1486.       #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1487.         bool canAppendMoreEvents = true;

  1488.         inputEventList.init();

  1489. 

  1490.        #if DISTRHO_PLUGIN_HAS_UI

  1491.         while (fNotesRingBuffer.isDataAvailableForReading())

  1492.         {

  1493.             uint8_t midiData[3];

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

  1495.                 break;

  1496. 

  1497.             if (inputEventList.appendFromUI(midiData))

  1498.             {

  1499.                 canAppendMoreEvents = false;

  1500.                 break;

  1501.             }

  1502.         }

  1503.        #endif

  1504. 

  1505.         if (canAppendMoreEvents)

  1506.         {

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

  1508.             {

  1509.                 v3_event event;

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

  1511.                 {

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

  1513.                         break;

  1514. 

  1515.                     if (inputEventList.appendEvent(event))

  1516.                     {

  1517.                         canAppendMoreEvents = false;

  1518.                         break;

  1519.                     }

  1520.                 }

  1521.             }

  1522.         }

  1523.       #endif

  1524. 

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

  1526.         {

  1527.             int32_t offset;

  1528.             double normalized;

  1529. 

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

  1531.             {

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

  1533.                 DISTRHO_SAFE_ASSERT_BREAK(queue != nullptr);

  1534. 

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

  1536.                 DISTRHO_SAFE_ASSERT_UINT_BREAK(rindex < fVst3ParameterCount, rindex);

  1537. 

  1538.                #if DPF_VST3_HAS_INTERNAL_PARAMETERS

  1539.                 if (rindex < kVst3InternalParameterCount)

  1540.                 {

  1541.                    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

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

  1544.                     {

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

  1546.                         {

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

  1548.                                 break;

  1549. 

  1550.                             if (inputEventList.appendCC(offset, rindex, normalized))

  1551.                             {

  1552.                                 canAppendMoreEvents = false;

  1553.                                 break;

  1554.                             }

  1555.                         }

  1556.                     }

  1557.                    #endif

  1558.                     continue;

  1559.                 }

  1560.                #endif

  1561. 

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

  1563.                     continue;

  1564. 

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

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

  1567.                     break;

  1568. 

  1569.                 if (offset != 0)

  1570.                     continue;

  1571. 

  1572.                 const uint32_t index = rindex - kVst3InternalParameterCount;

  1573.                 _setNormalizedPluginParameterValue(index, normalized);

  1574.             }

  1575.         }

  1576. 

  1577.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

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

  1580.        #else

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

  1582.        #endif

  1583. 

  1584.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1585.         fHostEventOutputHandle = nullptr;

  1586.        #endif

  1587. 

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

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

  1590.         {

  1591.             int32_t offset;

  1592.             double normalized;

  1593. 

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

  1595.             {

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

  1597.                 DISTRHO_SAFE_ASSERT_BREAK(queue != nullptr);

  1598. 

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

  1600.                 DISTRHO_SAFE_ASSERT_UINT_BREAK(rindex < fVst3ParameterCount, rindex);

  1601. 

  1602.                #if DPF_VST3_HAS_INTERNAL_PARAMETERS

  1603.                 if (rindex < kVst3InternalParameterCount)

  1604.                     continue;

  1605.                #endif

  1606. 

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

  1608. 

  1609.                 if (pcount <= 0)

  1610.                     continue;

  1611. 

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

  1613.                     break;

  1614. 

  1615.                 if (offset == 0)

  1616.                     continue;

  1617. 

  1618.                 const uint32_t index = rindex - kVst3InternalParameterCount;

  1619.                 _setNormalizedPluginParameterValue(index, normalized);

  1620.             }

  1621.         }

  1622. 

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

  1624.         return V3_OK;

  1625.     }

  1626. 

  1627.     uint32_t getTailSamples() const noexcept

  1628.     {

  1629.         return 0;

  1630.     }

  1631. 

  1632.     // ----------------------------------------------------------------------------------------------------------------

  1633.     // v3_edit_controller interface calls

  1634. 

  1635.     int32_t getParameterCount() const noexcept

  1636.     {

  1637.         return fVst3ParameterCount;

  1638.     }

  1639. 

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

  1641.     {

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

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

  1644. 

  1645.         // TODO hash the parameter symbol

  1646.         info->param_id = rindex;

  1647. 

  1648.       #if DPF_VST3_USES_SEPARATE_CONTROLLER || DISTRHO_PLUGIN_WANT_LATENCY || DISTRHO_PLUGIN_WANT_PROGRAMS

  1649.         switch (rindex)

  1650.         {

  1651.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1652.         case kVst3InternalParameterBufferSize:

  1653.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

  1654.             info->step_count = DPF_VST3_MAX_BUFFER_SIZE - 1;

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

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

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

  1658.             return V3_OK;

  1659.         case kVst3InternalParameterSampleRate:

  1660.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

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

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

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

  1664.             return V3_OK;

  1665.        #endif

  1666.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1667.         case kVst3InternalParameterLatency:

  1668.             info->flags = V3_PARAM_READ_ONLY | V3_PARAM_IS_HIDDEN;

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

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

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

  1672.             return V3_OK;

  1673.        #endif

  1674.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1675.         case kVst3InternalParameterProgram:

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

  1677.             info->step_count = fProgramCountMinusOne;

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

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

  1680.             return V3_OK;

  1681.        #endif

  1682.         }

  1683.       #endif

  1684. 

  1685.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1686.         if (rindex < kVst3InternalParameterCount)

  1687.         {

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

  1689.             info->flags = V3_PARAM_CAN_AUTOMATE | V3_PARAM_IS_HIDDEN;

  1690.             info->step_count = 127;

  1691.             char ccstr[24];

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

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

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

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

  1696.             return V3_OK;

  1697.         }

  1698.        #endif

  1699. 

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

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

  1702. 

  1703.         // set up flags

  1704.         int32_t flags = 0;

  1705. 

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

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

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

  1709. 

  1710.         switch (fPlugin.getParameterDesignation(index))

  1711.         {

  1712.         case kParameterDesignationNull:

  1713.             break;

  1714.         case kParameterDesignationBypass:

  1715.             flags |= V3_PARAM_IS_BYPASS;

  1716.             break;

  1717.         }

  1718. 

  1719.         if (hints & kParameterIsAutomatable)

  1720.             flags |= V3_PARAM_CAN_AUTOMATE;

  1721.         if (hints & kParameterIsOutput)

  1722.             flags |= V3_PARAM_READ_ONLY;

  1723. 

  1724.         // set up step_count

  1725.         int32_t step_count = 0;

  1726. 

  1727.         if (hints & kParameterIsBoolean)

  1728.             step_count = 1;

  1729.         else if (hints & kParameterIsInteger)

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

  1731. 

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

  1733.         {

  1734.             flags |= V3_PARAM_IS_LIST;

  1735.             step_count = enumValues.count - 1;

  1736.         }

  1737. 

  1738.         info->flags = flags;

  1739.         info->step_count = step_count;

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

  1741.         // int32_t unit_id;

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

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

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

  1745.         return V3_OK;

  1746.     }

  1747. 

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

  1749.     {

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

  1751. 

  1752.       #if DPF_VST3_USES_SEPARATE_CONTROLLER || DISTRHO_PLUGIN_WANT_LATENCY || DISTRHO_PLUGIN_WANT_PROGRAMS

  1753.         switch (rindex)

  1754.         {

  1755.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1756.         case kVst3InternalParameterBufferSize:

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

  1758.             return V3_OK;

  1759.         case kVst3InternalParameterSampleRate:

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

  1761.             return V3_OK;

  1762.        #endif

  1763.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1764.         case kVst3InternalParameterLatency:

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

  1766.             return V3_OK;

  1767.        #endif

  1768.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1769.         case kVst3InternalParameterProgram:

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

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

  1772.             return V3_OK;

  1773.        #endif

  1774.         }

  1775.       #endif

  1776. 

  1777.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1778.         if (rindex < kVst3InternalParameterCount)

  1779.         {

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

  1781.             return V3_OK;

  1782.         }

  1783.        #endif

  1784. 

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

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

  1787. 

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

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

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

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

  1792. 

  1793.         if (hints & kParameterIsBoolean)

  1794.         {

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

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

  1797.         }

  1798.         else if (hints & kParameterIsInteger)

  1799.         {

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

  1801.         }

  1802. 

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

  1804.         {

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

  1806.             {

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

  1808.                 return V3_OK;

  1809.             }

  1810.         }

  1811. 

  1812.         if (hints & kParameterIsInteger)

  1813.             snprintf_i32_utf16(output, value, 128);

  1814.         else

  1815.             snprintf_f32_utf16(output, value, 128);

  1816. 

  1817.         return V3_OK;

  1818.     }

  1819. 

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

  1821.     {

  1822.       #if DPF_VST3_USES_SEPARATE_CONTROLLER || DISTRHO_PLUGIN_WANT_LATENCY || DISTRHO_PLUGIN_WANT_PROGRAMS

  1823.         switch (rindex)

  1824.         {

  1825.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1826.         case kVst3InternalParameterBufferSize:

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

  1828.             return V3_OK;

  1829.         case kVst3InternalParameterSampleRate:

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

  1831.             return V3_OK;

  1832.        #endif

  1833.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1834.         case kVst3InternalParameterLatency:

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

  1836.             return V3_OK;

  1837.        #endif

  1838.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1839.         case kVst3InternalParameterProgram:

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

  1841.             {

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

  1843.                 {

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

  1845.                     return V3_OK;

  1846.                 }

  1847.             }

  1848.             return V3_INVALID_ARG;

  1849.        #endif

  1850.         }

  1851.       #endif

  1852. 

  1853.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1854.         if (rindex < kVst3InternalParameterCount)

  1855.         {

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

  1857.             return V3_NOT_IMPLEMENTED;

  1858.         }

  1859.        #endif

  1860. 

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

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

  1863. 

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

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

  1866. 

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

  1868.         {

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

  1870.             {

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

  1872.                 return V3_OK;

  1873.             }

  1874.         }

  1875. 

  1876.         const ScopedUTF8String input8(input);

  1877. 

  1878.         float value;

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

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

  1881.         else

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

  1883. 

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

  1885.         return V3_OK;

  1886.     }

  1887. 

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

  1889.     {

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

  1891. 

  1892.       #if DPF_VST3_USES_SEPARATE_CONTROLLER || DISTRHO_PLUGIN_WANT_LATENCY || DISTRHO_PLUGIN_WANT_PROGRAMS

  1893.         switch (rindex)

  1894.         {

  1895.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1896.         case kVst3InternalParameterBufferSize:

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

  1898.         case kVst3InternalParameterSampleRate:

  1899.             return normalized * DPF_VST3_MAX_SAMPLE_RATE;

  1900.        #endif

  1901.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1902.         case kVst3InternalParameterLatency:

  1903.             return normalized * DPF_VST3_MAX_LATENCY;

  1904.        #endif

  1905.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1906.         case kVst3InternalParameterProgram:

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

  1908.        #endif

  1909.         }

  1910.       #endif

  1911. 

  1912.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1913.         if (rindex < kVst3InternalParameterCount)

  1914.             return std::round(normalized * 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.         const uint32_t hints = fPlugin.getParameterHints(index);

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

  1923. 

  1924.         if (hints & kParameterIsBoolean)

  1925.         {

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

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

  1928.         }

  1929.         else if (hints & kParameterIsInteger)

  1930.         {

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

  1932.         }

  1933. 

  1934.         return value;

  1935.     }

  1936. 

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

  1938.     {

  1939.       #if DPF_VST3_USES_SEPARATE_CONTROLLER || DISTRHO_PLUGIN_WANT_LATENCY || DISTRHO_PLUGIN_WANT_PROGRAMS

  1940.         switch (rindex)

  1941.         {

  1942.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1943.         case kVst3InternalParameterBufferSize:

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

  1945.         case kVst3InternalParameterSampleRate:

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

  1947.        #endif

  1948.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1949.         case kVst3InternalParameterLatency:

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

  1951.        #endif

  1952.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1953.         case kVst3InternalParameterProgram:

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

  1955.        #endif

  1956.         }

  1957.       #endif

  1958. 

  1959.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1960.         if (rindex < kVst3InternalParameterCount)

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

  1962.        #endif

  1963. 

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

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

  1966. 

  1967.         return _getNormalizedParameterValue(index, plain);

  1968.     }

  1969. 

  1970.     double getParameterNormalized(const v3_param_id rindex)

  1971.     {

  1972.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1973.         // TODO something to do here?

  1974.         if (

  1975.            #if !DPF_VST3_PURE_MIDI_INTERNAL_PARAMETERS

  1976.             rindex >= kVst3InternalParameterMidiCC_start &&

  1977.            #endif

  1978.             rindex <= kVst3InternalParameterMidiCC_end)

  1979.             return 0.0;

  1980.        #endif

  1981. 

  1982.       #if DPF_VST3_USES_SEPARATE_CONTROLLER || DISTRHO_PLUGIN_WANT_LATENCY || DISTRHO_PLUGIN_WANT_PROGRAMS

  1983.         switch (rindex)

  1984.         {

  1985.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  1986.         case kVst3InternalParameterBufferSize:

  1987.         case kVst3InternalParameterSampleRate:

  1988.        #endif

  1989.        #if DISTRHO_PLUGIN_WANT_LATENCY

  1990.         case kVst3InternalParameterLatency:

  1991.        #endif

  1992.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1993.         case kVst3InternalParameterProgram:

  1994.        #endif

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

  1996.         }

  1997.       #endif

  1998. 

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

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

  2001. 

  2002.         return _getNormalizedParameterValue(index, fCachedParameterValues[kVst3InternalParameterBaseCount + index]);

  2003.     }

  2004. 

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

  2006.     {

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

  2008. 

  2009.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2010.         // TODO something to do here?

  2011.         if (

  2012.            #if !DPF_VST3_PURE_MIDI_INTERNAL_PARAMETERS

  2013.             rindex >= kVst3InternalParameterMidiCC_start &&

  2014.            #endif

  2015.             rindex <= kVst3InternalParameterMidiCC_end)

  2016.             return V3_INVALID_ARG;

  2017.        #endif

  2018. 

  2019.        #if DPF_VST3_USES_SEPARATE_CONTROLLER || DISTRHO_PLUGIN_WANT_LATENCY || DISTRHO_PLUGIN_WANT_PROGRAMS

  2020.         if (rindex < kVst3InternalParameterBaseCount)

  2021.         {

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

  2023.             int flags = 0;

  2024. 

  2025.             switch (rindex)

  2026.             {

  2027.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2028.             case kVst3InternalParameterBufferSize:

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

  2030.                 break;

  2031.             case kVst3InternalParameterSampleRate:

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

  2033.                 break;

  2034.            #endif

  2035.            #if DISTRHO_PLUGIN_WANT_LATENCY

  2036.             case kVst3InternalParameterLatency:

  2037.                 flags = V3_RESTART_LATENCY_CHANGED;

  2038.                 break;

  2039.            #endif

  2040.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2041.             case kVst3InternalParameterProgram:

  2042.                 flags = V3_RESTART_PARAM_VALUES_CHANGED;

  2043.                 fCurrentProgram = fCachedParameterValues[rindex];

  2044.                 fPlugin.loadProgram(fCurrentProgram);

  2045. 

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

  2047.                 {

  2048.                     if (fPlugin.isParameterOutputOrTrigger(i))

  2049.                         continue;

  2050.                     fCachedParameterValues[kVst3InternalParameterBaseCount + i] = fPlugin.getParameterValue(i);

  2051.                 }

  2052. 

  2053.                #if DISTRHO_PLUGIN_HAS_UI

  2054.                 fParameterValueChangesForUI[kVst3InternalParameterProgram] = true;

  2055.                #endif

  2056.                 break;

  2057.            #endif

  2058.             }

  2059. 

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

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

  2062. 

  2063.             return V3_OK;

  2064.         }

  2065.        #endif

  2066. 

  2067.         DISTRHO_SAFE_ASSERT_UINT2_RETURN(rindex >= kVst3InternalParameterCount, rindex, kVst3InternalParameterCount, V3_INVALID_ARG);

  2068. 

  2069.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  2072. 

  2073.         if (fIsComponent) {

  2074.             DISTRHO_SAFE_ASSERT_RETURN(!fPlugin.isParameterOutputOrTrigger(index), V3_INVALID_ARG);

  2075.         }

  2076. 

  2077.         _setNormalizedPluginParameterValue(index, normalized);

  2078.        #endif

  2079. 

  2080.         return V3_OK;

  2081.     }

  2082. 

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

  2084.     {

  2085.         fComponentHandler = handler;

  2086.         return V3_OK;

  2087.     }

  2088. 

  2089. #if DISTRHO_PLUGIN_HAS_UI

  2090.     // ----------------------------------------------------------------------------------------------------------------

  2091.     // v3_connection_point interface calls

  2092. 

  2093.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2094.     void comp2ctrl_connect(v3_connection_point** const other)

  2095.     {

  2096.         fConnectionFromCompToCtrl = other;

  2097.     }

  2098. 

  2099.     void comp2ctrl_disconnect()

  2100.     {

  2101.         fConnectionFromCompToCtrl = nullptr;

  2102.     }

  2103. 

  2104.     v3_result comp2ctrl_notify(v3_message** const message)

  2105.     {

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

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

  2108. 

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

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

  2111. 

  2112.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  2114.             return notify_midi(attrs);

  2115.        #endif

  2116. 

  2117.        #if DISTRHO_PLUGIN_WANT_STATE

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

  2119.             return notify_state(attrs);

  2120.        #endif

  2121. 

  2122.         d_stderr("comp2ctrl_notify received unknown msg '%s'", msgid);

  2123. 

  2124.         return V3_NOT_IMPLEMENTED;

  2125.     }

  2126.    #endif // DPF_VST3_USES_SEPARATE_CONTROLLER

  2127. 

  2128.     // ----------------------------------------------------------------------------------------------------------------

  2129. 

  2130.     void ctrl2view_connect(v3_connection_point** const other)

  2131.     {

  2132.         DISTRHO_SAFE_ASSERT(fConnectedToUI == false);

  2133. 

  2134.         fConnectionFromCtrlToView = other;

  2135.         fConnectedToUI = false;

  2136.     }

  2137. 

  2138.     void ctrl2view_disconnect()

  2139.     {

  2140.         fConnectedToUI = false;

  2141.         fConnectionFromCtrlToView = nullptr;

  2142.     }

  2143. 

  2144.     v3_result ctrl2view_notify(v3_message** const message)

  2145.     {

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

  2147. 

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

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

  2150. 

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

  2152.         {

  2153.             fConnectedToUI = true;

  2154. 

  2155.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2156.             fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = false;

  2157.             sendParameterSetToUI(kVst3InternalParameterSampleRate,

  2158.                                  fCachedParameterValues[kVst3InternalParameterSampleRate]);

  2159.            #endif

  2160. 

  2161.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2162.             fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  2163.             sendParameterSetToUI(kVst3InternalParameterProgram, fCurrentProgram);

  2164.            #endif

  2165. 

  2166.            #if DISTRHO_PLUGIN_WANT_FULL_STATE

  2167.             // Update current state from plugin side

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

  2169.             {

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

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

  2172.             }

  2173.            #endif

  2174. 

  2175.            #if DISTRHO_PLUGIN_WANT_STATE

  2176.             // Set state

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

  2178.             {

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

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

  2181. 

  2182.                 sendStateSetToUI(key, value);

  2183.             }

  2184.            #endif

  2185. 

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

  2187.             {

  2188.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  2189.                 sendParameterSetToUI(kVst3InternalParameterCount + i,

  2190.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  2191.             }

  2192. 

  2193.             sendReadyToUI();

  2194.             return V3_OK;

  2195.         }

  2196. 

  2197.         DISTRHO_SAFE_ASSERT_RETURN(fConnectedToUI, V3_INTERNAL_ERR);

  2198. 

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

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

  2201. 

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

  2203.         {

  2204.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2205.             if (fParameterValueChangesForUI[kVst3InternalParameterSampleRate])

  2206.             {

  2207.                 fParameterValueChangesForUI[kVst3InternalParameterSampleRate] = false;

  2208.                 sendParameterSetToUI(kVst3InternalParameterSampleRate,

  2209.                                      fCachedParameterValues[kVst3InternalParameterSampleRate]);

  2210.             }

  2211.            #endif

  2212. 

  2213.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2214.             if (fParameterValueChangesForUI[kVst3InternalParameterProgram])

  2215.             {

  2216.                 fParameterValueChangesForUI[kVst3InternalParameterProgram] = false;

  2217.                 sendParameterSetToUI(kVst3InternalParameterProgram, fCurrentProgram);

  2218.             }

  2219.            #endif

  2220. 

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

  2222.             {

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

  2224.                     continue;

  2225. 

  2226.                 fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = false;

  2227.                 sendParameterSetToUI(kVst3InternalParameterCount + i,

  2228.                                      fCachedParameterValues[kVst3InternalParameterBaseCount + i]);

  2229.             }

  2230. 

  2231.             sendReadyToUI();

  2232.             return V3_OK;

  2233.         }

  2234. 

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

  2236.         {

  2237.             fConnectedToUI = false;

  2238.             return V3_OK;

  2239.         }

  2240. 

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

  2242.         {

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

  2244. 

  2245.             int64_t rindex;

  2246.             int64_t started;

  2247.             v3_result res;

  2248. 

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

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

  2251.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex >= kVst3InternalParameterCount,

  2252.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2253.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex < kVst3InternalParameterCount + fParameterCount,

  2254.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2255. 

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

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

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

  2259. 

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

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

  2262.         }

  2263. 

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

  2265.         {

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

  2267. 

  2268.             int64_t rindex;

  2269.             double value;

  2270.             v3_result res;

  2271. 

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

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

  2274.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex >= kVst3InternalParameterCount,

  2275.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2276.             DISTRHO_SAFE_ASSERT_INT2_RETURN(rindex < kVst3InternalParameterCount + fParameterCount,

  2277.                                             rindex, fParameterCount, V3_INTERNAL_ERR);

  2278. 

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

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

  2281. 

  2282.             const uint32_t index = rindex - kVst3InternalParameterCount;

  2283.             const double normalized = _getNormalizedParameterValue(index, value);

  2284. 

  2285.             fCachedParameterValues[kVst3InternalParameterBaseCount + index] = value;

  2286. 

  2287.             if (! fPlugin.isParameterOutputOrTrigger(index))

  2288.                 fPlugin.setParameterValue(index, value);

  2289. 

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

  2291.         }

  2292. 

  2293.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  2295.         {

  2296.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  2299.            #else

  2300.             return notify_midi(attrs);

  2301.            #endif

  2302.         }

  2303.        #endif

  2304. 

  2305.        #if DISTRHO_PLUGIN_WANT_STATE

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

  2307.         {

  2308.             const v3_result res = notify_state(attrs);

  2309. 

  2310.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2311.             if (res != V3_OK)

  2312.                 return res;

  2313. 

  2314.             // notify component of the change

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

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

  2317.            #else

  2318.             return res;

  2319.            #endif

  2320.         }

  2321.        #endif

  2322. 

  2323.         d_stderr("ctrl2view_notify received unknown msg '%s'", msgid);

  2324. 

  2325.         return V3_NOT_IMPLEMENTED;

  2326.     }

  2327. 

  2328.    #if DISTRHO_PLUGIN_WANT_STATE

  2329.     v3_result notify_state(v3_attribute_list** const attrs)

  2330.     {

  2331.         int64_t keyLength = -1;

  2332.         int64_t valueLength = -1;

  2333.         v3_result res;

  2334. 

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

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

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

  2338. 

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

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

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

  2342. 

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

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

  2345. 

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

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

  2348. 

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

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

  2351. 

  2352.         if (valueLength != 0)

  2353.         {

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

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

  2356.         }

  2357. 

  2358.         // do cheap inline conversion

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

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

  2361. 

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

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

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

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

  2366. 

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

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

  2369. 

  2370.         fPlugin.setState(key, value);

  2371. 

  2372.         // save this key as needed

  2373.         if (fPlugin.wantStateKey(key))

  2374.         {

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

  2376.             {

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

  2378. 

  2379.                 if (dkey == key)

  2380.                 {

  2381.                     it->second = value;

  2382.                     std::free(key16);

  2383.                     std::free(value16);

  2384.                     return V3_OK;

  2385.                 }

  2386.             }

  2387. 

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

  2389.         }

  2390. 

  2391.         std::free(key16);

  2392.         std::free(value16);

  2393.         return V3_OK;

  2394.     }

  2395.    #endif // DISTRHO_PLUGIN_WANT_STATE

  2396. 

  2397.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2398.     v3_result notify_midi(v3_attribute_list** const attrs)

  2399.     {

  2400.         uint8_t* data;

  2401.         uint32_t size;

  2402.         v3_result res;

  2403. 

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

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

  2406. 

  2407.         // known maximum size

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

  2409. 

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

  2411.     }

  2412.    #endif // DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2413. #endif

  2414. 

  2415.     // ----------------------------------------------------------------------------------------------------------------

  2416. 

  2417. private:

  2418.     // Plugin

  2419.     PluginExporter fPlugin;

  2420. 

  2421.     // VST3 stuff

  2422.     v3_component_handler** fComponentHandler;

  2423.   #if DISTRHO_PLUGIN_HAS_UI

  2424.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2425.     v3_connection_point** fConnectionFromCompToCtrl;

  2426.    #endif

  2427.     v3_connection_point** fConnectionFromCtrlToView;

  2428.     v3_host_application** const fHostApplication;

  2429.   #endif

  2430. 

  2431.     // Temporary data

  2432.     const uint32_t fParameterCount;

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

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

  2435.     float* fDummyAudioBuffer;

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

  2437.    #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  2438.     bool fEnabledInputs[DISTRHO_PLUGIN_NUM_INPUTS];

  2439.    #endif

  2440.    #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2441.     bool fEnabledOutputs[DISTRHO_PLUGIN_NUM_OUTPUTS];

  2442.    #endif

  2443.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  2444.     const bool fIsComponent;

  2445.    #endif

  2446.    #if DISTRHO_PLUGIN_HAS_UI

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

  2448.     bool fConnectedToUI;

  2449.    #endif

  2450.    #if DISTRHO_PLUGIN_WANT_LATENCY

  2451.     uint32_t fLastKnownLatency;

  2452.    #endif

  2453.   #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2454.     MidiEvent fMidiEvents[kMaxMidiEvents];

  2455.    #if DISTRHO_PLUGIN_HAS_UI

  2456.     SmallStackRingBuffer fNotesRingBuffer;

  2457.    #endif

  2458.   #endif

  2459.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2460.     v3_event_list** fHostEventOutputHandle;

  2461.    #endif

  2462.    #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2463.     uint32_t fCurrentProgram;

  2464.     const uint32_t fProgramCountMinusOne;

  2465.    #endif

  2466.    #if DISTRHO_PLUGIN_WANT_STATE

  2467.     StringMap fStateMap;

  2468.    #endif

  2469.    #if DISTRHO_PLUGIN_WANT_TIMEPOS

  2470.     TimePosition fTimePosition;

  2471.    #endif

  2472. 

  2473.     // ----------------------------------------------------------------------------------------------------------------

  2474.     // helper functions for dealing with buses

  2475. 

  2476.    #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2477.     template<bool isInput>

  2478.     void fillInBusInfoDetails()

  2479.     {

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

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

  2482.         bool* const enabledPorts = isInput

  2483.                                 #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  2484.                                  ? fEnabledInputs

  2485.                                 #else

  2486.                                  ? nullptr

  2487.                                 #endif

  2488.                                 #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2489.                                  : fEnabledOutputs;

  2490.                                 #else

  2491.                                  : nullptr;

  2492.                                 #endif

  2493. 

  2494.         std::vector<uint32_t> visitedPortGroups;

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

  2496.         {

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

  2498. 

  2499.             if (port.groupId != kPortGroupNone)

  2500.             {

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

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

  2503.                 {

  2504.                     visitedPortGroups.push_back(port.groupId);

  2505.                     ++busInfo.groups;

  2506.                 }

  2507.                 ++busInfo.groupPorts;

  2508.                 continue;

  2509.             }

  2510. 

  2511.             if (port.hints & kAudioPortIsCV)

  2512.                 ++busInfo.cvPorts;

  2513.             else if (port.hints & kAudioPortIsSidechain)

  2514.                 ++busInfo.sidechainPorts;

  2515.             else

  2516.                 ++busInfo.audioPorts;

  2517.         }

  2518. 

  2519.         if (busInfo.audioPorts != 0)

  2520.             busInfo.audio = 1;

  2521.         if (busInfo.sidechainPorts != 0)

  2522.             busInfo.sidechain = 1;

  2523. 

  2524.         uint32_t busIdForCV = 0;

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

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

  2527. 

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

  2529.         {

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

  2531. 

  2532.             if (port.groupId != kPortGroupNone)

  2533.             {

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

  2535. 

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

  2537.                     enabledPorts[i] = true;

  2538.             }

  2539.             else

  2540.             {

  2541.                 if (port.hints & kAudioPortIsCV)

  2542.                 {

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

  2544.                 }

  2545.                 else if (port.hints & kAudioPortIsSidechain)

  2546.                 {

  2547.                     port.busId = busInfo.audio;

  2548.                 }

  2549.                 else

  2550.                 {

  2551.                     port.busId = 0;

  2552.                     enabledPorts[i] = true;

  2553.                 }

  2554. 

  2555.                 port.busId += busInfo.groups;

  2556.             }

  2557.         }

  2558.     }

  2559. 

  2560.     template<bool isInput>

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

  2562.     {

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

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

  2565. 

  2566.         int32_t numChannels;

  2567.         uint32_t flags;

  2568.         v3_bus_types busType;

  2569.         v3_str_128 busName = {};

  2570. 

  2571.         if (busId < busInfo.groups)

  2572.         {

  2573.             numChannels = 0;

  2574. 

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

  2576.             {

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

  2578. 

  2579.                 if (port.busId == busId)

  2580.                 {

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

  2582. 

  2583.                     switch (port.groupId)

  2584.                     {

  2585.                     case kPortGroupStereo:

  2586.                     case kPortGroupMono:

  2587.                         if (busId == 0)

  2588.                         {

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

  2590.                             break;

  2591.                         }

  2592.                     // fall-through

  2593.                     default:

  2594.                         if (group.name.isNotEmpty())

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

  2596.                         else

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

  2598.                         break;

  2599.                     }

  2600. 

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

  2602. 

  2603.                     if (port.hints & kAudioPortIsCV)

  2604.                     {

  2605.                         busType = V3_MAIN;

  2606.                         flags = V3_IS_CONTROL_VOLTAGE;

  2607.                     }

  2608.                     else if (port.hints & kAudioPortIsSidechain)

  2609.                     {

  2610.                         busType = V3_AUX;

  2611.                         flags = 0;

  2612.                     }

  2613.                     else

  2614.                     {

  2615.                         busType = V3_MAIN;

  2616.                         flags = busInfo.audio == 0 ? V3_DEFAULT_ACTIVE : 0;

  2617.                     }

  2618.                     break;

  2619.                 }

  2620.             }

  2621. 

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

  2623.         }

  2624.         else

  2625.         {

  2626.             switch (busId - busInfo.groups)

  2627.             {

  2628.             case 0:

  2629.                 if (busInfo.audio)

  2630.                 {

  2631.                     numChannels = busInfo.audioPorts;

  2632.                     busType = V3_MAIN;

  2633.                     flags = V3_DEFAULT_ACTIVE;

  2634.                     break;

  2635.                 }

  2636.             // fall-through

  2637.             case 1:

  2638.                 if (busInfo.sidechain)

  2639.                 {

  2640.                     numChannels = busInfo.sidechainPorts;

  2641.                     busType = V3_AUX;

  2642.                     flags = 0;

  2643.                     break;

  2644.                 }

  2645.             // fall-through

  2646.             default:

  2647.                 numChannels = 1;

  2648.                 busType = V3_MAIN;

  2649.                 flags = V3_IS_CONTROL_VOLTAGE;

  2650.                 break;

  2651.             }

  2652. 

  2653.             if (busType == V3_MAIN && flags != V3_IS_CONTROL_VOLTAGE)

  2654.             {

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

  2656.             }

  2657.             else

  2658.             {

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

  2660.                 {

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

  2662. 

  2663.                     if (port.busId == busId)

  2664.                     {

  2665.                         String groupName;

  2666.                         if (busInfo.groups)

  2667.                             groupName = fPlugin.getPortGroupById(port.groupId).name;

  2668.                         if (groupName.isEmpty())

  2669.                             groupName = port.name;

  2670.                         strncpy_utf16(busName, groupName, 128);

  2671.                         break;

  2672.                     }

  2673.                 }

  2674.             }

  2675.         }

  2676. 

  2677.         // d_debug("getAudioBusInfo %d %d %d", (int)isInput, busId, numChannels);

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

  2679.         info->media_type = V3_AUDIO;

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

  2681.         info->channel_count = numChannels;

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

  2683.         info->bus_type = busType;

  2684.         info->flags = flags;

  2685.         return V3_OK;

  2686.     }

  2687. 

  2688.     // someone please tell me what is up with these..

  2689.     static inline v3_speaker_arrangement portCountToSpeaker(const uint32_t portCount)

  2690.     {

  2691.         DISTRHO_SAFE_ASSERT_RETURN(portCount != 0, 0);

  2692. 

  2693.         switch (portCount)

  2694.         {

  2695.         // regular mono

  2696.         case 1: return V3_SPEAKER_M;

  2697.         // regular stereo

  2698.         case 2: return V3_SPEAKER_L | V3_SPEAKER_R;

  2699.         // stereo with center channel

  2700.         case 3: return V3_SPEAKER_L | V3_SPEAKER_R | V3_SPEAKER_C;

  2701.         // stereo with surround (quadro)

  2702.         case 4: return V3_SPEAKER_L | V3_SPEAKER_R | V3_SPEAKER_LS | V3_SPEAKER_RS;

  2703.         // regular 5.0

  2704.         case 5: return V3_SPEAKER_L | V3_SPEAKER_R | V3_SPEAKER_LS | V3_SPEAKER_RS | V3_SPEAKER_C;

  2705.         // regular 6.0

  2706.         case 6: return V3_SPEAKER_L | V3_SPEAKER_R | V3_SPEAKER_LS | V3_SPEAKER_RS | V3_SPEAKER_SL | V3_SPEAKER_SR;

  2707.         // regular 7.0

  2708.         case 7: return V3_SPEAKER_L | V3_SPEAKER_R | V3_SPEAKER_LS | V3_SPEAKER_RS | V3_SPEAKER_SL | V3_SPEAKER_SR | V3_SPEAKER_C;

  2709.         // regular 8.0

  2710.         case 8: return V3_SPEAKER_L | V3_SPEAKER_R | V3_SPEAKER_LS | V3_SPEAKER_RS | V3_SPEAKER_SL | V3_SPEAKER_SR | V3_SPEAKER_C | V3_SPEAKER_S;

  2711.         // regular 8.1

  2712.         case 9: return V3_SPEAKER_L | V3_SPEAKER_R | V3_SPEAKER_LS | V3_SPEAKER_RS | V3_SPEAKER_SL | V3_SPEAKER_SR | V3_SPEAKER_C | V3_SPEAKER_S | V3_SPEAKER_LFE;

  2713.         // cinema 10.0

  2714.         case 10: return (

  2715.             V3_SPEAKER_L | V3_SPEAKER_R |

  2716.             V3_SPEAKER_LS | V3_SPEAKER_RS |

  2717.             V3_SPEAKER_SL | V3_SPEAKER_SR |

  2718.             V3_SPEAKER_LC | V3_SPEAKER_RC |

  2719.             V3_SPEAKER_C | V3_SPEAKER_S);

  2720.         // cinema 10.1

  2721.         case 11: return (

  2722.             V3_SPEAKER_L | V3_SPEAKER_R |

  2723.             V3_SPEAKER_LS | V3_SPEAKER_RS |

  2724.             V3_SPEAKER_SL | V3_SPEAKER_SR |

  2725.             V3_SPEAKER_LC | V3_SPEAKER_RC |

  2726.             V3_SPEAKER_C | V3_SPEAKER_S | V3_SPEAKER_LFE);

  2727.         default:

  2728.             d_stderr("portCountToSpeaker error: got weirdly big number ports %u in a single bus", portCount);

  2729.             return 0;

  2730.         }

  2731.     }

  2732. 

  2733.     template<bool isInput>

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

  2735.     {

  2736.         switch (portGroupId)

  2737.         {

  2738.         case kPortGroupMono:

  2739.             return V3_SPEAKER_M;

  2740.         case kPortGroupStereo:

  2741.             return V3_SPEAKER_L | V3_SPEAKER_R;

  2742.         }

  2743. 

  2744.         if (busId < busInfo.groups)

  2745.             return portCountToSpeaker(fPlugin.getAudioPortCountWithGroupId(isInput, portGroupId));

  2746. 

  2747.         if (busInfo.audio != 0 && busId == busInfo.groups)

  2748.             return portCountToSpeaker(busInfo.audioPorts);

  2749. 

  2750.         if (busInfo.sidechain != 0 && busId == busInfo.groups + busInfo.audio)

  2751.             return portCountToSpeaker(busInfo.sidechainPorts);

  2752. 

  2753.         return V3_SPEAKER_M;

  2754.     }

  2755. 

  2756.     template<bool isInput>

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

  2758.     {

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

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

  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.                 // d_debug("port.busId != busId: %d %d", port.busId, busId);

  2769.                 continue;

  2770.             }

  2771. 

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

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

  2774.             return true;

  2775.         }

  2776. 

  2777.         return false;

  2778.     }

  2779. 

  2780.     template<bool isInput>

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

  2782.     {

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

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

  2785.         bool* const enabledPorts = isInput

  2786.                                 #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  2787.                                  ? fEnabledInputs

  2788.                                 #else

  2789.                                  ? nullptr

  2790.                                 #endif

  2791.                                 #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  2792.                                  : fEnabledOutputs;

  2793.                                 #else

  2794.                                  : nullptr;

  2795.                                 #endif

  2796. 

  2797.         bool ok = true;

  2798. 

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

  2800.         {

  2801.             const v3_speaker_arrangement arr = speakers[busId];

  2802. 

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

  2804. 

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

  2806.             {

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

  2808. 

  2809.                 if (port.busId != busId)

  2810.                 {

  2811.                     // d_debug("setAudioBusArrangement port.busId != busId: %d %d", port.busId, busId);

  2812.                     continue;

  2813.                 }

  2814. 

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

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

  2817. 

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

  2819.                 // FIXME should we allow to map speaker to zero as a way to disable it?

  2820.                 if (earr != arr /* && arr != 0 */)

  2821.                 {

  2822.                     ok = false;

  2823.                     continue;

  2824.                 }

  2825. 

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

  2827.             }

  2828.         }

  2829. 

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

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

  2832. 

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

  2834.         {

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

  2836.             {

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

  2838. 

  2839.                 if (port.busId == busId)

  2840.                 {

  2841.                     enabledPorts[i] = false;

  2842.                     break;

  2843.                 }

  2844.             }

  2845.         }

  2846. 

  2847.         return ok;

  2848.     }

  2849.    #endif

  2850. 

  2851.     // ----------------------------------------------------------------------------------------------------------------

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

  2853. 

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

  2855.     {

  2856.         DISTRHO_SAFE_ASSERT_RETURN(outparamsptr != nullptr,);

  2857. 

  2858.         float curValue;

  2859.         double normalized;

  2860. 

  2861.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  2863.         {

  2864.             if (! fParameterValuesChangedDuringProcessing[i])

  2865.                 continue;

  2866. 

  2867.             normalized = plainParameterToNormalized(i, fCachedParameterValues[i]);

  2868.             fParameterValuesChangedDuringProcessing[i] = false;

  2869.             addParameterDataToHostOutputEvents(outparamsptr, i, normalized);

  2870.         }

  2871.        #endif

  2872. 

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

  2874.         {

  2875.             if (fPlugin.isParameterOutput(i))

  2876.             {

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

  2878.                 curValue = fPlugin.getParameterValue(i);

  2879. 

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

  2881.                     continue;

  2882.             }

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

  2884.             {

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

  2886.                 curValue = fPlugin.getParameterValue(i);

  2887. 

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

  2889.                     continue;

  2890. 

  2891.                 fPlugin.setParameterValue(i, curValue);

  2892.             }

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

  2894.             {

  2895.                 fParameterValuesChangedDuringProcessing[kVst3InternalParameterBaseCount + i] = false;

  2896.                 curValue = fPlugin.getParameterValue(i);

  2897.             }

  2898.             else

  2899.             {

  2900.                 continue;

  2901.             }

  2902. 

  2903.             fCachedParameterValues[kVst3InternalParameterBaseCount + i] = curValue;

  2904.            #if DISTRHO_PLUGIN_HAS_UI

  2905.             fParameterValueChangesForUI[kVst3InternalParameterBaseCount + i] = true;

  2906.            #endif

  2907. 

  2908.             normalized = _getNormalizedParameterValue(i, curValue);

  2909. 

  2910.             if (! addParameterDataToHostOutputEvents(outparamsptr, kVst3InternalParameterCount + i, normalized, offset))

  2911.                 break;

  2912.         }

  2913. 

  2914.        #if DISTRHO_PLUGIN_WANT_LATENCY

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

  2916. 

  2917.         if (fLastKnownLatency != latency)

  2918.         {

  2919.             fLastKnownLatency = latency;

  2920. 

  2921.             normalized = plainParameterToNormalized(kVst3InternalParameterLatency,

  2922.                                                     fCachedParameterValues[kVst3InternalParameterLatency]);

  2923.             addParameterDataToHostOutputEvents(outparamsptr, kVst3InternalParameterLatency, normalized);

  2924.         }

  2925.        #endif

  2926.     }

  2927. 

  2928.     bool addParameterDataToHostOutputEvents(v3_param_changes** const outparamsptr,

  2929.                                             v3_param_id paramId,

  2930.                                             const double normalized,

  2931.                                             const int32_t offset = 0)

  2932.     {

  2933.         int32_t index = 0;

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

  2935.                                                                                       &paramId, &index);

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

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

  2938. 

  2939.         /* FLStudio gets confused with this one, skip it for now

  2940.         if (offset != 0)

  2941.             v3_cpp_obj(queue)->add_point(queue, offset, normalized, &index);

  2942.         */

  2943. 

  2944.         return true;

  2945. 

  2946.         // unused at the moment, buggy VST3 hosts :/

  2947.         (void)offset;

  2948.     }

  2949. 

  2950.    #if DISTRHO_PLUGIN_HAS_UI

  2951.     // ----------------------------------------------------------------------------------------------------------------

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

  2953. 

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

  2955.     {

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

  2957. 

  2958.         v3_tuid iid;

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

  2960.         v3_message** msg = nullptr;

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

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

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

  2964. 

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

  2966.         return msg;

  2967.     }

  2968. 

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

  2970.     {

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

  2972.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2973. 

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

  2975.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  2976. 

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

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

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

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

  2981. 

  2982.         v3_cpp_obj_unref(message);

  2983.     }

  2984. 

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

  2986.     {

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

  2988.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2989. 

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

  2991.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  2992. 

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

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

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

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

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

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

  2999. 

  3000.         v3_cpp_obj_unref(message);

  3001.     }

  3002. 

  3003.     void sendReadyToUI() const

  3004.     {

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

  3006.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  3007. 

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

  3009.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  3010. 

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

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

  3013. 

  3014.         v3_cpp_obj_unref(message);

  3015.     }

  3016.    #endif

  3017. 

  3018.     // ----------------------------------------------------------------------------------------------------------------

  3019.     // DPF callbacks

  3020. 

  3021.    #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  3022.     bool requestParameterValueChange(const uint32_t index, float)

  3023.     {

  3024.         fParameterValuesChangedDuringProcessing[kVst3InternalParameterBaseCount + index] = true;

  3025.         return true;

  3026.     }

  3027. 

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

  3029.     {

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

  3031.     }

  3032.    #endif

  3033. 

  3034.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  3035.     bool writeMidi(const MidiEvent& midiEvent)

  3036.     {

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

  3038. 

  3039.         v3_event event;

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

  3041.         event.sample_offset = midiEvent.frame;

  3042. 

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

  3044. 

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

  3046.         {

  3047.         case 0x80:

  3048.             event.type = V3_EVENT_NOTE_OFF;

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

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

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

  3052.             // int32_t note_id;

  3053.             // float tuning;

  3054.             break;

  3055.         case 0x90:

  3056.             event.type = V3_EVENT_NOTE_ON;

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

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

  3059.             // float tuning;

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

  3061.             // int32_t length;

  3062.             // int32_t note_id;

  3063.             break;

  3064.         case 0xA0:

  3065.             event.type = V3_EVENT_POLY_PRESSURE;

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

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

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

  3069.             // int32_t note_id;

  3070.             break;

  3071.         case 0xB0:

  3072.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

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

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

  3076.             if (midiEvent.size == 4)

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

  3078.             break;

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

  3080.         case 0xC0:

  3081.             break;

  3082.         */

  3083.         case 0xD0:

  3084.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

  3086.             event.midi_cc_out.cc_number = 128;

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

  3088.             break;

  3089.         case 0xE0:

  3090.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

  3092.             event.midi_cc_out.cc_number = 129;

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

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

  3095.             break;

  3096.         default:

  3097.             return true;

  3098.         }

  3099. 

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

  3101.     }

  3102. 

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

  3104.     {

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

  3106.     }

  3107.    #endif

  3108. };

  3109. 

  3110. // --------------------------------------------------------------------------------------------------------------------

  3111. 

  3112. /**

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

  3114.  */

  3115. 

  3116. // --------------------------------------------------------------------------------------------------------------------

  3117. // v3_funknown for static instances

  3118. 

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

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

  3121. 

  3122. // --------------------------------------------------------------------------------------------------------------------

  3123. // v3_funknown for classes with a single instance

  3124. 

  3125. template<class T>

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

  3127. {

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

  3129. }

  3130. 

  3131. template<class T>

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

  3133. {

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

  3135. }

  3136. 

  3137. // --------------------------------------------------------------------------------------------------------------------

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

  3139. 

  3140. struct dpf_component;

  3141. 

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

  3143. 

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

  3145. {

  3146.     gComponentGarbage.push_back(componentptr);

  3147.     return 0;

  3148. }

  3149. 

  3150. #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3151. // --------------------------------------------------------------------------------------------------------------------

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

  3153. 

  3154. struct dpf_edit_controller;

  3155. 

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

  3157. 

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

  3159. {

  3160.     gControllerGarbage.push_back(controllerptr);

  3161.     return 0;

  3162. }

  3163. 

  3164. // --------------------------------------------------------------------------------------------------------------------

  3165. // dpf_comp2ctrl_connection_point

  3166. 

  3167. struct dpf_comp2ctrl_connection_point : v3_connection_point_cpp {

  3168.     std::atomic_int refcounter;

  3169.     ScopedPointer<PluginVst3>& vst3;

  3170.     v3_connection_point** other;

  3171. 

  3172.     dpf_comp2ctrl_connection_point(ScopedPointer<PluginVst3>& v)

  3173.         : refcounter(1),

  3174.           vst3(v),

  3175.           other(nullptr)

  3176.     {

  3177.         // v3_funknown, single instance

  3178.         query_interface = query_interface_connection_point;

  3179.         ref = dpf_single_instance_ref<dpf_comp2ctrl_connection_point>;

  3180.         unref = dpf_single_instance_unref<dpf_comp2ctrl_connection_point>;

  3181. 

  3182.         // v3_connection_point

  3183.         point.connect = connect;

  3184.         point.disconnect = disconnect;

  3185.         point.notify = notify;

  3186.     }

  3187. 

  3188.     // ----------------------------------------------------------------------------------------------------------------

  3189.     // v3_funknown

  3190. 

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

  3192.     {

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

  3194. 

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

  3196.             v3_tuid_match(iid, v3_connection_point_iid))

  3197.         {

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

  3199.             ++point->refcounter;

  3200.             *iface = self;

  3201.             return V3_OK;

  3202.         }

  3203. 

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

  3205. 

  3206.         *iface = nullptr;

  3207.         return V3_NO_INTERFACE;

  3208.     }

  3209. 

  3210.     // ----------------------------------------------------------------------------------------------------------------

  3211.     // v3_connection_point

  3212. 

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

  3214.     {

  3215.         d_debug("dpf_comp2ctrl_connection_point::connect => %p %p", self, other);

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

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

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

  3219. 

  3220.         point->other = other;

  3221. 

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

  3223.             vst3->comp2ctrl_connect(other);

  3224. 

  3225.         return V3_OK;

  3226.     }

  3227. 

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

  3229.     {

  3230.         d_debug("dpf_comp2ctrl_connection_point => %p %p", self, other);

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

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

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

  3234. 

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

  3236.             vst3->comp2ctrl_disconnect();

  3237. 

  3238.         point->other = nullptr;

  3239. 

  3240.         return V3_OK;

  3241.     }

  3242. 

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

  3244.     {

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

  3246. 

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

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

  3249. 

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

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

  3252. 

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

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

  3255. 

  3256.         int64_t target = 0;

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

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

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

  3260. 

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

  3262.         return vst3->comp2ctrl_notify(message);

  3263.     }

  3264. };

  3265. #endif // DPF_VST3_USES_SEPARATE_CONTROLLER

  3266. 

  3267. #if DISTRHO_PLUGIN_HAS_UI

  3268. // --------------------------------------------------------------------------------------------------------------------

  3269. // dpf_ctrl2view_connection_point

  3270. 

  3271. struct dpf_ctrl2view_connection_point : v3_connection_point_cpp {

  3272.     ScopedPointer<PluginVst3>& vst3;

  3273.     v3_connection_point** other;

  3274. 

  3275.     dpf_ctrl2view_connection_point(ScopedPointer<PluginVst3>& v)

  3276.         : vst3(v),

  3277.           other(nullptr)

  3278.     {

  3279.         // v3_funknown, single instance, used internally

  3280.         query_interface = nullptr;

  3281.         ref = nullptr;

  3282.         unref = nullptr;

  3283. 

  3284.         // v3_connection_point

  3285.         point.connect = connect;

  3286.         point.disconnect = disconnect;

  3287.         point.notify = notify;

  3288.     }

  3289. 

  3290.     // ----------------------------------------------------------------------------------------------------------------

  3291.     // v3_connection_point

  3292. 

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

  3294.     {

  3295.         d_debug("dpf_ctrl2view_connection_point::connect => %p %p", self, other);

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

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

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

  3299. 

  3300.         point->other = other;

  3301. 

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

  3303.             vst3->ctrl2view_connect(other);

  3304. 

  3305.         return V3_OK;

  3306.     }

  3307. 

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

  3309.     {

  3310.         d_debug("dpf_ctrl2view_connection_point::disconnect => %p %p", self, other);

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

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

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

  3314. 

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

  3316.             vst3->ctrl2view_disconnect();

  3317. 

  3318.         v3_cpp_obj_unref(point->other);

  3319.         point->other = nullptr;

  3320. 

  3321.         return V3_OK;

  3322.     }

  3323. 

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

  3325.     {

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

  3327. 

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

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

  3330. 

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

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

  3333. 

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

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

  3336. 

  3337.         int64_t target = 0;

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

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

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

  3341. 

  3342.         if (target == 1)

  3343.         {

  3344.             // view -> edit controller

  3345.             return vst3->ctrl2view_notify(message);

  3346.         }

  3347.         else

  3348.         {

  3349.             // edit controller -> view

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

  3351.         }

  3352.     }

  3353. };

  3354. #endif // DISTRHO_PLUGIN_HAS_UI

  3355. 

  3356. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  3357. // --------------------------------------------------------------------------------------------------------------------

  3358. // dpf_midi_mapping

  3359. 

  3360. struct dpf_midi_mapping : v3_midi_mapping_cpp {

  3361.     dpf_midi_mapping()

  3362.     {

  3363.         // v3_funknown, static

  3364.         query_interface = query_interface_midi_mapping;

  3365.         ref = dpf_static_ref;

  3366.         unref = dpf_static_unref;

  3367. 

  3368.         // v3_midi_mapping

  3369.         map.get_midi_controller_assignment = get_midi_controller_assignment;

  3370.     }

  3371. 

  3372.     // ----------------------------------------------------------------------------------------------------------------

  3373.     // v3_funknown

  3374. 

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

  3376.     {

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

  3378.             v3_tuid_match(iid, v3_midi_mapping_iid))

  3379.         {

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

  3381.             *iface = self;

  3382.             return V3_OK;

  3383.         }

  3384. 

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

  3386. 

  3387.         *iface = nullptr;

  3388.         return V3_NO_INTERFACE;

  3389.     }

  3390. 

  3391.     // ----------------------------------------------------------------------------------------------------------------

  3392.     // v3_midi_mapping

  3393. 

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

  3395.     {

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

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

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

  3399. 

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

  3401.         return V3_TRUE;

  3402.     }

  3403. 

  3404.     DISTRHO_PREVENT_HEAP_ALLOCATION

  3405. };

  3406. #endif // DISTRHO_PLUGIN_WANT_MIDI_INPUT

  3407. 

  3408. // --------------------------------------------------------------------------------------------------------------------

  3409. // dpf_edit_controller

  3410. 

  3411. struct dpf_edit_controller : v3_edit_controller_cpp {

  3412.     std::atomic_int refcounter;

  3413.    #if DISTRHO_PLUGIN_HAS_UI

  3414.     ScopedPointer<dpf_ctrl2view_connection_point> connectionCtrl2View;

  3415.    #endif

  3416.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3417.     ScopedPointer<dpf_comp2ctrl_connection_point> connectionComp2Ctrl;

  3418.     ScopedPointer<PluginVst3> vst3;

  3419.    #else

  3420.     ScopedPointer<PluginVst3>& vst3;

  3421.     bool initialized;

  3422.    #endif

  3423.     // cached values

  3424.     v3_component_handler** handler;

  3425.     v3_host_application** const hostApplicationFromFactory;

  3426.    #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3427.     v3_host_application** const hostApplicationFromComponent;

  3428.     v3_host_application** hostApplicationFromComponentInitialize;

  3429.    #endif

  3430.     v3_host_application** hostApplicationFromInitialize;

  3431. 

  3432.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3433.     dpf_edit_controller(v3_host_application** const hostApp)

  3434.         : refcounter(1),

  3435.           vst3(nullptr),

  3436.    #else

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

  3438.         : refcounter(1),

  3439.           vst3(v),

  3440.           initialized(false),

  3441.    #endif

  3442.           handler(nullptr),

  3443.           hostApplicationFromFactory(hostApp),

  3444.          #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3445.           hostApplicationFromComponent(hostComp),

  3446.           hostApplicationFromComponentInitialize(nullptr),

  3447.          #endif

  3448.           hostApplicationFromInitialize(nullptr)

  3449.     {

  3450.         d_debug("dpf_edit_controller() with hostApplication %p", hostApplicationFromFactory);

  3451. 

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

  3453.         if (hostApplicationFromFactory != nullptr)

  3454.             v3_cpp_obj_ref(hostApplicationFromFactory);

  3455.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3456.         if (hostApplicationFromComponent != nullptr)

  3457.             v3_cpp_obj_ref(hostApplicationFromComponent);

  3458.        #endif

  3459. 

  3460.         // v3_funknown, everything custom

  3461.         query_interface = query_interface_edit_controller;

  3462.         ref = ref_edit_controller;

  3463.         unref = unref_edit_controller;

  3464. 

  3465.         // v3_plugin_base

  3466.         base.initialize = initialize;

  3467.         base.terminate = terminate;

  3468. 

  3469.         // v3_edit_controller

  3470.         ctrl.set_component_state = set_component_state;

  3471.         ctrl.set_state = set_state;

  3472.         ctrl.get_state = get_state;

  3473.         ctrl.get_parameter_count = get_parameter_count;

  3474.         ctrl.get_parameter_info = get_parameter_info;

  3475.         ctrl.get_parameter_string_for_value = get_parameter_string_for_value;

  3476.         ctrl.get_parameter_value_for_string = get_parameter_value_for_string;

  3477.         ctrl.normalised_parameter_to_plain = normalised_parameter_to_plain;

  3478.         ctrl.plain_parameter_to_normalised = plain_parameter_to_normalised;

  3479.         ctrl.get_parameter_normalised = get_parameter_normalised;

  3480.         ctrl.set_parameter_normalised = set_parameter_normalised;

  3481.         ctrl.set_component_handler = set_component_handler;

  3482.         ctrl.create_view = create_view;

  3483.     }

  3484. 

  3485.     ~dpf_edit_controller()

  3486.     {

  3487.         d_debug("~dpf_edit_controller()");

  3488.        #if DISTRHO_PLUGIN_HAS_UI

  3489.         connectionCtrl2View = nullptr;

  3490.        #endif

  3491.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3492.         connectionComp2Ctrl = nullptr;

  3493.         vst3 = nullptr;

  3494.        #endif

  3495. 

  3496.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3497.         if (hostApplicationFromComponent != nullptr)

  3498.             v3_cpp_obj_unref(hostApplicationFromComponent);

  3499.        #endif

  3500.         if (hostApplicationFromFactory != nullptr)

  3501.             v3_cpp_obj_unref(hostApplicationFromFactory);

  3502.     }

  3503. 

  3504.     // ----------------------------------------------------------------------------------------------------------------

  3505.     // v3_funknown

  3506. 

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

  3508.     {

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

  3510. 

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

  3512.             v3_tuid_match(iid, v3_plugin_base_iid) ||

  3513.             v3_tuid_match(iid, v3_edit_controller_iid))

  3514.         {

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

  3516.             ++controller->refcounter;

  3517.             *iface = self;

  3518.             return V3_OK;

  3519.         }

  3520. 

  3521.         if (v3_tuid_match(iid, v3_midi_mapping_iid))

  3522.         {

  3523.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  3525.             static dpf_midi_mapping midi_mapping;

  3526.             static dpf_midi_mapping* midi_mapping_ptr = &midi_mapping;

  3527.             *iface = &midi_mapping_ptr;

  3528.             return V3_OK;

  3529.            #else

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

  3531.             *iface = nullptr;

  3532.             return V3_NO_INTERFACE;

  3533.            #endif

  3534.         }

  3535. 

  3536.         if (v3_tuid_match(iid, v3_connection_point_iid))

  3537.         {

  3538.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3539.             d_debug("query_interface_edit_controller => %p %s %p | OK convert %p",

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

  3541. 

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

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

  3544.             else

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

  3546.             *iface = &controller->connectionComp2Ctrl;

  3547.             return V3_OK;

  3548.            #else

  3549.             d_debug("query_interface_edit_controller => %p %s %p | reject unwanted", self, tuid2str(iid), iface);

  3550.             *iface = nullptr;

  3551.             return V3_NO_INTERFACE;

  3552.            #endif

  3553.         }

  3554. 

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

  3556.         *iface = nullptr;

  3557.         return V3_NO_INTERFACE;

  3558.     }

  3559. 

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

  3561.     {

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

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

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

  3565.         return refcount;

  3566.     }

  3567. 

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

  3569.     {

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

  3571.         dpf_edit_controller* const controller = *controllerptr;

  3572. 

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

  3574.         {

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

  3576.             return refcount;

  3577.         }

  3578. 

  3579.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3580.         /**

  3581.          * Some hosts will have unclean instances of a few of the controller child classes at this point.

  3582.          * We check for those here, going through the whole possible chain to see if it is safe to delete.

  3583.          * If not, we add this controller to the `gControllerGarbage` global which will take care of it during unload.

  3584.          */

  3585. 

  3586.         bool unclean = false;

  3587. 

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

  3589.         {

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

  3591.             {

  3592.                 unclean = true;

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

  3594.             }

  3595.         }

  3596. 

  3597.         if (unclean)

  3598.             return handleUncleanController(controllerptr);

  3599. 

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

  3601. 

  3602.         delete controller;

  3603.         delete controllerptr;

  3604.        #else

  3605.         d_debug("dpf_edit_controller::unref => %p | refcount is zero, deletion will be done by component later", self);

  3606.        #endif

  3607.         return 0;

  3608.     }

  3609. 

  3610.     // ----------------------------------------------------------------------------------------------------------------

  3611.     // v3_plugin_base

  3612. 

  3613.     static v3_result V3_API initialize(void* const self, v3_funknown** const context)

  3614.     {

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

  3616. 

  3617.         // check if already initialized

  3618.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  3620.        #else

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

  3622.        #endif

  3623. 

  3624.         // query for host application

  3625.         v3_host_application** hostApplication = nullptr;

  3626.         if (context != nullptr)

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

  3628. 

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

  3630. 

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

  3632.         controller->hostApplicationFromInitialize = hostApplication;

  3633. 

  3634.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  3636.         if (hostApplication == nullptr)

  3637.             hostApplication = controller->hostApplicationFromFactory;

  3638. 

  3639.         // default early values

  3640.         if (d_nextBufferSize == 0)

  3641.             d_nextBufferSize = 1024;

  3642.         if (d_nextSampleRate <= 0.0)

  3643.             d_nextSampleRate = 44100.0;

  3644. 

  3645.         d_nextCanRequestParameterValueChanges = true;

  3646. 

  3647.         // create the actual plugin

  3648.         controller->vst3 = new PluginVst3(hostApplication, false);

  3649. 

  3650.         // set connection point if needed

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

  3652.         {

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

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

  3655.         }

  3656.        #else

  3657.         // mark as initialized

  3658.         controller->initialized = true;

  3659.        #endif

  3660. 

  3661.         return V3_OK;

  3662.     }

  3663. 

  3664.     static v3_result V3_API terminate(void* self)

  3665.     {

  3666.         d_debug("dpf_edit_controller::terminate => %p", self);

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

  3668. 

  3669.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  3670.         // check if already terminated

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

  3672. 

  3673.         // delete actual plugin

  3674.         controller->vst3 = nullptr;

  3675.        #else

  3676.         // check if already terminated

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

  3678. 

  3679.         // mark as uninitialzed

  3680.         controller->initialized = false;

  3681.        #endif

  3682. 

  3683.         // unref host application received during initialize

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

  3685.         {

  3686.             v3_cpp_obj_unref(controller->hostApplicationFromInitialize);

  3687.             controller->hostApplicationFromInitialize = nullptr;

  3688.         }

  3689. 

  3690.         return V3_OK;

  3691.     }

  3692. 

  3693.     // ----------------------------------------------------------------------------------------------------------------

  3694.     // v3_edit_controller

  3695. 

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

  3697.     {

  3698.         d_debug("dpf_edit_controller::set_component_state => %p %p", self, stream);

  3699. 

  3700.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

  3702. 

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

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

  3705. 

  3706.         return vst3->setState(stream);

  3707.        #else

  3708.         return V3_OK;

  3709. 

  3710.         // unused

  3711.         (void)self;

  3712.         (void)stream;

  3713.        #endif

  3714.     }

  3715. 

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

  3717.     {

  3718.         d_debug("dpf_edit_controller::set_state => %p %p", self, stream);

  3719. 

  3720.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  3723.        #endif

  3724. 

  3725.         return V3_NOT_IMPLEMENTED;

  3726. 

  3727.         // maybe unused

  3728.         (void)self;

  3729.         (void)stream;

  3730.     }

  3731. 

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

  3733.     {

  3734.         d_debug("dpf_edit_controller::get_state => %p %p", self, stream);

  3735. 

  3736.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

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

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

  3739.        #endif

  3740. 

  3741.         return V3_NOT_IMPLEMENTED;

  3742. 

  3743.         // maybe unused

  3744.         (void)self;

  3745.         (void)stream;

  3746.     }

  3747. 

  3748.     static int32_t V3_API get_parameter_count(void* self)

  3749.     {

  3750.         // d_debug("dpf_edit_controller::get_parameter_count => %p", self);

  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->getParameterCount();

  3757.     }

  3758. 

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

  3760.     {

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

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

  3763. 

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

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

  3766. 

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

  3768.     }

  3769. 

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

  3771.     {

  3772.         // NOTE very noisy, called many times

  3773.         // d_debug("dpf_edit_controller::get_parameter_string_for_value => %p %u %f %p", self, index, normalized, output);

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

  3775. 

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

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

  3778. 

  3779.         return vst3->getParameterStringForValue(index, normalized, output);

  3780.     }

  3781. 

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

  3783.     {

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

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

  3786. 

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

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

  3789. 

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

  3791.     }

  3792. 

  3793.     static double V3_API normalised_parameter_to_plain(void* self, v3_param_id index, double normalized)

  3794.     {

  3795.         d_debug("dpf_edit_controller::normalised_parameter_to_plain => %p %u %f", self, index, normalized);

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

  3797. 

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

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

  3800. 

  3801.         return vst3->normalizedParameterToPlain(index, normalized);

  3802.     }

  3803. 

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

  3805.     {

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

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

  3808. 

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

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

  3811. 

  3812.         return vst3->plainParameterToNormalized(index, plain);

  3813.     }

  3814. 

  3815.     static double V3_API get_parameter_normalised(void* self, v3_param_id index)

  3816.     {

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

  3818. 

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

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

  3821. 

  3822.         return vst3->getParameterNormalized(index);

  3823.     }

  3824. 

  3825.     static v3_result V3_API set_parameter_normalised(void* const self, const v3_param_id index, const double normalized)

  3826.     {

  3827.         // d_debug("dpf_edit_controller::set_parameter_normalised => %p %u %f", self, index, normalized);

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

  3829. 

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

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

  3832. 

  3833.         return vst3->setParameterNormalized(index, normalized);

  3834.     }

  3835. 

  3836.     static v3_result V3_API set_component_handler(void* self, v3_component_handler** handler)

  3837.     {

  3838.         d_debug("dpf_edit_controller::set_component_handler => %p %p", self, handler);

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

  3840. 

  3841.         controller->handler = handler;

  3842. 

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

  3844.             return vst3->setComponentHandler(handler);

  3845. 

  3846.         return V3_NOT_INITIALIZED;

  3847.     }

  3848. 

  3849.     static v3_plugin_view** V3_API create_view(void* self, const char* name)

  3850.     {

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

  3852. 

  3853.        #if DISTRHO_PLUGIN_HAS_UI

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

  3855. 

  3856.         d_debug("create_view has contexts %p %p",

  3857.                 controller->hostApplicationFromFactory, controller->hostApplicationFromInitialize);

  3858. 

  3859.         // plugin must be initialized

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

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

  3862. 

  3863.         d_debug("dpf_edit_controller::create_view => %p %s | edit-ctrl %p, factory %p",

  3864.                 self, name,

  3865.                 controller->hostApplicationFromInitialize,

  3866.                 controller->hostApplicationFromFactory);

  3867. 

  3868.         // we require a host application for message creation

  3869.         v3_host_application** const host = controller->hostApplicationFromInitialize != nullptr

  3870.                                          ? controller->hostApplicationFromInitialize

  3871.                                         #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  3872.                                          : controller->hostApplicationFromComponent != nullptr

  3873.                                          ? controller->hostApplicationFromComponent

  3874.                                          : controller->hostApplicationFromComponentInitialize != nullptr

  3875.                                          ? controller->hostApplicationFromComponentInitialize

  3876.                                         #endif

  3877.                                          : controller->hostApplicationFromFactory;

  3878.         DISTRHO_SAFE_ASSERT_RETURN(host != nullptr, nullptr);

  3879. 

  3880.         v3_plugin_view** const view = dpf_plugin_view_create(host,

  3881.                                                              vst3->getInstancePointer(),

  3882.                                                              vst3->getSampleRate());

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

  3884. 

  3885.         v3_connection_point** uiconn = nullptr;

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

  3887.         {

  3888.             d_debug("view connection query ok %p", uiconn);

  3889.             controller->connectionCtrl2View = new dpf_ctrl2view_connection_point(controller->vst3);

  3890. 

  3891.             v3_connection_point** const ctrlconn = (v3_connection_point**)&controller->connectionCtrl2View;

  3892. 

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

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

  3895.         }

  3896.         else

  3897.         {

  3898.             controller->connectionCtrl2View = nullptr;

  3899.         }

  3900. 

  3901.         return view;

  3902.        #else

  3903.         return nullptr;

  3904.        #endif

  3905. 

  3906.         // maybe unused

  3907.         (void)self;

  3908.         (void)name;

  3909.     }

  3910. };

  3911. 

  3912. // --------------------------------------------------------------------------------------------------------------------

  3913. // dpf_process_context_requirements

  3914. 

  3915. struct dpf_process_context_requirements : v3_process_context_requirements_cpp {

  3916.     dpf_process_context_requirements()

  3917.     {

  3918.         // v3_funknown, static

  3919.         query_interface = query_interface_process_context_requirements;

  3920.         ref = dpf_static_ref;

  3921.         unref = dpf_static_unref;

  3922. 

  3923.         // v3_process_context_requirements

  3924.         req.get_process_context_requirements = get_process_context_requirements;

  3925.     }

  3926. 

  3927.     // ----------------------------------------------------------------------------------------------------------------

  3928.     // v3_funknown

  3929. 

  3930.     static v3_result V3_API query_interface_process_context_requirements(void* const self, const v3_tuid iid, void** const iface)

  3931.     {

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

  3933.             v3_tuid_match(iid, v3_process_context_requirements_iid))

  3934.         {

  3935.             d_debug("query_interface_process_context_requirements => %p %s %p | OK", self, tuid2str(iid), iface);

  3936.             *iface = self;

  3937.             return V3_OK;

  3938.         }

  3939. 

  3940.         d_debug("query_interface_process_context_requirements => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  3941. 

  3942.         *iface = nullptr;

  3943.         return V3_NO_INTERFACE;

  3944.     }

  3945. 

  3946.     // ----------------------------------------------------------------------------------------------------------------

  3947.     // v3_process_context_requirements

  3948. 

  3949.     static uint32_t V3_API get_process_context_requirements(void*)

  3950.     {

  3951.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  3952.         return 0x0

  3953.             | V3_PROCESS_CTX_NEED_CONTINUOUS_TIME  // V3_PROCESS_CTX_CONT_TIME_VALID

  3954.             | V3_PROCESS_CTX_NEED_PROJECT_TIME     // V3_PROCESS_CTX_PROJECT_TIME_VALID

  3955.             | V3_PROCESS_CTX_NEED_TEMPO            // V3_PROCESS_CTX_TEMPO_VALID

  3956.             | V3_PROCESS_CTX_NEED_TIME_SIG         // V3_PROCESS_CTX_TIME_SIG_VALID

  3957.             | V3_PROCESS_CTX_NEED_TRANSPORT_STATE; // V3_PROCESS_CTX_PLAYING

  3958.        #else

  3959.         return 0x0;

  3960.        #endif

  3961.     }

  3962. 

  3963.     DISTRHO_PREVENT_HEAP_ALLOCATION

  3964. };

  3965. 

  3966. // --------------------------------------------------------------------------------------------------------------------

  3967. // dpf_audio_processor

  3968. 

  3969. struct dpf_audio_processor : v3_audio_processor_cpp {

  3970.     std::atomic_int refcounter;

  3971.     ScopedPointer<PluginVst3>& vst3;

  3972. 

  3973.     dpf_audio_processor(ScopedPointer<PluginVst3>& v)

  3974.         : refcounter(1),

  3975.           vst3(v)

  3976.     {

  3977.         // v3_funknown, single instance

  3978.         query_interface = query_interface_audio_processor;

  3979.         ref = dpf_single_instance_ref<dpf_audio_processor>;

  3980.         unref = dpf_single_instance_unref<dpf_audio_processor>;

  3981. 

  3982.         // v3_audio_processor

  3983.         proc.set_bus_arrangements = set_bus_arrangements;

  3984.         proc.get_bus_arrangement = get_bus_arrangement;

  3985.         proc.can_process_sample_size = can_process_sample_size;

  3986.         proc.get_latency_samples = get_latency_samples;

  3987.         proc.setup_processing = setup_processing;

  3988.         proc.set_processing = set_processing;

  3989.         proc.process = process;

  3990.         proc.get_tail_samples = get_tail_samples;

  3991.     }

  3992. 

  3993.     // ----------------------------------------------------------------------------------------------------------------

  3994.     // v3_funknown

  3995. 

  3996.     static v3_result V3_API query_interface_audio_processor(void* const self, const v3_tuid iid, void** const iface)

  3997.     {

  3998.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  3999. 

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

  4001.             v3_tuid_match(iid, v3_audio_processor_iid))

  4002.         {

  4003.             d_debug("query_interface_audio_processor => %p %s %p | OK", self, tuid2str(iid), iface);

  4004.             ++processor->refcounter;

  4005.             *iface = self;

  4006.             return V3_OK;

  4007.         }

  4008. 

  4009.         if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  4010.         {

  4011.             d_debug("query_interface_audio_processor => %p %s %p | OK convert static", self, tuid2str(iid), iface);

  4012.             static dpf_process_context_requirements context_req;

  4013.             static dpf_process_context_requirements* context_req_ptr = &context_req;

  4014.             *iface = &context_req_ptr;

  4015.             return V3_OK;

  4016.         }

  4017. 

  4018.         d_debug("query_interface_audio_processor => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  4019. 

  4020.         *iface = nullptr;

  4021.         return V3_NO_INTERFACE;

  4022.     }

  4023. 

  4024.     // ----------------------------------------------------------------------------------------------------------------

  4025.     // v3_audio_processor

  4026. 

  4027.     static v3_result V3_API set_bus_arrangements(void* const self,

  4028.                                                  v3_speaker_arrangement* const inputs, const int32_t num_inputs,

  4029.                                                  v3_speaker_arrangement* const outputs, const int32_t num_outputs)

  4030.     {

  4031.         // NOTE this is called a bunch of times in JUCE hosts

  4032.         d_debug("dpf_audio_processor::set_bus_arrangements => %p %p %i %p %i",

  4033.                 self, inputs, num_inputs, outputs, num_outputs);

  4034.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4035. 

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

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

  4038. 

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

  4040.     }

  4041. 

  4042.     static v3_result V3_API get_bus_arrangement(void* const self, const int32_t bus_direction,

  4043.                                                 const int32_t idx, v3_speaker_arrangement* const arr)

  4044.     {

  4045.         d_debug("dpf_audio_processor::get_bus_arrangement => %p %s %i %p",

  4046.                 self, v3_bus_direction_str(bus_direction), idx, arr);

  4047.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4048. 

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

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

  4051. 

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

  4053.     }

  4054. 

  4055.     static v3_result V3_API can_process_sample_size(void*, const int32_t symbolic_sample_size)

  4056.     {

  4057.         // NOTE runs during RT

  4058.         // d_debug("dpf_audio_processor::can_process_sample_size => %i", symbolic_sample_size);

  4059.         return symbolic_sample_size == V3_SAMPLE_32 ? V3_OK : V3_NOT_IMPLEMENTED;

  4060.     }

  4061. 

  4062.     static uint32_t V3_API get_latency_samples(void* const self)

  4063.     {

  4064.         d_debug("dpf_audio_processor::get_latency_samples => %p", self);

  4065.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4066. 

  4067.         PluginVst3* const vst3 = processor->vst3;

  4068.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, 0);

  4069. 

  4070.         return processor->vst3->getLatencySamples();

  4071.     }

  4072. 

  4073.     static v3_result V3_API setup_processing(void* const self, v3_process_setup* const setup)

  4074.     {

  4075.         d_debug("dpf_audio_processor::setup_processing => %p %p", self, setup);

  4076.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4077. 

  4078.         PluginVst3* const vst3 = processor->vst3;

  4079.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4080. 

  4081.         d_debug("dpf_audio_processor::setup_processing => %p %p | %d %f", self, setup, setup->max_block_size, setup->sample_rate);

  4082. 

  4083.         d_nextBufferSize = setup->max_block_size;

  4084.         d_nextSampleRate = setup->sample_rate;

  4085.         return processor->vst3->setupProcessing(setup);

  4086.     }

  4087. 

  4088.     static v3_result V3_API set_processing(void* const self, const v3_bool state)

  4089.     {

  4090.         d_debug("dpf_audio_processor::set_processing => %p %u", self, state);

  4091.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4092. 

  4093.         PluginVst3* const vst3 = processor->vst3;

  4094.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4095. 

  4096.         return processor->vst3->setProcessing(state);

  4097.     }

  4098. 

  4099.     static v3_result V3_API process(void* const self, v3_process_data* const data)

  4100.     {

  4101.         // NOTE runs during RT

  4102.         // d_debug("dpf_audio_processor::process => %p", self);

  4103.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4104. 

  4105.         PluginVst3* const vst3 = processor->vst3;

  4106.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4107. 

  4108.         return processor->vst3->process(data);

  4109.     }

  4110. 

  4111.     static uint32_t V3_API get_tail_samples(void* const self)

  4112.     {

  4113.         d_debug("dpf_audio_processor::get_tail_samples => %p", self);

  4114.         dpf_audio_processor* const processor = *static_cast<dpf_audio_processor**>(self);

  4115. 

  4116.         PluginVst3* const vst3 = processor->vst3;

  4117.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, 0);

  4118. 

  4119.         return processor->vst3->getTailSamples();

  4120.     }

  4121. };

  4122. 

  4123. // --------------------------------------------------------------------------------------------------------------------

  4124. // dpf_component

  4125. 

  4126. struct dpf_component : v3_component_cpp {

  4127.     std::atomic_int refcounter;

  4128.     ScopedPointer<dpf_audio_processor> processor;

  4129.    #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4130.     ScopedPointer<dpf_comp2ctrl_connection_point> connectionComp2Ctrl;

  4131.    #else

  4132.     ScopedPointer<dpf_edit_controller> controller;

  4133.    #endif

  4134.     ScopedPointer<PluginVst3> vst3;

  4135.     v3_host_application** const hostApplicationFromFactory;

  4136.     v3_host_application** hostApplicationFromInitialize;

  4137. 

  4138.     dpf_component(v3_host_application** const host)

  4139.         : refcounter(1),

  4140.           hostApplicationFromFactory(host),

  4141.           hostApplicationFromInitialize(nullptr)

  4142.     {

  4143.         d_debug("dpf_component() with hostApplication %p", hostApplicationFromFactory);

  4144. 

  4145.         // make sure host application is valid through out this component lifetime

  4146.         if (hostApplicationFromFactory != nullptr)

  4147.             v3_cpp_obj_ref(hostApplicationFromFactory);

  4148. 

  4149.         // v3_funknown, everything custom

  4150.         query_interface = query_interface_component;

  4151.         ref = ref_component;

  4152.         unref = unref_component;

  4153. 

  4154.         // v3_plugin_base

  4155.         base.initialize = initialize;

  4156.         base.terminate = terminate;

  4157. 

  4158.         // v3_component

  4159.         comp.get_controller_class_id = get_controller_class_id;

  4160.         comp.set_io_mode = set_io_mode;

  4161.         comp.get_bus_count = get_bus_count;

  4162.         comp.get_bus_info = get_bus_info;

  4163.         comp.get_routing_info = get_routing_info;

  4164.         comp.activate_bus = activate_bus;

  4165.         comp.set_active = set_active;

  4166.         comp.set_state = set_state;

  4167.         comp.get_state = get_state;

  4168.     }

  4169. 

  4170.     ~dpf_component()

  4171.     {

  4172.         d_debug("~dpf_component()");

  4173.         processor = nullptr;

  4174.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4175.         connectionComp2Ctrl = nullptr;

  4176.        #else

  4177.         controller = nullptr;

  4178.        #endif

  4179.         vst3 = nullptr;

  4180. 

  4181.         if (hostApplicationFromFactory != nullptr)

  4182.             v3_cpp_obj_unref(hostApplicationFromFactory);

  4183.     }

  4184. 

  4185.     // ----------------------------------------------------------------------------------------------------------------

  4186.     // v3_funknown

  4187. 

  4188.     static v3_result V3_API query_interface_component(void* const self, const v3_tuid iid, void** const iface)

  4189.     {

  4190.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4191. 

  4192.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  4193.             v3_tuid_match(iid, v3_plugin_base_iid) ||

  4194.             v3_tuid_match(iid, v3_component_iid))

  4195.         {

  4196.             d_debug("query_interface_component => %p %s %p | OK", self, tuid2str(iid), iface);

  4197.             ++component->refcounter;

  4198.             *iface = self;

  4199.             return V3_OK;

  4200.         }

  4201. 

  4202.         if (v3_tuid_match(iid, v3_midi_mapping_iid))

  4203.         {

  4204.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  4205.             d_debug("query_interface_component => %p %s %p | OK convert static", self, tuid2str(iid), iface);

  4206.             static dpf_midi_mapping midi_mapping;

  4207.             static dpf_midi_mapping* midi_mapping_ptr = &midi_mapping;

  4208.             *iface = &midi_mapping_ptr;

  4209.             return V3_OK;

  4210.            #else

  4211.             d_debug("query_interface_component => %p %s %p | reject unused", self, tuid2str(iid), iface);

  4212.             *iface = nullptr;

  4213.             return V3_NO_INTERFACE;

  4214.            #endif

  4215.         }

  4216. 

  4217.         if (v3_tuid_match(iid, v3_audio_processor_iid))

  4218.         {

  4219.             d_debug("query_interface_component => %p %s %p | OK convert %p",

  4220.                     self, tuid2str(iid), iface, component->processor.get());

  4221. 

  4222.             if (component->processor == nullptr)

  4223.                 component->processor = new dpf_audio_processor(component->vst3);

  4224.             else

  4225.                 ++component->processor->refcounter;

  4226.             *iface = &component->processor;

  4227.             return V3_OK;

  4228.         }

  4229. 

  4230.         if (v3_tuid_match(iid, v3_connection_point_iid))

  4231.         {

  4232.            #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4233.             d_debug("query_interface_component => %p %s %p | OK convert %p",

  4234.                     self, tuid2str(iid), iface, component->connectionComp2Ctrl.get());

  4235. 

  4236.             if (component->connectionComp2Ctrl == nullptr)

  4237.                 component->connectionComp2Ctrl = new dpf_comp2ctrl_connection_point(component->vst3);

  4238.             else

  4239.                 ++component->connectionComp2Ctrl->refcounter;

  4240.             *iface = &component->connectionComp2Ctrl;

  4241.             return V3_OK;

  4242.            #else

  4243.             d_debug("query_interface_component => %p %s %p | reject unwanted", self, tuid2str(iid), iface);

  4244.             *iface = nullptr;

  4245.             return V3_NO_INTERFACE;

  4246.            #endif

  4247.         }

  4248. 

  4249.         if (v3_tuid_match(iid, v3_edit_controller_iid))

  4250.         {

  4251.            #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  4252.             d_debug("query_interface_component => %p %s %p | OK convert %p",

  4253.                     self, tuid2str(iid), iface, component->controller.get());

  4254. 

  4255.             if (component->controller == nullptr)

  4256.                 component->controller = new dpf_edit_controller(component->vst3,

  4257.                                                                 component->hostApplicationFromFactory,

  4258.                                                                 component->hostApplicationFromInitialize);

  4259.             else

  4260.                 ++component->controller->refcounter;

  4261.             *iface = &component->controller;

  4262.             return V3_OK;

  4263.            #else

  4264.             d_debug("query_interface_component => %p %s %p | reject unwanted", self, tuid2str(iid), iface);

  4265.             *iface = nullptr;

  4266.             return V3_NO_INTERFACE;

  4267.            #endif

  4268.         }

  4269. 

  4270.         d_debug("query_interface_component => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  4271.         *iface = nullptr;

  4272.         return V3_NO_INTERFACE;

  4273.     }

  4274. 

  4275.     static uint32_t V3_API ref_component(void* const self)

  4276.     {

  4277.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4278.         const int refcount = ++component->refcounter;

  4279.         d_debug("dpf_component::ref => %p | refcount %i", self, refcount);

  4280.         return refcount;

  4281.     }

  4282. 

  4283.     static uint32_t V3_API unref_component(void* const self)

  4284.     {

  4285.         dpf_component** const componentptr = static_cast<dpf_component**>(self);

  4286.         dpf_component* const component = *componentptr;

  4287. 

  4288.         if (const int refcount = --component->refcounter)

  4289.         {

  4290.             d_debug("dpf_component::unref => %p | refcount %i", self, refcount);

  4291.             return refcount;

  4292.         }

  4293. 

  4294.         /**

  4295.          * Some hosts will have unclean instances of a few of the component child classes at this point.

  4296.          * We check for those here, going through the whole possible chain to see if it is safe to delete.

  4297.          * If not, we add this component to the `gComponentGarbage` global which will take care of it during unload.

  4298.          */

  4299. 

  4300.         bool unclean = false;

  4301. 

  4302.         if (dpf_audio_processor* const proc = component->processor)

  4303.         {

  4304.             if (const int refcount = proc->refcounter)

  4305.             {

  4306.                 unclean = true;

  4307.                 d_stderr("DPF warning: asked to delete component while audio processor still active (refcount %d)", refcount);

  4308.             }

  4309.         }

  4310. 

  4311.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4312.         if (dpf_comp2ctrl_connection_point* const point = component->connectionComp2Ctrl)

  4313.         {

  4314.             if (const int refcount = point->refcounter)

  4315.             {

  4316.                 unclean = true;

  4317.                 d_stderr("DPF warning: asked to delete component while connection point still active (refcount %d)", refcount);

  4318.             }

  4319.         }

  4320.        #else

  4321.         if (dpf_edit_controller* const controller = component->controller)

  4322.         {

  4323.             if (const int refcount = controller->refcounter)

  4324.             {

  4325.                 unclean = true;

  4326.                 d_stderr("DPF warning: asked to delete component while edit controller still active (refcount %d)", refcount);

  4327.             }

  4328.         }

  4329.        #endif

  4330. 

  4331.         if (unclean)

  4332.             return handleUncleanComponent(componentptr);

  4333. 

  4334.         d_debug("dpf_component::unref => %p | refcount is zero, deleting everything now!", self);

  4335. 

  4336.         delete component;

  4337.         delete componentptr;

  4338.         return 0;

  4339.     }

  4340. 

  4341.     // ----------------------------------------------------------------------------------------------------------------

  4342.     // v3_plugin_base

  4343. 

  4344.     static v3_result V3_API initialize(void* const self, v3_funknown** const context)

  4345.     {

  4346.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4347. 

  4348.         // check if already initialized

  4349.         DISTRHO_SAFE_ASSERT_RETURN(component->vst3 == nullptr, V3_INVALID_ARG);

  4350. 

  4351.         // query for host application

  4352.         v3_host_application** hostApplication = nullptr;

  4353.         if (context != nullptr)

  4354.             v3_cpp_obj_query_interface(context, v3_host_application_iid, &hostApplication);

  4355. 

  4356.         d_debug("dpf_component::initialize => %p %p | hostApplication %p", self, context, hostApplication);

  4357. 

  4358.         // save it for later so we can unref it

  4359.         component->hostApplicationFromInitialize = hostApplication;

  4360. 

  4361.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  4362.         // save it in edit controller too, needed for some hosts

  4363.         if (component->controller != nullptr)

  4364.             component->controller->hostApplicationFromComponentInitialize = hostApplication;

  4365.        #endif

  4366. 

  4367.         // provide the factory application to the plugin if this new one is missing

  4368.         if (hostApplication == nullptr)

  4369.             hostApplication = component->hostApplicationFromFactory;

  4370. 

  4371.         // default early values

  4372.         if (d_nextBufferSize == 0)

  4373.             d_nextBufferSize = 1024;

  4374.         if (d_nextSampleRate <= 0.0)

  4375.             d_nextSampleRate = 44100.0;

  4376. 

  4377.         d_nextCanRequestParameterValueChanges = true;

  4378. 

  4379.         // create the actual plugin

  4380.         component->vst3 = new PluginVst3(hostApplication, true);

  4381. 

  4382.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4383.         // set connection point if needed

  4384.         if (dpf_comp2ctrl_connection_point* const point = component->connectionComp2Ctrl)

  4385.         {

  4386.             if (point->other != nullptr)

  4387.                 component->vst3->comp2ctrl_connect(point->other);

  4388.         }

  4389.        #endif

  4390. 

  4391.         return V3_OK;

  4392.     }

  4393. 

  4394.     static v3_result V3_API terminate(void* const self)

  4395.     {

  4396.         d_debug("dpf_component::terminate => %p", self);

  4397.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4398. 

  4399.         // check if already terminated

  4400.         DISTRHO_SAFE_ASSERT_RETURN(component->vst3 != nullptr, V3_INVALID_ARG);

  4401. 

  4402.         // delete actual plugin

  4403.         component->vst3 = nullptr;

  4404. 

  4405.        #if !DPF_VST3_USES_SEPARATE_CONTROLLER

  4406.         // remove previous host application saved during initialize

  4407.         if (component->controller != nullptr)

  4408.             component->controller->hostApplicationFromComponentInitialize = nullptr;

  4409.        #endif

  4410. 

  4411.         // unref host application received during initialize

  4412.         if (component->hostApplicationFromInitialize != nullptr)

  4413.         {

  4414.             v3_cpp_obj_unref(component->hostApplicationFromInitialize);

  4415.             component->hostApplicationFromInitialize = nullptr;

  4416.         }

  4417. 

  4418.         return V3_OK;

  4419.     }

  4420. 

  4421.     // ----------------------------------------------------------------------------------------------------------------

  4422.     // v3_component

  4423. 

  4424.     static v3_result V3_API get_controller_class_id(void*, v3_tuid class_id)

  4425.     {

  4426.         d_debug("dpf_component::get_controller_class_id => %p", class_id);

  4427. 

  4428.         std::memcpy(class_id, dpf_tuid_controller, sizeof(v3_tuid));

  4429.         return V3_OK;

  4430.     }

  4431. 

  4432.     static v3_result V3_API set_io_mode(void* const self, const int32_t io_mode)

  4433.     {

  4434.         d_debug("dpf_component::set_io_mode => %p %i", self, io_mode);

  4435. 

  4436.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4437. 

  4438.         PluginVst3* const vst3 = component->vst3;

  4439.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4440. 

  4441.         // TODO

  4442.         return V3_NOT_IMPLEMENTED;

  4443. 

  4444.         // unused

  4445.         (void)io_mode;

  4446.     }

  4447. 

  4448.     static int32_t V3_API get_bus_count(void* const self, const int32_t media_type, const int32_t bus_direction)

  4449.     {

  4450.         // NOTE runs during RT

  4451.         // d_debug("dpf_component::get_bus_count => %p %s %s",

  4452.         //          self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction));

  4453.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4454. 

  4455.         PluginVst3* const vst3 = component->vst3;

  4456.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4457. 

  4458.         const int32_t ret = vst3->getBusCount(media_type, bus_direction);

  4459.         // d_debug("dpf_component::get_bus_count returns %i", ret);

  4460.         return ret;

  4461.     }

  4462. 

  4463.     static v3_result V3_API get_bus_info(void* const self, const int32_t media_type, const int32_t bus_direction,

  4464.                                          const int32_t bus_idx, v3_bus_info* const info)

  4465.     {

  4466.         d_debug("dpf_component::get_bus_info => %p %s %s %i %p",

  4467.                 self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction), bus_idx, info);

  4468.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4469. 

  4470.         PluginVst3* const vst3 = component->vst3;

  4471.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4472. 

  4473.         return vst3->getBusInfo(media_type, bus_direction, bus_idx, info);

  4474.     }

  4475. 

  4476.     static v3_result V3_API get_routing_info(void* const self, v3_routing_info* const input, v3_routing_info* const output)

  4477.     {

  4478.         d_debug("dpf_component::get_routing_info => %p %p %p", self, input, output);

  4479.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4480. 

  4481.         PluginVst3* const vst3 = component->vst3;

  4482.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4483. 

  4484.         return vst3->getRoutingInfo(input, output);

  4485.     }

  4486. 

  4487.     static v3_result V3_API activate_bus(void* const self, const int32_t media_type, const int32_t bus_direction,

  4488.                                          const int32_t bus_idx, const v3_bool state)

  4489.     {

  4490.         // NOTE this is called a bunch of times

  4491.         // d_debug("dpf_component::activate_bus => %p %s %s %i %u",

  4492.         //         self, v3_media_type_str(media_type), v3_bus_direction_str(bus_direction), bus_idx, state);

  4493.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4494. 

  4495.         PluginVst3* const vst3 = component->vst3;

  4496.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4497. 

  4498.         return vst3->activateBus(media_type, bus_direction, bus_idx, state);

  4499.     }

  4500. 

  4501.     static v3_result V3_API set_active(void* const self, const v3_bool state)

  4502.     {

  4503.         d_debug("dpf_component::set_active => %p %u", self, state);

  4504.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4505. 

  4506.         PluginVst3* const vst3 = component->vst3;

  4507.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4508. 

  4509.         return component->vst3->setActive(state);

  4510.     }

  4511. 

  4512.     static v3_result V3_API set_state(void* const self, v3_bstream** const stream)

  4513.     {

  4514.         d_debug("dpf_component::set_state => %p", self);

  4515.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4516. 

  4517.         PluginVst3* const vst3 = component->vst3;

  4518.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4519. 

  4520.         return vst3->setState(stream);

  4521.     }

  4522. 

  4523.     static v3_result V3_API get_state(void* const self, v3_bstream** const stream)

  4524.     {

  4525.         d_debug("dpf_component::get_state => %p %p", self, stream);

  4526.         dpf_component* const component = *static_cast<dpf_component**>(self);

  4527. 

  4528.         PluginVst3* const vst3 = component->vst3;

  4529.         DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALIZED);

  4530. 

  4531.         return vst3->getState(stream);

  4532.     }

  4533. };

  4534. 

  4535. // --------------------------------------------------------------------------------------------------------------------

  4536. // Dummy plugin to get data from

  4537. 

  4538. static ScopedPointer<PluginExporter> sPlugin;

  4539. 

  4540. static const char* getPluginCategories()

  4541. {

  4542.     static String categories;

  4543.     static bool firstInit = true;

  4544. 

  4545.     if (firstInit)

  4546.     {

  4547.        #ifdef DISTRHO_PLUGIN_VST3_CATEGORIES

  4548.         categories = DISTRHO_PLUGIN_VST3_CATEGORIES;

  4549.        #elif DISTRHO_PLUGIN_IS_SYNTH

  4550.         categories = "Instrument";

  4551.        #endif

  4552.         firstInit = false;

  4553.     }

  4554. 

  4555.     return categories.buffer();

  4556. }

  4557. 

  4558. static const char* getPluginVersion()

  4559. {

  4560.     static String version;

  4561. 

  4562.     if (version.isEmpty())

  4563.     {

  4564.         const uint32_t versionNum = sPlugin->getVersion();

  4565. 

  4566.         char versionBuf[64];

  4567.         std::snprintf(versionBuf, sizeof(versionBuf)-1, "%d.%d.%d",

  4568.                       (versionNum >> 16) & 0xff,

  4569.                       (versionNum >>  8) & 0xff,

  4570.                       (versionNum >>  0) & 0xff);

  4571.         versionBuf[sizeof(versionBuf)-1] = '\0';

  4572.         version = versionBuf;

  4573.     }

  4574. 

  4575.     return version.buffer();

  4576. }

  4577. 

  4578. // --------------------------------------------------------------------------------------------------------------------

  4579. // dpf_factory

  4580. 

  4581. struct dpf_factory : v3_plugin_factory_cpp {

  4582.     std::atomic_int refcounter;

  4583. 

  4584.     // cached values

  4585.     v3_funknown** hostContext;

  4586. 

  4587.     dpf_factory()

  4588.         : refcounter(1),

  4589.           hostContext(nullptr)

  4590.     {

  4591.         // v3_funknown, static

  4592.         query_interface = query_interface_factory;

  4593.         ref = ref_factory;

  4594.         unref = unref_factory;

  4595. 

  4596.         // v3_plugin_factory

  4597.         v1.get_factory_info = get_factory_info;

  4598.         v1.num_classes = num_classes;

  4599.         v1.get_class_info = get_class_info;

  4600.         v1.create_instance = create_instance;

  4601. 

  4602.         // v3_plugin_factory_2

  4603.         v2.get_class_info_2 = get_class_info_2;

  4604. 

  4605.         // v3_plugin_factory_3

  4606.         v3.get_class_info_utf16 = get_class_info_utf16;

  4607.         v3.set_host_context = set_host_context;

  4608.     }

  4609. 

  4610.     ~dpf_factory()

  4611.     {

  4612.         // unref old context if there is one

  4613.         if (hostContext != nullptr)

  4614.             v3_cpp_obj_unref(hostContext);

  4615. 

  4616.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4617.         if (gControllerGarbage.size() != 0)

  4618.         {

  4619.             d_debug("DPF notice: cleaning up previously undeleted controllers now");

  4620. 

  4621.             for (std::vector<dpf_edit_controller**>::iterator it = gControllerGarbage.begin();

  4622.                 it != gControllerGarbage.end(); ++it)

  4623.             {

  4624.                 dpf_edit_controller** const controllerptr = *it;

  4625.                 dpf_edit_controller* const controller = *controllerptr;

  4626.                 delete controller;

  4627.                 delete controllerptr;

  4628.             }

  4629. 

  4630.             gControllerGarbage.clear();

  4631.         }

  4632.        #endif

  4633. 

  4634.         if (gComponentGarbage.size() != 0)

  4635.         {

  4636.             d_debug("DPF notice: cleaning up previously undeleted components now");

  4637. 

  4638.             for (std::vector<dpf_component**>::iterator it = gComponentGarbage.begin();

  4639.                 it != gComponentGarbage.end(); ++it)

  4640.             {

  4641.                 dpf_component** const componentptr = *it;

  4642.                 dpf_component* const component = *componentptr;

  4643.                 delete component;

  4644.                 delete componentptr;

  4645.             }

  4646. 

  4647.             gComponentGarbage.clear();

  4648.         }

  4649.     }

  4650. 

  4651.     // ----------------------------------------------------------------------------------------------------------------

  4652.     // v3_funknown

  4653. 

  4654.     static v3_result V3_API query_interface_factory(void* const self, const v3_tuid iid, void** const iface)

  4655.     {

  4656.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4657. 

  4658.         if (v3_tuid_match(iid, v3_funknown_iid) ||

  4659.             v3_tuid_match(iid, v3_plugin_factory_iid) ||

  4660.             v3_tuid_match(iid, v3_plugin_factory_2_iid) ||

  4661.             v3_tuid_match(iid, v3_plugin_factory_3_iid))

  4662.         {

  4663.             d_debug("query_interface_factory => %p %s %p | OK", self, tuid2str(iid), iface);

  4664.             ++factory->refcounter;

  4665.             *iface = self;

  4666.             return V3_OK;

  4667.         }

  4668. 

  4669.         d_debug("query_interface_factory => %p %s %p | WARNING UNSUPPORTED", self, tuid2str(iid), iface);

  4670. 

  4671.         *iface = nullptr;

  4672.         return V3_NO_INTERFACE;

  4673.     }

  4674. 

  4675.     static uint32_t V3_API ref_factory(void* const self)

  4676.     {

  4677.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4678.         const int refcount = ++factory->refcounter;

  4679.         d_debug("ref_factory::ref => %p | refcount %i", self, refcount);

  4680.         return refcount;

  4681.     }

  4682. 

  4683.     static uint32_t V3_API unref_factory(void* const self)

  4684.     {

  4685.         dpf_factory** const factoryptr = static_cast<dpf_factory**>(self);

  4686.         dpf_factory* const factory = *factoryptr;

  4687. 

  4688.         if (const int refcount = --factory->refcounter)

  4689.         {

  4690.             d_debug("unref_factory::unref => %p | refcount %i", self, refcount);

  4691.             return refcount;

  4692.         }

  4693. 

  4694.         d_debug("unref_factory::unref => %p | refcount is zero, deleting factory", self);

  4695. 

  4696.         delete factory;

  4697.         delete factoryptr;

  4698.         return 0;

  4699.     }

  4700. 

  4701.     // ----------------------------------------------------------------------------------------------------------------

  4702.     // v3_plugin_factory

  4703. 

  4704.     static v3_result V3_API get_factory_info(void*, v3_factory_info* const info)

  4705.     {

  4706.         d_debug("dpf_factory::get_factory_info => %p", info);

  4707.         std::memset(info, 0, sizeof(*info));

  4708. 

  4709.         info->flags = 0x10; // unicode

  4710.         DISTRHO_NAMESPACE::strncpy(info->vendor, sPlugin->getMaker(), ARRAY_SIZE(info->vendor));

  4711.         DISTRHO_NAMESPACE::strncpy(info->url, sPlugin->getHomePage(), ARRAY_SIZE(info->url));

  4712.         // DISTRHO_NAMESPACE::strncpy(info->email, "", ARRAY_SIZE(info->email)); // TODO

  4713.         return V3_OK;

  4714.     }

  4715. 

  4716.     static int32_t V3_API num_classes(void*)

  4717.     {

  4718.         d_debug("dpf_factory::num_classes");

  4719.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4720.         return 2; // factory can create component and edit-controller

  4721.        #else

  4722.         return 1; // factory can only create component, edit-controller must be casted

  4723.        #endif

  4724.     }

  4725. 

  4726.     static v3_result V3_API get_class_info(void*, const int32_t idx, v3_class_info* const info)

  4727.     {

  4728.         d_debug("dpf_factory::get_class_info => %i %p", idx, info);

  4729.         std::memset(info, 0, sizeof(*info));

  4730.         DISTRHO_SAFE_ASSERT_RETURN(idx <= 2, V3_INVALID_ARG);

  4731. 

  4732.         info->cardinality = 0x7FFFFFFF;

  4733.         DISTRHO_NAMESPACE::strncpy(info->name, sPlugin->getName(), ARRAY_SIZE(info->name));

  4734. 

  4735.         if (idx == 0)

  4736.         {

  4737.             std::memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  4738.             DISTRHO_NAMESPACE::strncpy(info->category, "Audio Module Class", ARRAY_SIZE(info->category));

  4739.         }

  4740.         else

  4741.         {

  4742.             std::memcpy(info->class_id, dpf_tuid_controller, sizeof(v3_tuid));

  4743.             DISTRHO_NAMESPACE::strncpy(info->category, "Component Controller Class", ARRAY_SIZE(info->category));

  4744.         }

  4745. 

  4746.         return V3_OK;

  4747.     }

  4748. 

  4749.     static v3_result V3_API create_instance(void* self, const v3_tuid class_id, const v3_tuid iid, void** const instance)

  4750.     {

  4751.         d_debug("dpf_factory::create_instance => %p %s %s %p", self, tuid2str(class_id), tuid2str(iid), instance);

  4752.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4753. 

  4754.         // query for host application

  4755.         v3_host_application** hostApplication = nullptr;

  4756.         if (factory->hostContext != nullptr)

  4757.             v3_cpp_obj_query_interface(factory->hostContext, v3_host_application_iid, &hostApplication);

  4758. 

  4759.         // create component

  4760.         if (v3_tuid_match(class_id, *(const v3_tuid*)&dpf_tuid_class) && (v3_tuid_match(iid, v3_component_iid) ||

  4761.                                                                           v3_tuid_match(iid, v3_funknown_iid)))

  4762.         {

  4763.             dpf_component** const componentptr = new dpf_component*;

  4764.             *componentptr = new dpf_component(hostApplication);

  4765.             *instance = static_cast<void*>(componentptr);

  4766.             return V3_OK;

  4767.         }

  4768. 

  4769.        #if DPF_VST3_USES_SEPARATE_CONTROLLER

  4770.         // create edit controller

  4771.         if (v3_tuid_match(class_id, *(const v3_tuid*)&dpf_tuid_controller) && (v3_tuid_match(iid, v3_edit_controller_iid) ||

  4772.                                                                                v3_tuid_match(iid, v3_funknown_iid)))

  4773.         {

  4774.             dpf_edit_controller** const controllerptr = new dpf_edit_controller*;

  4775.             *controllerptr = new dpf_edit_controller(hostApplication);

  4776.             *instance = static_cast<void*>(controllerptr);

  4777.             return V3_OK;

  4778.         }

  4779.        #endif

  4780. 

  4781.         // unsupported, roll back host application

  4782.         if (hostApplication != nullptr)

  4783.             v3_cpp_obj_unref(hostApplication);

  4784. 

  4785.         return V3_NO_INTERFACE;

  4786.     }

  4787. 

  4788.     // ----------------------------------------------------------------------------------------------------------------

  4789.     // v3_plugin_factory_2

  4790. 

  4791.     static v3_result V3_API get_class_info_2(void*, const int32_t idx, v3_class_info_2* const info)

  4792.     {

  4793.         d_debug("dpf_factory::get_class_info_2 => %i %p", idx, info);

  4794.         std::memset(info, 0, sizeof(*info));

  4795.         DISTRHO_SAFE_ASSERT_RETURN(idx <= 2, V3_INVALID_ARG);

  4796. 

  4797.         info->cardinality = 0x7FFFFFFF;

  4798.        #if DPF_VST3_USES_SEPARATE_CONTROLLER || !DISTRHO_PLUGIN_HAS_UI

  4799.         info->class_flags = V3_DISTRIBUTABLE;

  4800.        #endif

  4801.         DISTRHO_NAMESPACE::strncpy(info->sub_categories, getPluginCategories(), ARRAY_SIZE(info->sub_categories));

  4802.         DISTRHO_NAMESPACE::strncpy(info->name, sPlugin->getName(), ARRAY_SIZE(info->name));

  4803.         DISTRHO_NAMESPACE::strncpy(info->vendor, sPlugin->getMaker(), ARRAY_SIZE(info->vendor));

  4804.         DISTRHO_NAMESPACE::strncpy(info->version, getPluginVersion(), ARRAY_SIZE(info->version));

  4805.         DISTRHO_NAMESPACE::strncpy(info->sdk_version, "Travesty 3.7.4", ARRAY_SIZE(info->sdk_version));

  4806. 

  4807.         if (idx == 0)

  4808.         {

  4809.             std::memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  4810.             DISTRHO_NAMESPACE::strncpy(info->category, "Audio Module Class", ARRAY_SIZE(info->category));

  4811.         }

  4812.         else

  4813.         {

  4814.             std::memcpy(info->class_id, dpf_tuid_controller, sizeof(v3_tuid));

  4815.             DISTRHO_NAMESPACE::strncpy(info->category, "Component Controller Class", ARRAY_SIZE(info->category));

  4816.         }

  4817. 

  4818.         return V3_OK;

  4819.     }

  4820. 

  4821.     // ------------------------------------------------------------------------------------------------------------

  4822.     // v3_plugin_factory_3

  4823. 

  4824.     static v3_result V3_API get_class_info_utf16(void*, const int32_t idx, v3_class_info_3* const info)

  4825.     {

  4826.         d_debug("dpf_factory::get_class_info_utf16 => %i %p", idx, info);

  4827.         std::memset(info, 0, sizeof(*info));

  4828.         DISTRHO_SAFE_ASSERT_RETURN(idx <= 2, V3_INVALID_ARG);

  4829. 

  4830.         info->cardinality = 0x7FFFFFFF;

  4831.        #if DPF_VST3_USES_SEPARATE_CONTROLLER || !DISTRHO_PLUGIN_HAS_UI

  4832.         info->class_flags = V3_DISTRIBUTABLE;

  4833.        #endif

  4834.         DISTRHO_NAMESPACE::strncpy(info->sub_categories, getPluginCategories(), ARRAY_SIZE(info->sub_categories));

  4835.         DISTRHO_NAMESPACE::strncpy_utf16(info->name, sPlugin->getName(), ARRAY_SIZE(info->name));

  4836.         DISTRHO_NAMESPACE::strncpy_utf16(info->vendor, sPlugin->getMaker(), ARRAY_SIZE(info->vendor));

  4837.         DISTRHO_NAMESPACE::strncpy_utf16(info->version, getPluginVersion(), ARRAY_SIZE(info->version));

  4838.         DISTRHO_NAMESPACE::strncpy_utf16(info->sdk_version, "Travesty 3.7.4", ARRAY_SIZE(info->sdk_version));

  4839. 

  4840.         if (idx == 0)

  4841.         {

  4842.             std::memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  4843.             DISTRHO_NAMESPACE::strncpy(info->category, "Audio Module Class", ARRAY_SIZE(info->category));

  4844.         }

  4845.         else

  4846.         {

  4847.             std::memcpy(info->class_id, dpf_tuid_controller, sizeof(v3_tuid));

  4848.             DISTRHO_NAMESPACE::strncpy(info->category, "Component Controller Class", ARRAY_SIZE(info->category));

  4849.         }

  4850. 

  4851.         return V3_OK;

  4852.     }

  4853. 

  4854.     static v3_result V3_API set_host_context(void* const self, v3_funknown** const context)

  4855.     {

  4856.         d_debug("dpf_factory::set_host_context => %p %p", self, context);

  4857.         dpf_factory* const factory = *static_cast<dpf_factory**>(self);

  4858. 

  4859.         // unref old context if there is one

  4860.         if (factory->hostContext != nullptr)

  4861.             v3_cpp_obj_unref(factory->hostContext);

  4862. 

  4863.         // store new context

  4864.         factory->hostContext = context;

  4865. 

  4866.         // make sure the object keeps being valid for a while

  4867.         if (context != nullptr)

  4868.             v3_cpp_obj_ref(context);

  4869. 

  4870.         return V3_OK;

  4871.     }

  4872. };

  4873. 

  4874. END_NAMESPACE_DISTRHO

  4875. 

  4876. // --------------------------------------------------------------------------------------------------------------------

  4877. // VST3 entry point

  4878. 

  4879. DISTRHO_PLUGIN_EXPORT

  4880. const void* GetPluginFactory(void);

  4881. 

  4882. const void* GetPluginFactory(void)

  4883. {

  4884.     USE_NAMESPACE_DISTRHO;

  4885.     dpf_factory** const factoryptr = new dpf_factory*;

  4886.     *factoryptr = new dpf_factory;

  4887.     return static_cast<void*>(factoryptr);

  4888. }

  4889. 

  4890. // --------------------------------------------------------------------------------------------------------------------

  4891. // OS specific module load

  4892. 

  4893. #if defined(DISTRHO_OS_MAC)

  4894. # define ENTRYFNNAME bundleEntry

  4895. # define ENTRYFNNAMEARGS void*

  4896. # define EXITFNNAME bundleExit

  4897. #elif defined(DISTRHO_OS_WINDOWS)

  4898. # define ENTRYFNNAME InitDll

  4899. # define ENTRYFNNAMEARGS void

  4900. # define EXITFNNAME ExitDll

  4901. #else

  4902. # define ENTRYFNNAME ModuleEntry

  4903. # define ENTRYFNNAMEARGS void*

  4904. # define EXITFNNAME ModuleExit

  4905. #endif

  4906. 

  4907. DISTRHO_PLUGIN_EXPORT

  4908. bool ENTRYFNNAME(ENTRYFNNAMEARGS);

  4909. 

  4910. bool ENTRYFNNAME(ENTRYFNNAMEARGS)

  4911. {

  4912.     USE_NAMESPACE_DISTRHO;

  4913. 

  4914.     // find plugin bundle

  4915.     static String bundlePath;

  4916.     if (bundlePath.isEmpty())

  4917.     {

  4918.         String tmpPath(getBinaryFilename());

  4919.         tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  4920.         tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  4921. 

  4922.         if (tmpPath.endsWith(DISTRHO_OS_SEP_STR "Contents"))

  4923.         {

  4924.             tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  4925.             bundlePath = tmpPath;

  4926.             d_nextBundlePath = bundlePath.buffer();

  4927.         }

  4928.         else

  4929.         {

  4930.             bundlePath = "error";

  4931.         }

  4932.     }

  4933. 

  4934.     // init dummy plugin and set uniqueId

  4935.     if (sPlugin == nullptr)

  4936.     {

  4937.         // set valid but dummy values

  4938.         d_nextBufferSize = 512;

  4939.         d_nextSampleRate = 44100.0;

  4940.         d_nextPluginIsDummy = true;

  4941.         d_nextCanRequestParameterValueChanges = true;

  4942. 

  4943.         // Create dummy plugin to get data from

  4944.         sPlugin = new PluginExporter(nullptr, nullptr, nullptr, nullptr);

  4945. 

  4946.         // unset

  4947.         d_nextBufferSize = 0;

  4948.         d_nextSampleRate = 0.0;

  4949.         d_nextPluginIsDummy = false;

  4950.         d_nextCanRequestParameterValueChanges = false;

  4951. 

  4952.         dpf_tuid_class[2] = dpf_tuid_component[2] = dpf_tuid_controller[2]

  4953.             = dpf_tuid_processor[2] = dpf_tuid_view[2] = sPlugin->getUniqueId();

  4954.     }

  4955. 

  4956.     return true;

  4957. }

  4958. 

  4959. DISTRHO_PLUGIN_EXPORT

  4960. bool EXITFNNAME(void);

  4961. 

  4962. bool EXITFNNAME(void)

  4963. {

  4964.     DISTRHO_NAMESPACE::sPlugin = nullptr;

  4965.     return true;

  4966. }

  4967. 

  4968. #undef ENTRYFNNAME

  4969. #undef EXITFNNAME

  4970. 

  4971. // --------------------------------------------------------------------------------------------------------------------