From 2f1fc152ff55f3a00dae5087c3be99da32796a8a Mon Sep 17 00:00:00 2001 From: Nanako <469449812@qq.com> Date: Tue, 27 Feb 2024 17:55:28 +0800 Subject: [PATCH] vst2 host --- core/audio/device/audio_device_manager.cpp | 28 +- core/audio/device/audio_device_manager.h | 11 +- core/audio/misc/audio_buffer.h | 4 +- core/audio/mixer/channel_interface.cpp | 7 +- core/audio/mixer/mixer.cpp | 6 +- core/audio/mixer/mixer.h | 2 +- core/audio/mixer/mixer_track.cpp | 5 + core/audio/mixer/mixer_track.h | 4 + core/audio/plugin_host/midi_sequencer.cpp | 9 + core/audio/plugin_host/midi_sequencer.h | 3 +- core/audio/plugin_host/plugin_host.cpp | 16 + core/audio/plugin_host/plugin_host.h | 26 +- .../audio/plugin_host/plugin_host_manager.cpp | 12 +- core/audio/plugin_host/plugin_host_manager.h | 6 +- .../vst2/pluginterfaces/vst2.x/aeffect.h | 396 ++++++ .../vst2/pluginterfaces/vst2.x/aeffectx.h | 1170 +++++++++++++++++ .../vst2/pluginterfaces/vst2.x/vstfxstore.h | 128 ++ .../plugin_host/vst2/vst2_plugin_host.cpp | 266 ++++ .../audio/plugin_host/vst2/vst2_plugin_host.h | 38 + core/misc/glfw_misc.cpp | 20 + core/misc/glfw_misc.h | 7 + core/misc/lib_load.h | 62 + core/misc/singleton/singleton.h | 9 + core/rhi/renderer.h | 6 +- 24 files changed, 2216 insertions(+), 25 deletions(-) create mode 100644 core/audio/plugin_host/vst2/pluginterfaces/vst2.x/aeffect.h create mode 100644 core/audio/plugin_host/vst2/pluginterfaces/vst2.x/aeffectx.h create mode 100644 core/audio/plugin_host/vst2/pluginterfaces/vst2.x/vstfxstore.h create mode 100644 core/audio/plugin_host/vst2/vst2_plugin_host.cpp create mode 100644 core/audio/plugin_host/vst2/vst2_plugin_host.h create mode 100644 core/misc/glfw_misc.cpp create mode 100644 core/misc/glfw_misc.h create mode 100644 core/misc/lib_load.h diff --git a/core/audio/device/audio_device_manager.cpp b/core/audio/device/audio_device_manager.cpp index 626b3f2..0902526 100644 --- a/core/audio/device/audio_device_manager.cpp +++ b/core/audio/device/audio_device_manager.cpp @@ -6,7 +6,7 @@ void audio_device_manager::init(singleton_initliazer& initliazer) { singleton_t::init(initliazer); - initliazer.require(); + dummy_audio_device_ = new dummy_audio_device(); main_audio_device_ = new port_audio_device(); @@ -19,3 +19,29 @@ void audio_device_manager::release() { delete dummy_audio_device_; delete main_audio_device_; } + +double audio_device_manager::get_sample_rate() const { + return main_audio_device_->sample_rate(); +} + +void audio_device_manager::set_sample_rate(double sample_rate) { + main_audio_device_->set_sample_rate(sample_rate); + dummy_audio_device_->set_sample_rate(sample_rate); +} + +uint32_t audio_device_manager::get_buffer_size() const { + return main_audio_device_->buffer_size(); +} + +void audio_device_manager::set_buffer_size(int buffer_size) { + main_audio_device_->set_buffer_size(buffer_size); + dummy_audio_device_->set_buffer_size(buffer_size); +} + +uint32_t audio_device_manager::get_input_channel_count() const { + return 0; +} + +uint32_t audio_device_manager::get_output_channel_count() const { + return 2; // 现在是固定值, 以后可能会改 +} diff --git a/core/audio/device/audio_device_manager.h b/core/audio/device/audio_device_manager.h index 506c979..2636117 100644 --- a/core/audio/device/audio_device_manager.h +++ b/core/audio/device/audio_device_manager.h @@ -9,10 +9,17 @@ public: void init(singleton_initliazer& initliazer) override; void release() override; - const char* get_name() override { return "audio_device_manager"; } + [[nodiscard]] const char* get_name() override { return "audio_device_manager"; } + + [[nodiscard]] double get_sample_rate() const; + void set_sample_rate(double sample_rate); + [[nodiscard]] uint32_t get_buffer_size() const; + void set_buffer_size(int buffer_size); + [[nodiscard]] uint32_t get_input_channel_count() const; + [[nodiscard]] uint32_t get_output_channel_count() const; private: port_audio_device* main_audio_device_ = nullptr; dummy_audio_device* dummy_audio_device_ = nullptr; }; -CORE_API inline audio_device_manager g_audio_device_manager; +DEFINE_SINGLETON_INSTANCE(audio_device_manager) diff --git a/core/audio/misc/audio_buffer.h b/core/audio/misc/audio_buffer.h index 8ad95e3..2a58413 100644 --- a/core/audio/misc/audio_buffer.h +++ b/core/audio/misc/audio_buffer.h @@ -16,6 +16,6 @@ public: private: std::vector> buffer_; - std::vector headers_; - std::mutex lock_; + std::vector headers_{}; + std::mutex lock_{}; }; diff --git a/core/audio/mixer/channel_interface.cpp b/core/audio/mixer/channel_interface.cpp index 290e7e6..ef0a2a6 100644 --- a/core/audio/mixer/channel_interface.cpp +++ b/core/audio/mixer/channel_interface.cpp @@ -1,6 +1,7 @@ #include "channel_interface.h" #include "channel_node.h" +#include "mixer.h" channel_interface::channel_interface(uint32_t input_channels, uint32_t output_channels) { const uint32_t input_node_num = input_channels / 2; @@ -32,7 +33,8 @@ void channel_interface::set_input_channel(uint32_t node_index, channel_node* nod input_headers_[node_index * 2] = node_headers[0]; input_headers_[node_index * 2 + 1] = node_headers[1]; - // TODO rebuild process node + + g_mixer.request_build_process_node(); } void channel_interface::set_input_channel(const std::vector& nodes, uint32_t start_index) { @@ -52,7 +54,8 @@ void channel_interface::set_output_channel(uint32_t node_index, channel_node* no output_headers_[node_index * 2] = node_headers[0]; output_headers_[node_index * 2 + 1] = node_headers[1]; - // TODO rebuild process node + + g_mixer.request_build_process_node(); } void channel_interface::set_output_channel(const std::vector& nodes, uint32_t start_index) { diff --git a/core/audio/mixer/mixer.cpp b/core/audio/mixer/mixer.cpp index 68d4d7f..af710fc 100644 --- a/core/audio/mixer/mixer.cpp +++ b/core/audio/mixer/mixer.cpp @@ -3,6 +3,7 @@ #include "channel_interface.h" #include "channel_node.h" #include "mixer_track.h" +#include "audio/device/audio_device_manager.h" #include "audio/plugin_host/plugin_host.h" #include "audio/plugin_host/plugin_host_manager.h" #include "thread_message/thread_message_hubs.h" @@ -46,7 +47,7 @@ int32_t build_process_node_internal(mixer_track* track, std::mapeffects) { - build_effect_channel_interface(ChildTrack, effect->interface.get(), processed_tracks); + build_effect_channel_interface(ChildTrack, effect->channel, processed_tracks); } } return ++layer; @@ -55,12 +56,13 @@ int32_t build_process_node_internal(mixer_track* track, std::map& processed_tracks) { for (mixer_track* Track : host->owner_tracks) { - build_effect_channel_interface(Track, host->interface.get(), processed_tracks); + build_effect_channel_interface(Track, host->channel, processed_tracks); } } void mixer::init(singleton_initliazer& initliazer) { singleton_t::init(initliazer); + initliazer.require(); zero_track = new dummy_track(); zero_track->rename("zero"); zero_track->init(); diff --git a/core/audio/mixer/mixer.h b/core/audio/mixer/mixer.h index 9cf2504..ead5c1b 100644 --- a/core/audio/mixer/mixer.h +++ b/core/audio/mixer/mixer.h @@ -42,4 +42,4 @@ private: std::vector layer_order_; }; -CORE_API inline mixer g_mixer; +DEFINE_SINGLETON_INSTANCE(mixer) diff --git a/core/audio/mixer/mixer_track.cpp b/core/audio/mixer/mixer_track.cpp index 9fc3032..476efad 100644 --- a/core/audio/mixer/mixer_track.cpp +++ b/core/audio/mixer/mixer_track.cpp @@ -1,5 +1,7 @@ #include "mixer_track.h" +#include "channel_interface.h" +#include "audio/device/audio_device_manager.h" #include "audio/plugin_host/plugin_host.h" mixer_track::~mixer_track() { @@ -7,7 +9,10 @@ mixer_track::~mixer_track() { } void mixer_track::init() { + const uint32_t channel_count = g_audio_device_manager.get_output_channel_count(); + buffer.resize(channel_count, g_audio_device_manager.get_buffer_size()); + channel_interface_ = new mixer_channel_interface(this); } void mixer_track::add_effect(plugin_host* in_effect) { diff --git a/core/audio/mixer/mixer_track.h b/core/audio/mixer/mixer_track.h index da59c26..b653a0e 100644 --- a/core/audio/mixer/mixer_track.h +++ b/core/audio/mixer/mixer_track.h @@ -1,6 +1,7 @@ #pragma once #include "audio/misc/audio_buffer.h" +class channel_interface; class mixer_track; class plugin_host; @@ -35,6 +36,8 @@ public: [[nodiscard]] mixer_track_type get_type() const { return type_; } + [[nodiscard]] channel_interface* get_channel_interface() const { return channel_interface_; } + audio_buffer buffer; std::atomic volume = 1.0f; std::vector effects{}; @@ -42,6 +45,7 @@ public: private: void add_effect_internal(plugin_host* in_effect); const mixer_track_type type_; + channel_interface* channel_interface_ = nullptr; }; class instrument_track : public mixer_track { diff --git a/core/audio/plugin_host/midi_sequencer.cpp b/core/audio/plugin_host/midi_sequencer.cpp index c2a6274..8dbcfe3 100644 --- a/core/audio/plugin_host/midi_sequencer.cpp +++ b/core/audio/plugin_host/midi_sequencer.cpp @@ -1,4 +1,13 @@ #include "midi_sequencer.h" +#include "vst2/vst2_plugin_host.h" + +void midi_sequencer::init(singleton_initliazer& initliazer) { + singleton_t::init(initliazer); + + vst2_plugin_host::vst_time_info.tempo = 128.0; + +} + void midi_sequencer::process(double sample_rate, uint32_t in_frames) { } diff --git a/core/audio/plugin_host/midi_sequencer.h b/core/audio/plugin_host/midi_sequencer.h index 054b3f5..5cfd9dc 100644 --- a/core/audio/plugin_host/midi_sequencer.h +++ b/core/audio/plugin_host/midi_sequencer.h @@ -3,9 +3,10 @@ class midi_sequencer : public singleton_t { public: + void init(singleton_initliazer& initliazer) override; void process(double sample_rate, uint32_t in_frames); const char* get_name() override { return "midi_sequencer"; } }; -CORE_API inline midi_sequencer g_midi_sequencer; +DEFINE_SINGLETON_INSTANCE(midi_sequencer) diff --git a/core/audio/plugin_host/plugin_host.cpp b/core/audio/plugin_host/plugin_host.cpp index 1fc03ef..9aa2d09 100644 --- a/core/audio/plugin_host/plugin_host.cpp +++ b/core/audio/plugin_host/plugin_host.cpp @@ -1 +1,17 @@ #include "plugin_host.h" + +#include "audio/mixer/channel_interface.h" + +plugin_host::~plugin_host() { + delete channel; +} + +void plugin_host::try_open_editor() { + auto editor_size = get_editor_size(); + editor_window = glfwCreateWindow(editor_size.x, editor_size.y, name.c_str(), nullptr, nullptr); + open_editor(editor_window); +} + +void plugin_host::init_channel_interface() { + channel = new channel_interface(get_input_channels(), get_output_channels()); +} diff --git a/core/audio/plugin_host/plugin_host.h b/core/audio/plugin_host/plugin_host.h index ff88856..2676bdc 100644 --- a/core/audio/plugin_host/plugin_host.h +++ b/core/audio/plugin_host/plugin_host.h @@ -7,6 +7,8 @@ class channel_interface; class plugin_host { public: + virtual ~plugin_host(); + virtual bool load_plugin(const char* path) = 0; virtual void set_enabled(bool enabled) = 0; @@ -14,20 +16,28 @@ public: virtual void on_update_sample_rate(double sample_rate) = 0; virtual void on_update_buffer_size(int buffer_size) = 0; - virtual uint32_t get_input_channels() const = 0; - virtual uint32_t get_output_channels() const = 0; + [[nodiscard]] virtual uint32_t get_input_channels() const = 0; + [[nodiscard]] virtual uint32_t get_output_channels() const = 0; virtual void update_channel_node_name() {} - virtual void process(uint32_t frame_num) {} + virtual void process(uint32_t frame_num) = 0; - virtual void open_editor(GLFWwindow* window) {} - virtual void close_editor() {} + void try_open_editor(); + virtual void open_editor(GLFWwindow* window) = 0; + virtual void close_editor() = 0; virtual void idle_editor() {} - virtual bool has_editor() const { return false; } - virtual ImVec2 get_editor_size() const { return ImVec2(0, 0); } + + [[nodiscard]] virtual bool has_editor() const { return false; } + [[nodiscard]] virtual ImVec2 get_editor_size() const { return ImVec2(0, 0); } + + [[nodiscard]] virtual std::string load_name() const { return ""; } + [[nodiscard]] virtual std::string load_vendor() const { return ""; } + + void init_channel_interface(); std::string name; std::string vendor; - std::shared_ptr interface; + channel_interface* channel = nullptr; std::vector owner_tracks; + GLFWwindow* editor_window = nullptr; }; diff --git a/core/audio/plugin_host/plugin_host_manager.cpp b/core/audio/plugin_host/plugin_host_manager.cpp index 25a2565..02f4217 100644 --- a/core/audio/plugin_host/plugin_host_manager.cpp +++ b/core/audio/plugin_host/plugin_host_manager.cpp @@ -6,6 +6,7 @@ #include "audio/mixer/channel_interface.h" #include "audio/mixer/mixer.h" #include "misc/singleton/singleton_manager.h" +#include "vst2/vst2_plugin_host.h" void plugin_host_manager::init(singleton_initliazer& initliazer) { singleton_t::init(initliazer); @@ -13,6 +14,15 @@ void plugin_host_manager::init(singleton_initliazer& initliazer) { mixer_ptr->on_remove_track.add_raw(this, &plugin_host_manager::on_mixer_track_removed); } +plugin_host* plugin_host_manager::load_plugin(const char* path) { + auto host = new vst2_plugin_host(); + host->load_plugin(path); + host->init_channel_interface(); + plugin_hosts_.push_back(host); + host->try_open_editor(); + return host; +} + void plugin_host_manager::process(uint32_t in_frames) const { tf::Executor executor; tf::Taskflow taskflow; @@ -26,6 +36,6 @@ void plugin_host_manager::process(uint32_t in_frames) const { void plugin_host_manager::on_mixer_track_removed(mixer_track* track) { for (auto host : plugin_hosts_) { - host->interface->remove_track(track); + host->channel->remove_track(track); } } diff --git a/core/audio/plugin_host/plugin_host_manager.h b/core/audio/plugin_host/plugin_host_manager.h index cb49c80..06af03e 100644 --- a/core/audio/plugin_host/plugin_host_manager.h +++ b/core/audio/plugin_host/plugin_host_manager.h @@ -4,10 +4,12 @@ class plugin_host; class mixer_track; -class plugin_host_manager : public singleton_t { +class CORE_API plugin_host_manager : public singleton_t { public: void init(singleton_initliazer& initliazer) override; + plugin_host* load_plugin(const char* path); + const std::vector& get_plugin_hosts() { return plugin_hosts_; } void process(uint32_t in_frames) const; @@ -19,4 +21,4 @@ private: std::vector plugin_hosts_{}; }; -CORE_API inline plugin_host_manager g_plugin_host_manager; +DEFINE_SINGLETON_INSTANCE(plugin_host_manager) diff --git a/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/aeffect.h b/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/aeffect.h new file mode 100644 index 0000000..86c7e7b --- /dev/null +++ b/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/aeffect.h @@ -0,0 +1,396 @@ +//------------------------------------------------------------------------ +// Project : VST SDK +// Version : 2.4 +// +// Category : VST 2.x Interfaces +// Filename : pluginterfaces/vst2.x/aeffect.h +// Created by : Steinberg, 01/2004 +// Description : Definition of AEffect structure (VST 1.0) +// +//----------------------------------------------------------------------------- +// LICENSE +// (c) 2016, Steinberg Media Technologies GmbH, All Rights Reserved +//----------------------------------------------------------------------------- +// This Software Development Kit may not be distributed in parts or its entirety +// without prior written agreement by Steinberg Media Technologies GmbH. +// This SDK must not be used to re-engineer or manipulate any technology used +// in any Steinberg or Third-party application or software module, +// unless permitted by law. +// Neither the name of the Steinberg Media Technologies nor the names of its +// contributors may be used to endorse or promote products derived from this +// software without specific prior written permission. +// +// THIS SDK IS PROVIDED BY STEINBERG MEDIA TECHNOLOGIES GMBH "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +// IN NO EVENT SHALL STEINBERG MEDIA TECHNOLOGIES GMBH BE LIABLE FOR ANY DIRECT, +// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +// OF THE POSSIBILITY OF SUCH DAMAGE. +//---------------------------------------------------------------------------------- + +#ifndef __aeffect__ +#define __aeffect__ + +//------------------------------------------------------------------------------------------------------- +// gcc based compiler, or CodeWarrior on Mac OS X +#if ((defined(__GNUC__) && (defined(__APPLE_CPP__) || defined(__APPLE_CC__))) || (defined (__MWERKS__) && defined (__MACH__))) + #ifndef TARGET_API_MAC_CARBON + #define TARGET_API_MAC_CARBON 1 + #endif + #if __ppc__ + #ifndef VST_FORCE_DEPRECATED + #define VST_FORCE_DEPRECATED 0 + #endif + #endif +#endif + +#ifdef _WIN32 + #ifndef WIN32 + #define WIN32 1 + #endif +#endif + +#ifdef TARGET_API_MAC_CARBON + #ifdef __LP64__ + #pragma options align=power + #else + #pragma options align=mac68k + #endif + #define VSTCALLBACK +#elif defined __BORLANDC__ + #pragma -a8 + #pragma options push -a8 +#elif defined(__GNUC__) + #pragma pack(push,8) + #define VSTCALLBACK //__cdecl +#elif defined(WIN32) || defined(__FLAT__) || defined CBUILDER + #pragma pack(push) + #pragma pack(8) + #define VSTCALLBACK __cdecl +#else + #define VSTCALLBACK +#endif +//------------------------------------------------------------------------------------------------------- + +#include // for strncpy + +//------------------------------------------------------------------------------------------------------- +// VST Version +//------------------------------------------------------------------------------------------------------- + +/** Define SDK Version (you can generate different versions (from 2.0 to 2.4) of this SDK by setting the unwanted extensions to 0). */ +#define VST_2_1_EXTENSIONS 1 ///< Version 2.1 extensions (08-06-2000) +#define VST_2_2_EXTENSIONS 1 ///< Version 2.2 extensions (08-06-2001) +#define VST_2_3_EXTENSIONS 1 ///< Version 2.3 extensions (20-05-2003) +#ifndef VST_2_4_EXTENSIONS +#define VST_2_4_EXTENSIONS 1 ///< Version 2.4 extensions (01-01-2006) +#endif + +/** Current VST Version */ +#if VST_2_4_EXTENSIONS + #define kVstVersion 2400 +#elif VST_2_3_EXTENSIONS + #define kVstVersion 2300 +#elif VST_2_2_EXTENSIONS + #define kVstVersion 2200 +#elif VST_2_1_EXTENSIONS + #define kVstVersion 2100 +#else + #define kVstVersion 2 +#endif + + + +/** Disable for Hosts to serve Plug-ins below VST 2.4 */ +#ifndef VST_FORCE_DEPRECATED +#define VST_FORCE_DEPRECATED VST_2_4_EXTENSIONS +#endif + +#undef VST_FORCE_DEPRECATED + +/** Declares identifier as deprecated. */ +#ifdef VST_FORCE_DEPRECATED +#define DECLARE_VST_DEPRECATED(identifier) __##identifier##Deprecated +#else +#define DECLARE_VST_DEPRECATED(identifier) identifier +#endif + +/** Define for 64 Bit Platform. */ +#ifndef VST_64BIT_PLATFORM +#define VST_64BIT_PLATFORM _WIN64 || __LP64__ +#endif + +//------------------------------------------------------------------------------------------------------- +// Integral Types +//------------------------------------------------------------------------------------------------------- + +typedef char VstInt8; ///< 8 bit integer type + +#ifdef WIN32 + typedef short VstInt16; ///< 16 bit integer type + typedef int VstInt32; ///< 32 bit integer type + typedef __int64 VstInt64; ///< 64 bit integer type +#else + #include + typedef int16_t VstInt16; ///< 16 bit integer type + typedef int32_t VstInt32; ///< 32 bit integer type + typedef int64_t VstInt64; ///< 64 bit integer type +#endif + +//------------------------------------------------------------------------------------------------------- +// Generic Types +//------------------------------------------------------------------------------------------------------- + +#if VST_64BIT_PLATFORM +typedef VstInt64 VstIntPtr; ///< platform-dependent integer type, same size as pointer +#else +typedef VstInt32 VstIntPtr; ///< platform-dependent integer type, same size as pointer +#endif + +//------------------------------------------------------------------------------------------------------- +// Misc. Definition +//------------------------------------------------------------------------------------------------------- +#undef CCONST +typedef struct AEffect AEffect; + +//------------------------------------------------------------------------------------------------------- +/// @cond ignore +typedef VstIntPtr (VSTCALLBACK *audioMasterCallback) (AEffect* effect, VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt); +typedef VstIntPtr (VSTCALLBACK *AEffectDispatcherProc) (AEffect* effect, VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt); +typedef void (VSTCALLBACK *AEffectProcessProc) (AEffect* effect, float** inputs, float** outputs, VstInt32 sampleFrames); +typedef void (VSTCALLBACK *AEffectProcessDoubleProc) (AEffect* effect, double** inputs, double** outputs, VstInt32 sampleFrames); +typedef void (VSTCALLBACK *AEffectSetParameterProc) (AEffect* effect, VstInt32 index, float parameter); +typedef float (VSTCALLBACK *AEffectGetParameterProc) (AEffect* effect, VstInt32 index); +/// @endcond + +/** Four Character Constant (for AEffect->uniqueID) */ +#define CCONST(a, b, c, d) \ + ((((VstInt32)a) << 24) | (((VstInt32)b) << 16) | (((VstInt32)c) << 8) | (((VstInt32)d) << 0)) + +/** AEffect magic number */ +#define kEffectMagic CCONST ('V', 's', 't', 'P') + +//------------------------------------------------------------------------------------------------------- +/** Basic VST Effect "C" Interface. */ +//------------------------------------------------------------------------------------------------------- +struct AEffect +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 magic; ///< must be #kEffectMagic ('VstP') + + /** Host to Plug-in dispatcher @see AudioEffect::dispatcher */ + AEffectDispatcherProc dispatcher; + + /** \deprecated Accumulating process mode is deprecated in VST 2.4! Use AEffect::processReplacing instead! */ + AEffectProcessProc DECLARE_VST_DEPRECATED (process); + + /** Set new value of automatable parameter @see AudioEffect::setParameter */ + AEffectSetParameterProc setParameter; + + /** Returns current value of automatable parameter @see AudioEffect::getParameter*/ + AEffectGetParameterProc getParameter; + + VstInt32 numPrograms; ///< number of programs + VstInt32 numParams; ///< all programs are assumed to have numParams parameters + VstInt32 numInputs; ///< number of audio inputs + VstInt32 numOutputs; ///< number of audio outputs + + VstInt32 flags; ///< @see VstAEffectFlags + + VstIntPtr resvd1; ///< reserved for Host, must be 0 + VstIntPtr resvd2; ///< reserved for Host, must be 0 + + VstInt32 initialDelay; ///< for algorithms which need input in the first place (Group delay or latency in Samples). This value should be initialized in a resume state. + + VstInt32 DECLARE_VST_DEPRECATED (realQualities); ///< \deprecated unused member + VstInt32 DECLARE_VST_DEPRECATED (offQualities); ///< \deprecated unused member + float DECLARE_VST_DEPRECATED (ioRatio); ///< \deprecated unused member + + void* object; ///< #AudioEffect class pointer + void* user; ///< user-defined pointer + + VstInt32 uniqueID; ///< registered unique identifier (register it at Steinberg 3rd party support Web). This is used to identify a plug-in during save+load of preset and project. + VstInt32 version; ///< plug-in version (example 1100 for version 1.1.0.0) + + /** Process audio samples in replacing mode @see AudioEffect::processReplacing */ + AEffectProcessProc processReplacing; + +#if VST_2_4_EXTENSIONS + /** Process double-precision audio samples in replacing mode @see AudioEffect::processDoubleReplacing */ + AEffectProcessDoubleProc processDoubleReplacing; + + char future[56]; ///< reserved for future use (please zero) +#else + char future[60]; ///< reserved for future use (please zero) +#endif // VST_2_4_EXTENSIONS +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** AEffect flags */ +//------------------------------------------------------------------------------------------------------- +enum VstAEffectFlags +{ +//------------------------------------------------------------------------------------------------------- + effFlagsHasEditor = 1 << 0, ///< set if the plug-in provides a custom editor + effFlagsCanReplacing = 1 << 4, ///< supports replacing process mode (which should the default mode in VST 2.4) + effFlagsProgramChunks = 1 << 5, ///< program data is handled in formatless chunks + effFlagsIsSynth = 1 << 8, ///< plug-in is a synth (VSTi), Host may assign mixer channels for its outputs + effFlagsNoSoundInStop = 1 << 9, ///< plug-in does not produce sound when input is all silence + +#if VST_2_4_EXTENSIONS + effFlagsCanDoubleReplacing = 1 << 12, ///< plug-in supports double precision processing +#endif + + DECLARE_VST_DEPRECATED (effFlagsHasClip) = 1 << 1, ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (effFlagsHasVu) = 1 << 2, ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (effFlagsCanMono) = 1 << 3, ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (effFlagsExtIsAsync) = 1 << 10, ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (effFlagsExtHasBuffer) = 1 << 11 ///< \deprecated deprecated in VST 2.4 +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Basic dispatcher Opcodes (Host to Plug-in) */ +//------------------------------------------------------------------------------------------------------- +enum AEffectOpcodes +{ + effOpen = 0, ///< no arguments @see AudioEffect::open + effClose, ///< no arguments @see AudioEffect::close + + effSetProgram, ///< [value]: new program number @see AudioEffect::setProgram + effGetProgram, ///< [return value]: current program number @see AudioEffect::getProgram + effSetProgramName, ///< [ptr]: char* with new program name, limited to #kVstMaxProgNameLen @see AudioEffect::setProgramName + effGetProgramName, ///< [ptr]: char buffer for current program name, limited to #kVstMaxProgNameLen @see AudioEffect::getProgramName + + effGetParamLabel, ///< [ptr]: char buffer for parameter label, limited to #kVstMaxParamStrLen @see AudioEffect::getParameterLabel + effGetParamDisplay, ///< [ptr]: char buffer for parameter display, limited to #kVstMaxParamStrLen @see AudioEffect::getParameterDisplay + effGetParamName, ///< [ptr]: char buffer for parameter name, limited to #kVstMaxParamStrLen @see AudioEffect::getParameterName + + DECLARE_VST_DEPRECATED (effGetVu), ///< \deprecated deprecated in VST 2.4 + + effSetSampleRate, ///< [opt]: new sample rate for audio processing @see AudioEffect::setSampleRate + effSetBlockSize, ///< [value]: new maximum block size for audio processing @see AudioEffect::setBlockSize + effMainsChanged, ///< [value]: 0 means "turn off", 1 means "turn on" @see AudioEffect::suspend @see AudioEffect::resume + + effEditGetRect, ///< [ptr]: #ERect** receiving pointer to editor size @see ERect @see AEffEditor::getRect + effEditOpen, ///< [ptr]: system dependent Window pointer, e.g. HWND on Windows @see AEffEditor::open + effEditClose, ///< no arguments @see AEffEditor::close + + DECLARE_VST_DEPRECATED (effEditDraw), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (effEditMouse), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (effEditKey), ///< \deprecated deprecated in VST 2.4 + + effEditIdle, ///< no arguments @see AEffEditor::idle + + DECLARE_VST_DEPRECATED (effEditTop), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (effEditSleep), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (effIdentify), ///< \deprecated deprecated in VST 2.4 + + effGetChunk, ///< [ptr]: void** for chunk data address [index]: 0 for bank, 1 for program @see AudioEffect::getChunk + effSetChunk, ///< [ptr]: chunk data [value]: byte size [index]: 0 for bank, 1 for program @see AudioEffect::setChunk + + effNumOpcodes +}; + +//------------------------------------------------------------------------------------------------------- +/** Basic dispatcher Opcodes (Plug-in to Host) */ +//------------------------------------------------------------------------------------------------------- +enum AudioMasterOpcodes +{ +//------------------------------------------------------------------------------------------------------- + audioMasterAutomate = 0, ///< [index]: parameter index [opt]: parameter value @see AudioEffect::setParameterAutomated + audioMasterVersion, ///< [return value]: Host VST version (for example 2400 for VST 2.4) @see AudioEffect::getMasterVersion + audioMasterCurrentId, ///< [return value]: current unique identifier on shell plug-in @see AudioEffect::getCurrentUniqueId + audioMasterIdle, ///< no arguments @see AudioEffect::masterIdle + DECLARE_VST_DEPRECATED (audioMasterPinConnected) ///< \deprecated deprecated in VST 2.4 r2 +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** String length limits (in characters excl. 0 byte) */ +//------------------------------------------------------------------------------------------------------- +enum VstStringConstants +{ +//------------------------------------------------------------------------------------------------------- + kVstMaxProgNameLen = 24, ///< used for #effGetProgramName, #effSetProgramName, #effGetProgramNameIndexed + kVstMaxParamStrLen = 8, ///< used for #effGetParamLabel, #effGetParamDisplay, #effGetParamName + kVstMaxVendorStrLen = 64, ///< used for #effGetVendorString, #audioMasterGetVendorString + kVstMaxProductStrLen = 64, ///< used for #effGetProductString, #audioMasterGetProductString + kVstMaxEffectNameLen = 32 ///< used for #effGetEffectName +//------------------------------------------------------------------------------------------------------- +}; + +#ifdef __cplusplus +#define VST_INLINE inline +#else +#define VST_INLINE +#endif + +//------------------------------------------------------------------------------------------------------- +/** String copy taking care of null terminator. */ +//------------------------------------------------------------------------------------------------------- +VST_INLINE char* vst_strncpy (char* dst, const char* src, size_t maxLen) +{ + char* result = strncpy (dst, src, maxLen); + dst[maxLen] = 0; + return result; +} + +//------------------------------------------------------------------------------------------------------- +/** String concatenation taking care of null terminator. */ +//------------------------------------------------------------------------------------------------------- +VST_INLINE char* vst_strncat (char* dst, const char* src, size_t maxLen) +{ + char* result = strncat (dst, src, maxLen); + dst[maxLen] = 0; + return result; +} + +#ifdef __cplusplus +//------------------------------------------------------------------------------------------------------- +/** Cast #VstIntPtr to pointer. */ +//------------------------------------------------------------------------------------------------------- +template inline T* FromVstPtr (VstIntPtr& arg) +{ + T** address = (T**)&arg; + return *address; +} + +//------------------------------------------------------------------------------------------------------- +/** Cast pointer to #VstIntPtr. */ +//------------------------------------------------------------------------------------------------------- +template inline VstIntPtr ToVstPtr (T* ptr) +{ + VstIntPtr* address = (VstIntPtr*)&ptr; + return *address; +} +#endif // __cplusplus + +//------------------------------------------------------------------------------------------------------- +/** Structure used for #effEditGetRect. */ +//------------------------------------------------------------------------------------------------------- +struct ERect +{ +//------------------------------------------------------------------------------------------------------- + VstInt16 top; ///< top coordinate + VstInt16 left; ///< left coordinate + VstInt16 bottom; ///< bottom coordinate + VstInt16 right; ///< right coordinate +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +#if TARGET_API_MAC_CARBON + #pragma options align=reset +#elif defined(WIN32) || defined(__FLAT__) || defined(__GNUC__) + #pragma pack(pop) +#elif defined __BORLANDC__ + #pragma -a- +#endif + +#endif // __aeffect__ diff --git a/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/aeffectx.h b/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/aeffectx.h new file mode 100644 index 0000000..7129619 --- /dev/null +++ b/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/aeffectx.h @@ -0,0 +1,1170 @@ +//------------------------------------------------------------------------ +// Project : VST SDK +// Version : 2.4 +// +// Category : VST 2.x Interfaces +// Filename : pluginterfaces/vst2.x/aeffectx.h +// Created by : Steinberg, 01/2004 +// Description : Definition of auxiliary structures, extensions from VST 1.0 to VST 2.4 +// +//----------------------------------------------------------------------------- +// LICENSE +// (c) 2016, Steinberg Media Technologies GmbH, All Rights Reserved +//----------------------------------------------------------------------------- +// This Software Development Kit may not be distributed in parts or its entirety +// without prior written agreement by Steinberg Media Technologies GmbH. +// This SDK must not be used to re-engineer or manipulate any technology used +// in any Steinberg or Third-party application or software module, +// unless permitted by law. +// Neither the name of the Steinberg Media Technologies nor the names of its +// contributors may be used to endorse or promote products derived from this +// software without specific prior written permission. +// +// THIS SDK IS PROVIDED BY STEINBERG MEDIA TECHNOLOGIES GMBH "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +// IN NO EVENT SHALL STEINBERG MEDIA TECHNOLOGIES GMBH BE LIABLE FOR ANY DIRECT, +// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +// OF THE POSSIBILITY OF SUCH DAMAGE. +//---------------------------------------------------------------------------------- + +#ifndef __aeffectx__ +#define __aeffectx__ + +// VST 1.0 is included +#ifndef __aeffect__ +#include "aeffect.h" +#endif + +//------------------------------------------------------------------------------------------------------- +// Define some compiler flags +#ifdef TARGET_API_MAC_CARBON + #ifdef __LP64__ + #pragma options align=power + #else + #pragma options align=mac68k + #endif +#elif defined __BORLANDC__ + #pragma -a8 + #pragma options push -a8 +#elif defined(__GNUC__) + #pragma pack(push,8) +#elif defined(WIN32) || defined(__FLAT__) + #pragma pack(push) + #pragma pack(8) +#endif +//------------------------------------------------------------------------------------------------------- + +//------------------------------------------------------------------------------------------------------- +/** String length limits (in characters excl. 0 byte). */ +//------------------------------------------------------------------------------------------------------- +enum Vst2StringConstants +{ +//------------------------------------------------------------------------------------------------------- + kVstMaxNameLen = 64, ///< used for #MidiProgramName, #MidiProgramCategory, #MidiKeyName, #VstSpeakerProperties, #VstPinProperties + kVstMaxLabelLen = 64, ///< used for #VstParameterProperties->label, #VstPinProperties->label + kVstMaxShortLabelLen = 8, ///< used for #VstParameterProperties->shortLabel, #VstPinProperties->shortLabel + kVstMaxCategLabelLen = 24, ///< used for #VstParameterProperties->label + kVstMaxFileNameLen = 100 ///< used for #VstAudioFile->name +//------------------------------------------------------------------------------------------------------- +}; +//------------------------------------------------------------------------------------------------------- +// VstEvent +//------------------------------------------------------------------------------------------------------- +//------------------------------------------------------------------------------------------------------- +/** A generic timestamped event. */ +//------------------------------------------------------------------------------------------------------- +typedef struct VstEvent +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 type; ///< @see VstEventTypes + VstInt32 byteSize; ///< size of this event, excl. type and byteSize + VstInt32 deltaFrames; ///< sample frames related to the current block start sample position + VstInt32 flags; ///< generic flags, none defined yet + + char data[16]; ///< data size may vary, depending on event type +//------------------------------------------------------------------------------------------------------- +} VstEvent; + +//------------------------------------------------------------------------------------------------------- +/** VstEvent Types used by #VstEvent. */ +//------------------------------------------------------------------------------------------------------- +enum VstEventTypes +{ +//------------------------------------------------------------------------------------------------------- + kVstMidiType = 1, ///< MIDI event @see VstMidiEvent + DECLARE_VST_DEPRECATED (kVstAudioType), ///< \deprecated unused event type + DECLARE_VST_DEPRECATED (kVstVideoType), ///< \deprecated unused event type + DECLARE_VST_DEPRECATED (kVstParameterType), ///< \deprecated unused event type + DECLARE_VST_DEPRECATED (kVstTriggerType), ///< \deprecated unused event type + kVstSysExType ///< MIDI system exclusive @see VstMidiSysexEvent +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** A block of events for the current processed audio block. */ +//------------------------------------------------------------------------------------------------------- +struct VstEvents +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 numEvents; ///< number of Events in array + VstIntPtr reserved; ///< zero (Reserved for future use) + VstEvent* events[2]; ///< event pointer array, variable size +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** MIDI Event (to be casted from VstEvent). */ +//------------------------------------------------------------------------------------------------------- +struct VstMidiEvent +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 type; ///< #kVstMidiType + VstInt32 byteSize; ///< sizeof (VstMidiEvent) + VstInt32 deltaFrames; ///< sample frames related to the current block start sample position + VstInt32 flags; ///< @see VstMidiEventFlags + VstInt32 noteLength; ///< (in sample frames) of entire note, if available, else 0 + VstInt32 noteOffset; ///< offset (in sample frames) into note from note start if available, else 0 + char midiData[4]; ///< 1 to 3 MIDI bytes; midiData[3] is reserved (zero) + char detune; ///< -64 to +63 cents; for scales other than 'well-tempered' ('microtuning') + char noteOffVelocity; ///< Note Off Velocity [0, 127] + char reserved1; ///< zero (Reserved for future use) + char reserved2; ///< zero (Reserved for future use) +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Flags used in #VstMidiEvent. */ +//------------------------------------------------------------------------------------------------------- +enum VstMidiEventFlags +{ +//------------------------------------------------------------------------------------------------------- + kVstMidiEventIsRealtime = 1 << 0 ///< means that this event is played life (not in playback from a sequencer track).\n This allows the Plug-In to handle these flagged events with higher priority, especially when the Plug-In has a big latency (AEffect::initialDelay) +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** MIDI Sysex Event (to be casted from #VstEvent). */ +//------------------------------------------------------------------------------------------------------- +struct VstMidiSysexEvent +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 type; ///< #kVstSysexType + VstInt32 byteSize; ///< sizeof (VstMidiSysexEvent) + VstInt32 deltaFrames; ///< sample frames related to the current block start sample position + VstInt32 flags; ///< none defined yet (should be zero) + VstInt32 dumpBytes; ///< byte size of sysexDump + VstIntPtr resvd1; ///< zero (Reserved for future use) + char* sysexDump; ///< sysex dump + VstIntPtr resvd2; ///< zero (Reserved for future use) +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +// VstTimeInfo +//------------------------------------------------------------------------------------------------------- +//------------------------------------------------------------------------------------------------------- +/** VstTimeInfo requested via #audioMasterGetTime. @see AudioEffectX::getTimeInfo + +\note VstTimeInfo::samplePos :Current Position. It must always be valid, and should not cost a lot to ask for. The sample position is ahead of the time displayed to the user. In sequencer stop mode, its value does not change. A 32 bit integer is too small for sample positions, and it's a double to make it easier to convert between ppq and samples. +\note VstTimeInfo::ppqPos : At tempo 120, 1 quarter makes 1/2 second, so 2.0 ppq translates to 48000 samples at 48kHz sample rate. +.25 ppq is one sixteenth note then. if you need something like 480ppq, you simply multiply ppq by that scaler. +\note VstTimeInfo::barStartPos : Say we're at bars/beats readout 3.3.3. That's 2 bars + 2 q + 2 sixteenth, makes 2 * 4 + 2 + .25 = 10.25 ppq. at tempo 120, that's 10.25 * .5 = 5.125 seconds, times 48000 = 246000 samples (if my calculator servers me well :-). +\note VstTimeInfo::samplesToNextClock : MIDI Clock Resolution (24 per Quarter Note), can be negative the distance to the next midi clock (24 ppq, pulses per quarter) in samples. unless samplePos falls precicely on a midi clock, this will either be negative such that the previous MIDI clock is addressed, or positive when referencing the following (future) MIDI clock. +*/ +//------------------------------------------------------------------------------------------------------- +struct VstTimeInfo +{ +//------------------------------------------------------------------------------------------------------- + double samplePos; ///< current Position in audio samples (always valid) + double sampleRate; ///< current Sample Rate in Herz (always valid) + double nanoSeconds; ///< System Time in nanoseconds (10^-9 second) + double ppqPos; ///< Musical Position, in Quarter Note (1.0 equals 1 Quarter Note) + double tempo; ///< current Tempo in BPM (Beats Per Minute) + double barStartPos; ///< last Bar Start Position, in Quarter Note + double cycleStartPos; ///< Cycle Start (left locator), in Quarter Note + double cycleEndPos; ///< Cycle End (right locator), in Quarter Note + VstInt32 timeSigNumerator; ///< Time Signature Numerator (e.g. 3 for 3/4) + VstInt32 timeSigDenominator; ///< Time Signature Denominator (e.g. 4 for 3/4) + VstInt32 smpteOffset; ///< SMPTE offset (in SMPTE subframes (bits; 1/80 of a frame)). The current SMPTE position can be calculated using #samplePos, #sampleRate, and #smpteFrameRate. + VstInt32 smpteFrameRate; ///< @see VstSmpteFrameRate + VstInt32 samplesToNextClock; ///< MIDI Clock Resolution (24 Per Quarter Note), can be negative (nearest clock) + VstInt32 flags; ///< @see VstTimeInfoFlags +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Flags used in #VstTimeInfo. */ +//------------------------------------------------------------------------------------------------------- +enum VstTimeInfoFlags +{ +//------------------------------------------------------------------------------------------------------- + kVstTransportChanged = 1, ///< indicates that play, cycle or record state has changed + kVstTransportPlaying = 1 << 1, ///< set if Host sequencer is currently playing + kVstTransportCycleActive = 1 << 2, ///< set if Host sequencer is in cycle mode + kVstTransportRecording = 1 << 3, ///< set if Host sequencer is in record mode + kVstAutomationWriting = 1 << 6, ///< set if automation write mode active (record parameter changes) + kVstAutomationReading = 1 << 7, ///< set if automation read mode active (play parameter changes) + kVstNanosValid = 1 << 8, ///< VstTimeInfo::nanoSeconds valid + kVstPpqPosValid = 1 << 9, ///< VstTimeInfo::ppqPos valid + kVstTempoValid = 1 << 10, ///< VstTimeInfo::tempo valid + kVstBarsValid = 1 << 11, ///< VstTimeInfo::barStartPos valid + kVstCyclePosValid = 1 << 12, ///< VstTimeInfo::cycleStartPos and VstTimeInfo::cycleEndPos valid + kVstTimeSigValid = 1 << 13, ///< VstTimeInfo::timeSigNumerator and VstTimeInfo::timeSigDenominator valid + kVstSmpteValid = 1 << 14, ///< VstTimeInfo::smpteOffset and VstTimeInfo::smpteFrameRate valid + kVstClockValid = 1 << 15 ///< VstTimeInfo::samplesToNextClock valid +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** SMPTE Frame Rates. */ +//------------------------------------------------------------------------------------------------------- +enum VstSmpteFrameRate +{ +//------------------------------------------------------------------------------------------------------- + kVstSmpte24fps = 0, ///< 24 fps + kVstSmpte25fps = 1, ///< 25 fps + kVstSmpte2997fps = 2, ///< 29.97 fps + kVstSmpte30fps = 3, ///< 30 fps + kVstSmpte2997dfps = 4, ///< 29.97 drop + kVstSmpte30dfps = 5, ///< 30 drop + + kVstSmpteFilm16mm = 6, ///< Film 16mm + kVstSmpteFilm35mm = 7, ///< Film 35mm + kVstSmpte239fps = 10, ///< HDTV: 23.976 fps + kVstSmpte249fps = 11, ///< HDTV: 24.976 fps + kVstSmpte599fps = 12, ///< HDTV: 59.94 fps + kVstSmpte60fps = 13 ///< HDTV: 60 fps +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Variable IO for Offline Processing. */ +//------------------------------------------------------------------------------------------------------- +struct VstVariableIo +{ +//------------------------------------------------------------------------------------------------------- + float** inputs; ///< input audio buffers + float** outputs; ///< output audio buffers + VstInt32 numSamplesInput; ///< number of incoming samples + VstInt32 numSamplesOutput; ///< number of outgoing samples + VstInt32* numSamplesInputProcessed; ///< number of samples actually processed of input + VstInt32* numSamplesOutputProcessed; ///< number of samples actually processed of output +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Language code returned by audioMasterGetLanguage. */ +//------------------------------------------------------------------------------------------------------- +enum VstHostLanguage +{ +//------------------------------------------------------------------------------------------------------- + kVstLangEnglish = 1, ///< English + kVstLangGerman, ///< German + kVstLangFrench, ///< French + kVstLangItalian, ///< Italian + kVstLangSpanish, ///< Spanish + kVstLangJapanese ///< Japanese +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** VST 2.x dispatcher Opcodes (Plug-in to Host). Extension of #AudioMasterOpcodes */ +//------------------------------------------------------------------------------------------------------- +enum AudioMasterOpcodesX +{ +//------------------------------------------------------------------------------------------------------- + DECLARE_VST_DEPRECATED (audioMasterWantMidi) = DECLARE_VST_DEPRECATED (audioMasterPinConnected) + 2, ///< \deprecated deprecated in VST 2.4 + + audioMasterGetTime, ///< [return value]: #VstTimeInfo* or null if not supported [value]: request mask @see VstTimeInfoFlags @see AudioEffectX::getTimeInfo + audioMasterProcessEvents, ///< [ptr]: pointer to #VstEvents @see VstEvents @see AudioEffectX::sendVstEventsToHost + + DECLARE_VST_DEPRECATED (audioMasterSetTime), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (audioMasterTempoAt), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (audioMasterGetNumAutomatableParameters), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (audioMasterGetParameterQuantization), ///< \deprecated deprecated in VST 2.4 + + audioMasterIOChanged, ///< [return value]: 1 if supported @see AudioEffectX::ioChanged + + DECLARE_VST_DEPRECATED (audioMasterNeedIdle), ///< \deprecated deprecated in VST 2.4 + + audioMasterSizeWindow, ///< [index]: new width [value]: new height [return value]: 1 if supported @see AudioEffectX::sizeWindow + audioMasterGetSampleRate, ///< [return value]: current sample rate @see AudioEffectX::updateSampleRate + audioMasterGetBlockSize, ///< [return value]: current block size @see AudioEffectX::updateBlockSize + audioMasterGetInputLatency, ///< [return value]: input latency in audio samples @see AudioEffectX::getInputLatency + audioMasterGetOutputLatency, ///< [return value]: output latency in audio samples @see AudioEffectX::getOutputLatency + + DECLARE_VST_DEPRECATED (audioMasterGetPreviousPlug), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (audioMasterGetNextPlug), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (audioMasterWillReplaceOrAccumulate), ///< \deprecated deprecated in VST 2.4 + + audioMasterGetCurrentProcessLevel, ///< [return value]: current process level @see VstProcessLevels + audioMasterGetAutomationState, ///< [return value]: current automation state @see VstAutomationStates + + audioMasterOfflineStart, ///< [index]: numNewAudioFiles [value]: numAudioFiles [ptr]: #VstAudioFile* @see AudioEffectX::offlineStart + audioMasterOfflineRead, ///< [index]: bool readSource [value]: #VstOfflineOption* @see VstOfflineOption [ptr]: #VstOfflineTask* @see VstOfflineTask @see AudioEffectX::offlineRead + audioMasterOfflineWrite, ///< @see audioMasterOfflineRead @see AudioEffectX::offlineRead + audioMasterOfflineGetCurrentPass, ///< @see AudioEffectX::offlineGetCurrentPass + audioMasterOfflineGetCurrentMetaPass, ///< @see AudioEffectX::offlineGetCurrentMetaPass + + DECLARE_VST_DEPRECATED (audioMasterSetOutputSampleRate), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (audioMasterGetOutputSpeakerArrangement), ///< \deprecated deprecated in VST 2.4 + + audioMasterGetVendorString, ///< [ptr]: char buffer for vendor string, limited to #kVstMaxVendorStrLen @see AudioEffectX::getHostVendorString + audioMasterGetProductString, ///< [ptr]: char buffer for vendor string, limited to #kVstMaxProductStrLen @see AudioEffectX::getHostProductString + audioMasterGetVendorVersion, ///< [return value]: vendor-specific version @see AudioEffectX::getHostVendorVersion + audioMasterVendorSpecific, ///< no definition, vendor specific handling @see AudioEffectX::hostVendorSpecific + + DECLARE_VST_DEPRECATED (audioMasterSetIcon), ///< \deprecated deprecated in VST 2.4 + + audioMasterCanDo, ///< [ptr]: "can do" string [return value]: 1 for supported + audioMasterGetLanguage, ///< [return value]: language code @see VstHostLanguage + + DECLARE_VST_DEPRECATED (audioMasterOpenWindow), ///< \deprecated deprecated in VST 2.4 + DECLARE_VST_DEPRECATED (audioMasterCloseWindow), ///< \deprecated deprecated in VST 2.4 + + audioMasterGetDirectory, ///< [return value]: FSSpec on MAC, else char* @see AudioEffectX::getDirectory + audioMasterUpdateDisplay, ///< no arguments + audioMasterBeginEdit, ///< [index]: parameter index @see AudioEffectX::beginEdit + audioMasterEndEdit, ///< [index]: parameter index @see AudioEffectX::endEdit + audioMasterOpenFileSelector, ///< [ptr]: VstFileSelect* [return value]: 1 if supported @see AudioEffectX::openFileSelector + audioMasterCloseFileSelector, ///< [ptr]: VstFileSelect* @see AudioEffectX::closeFileSelector + + DECLARE_VST_DEPRECATED (audioMasterEditFile), ///< \deprecated deprecated in VST 2.4 + + DECLARE_VST_DEPRECATED (audioMasterGetChunkFile), ///< \deprecated deprecated in VST 2.4 [ptr]: char[2048] or sizeof (FSSpec) [return value]: 1 if supported @see AudioEffectX::getChunkFile + + DECLARE_VST_DEPRECATED (audioMasterGetInputSpeakerArrangement) ///< \deprecated deprecated in VST 2.4 +}; + +//------------------------------------------------------------------------------------------------------- +/** VST 2.x dispatcher Opcodes (Host to Plug-in). Extension of #AEffectOpcodes */ +//------------------------------------------------------------------------------------------------------- +enum AEffectXOpcodes +{ +//------------------------------------------------------------------------------------------------------- + effProcessEvents = effSetChunk + 1 ///< [ptr]: #VstEvents* @see AudioEffectX::processEvents + + , effCanBeAutomated ///< [index]: parameter index [return value]: 1=true, 0=false @see AudioEffectX::canParameterBeAutomated + , effString2Parameter ///< [index]: parameter index [ptr]: parameter string [return value]: true for success @see AudioEffectX::string2parameter + + , DECLARE_VST_DEPRECATED (effGetNumProgramCategories) ///< \deprecated deprecated in VST 2.4 + + , effGetProgramNameIndexed ///< [index]: program index [ptr]: buffer for program name, limited to #kVstMaxProgNameLen [return value]: true for success @see AudioEffectX::getProgramNameIndexed + + , DECLARE_VST_DEPRECATED (effCopyProgram) ///< \deprecated deprecated in VST 2.4 + , DECLARE_VST_DEPRECATED (effConnectInput) ///< \deprecated deprecated in VST 2.4 + , DECLARE_VST_DEPRECATED (effConnectOutput) ///< \deprecated deprecated in VST 2.4 + + , effGetInputProperties ///< [index]: input index [ptr]: #VstPinProperties* [return value]: 1 if supported @see AudioEffectX::getInputProperties + , effGetOutputProperties ///< [index]: output index [ptr]: #VstPinProperties* [return value]: 1 if supported @see AudioEffectX::getOutputProperties + , effGetPlugCategory ///< [return value]: category @see VstPlugCategory @see AudioEffectX::getPlugCategory + + , DECLARE_VST_DEPRECATED (effGetCurrentPosition) ///< \deprecated deprecated in VST 2.4 + , DECLARE_VST_DEPRECATED (effGetDestinationBuffer) ///< \deprecated deprecated in VST 2.4 + + , effOfflineNotify ///< [ptr]: #VstAudioFile array [value]: count [index]: start flag @see AudioEffectX::offlineNotify + , effOfflinePrepare ///< [ptr]: #VstOfflineTask array [value]: count @see AudioEffectX::offlinePrepare + , effOfflineRun ///< [ptr]: #VstOfflineTask array [value]: count @see AudioEffectX::offlineRun + + , effProcessVarIo ///< [ptr]: #VstVariableIo* @see AudioEffectX::processVariableIo + , effSetSpeakerArrangement ///< [value]: input #VstSpeakerArrangement* [ptr]: output #VstSpeakerArrangement* @see AudioEffectX::setSpeakerArrangement + + , DECLARE_VST_DEPRECATED (effSetBlockSizeAndSampleRate) ///< \deprecated deprecated in VST 2.4 + + , effSetBypass ///< [value]: 1 = bypass, 0 = no bypass @see AudioEffectX::setBypass + , effGetEffectName ///< [ptr]: buffer for effect name, limited to #kVstMaxEffectNameLen @see AudioEffectX::getEffectName + + , DECLARE_VST_DEPRECATED (effGetErrorText) ///< \deprecated deprecated in VST 2.4 + + , effGetVendorString ///< [ptr]: buffer for effect vendor string, limited to #kVstMaxVendorStrLen @see AudioEffectX::getVendorString + , effGetProductString ///< [ptr]: buffer for effect vendor string, limited to #kVstMaxProductStrLen @see AudioEffectX::getProductString + , effGetVendorVersion ///< [return value]: vendor-specific version @see AudioEffectX::getVendorVersion + , effVendorSpecific ///< no definition, vendor specific handling @see AudioEffectX::vendorSpecific + , effCanDo ///< [ptr]: "can do" string [return value]: 0: "don't know" -1: "no" 1: "yes" @see AudioEffectX::canDo + , effGetTailSize ///< [return value]: tail size (for example the reverb time of a reverb plug-in); 0 is default (return 1 for 'no tail') + + , DECLARE_VST_DEPRECATED (effIdle) ///< \deprecated deprecated in VST 2.4 + , DECLARE_VST_DEPRECATED (effGetIcon) ///< \deprecated deprecated in VST 2.4 + , DECLARE_VST_DEPRECATED (effSetViewPosition) ///< \deprecated deprecated in VST 2.4 + + , effGetParameterProperties ///< [index]: parameter index [ptr]: #VstParameterProperties* [return value]: 1 if supported @see AudioEffectX::getParameterProperties + + , DECLARE_VST_DEPRECATED (effKeysRequired) ///< \deprecated deprecated in VST 2.4 + + , effGetVstVersion ///< [return value]: VST version @see AudioEffectX::getVstVersion + +#if VST_2_1_EXTENSIONS + , effEditKeyDown ///< [index]: ASCII character [value]: virtual key [opt]: modifiers [return value]: 1 if key used @see AEffEditor::onKeyDown + , effEditKeyUp ///< [index]: ASCII character [value]: virtual key [opt]: modifiers [return value]: 1 if key used @see AEffEditor::onKeyUp + , effSetEditKnobMode ///< [value]: knob mode 0: circular, 1: circular relativ, 2: linear (CKnobMode in VSTGUI) @see AEffEditor::setKnobMode + + , effGetMidiProgramName ///< [index]: MIDI channel [ptr]: #MidiProgramName* [return value]: number of used programs, 0 if unsupported @see AudioEffectX::getMidiProgramName + , effGetCurrentMidiProgram ///< [index]: MIDI channel [ptr]: #MidiProgramName* [return value]: index of current program @see AudioEffectX::getCurrentMidiProgram + , effGetMidiProgramCategory ///< [index]: MIDI channel [ptr]: #MidiProgramCategory* [return value]: number of used categories, 0 if unsupported @see AudioEffectX::getMidiProgramCategory + , effHasMidiProgramsChanged ///< [index]: MIDI channel [return value]: 1 if the #MidiProgramName(s) or #MidiKeyName(s) have changed @see AudioEffectX::hasMidiProgramsChanged + , effGetMidiKeyName ///< [index]: MIDI channel [ptr]: #MidiKeyName* [return value]: true if supported, false otherwise @see AudioEffectX::getMidiKeyName + + , effBeginSetProgram ///< no arguments @see AudioEffectX::beginSetProgram + , effEndSetProgram ///< no arguments @see AudioEffectX::endSetProgram +#endif // VST_2_1_EXTENSIONS + +#if VST_2_3_EXTENSIONS + , effGetSpeakerArrangement ///< [value]: input #VstSpeakerArrangement* [ptr]: output #VstSpeakerArrangement* @see AudioEffectX::getSpeakerArrangement + , effShellGetNextPlugin ///< [ptr]: buffer for plug-in name, limited to #kVstMaxProductStrLen [return value]: next plugin's uniqueID @see AudioEffectX::getNextShellPlugin + + , effStartProcess ///< no arguments @see AudioEffectX::startProcess + , effStopProcess ///< no arguments @see AudioEffectX::stopProcess + , effSetTotalSampleToProcess ///< [value]: number of samples to process, offline only! @see AudioEffectX::setTotalSampleToProcess + , effSetPanLaw ///< [value]: pan law [opt]: gain @see VstPanLawType @see AudioEffectX::setPanLaw + + , effBeginLoadBank ///< [ptr]: #VstPatchChunkInfo* [return value]: -1: bank can't be loaded, 1: bank can be loaded, 0: unsupported @see AudioEffectX::beginLoadBank + , effBeginLoadProgram ///< [ptr]: #VstPatchChunkInfo* [return value]: -1: prog can't be loaded, 1: prog can be loaded, 0: unsupported @see AudioEffectX::beginLoadProgram +#endif // VST_2_3_EXTENSIONS + +#if VST_2_4_EXTENSIONS + , effSetProcessPrecision ///< [value]: @see VstProcessPrecision @see AudioEffectX::setProcessPrecision + , effGetNumMidiInputChannels ///< [return value]: number of used MIDI input channels (1-15) @see AudioEffectX::getNumMidiInputChannels + , effGetNumMidiOutputChannels ///< [return value]: number of used MIDI output channels (1-15) @see AudioEffectX::getNumMidiOutputChannels +#endif // VST_2_4_EXTENSIONS +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Symbolic precision constants used for effSetProcessPrecision. */ +//------------------------------------------------------------------------------------------------------- +enum VstProcessPrecision +{ + kVstProcessPrecision32 = 0, ///< single precision float (32bits) + kVstProcessPrecision64 ///< double precision (64bits) +}; + +//------------------------------------------------------------------------------------------------------- +/** Parameter Properties used in #effGetParameterProperties. */ +//------------------------------------------------------------------------------------------------------- +struct VstParameterProperties +{ +//------------------------------------------------------------------------------------------------------- + float stepFloat; ///< float step + float smallStepFloat; ///< small float step + float largeStepFloat; ///< large float step + char label[kVstMaxLabelLen];///< parameter label + VstInt32 flags; ///< @see VstParameterFlags + VstInt32 minInteger; ///< integer minimum + VstInt32 maxInteger; ///< integer maximum + VstInt32 stepInteger; ///< integer step + VstInt32 largeStepInteger; ///< large integer step + char shortLabel[kVstMaxShortLabelLen]; ///< short label, recommended: 6 + delimiter + + // The following are for remote controller display purposes. + // Note that the kVstParameterSupportsDisplayIndex flag must be set. + // Host can scan all parameters, and find out in what order + // to display them: + + VstInt16 displayIndex; ///< index where this parameter should be displayed (starting with 0) + + // Host can also possibly display the parameter group (category), such as... + // --------------------------- + // Osc 1 + // Wave Detune Octave Mod + // --------------------------- + // ...if the plug-in supports it (flag #kVstParameterSupportsDisplayCategory) + + VstInt16 category; ///< 0: no category, else group index + 1 + VstInt16 numParametersInCategory; ///< number of parameters in category + VstInt16 reserved; ///< zero + char categoryLabel[kVstMaxCategLabelLen]; ///< category label, e.g. "Osc 1" + + char future[16]; ///< reserved for future use +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Flags used in #VstParameterProperties. */ +//------------------------------------------------------------------------------------------------------- +enum VstParameterFlags +{ +//------------------------------------------------------------------------------------------------------- + kVstParameterIsSwitch = 1 << 0, ///< parameter is a switch (on/off) + kVstParameterUsesIntegerMinMax = 1 << 1, ///< minInteger, maxInteger valid + kVstParameterUsesFloatStep = 1 << 2, ///< stepFloat, smallStepFloat, largeStepFloat valid + kVstParameterUsesIntStep = 1 << 3, ///< stepInteger, largeStepInteger valid + kVstParameterSupportsDisplayIndex = 1 << 4, ///< displayIndex valid + kVstParameterSupportsDisplayCategory = 1 << 5, ///< category, etc. valid + kVstParameterCanRamp = 1 << 6 ///< set if parameter value can ramp up/down +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Pin Properties used in #effGetInputProperties and #effGetOutputProperties. */ +//------------------------------------------------------------------------------------------------------- +struct VstPinProperties +{ +//------------------------------------------------------------------------------------------------------- + char label[kVstMaxLabelLen]; ///< pin name + VstInt32 flags; ///< @see VstPinPropertiesFlags + VstInt32 arrangementType; ///< @see VstSpeakerArrangementType + char shortLabel[kVstMaxShortLabelLen]; ///< short name (recommended: 6 + delimiter) + + char future[48]; ///< reserved for future use +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Flags used in #VstPinProperties. */ +//------------------------------------------------------------------------------------------------------- +enum VstPinPropertiesFlags +{ +//------------------------------------------------------------------------------------------------------- + kVstPinIsActive = 1 << 0, ///< pin is active, ignored by Host + kVstPinIsStereo = 1 << 1, ///< pin is first of a stereo pair + kVstPinUseSpeaker = 1 << 2 ///< #VstPinProperties::arrangementType is valid and can be used to get the wanted arrangement +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Plug-in Categories. */ +//------------------------------------------------------------------------------------------------------- +enum VstPlugCategory +{ +//------------------------------------------------------------------------------------------------------- + kPlugCategUnknown = 0, ///< Unknown, category not implemented + kPlugCategEffect, ///< Simple Effect + kPlugCategSynth, ///< VST Instrument (Synths, samplers,...) + kPlugCategAnalysis, ///< Scope, Tuner, ... + kPlugCategMastering, ///< Dynamics, ... + kPlugCategSpacializer, ///< Panners, ... + kPlugCategRoomFx, ///< Delays and Reverbs + kPlugSurroundFx, ///< Dedicated surround processor + kPlugCategRestoration, ///< Denoiser, ... + kPlugCategOfflineProcess, ///< Offline Process + kPlugCategShell, ///< Plug-in is container of other plug-ins @see effShellGetNextPlugin + kPlugCategGenerator, ///< ToneGenerator, ... + + kPlugCategMaxCount ///< Marker to count the categories +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +// MIDI Programs +//------------------------------------------------------------------------------------------------------- +//------------------------------------------------------------------------------------------------------- +/** MIDI Program Description. */ +//------------------------------------------------------------------------------------------------------- +struct MidiProgramName +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 thisProgramIndex; ///< 0 or greater: fill struct for this program index + char name[kVstMaxNameLen]; ///< program name + char midiProgram; ///< -1:off, 0-127 + char midiBankMsb; ///< -1:off, 0-127 + char midiBankLsb; ///< -1:off, 0-127 + char reserved; ///< zero + VstInt32 parentCategoryIndex; ///< -1:no parent category + VstInt32 flags; ///< omni etc. @see VstMidiProgramNameFlags +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Flags used in MidiProgramName. */ +//------------------------------------------------------------------------------------------------------- +enum VstMidiProgramNameFlags +{ +//------------------------------------------------------------------------------------------------------- + kMidiIsOmni = 1 ///< default is multi. for omni mode, channel 0 is used for inquiries and program changes +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** MIDI Program Category. */ +//------------------------------------------------------------------------------------------------------- +struct MidiProgramCategory +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 thisCategoryIndex; ///< 0 or greater: fill struct for this category index. + char name[kVstMaxNameLen]; ///< name + VstInt32 parentCategoryIndex; ///< -1:no parent category + VstInt32 flags; ///< reserved, none defined yet, zero. +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** MIDI Key Description. */ +//------------------------------------------------------------------------------------------------------- +struct MidiKeyName +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 thisProgramIndex; ///< 0 or greater: fill struct for this program index. + VstInt32 thisKeyNumber; ///< 0 - 127. fill struct for this key number. + char keyName[kVstMaxNameLen]; ///< key name, empty means regular key names + VstInt32 reserved; ///< zero + VstInt32 flags; ///< reserved, none defined yet, zero. +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +// Surround Setup +//------------------------------------------------------------------------------------------------------- +//------------------------------------------------------------------------------------------------------- +/** Speaker Properties. + The origin for azimuth is right (as by math conventions dealing with radians). + The elevation origin is also right, visualizing a rotation of a circle across the + -pi/pi axis of the horizontal circle. Thus, an elevation of -pi/2 corresponds + to bottom, and a speaker standing on the left, and 'beaming' upwards would have + an azimuth of -pi, and an elevation of pi/2. + For user interface representation, grads are more likely to be used, and the + origins will obviously 'shift' accordingly. */ +//------------------------------------------------------------------------------------------------------- +typedef struct VstSpeakerProperties +{ +//------------------------------------------------------------------------------------------------------- + float azimuth; ///< unit: rad, range: -PI...PI, exception: 10.f for LFE channel + float elevation; ///< unit: rad, range: -PI/2...PI/2, exception: 10.f for LFE channel + float radius; ///< unit: meter, exception: 0.f for LFE channel + float reserved; ///< zero (reserved for future use) + char name[kVstMaxNameLen]; ///< for new setups, new names should be given (L/R/C... won't do) + VstInt32 type; ///< @see VstSpeakerType + + char future[28]; ///< reserved for future use +//------------------------------------------------------------------------------------------------------- +} VstSpeakerProperties; + +//------------------------------------------------------------------------------------------------------- +/** Speaker Arrangement. */ +//------------------------------------------------------------------------------------------------------- +struct VstSpeakerArrangement +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 type; ///< e.g. #kSpeakerArr51 for 5.1 @see VstSpeakerArrangementType + VstInt32 numChannels; ///< number of channels in this speaker arrangement + VstSpeakerProperties speakers[8]; ///< variable sized speaker array +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Speaker Types. */ +//------------------------------------------------------------------------------------------------------- +enum VstSpeakerType +{ +//------------------------------------------------------------------------------------------------------- + kSpeakerUndefined = 0x7fffffff, ///< Undefined + kSpeakerM = 0, ///< Mono (M) + kSpeakerL, ///< Left (L) + kSpeakerR, ///< Right (R) + kSpeakerC, ///< Center (C) + kSpeakerLfe, ///< Subbass (Lfe) + kSpeakerLs, ///< Left Surround (Ls) + kSpeakerRs, ///< Right Surround (Rs) + kSpeakerLc, ///< Left of Center (Lc) + kSpeakerRc, ///< Right of Center (Rc) + kSpeakerS, ///< Surround (S) + kSpeakerCs = kSpeakerS, ///< Center of Surround (Cs) = Surround (S) + kSpeakerSl, ///< Side Left (Sl) + kSpeakerSr, ///< Side Right (Sr) + kSpeakerTm, ///< Top Middle (Tm) + kSpeakerTfl, ///< Top Front Left (Tfl) + kSpeakerTfc, ///< Top Front Center (Tfc) + kSpeakerTfr, ///< Top Front Right (Tfr) + kSpeakerTrl, ///< Top Rear Left (Trl) + kSpeakerTrc, ///< Top Rear Center (Trc) + kSpeakerTrr, ///< Top Rear Right (Trr) + kSpeakerLfe2 ///< Subbass 2 (Lfe2) +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** User-defined speaker types, to be extended in the negative range. + Will be handled as their corresponding speaker types with abs values: + e.g abs(#kSpeakerU1) == #kSpeakerL, abs(#kSpeakerU2) == #kSpeakerR) */ +//------------------------------------------------------------------------------------------------------- +enum VstUserSpeakerType +{ +//------------------------------------------------------------------------------------------------------- + kSpeakerU32 = -32, + kSpeakerU31, + kSpeakerU30, + kSpeakerU29, + kSpeakerU28, + kSpeakerU27, + kSpeakerU26, + kSpeakerU25, + kSpeakerU24, + kSpeakerU23, + kSpeakerU22, + kSpeakerU21, + kSpeakerU20, ///< == #kSpeakerLfe2 + kSpeakerU19, ///< == #kSpeakerTrr + kSpeakerU18, ///< == #kSpeakerTrc + kSpeakerU17, ///< == #kSpeakerTrl + kSpeakerU16, ///< == #kSpeakerTfr + kSpeakerU15, ///< == #kSpeakerTfc + kSpeakerU14, ///< == #kSpeakerTfl + kSpeakerU13, ///< == #kSpeakerTm + kSpeakerU12, ///< == #kSpeakerSr + kSpeakerU11, ///< == #kSpeakerSl + kSpeakerU10, ///< == #kSpeakerCs + kSpeakerU9, ///< == #kSpeakerS + kSpeakerU8, ///< == #kSpeakerRc + kSpeakerU7, ///< == #kSpeakerLc + kSpeakerU6, ///< == #kSpeakerRs + kSpeakerU5, ///< == #kSpeakerLs + kSpeakerU4, ///< == #kSpeakerLfe + kSpeakerU3, ///< == #kSpeakerC + kSpeakerU2, ///< == #kSpeakerR + kSpeakerU1 ///< == #kSpeakerL +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Speaker Arrangement Types*/ +//------------------------------------------------------------------------------------------------------- +enum VstSpeakerArrangementType +{ +//------------------------------------------------------------------------------------------------------- + kSpeakerArrUserDefined = -2,///< user defined + kSpeakerArrEmpty = -1, ///< empty arrangement + kSpeakerArrMono = 0, ///< M + kSpeakerArrStereo, ///< L R + kSpeakerArrStereoSurround, ///< Ls Rs + kSpeakerArrStereoCenter, ///< Lc Rc + kSpeakerArrStereoSide, ///< Sl Sr + kSpeakerArrStereoCLfe, ///< C Lfe + kSpeakerArr30Cine, ///< L R C + kSpeakerArr30Music, ///< L R S + kSpeakerArr31Cine, ///< L R C Lfe + kSpeakerArr31Music, ///< L R Lfe S + kSpeakerArr40Cine, ///< L R C S (LCRS) + kSpeakerArr40Music, ///< L R Ls Rs (Quadro) + kSpeakerArr41Cine, ///< L R C Lfe S (LCRS+Lfe) + kSpeakerArr41Music, ///< L R Lfe Ls Rs (Quadro+Lfe) + kSpeakerArr50, ///< L R C Ls Rs + kSpeakerArr51, ///< L R C Lfe Ls Rs + kSpeakerArr60Cine, ///< L R C Ls Rs Cs + kSpeakerArr60Music, ///< L R Ls Rs Sl Sr + kSpeakerArr61Cine, ///< L R C Lfe Ls Rs Cs + kSpeakerArr61Music, ///< L R Lfe Ls Rs Sl Sr + kSpeakerArr70Cine, ///< L R C Ls Rs Lc Rc + kSpeakerArr70Music, ///< L R C Ls Rs Sl Sr + kSpeakerArr71Cine, ///< L R C Lfe Ls Rs Lc Rc + kSpeakerArr71Music, ///< L R C Lfe Ls Rs Sl Sr + kSpeakerArr80Cine, ///< L R C Ls Rs Lc Rc Cs + kSpeakerArr80Music, ///< L R C Ls Rs Cs Sl Sr + kSpeakerArr81Cine, ///< L R C Lfe Ls Rs Lc Rc Cs + kSpeakerArr81Music, ///< L R C Lfe Ls Rs Cs Sl Sr + kSpeakerArr102, ///< L R C Lfe Ls Rs Tfl Tfc Tfr Trl Trr Lfe2 + kNumSpeakerArr +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +// Offline Processing +//------------------------------------------------------------------------------------------------------- +//------------------------------------------------------------------------------------------------------- +/** Offline Task Description. */ +//------------------------------------------------------------------------------------------------------- +struct VstOfflineTask +{ +//------------------------------------------------------------------------------------------------------- + char processName[96]; ///< set by plug-in + + // audio access + double readPosition; ///< set by plug-in/Host + double writePosition; ///< set by plug-in/Host + VstInt32 readCount; ///< set by plug-in/Host + VstInt32 writeCount; ///< set by plug-in + VstInt32 sizeInputBuffer; ///< set by Host + VstInt32 sizeOutputBuffer; ///< set by Host + void* inputBuffer; ///< set by Host + void* outputBuffer; ///< set by Host + double positionToProcessFrom; ///< set by Host + double numFramesToProcess; ///< set by Host + double maxFramesToWrite; ///< set by plug-in + + // other data access + void* extraBuffer; ///< set by plug-in + VstInt32 value; ///< set by Host or plug-in + VstInt32 index; ///< set by Host or plug-in + + // file attributes + double numFramesInSourceFile; ///< set by Host + double sourceSampleRate; ///< set by Host or plug-in + double destinationSampleRate; ///< set by Host or plug-in + VstInt32 numSourceChannels; ///< set by Host or plug-in + VstInt32 numDestinationChannels;///< set by Host or plug-in + VstInt32 sourceFormat; ///< set by Host + VstInt32 destinationFormat; ///< set by plug-in + char outputText[512]; ///< set by plug-in or Host + + // progress notification + double progress; ///< set by plug-in + VstInt32 progressMode; ///< Reserved for future use + char progressText[100]; ///< set by plug-in + + VstInt32 flags; ///< set by Host and plug-in; see enum #VstOfflineTaskFlags + VstInt32 returnValue; ///< Reserved for future use + void* hostOwned; ///< set by Host + void* plugOwned; ///< set by plug-in + + char future[1024]; ///< Reserved for future use +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Flags used in #VstOfflineTask. */ +//------------------------------------------------------------------------------------------------------- +enum VstOfflineTaskFlags +{ +//------------------------------------------------------------------------------------------------------- + kVstOfflineUnvalidParameter = 1 << 0, ///< set by Host + kVstOfflineNewFile = 1 << 1, ///< set by Host + + kVstOfflinePlugError = 1 << 10, ///< set by plug-in + kVstOfflineInterleavedAudio = 1 << 11, ///< set by plug-in + kVstOfflineTempOutputFile = 1 << 12, ///< set by plug-in + kVstOfflineFloatOutputFile = 1 << 13, ///< set by plug-in + kVstOfflineRandomWrite = 1 << 14, ///< set by plug-in + kVstOfflineStretch = 1 << 15, ///< set by plug-in + kVstOfflineNoThread = 1 << 16 ///< set by plug-in +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Option passed to #offlineRead/#offlineWrite. */ +//------------------------------------------------------------------------------------------------------- +enum VstOfflineOption +{ +//------------------------------------------------------------------------------------------------------- + kVstOfflineAudio, ///< reading/writing audio samples + kVstOfflinePeaks, ///< reading graphic representation + kVstOfflineParameter, ///< reading/writing parameters + kVstOfflineMarker, ///< reading/writing marker + kVstOfflineCursor, ///< reading/moving edit cursor + kVstOfflineSelection, ///< reading/changing selection + kVstOfflineQueryFiles ///< to request the Host to call asynchronously #offlineNotify +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Structure passed to #offlineNotify and #offlineStart */ +//------------------------------------------------------------------------------------------------------- +struct VstAudioFile +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 flags; ///< see enum #VstAudioFileFlags + void* hostOwned; ///< any data private to Host + void* plugOwned; ///< any data private to plug-in + char name[kVstMaxFileNameLen]; ///< file title + VstInt32 uniqueId; ///< uniquely identify a file during a session + double sampleRate; ///< file sample rate + VstInt32 numChannels; ///< number of channels (1 for mono, 2 for stereo...) + double numFrames; ///< number of frames in the audio file + VstInt32 format; ///< Reserved for future use + double editCursorPosition; ///< -1 if no such cursor + double selectionStart; ///< frame index of first selected frame, or -1 + double selectionSize; ///< number of frames in selection, or 0 + VstInt32 selectedChannelsMask; ///< 1 bit per channel + VstInt32 numMarkers; ///< number of markers in the file + VstInt32 timeRulerUnit; ///< see doc for possible values + double timeRulerOffset; ///< offset in time ruler (positive or negative) + double tempo; ///< as BPM (Beats Per Minute) + VstInt32 timeSigNumerator; ///< time signature numerator + VstInt32 timeSigDenominator; ///< time signature denominator + VstInt32 ticksPerBlackNote; ///< resolution + VstInt32 smpteFrameRate; ///< SMPTE rate (set as in #VstTimeInfo) + + char future[64]; ///< Reserved for future use +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Flags used in #VstAudioFile. */ +//------------------------------------------------------------------------------------------------------- +enum VstAudioFileFlags +{ +//------------------------------------------------------------------------------------------------------- + kVstOfflineReadOnly = 1 << 0, ///< set by Host (in call #offlineNotify) + kVstOfflineNoRateConversion = 1 << 1, ///< set by Host (in call #offlineNotify) + kVstOfflineNoChannelChange = 1 << 2, ///< set by Host (in call #offlineNotify) + + kVstOfflineCanProcessSelection = 1 << 10, ///< set by plug-in (in call #offlineStart) + kVstOfflineNoCrossfade = 1 << 11, ///< set by plug-in (in call #offlineStart) + kVstOfflineWantRead = 1 << 12, ///< set by plug-in (in call #offlineStart) + kVstOfflineWantWrite = 1 << 13, ///< set by plug-in (in call #offlineStart) + kVstOfflineWantWriteMarker = 1 << 14, ///< set by plug-in (in call #offlineStart) + kVstOfflineWantMoveCursor = 1 << 15, ///< set by plug-in (in call #offlineStart) + kVstOfflineWantSelect = 1 << 16 ///< set by plug-in (in call #offlineStart) +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Audio file marker. */ +//------------------------------------------------------------------------------------------------------- +struct VstAudioFileMarker +{ +//------------------------------------------------------------------------------------------------------- + double position; ///< marker position + char name[32]; ///< marker name + VstInt32 type; ///< marker type + VstInt32 id; ///< marker identifier + VstInt32 reserved; ///< reserved for future use +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +// Others +//------------------------------------------------------------------------------------------------------- + +//------------------------------------------------------------------------------------------------------- +/** \deprecated Structure used for #openWindow and #closeWindow (deprecated in VST 2.4). */ +//------------------------------------------------------------------------------------------------------- +struct DECLARE_VST_DEPRECATED (VstWindow) +{ +//------------------------------------------------------------------------------------------------------- + char title[128]; + VstInt16 xPos; + VstInt16 yPos; + VstInt16 width; + VstInt16 height; + VstInt32 style; + void* parent; + void* userHandle; + void* winHandle; + + char future[104]; +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Structure used for keyUp/keyDown. */ +//------------------------------------------------------------------------------------------------------- +struct VstKeyCode +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 character; ///< ASCII character + unsigned char virt; ///< @see VstVirtualKey + unsigned char modifier; ///< @see VstModifierKey +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Platform-independent definition of Virtual Keys (used in #VstKeyCode). */ +//------------------------------------------------------------------------------------------------------- +enum VstVirtualKey +{ +//------------------------------------------------------------------------------------------------------- + VKEY_BACK = 1, + VKEY_TAB, + VKEY_CLEAR, + VKEY_RETURN, + VKEY_PAUSE, + VKEY_ESCAPE, + VKEY_SPACE, + VKEY_NEXT, + VKEY_END, + VKEY_HOME, + VKEY_LEFT, + VKEY_UP, + VKEY_RIGHT, + VKEY_DOWN, + VKEY_PAGEUP, + VKEY_PAGEDOWN, + VKEY_SELECT, + VKEY_PRINT, + VKEY_ENTER, + VKEY_SNAPSHOT, + VKEY_INSERT, + VKEY_DELETE, + VKEY_HELP, + VKEY_NUMPAD0, + VKEY_NUMPAD1, + VKEY_NUMPAD2, + VKEY_NUMPAD3, + VKEY_NUMPAD4, + VKEY_NUMPAD5, + VKEY_NUMPAD6, + VKEY_NUMPAD7, + VKEY_NUMPAD8, + VKEY_NUMPAD9, + VKEY_MULTIPLY, + VKEY_ADD, + VKEY_SEPARATOR, + VKEY_SUBTRACT, + VKEY_DECIMAL, + VKEY_DIVIDE, + VKEY_F1, + VKEY_F2, + VKEY_F3, + VKEY_F4, + VKEY_F5, + VKEY_F6, + VKEY_F7, + VKEY_F8, + VKEY_F9, + VKEY_F10, + VKEY_F11, + VKEY_F12, + VKEY_NUMLOCK, + VKEY_SCROLL, + VKEY_SHIFT, + VKEY_CONTROL, + VKEY_ALT, + VKEY_EQUALS +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Modifier flags used in #VstKeyCode. */ +//------------------------------------------------------------------------------------------------------- +enum VstModifierKey +{ +//------------------------------------------------------------------------------------------------------- + MODIFIER_SHIFT = 1<<0, ///< Shift + MODIFIER_ALTERNATE = 1<<1, ///< Alt + MODIFIER_COMMAND = 1<<2, ///< Control on Mac + MODIFIER_CONTROL = 1<<3 ///< Ctrl on PC, Apple on Mac +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** File filter used in #VstFileSelect. */ +//------------------------------------------------------------------------------------------------------- +typedef struct VstFileType +{ +//------------------------------------------------------------------------------------------------------- + char name[128]; ///< display name + char macType[8]; ///< MacOS type + char dosType[8]; ///< Windows file extension + char unixType[8]; ///< Unix file extension + char mimeType1[128]; ///< MIME type + char mimeType2[128]; ///< additional MIME type + +#ifdef __cplusplus + VstFileType (const char* _name = 0, const char* _macType = 0, const char* _dosType = 0, + const char* _unixType = 0, const char* _mimeType1 = 0, const char* _mimeType2 = 0) + { + vst_strncpy (name, _name ? _name : "", 127); + vst_strncpy (macType, _macType ? _macType : "", 7); + vst_strncpy (dosType, _dosType ? _dosType : "", 7); + vst_strncpy (unixType, _unixType ? _unixType : "", 7); + vst_strncpy (mimeType1, _mimeType1 ? _mimeType1 : "", 127); + vst_strncpy (mimeType2, _mimeType2 ? _mimeType2 : "", 127); + } +#endif // __cplusplus +//------------------------------------------------------------------------------------------------------- +} VstFileType; + +//------------------------------------------------------------------------------------------------------- +/** File Selector Description used in #audioMasterOpenFileSelector. */ +//------------------------------------------------------------------------------------------------------- +struct VstFileSelect +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 command; ///< @see VstFileSelectCommand + VstInt32 type; ///< @see VstFileSelectType + VstInt32 macCreator; ///< optional: 0 = no creator + VstInt32 nbFileTypes; ///< number of fileTypes + VstFileType* fileTypes; ///< list of fileTypes @see VstFileType + char title[1024]; ///< text to display in file selector's title + char* initialPath; ///< initial path + char* returnPath; ///< use with #kVstFileLoad and #kVstDirectorySelect. null: Host allocates memory, plug-in must call #closeOpenFileSelector! + VstInt32 sizeReturnPath; ///< size of allocated memory for return paths + char** returnMultiplePaths; ///< use with kVstMultipleFilesLoad. Host allocates memory, plug-in must call #closeOpenFileSelector! + VstInt32 nbReturnPath; ///< number of selected paths + VstIntPtr reserved; ///< reserved for Host application + + char future[116]; ///< reserved for future use +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Command constants used in #VstFileSelect structure. */ +//------------------------------------------------------------------------------------------------------- +enum VstFileSelectCommand +{ +//------------------------------------------------------------------------------------------------------- + kVstFileLoad = 0, ///< for loading a file + kVstFileSave, ///< for saving a file + kVstMultipleFilesLoad, ///< for loading multiple files + kVstDirectorySelect ///< for selecting a directory/folder +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Types used in #VstFileSelect structure. */ +//------------------------------------------------------------------------------------------------------- +enum VstFileSelectType +{ +//------------------------------------------------------------------------------------------------------- + kVstFileType = 0 ///< regular file selector +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Structure used for #effBeginLoadBank/#effBeginLoadProgram. */ +//------------------------------------------------------------------------------------------------------- +struct VstPatchChunkInfo +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 version; ///< Format Version (should be 1) + VstInt32 pluginUniqueID; ///< UniqueID of the plug-in + VstInt32 pluginVersion; ///< Plug-in Version + VstInt32 numElements; ///< Number of Programs (Bank) or Parameters (Program) + + char future[48]; ///< Reserved for future use +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** PanLaw Type. */ +//------------------------------------------------------------------------------------------------------- +enum VstPanLawType +{ +//------------------------------------------------------------------------------------------------------- + kLinearPanLaw = 0, ///< L = pan * M; R = (1 - pan) * M; + kEqualPowerPanLaw ///< L = pow (pan, 0.5) * M; R = pow ((1 - pan), 0.5) * M; +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Process Levels returned by #audioMasterGetCurrentProcessLevel. */ +//------------------------------------------------------------------------------------------------------- +enum VstProcessLevels +{ +//------------------------------------------------------------------------------------------------------- + kVstProcessLevelUnknown = 0, ///< not supported by Host + kVstProcessLevelUser, ///< 1: currently in user thread (GUI) + kVstProcessLevelRealtime, ///< 2: currently in audio thread (where process is called) + kVstProcessLevelPrefetch, ///< 3: currently in 'sequencer' thread (MIDI, timer etc) + kVstProcessLevelOffline ///< 4: currently offline processing and thus in user thread +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +/** Automation States returned by #audioMasterGetAutomationState. */ +//------------------------------------------------------------------------------------------------------- +enum VstAutomationStates +{ +//------------------------------------------------------------------------------------------------------- + kVstAutomationUnsupported = 0, ///< not supported by Host + kVstAutomationOff, ///< off + kVstAutomationRead, ///< read + kVstAutomationWrite, ///< write + kVstAutomationReadWrite ///< read and write +//------------------------------------------------------------------------------------------------------- +}; + +//------------------------------------------------------------------------------------------------------- +#ifdef TARGET_API_MAC_CARBON + #pragma options align=reset +#elif defined(WIN32) || defined(__FLAT__) || defined(__GNUC__) + #pragma pack(pop) +#elif defined __BORLANDC__ + #pragma -a- +#endif +//------------------------------------------------------------------------------------------------------- + +#endif //__aeffectx__ diff --git a/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/vstfxstore.h b/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/vstfxstore.h new file mode 100644 index 0000000..7f80a95 --- /dev/null +++ b/core/audio/plugin_host/vst2/pluginterfaces/vst2.x/vstfxstore.h @@ -0,0 +1,128 @@ +//------------------------------------------------------------------------ +// Project : VST SDK +// Version : 2.4 +// +// Category : VST 2.x Interfaces +// Filename : pluginterfaces/vst2.x/vstfxstore.h +// Created by : Steinberg, 01/2004 +// Description : Definition of Program (fxp) and Bank (fxb) structures +// +//----------------------------------------------------------------------------- +// LICENSE +// (c) 2016, Steinberg Media Technologies GmbH, All Rights Reserved +//----------------------------------------------------------------------------- +// This Software Development Kit may not be distributed in parts or its entirety +// without prior written agreement by Steinberg Media Technologies GmbH. +// This SDK must not be used to re-engineer or manipulate any technology used +// in any Steinberg or Third-party application or software module, +// unless permitted by law. +// Neither the name of the Steinberg Media Technologies nor the names of its +// contributors may be used to endorse or promote products derived from this +// software without specific prior written permission. +// +// THIS SDK IS PROVIDED BY STEINBERG MEDIA TECHNOLOGIES GMBH "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +// IN NO EVENT SHALL STEINBERG MEDIA TECHNOLOGIES GMBH BE LIABLE FOR ANY DIRECT, +// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +// OF THE POSSIBILITY OF SUCH DAMAGE. +//---------------------------------------------------------------------------------- + +#ifndef __vstfxstore__ +#define __vstfxstore__ + +#ifndef __aeffect__ +#include "aeffect.h" +#endif + +//------------------------------------------------------------------------------------------------------- +/** Root chunk identifier for Programs (fxp) and Banks (fxb). */ +#define cMagic 'CcnK' + +/** Regular Program (fxp) identifier. */ +#define fMagic 'FxCk' + +/** Regular Bank (fxb) identifier. */ +#define bankMagic 'FxBk' + +/** Program (fxp) identifier for opaque chunk data. */ +#define chunkPresetMagic 'FPCh' + +/** Bank (fxb) identifier for opaque chunk data. */ +#define chunkBankMagic 'FBCh' + +/* + Note: The C data structures below are for illustration only. You can not read/write them directly. + The byte order on disk of fxp and fxb files is Big Endian. You have to swap integer + and floating-point values on Little Endian platforms (Windows, MacIntel)! +*/ + +//------------------------------------------------------------------------------------------------------- +/** Program (fxp) structure. */ +//------------------------------------------------------------------------------------------------------- +typedef struct fxProgram +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 chunkMagic; ///< 'CcnK' + VstInt32 byteSize; ///< size of this chunk, excl. magic + byteSize + + VstInt32 fxMagic; ///< 'FxCk' (regular) or 'FPCh' (opaque chunk) + VstInt32 version; ///< format version (currently 1) + VstInt32 fxID; ///< fx unique ID + VstInt32 fxVersion; ///< fx version + + VstInt32 numParams; ///< number of parameters + char prgName[28]; ///< program name (null-terminated ASCII string) + + union + { + float params[1]; ///< variable sized array with parameter values + struct + { + VstInt32 size; ///< size of program data + char chunk[1]; ///< variable sized array with opaque program data + } data; ///< program chunk data + } content; ///< program content depending on fxMagic +//------------------------------------------------------------------------------------------------------- +} fxProgram; + +//------------------------------------------------------------------------------------------------------- +/** Bank (fxb) structure. */ +//------------------------------------------------------------------------------------------------------- +struct fxBank +{ +//------------------------------------------------------------------------------------------------------- + VstInt32 chunkMagic; ///< 'CcnK' + VstInt32 byteSize; ///< size of this chunk, excl. magic + byteSize + + VstInt32 fxMagic; ///< 'FxBk' (regular) or 'FBCh' (opaque chunk) + VstInt32 version; ///< format version (1 or 2) + VstInt32 fxID; ///< fx unique ID + VstInt32 fxVersion; ///< fx version + + VstInt32 numPrograms; ///< number of programs + +#if VST_2_4_EXTENSIONS + VstInt32 currentProgram; ///< version 2: current program number + char future[124]; ///< reserved, should be zero +#else + char future[128]; ///< reserved, should be zero +#endif + + union + { + fxProgram programs[1]; ///< variable number of programs + struct + { + VstInt32 size; ///< size of bank data + char chunk[1]; ///< variable sized array with opaque bank data + } data; ///< bank chunk data + } content; ///< bank content depending on fxMagic +//------------------------------------------------------------------------------------------------------- +}; + +#endif // __vstfxstore__ diff --git a/core/audio/plugin_host/vst2/vst2_plugin_host.cpp b/core/audio/plugin_host/vst2/vst2_plugin_host.cpp new file mode 100644 index 0000000..0846590 --- /dev/null +++ b/core/audio/plugin_host/vst2/vst2_plugin_host.cpp @@ -0,0 +1,266 @@ +#include "vst2_plugin_host.h" + +#include "audio/device/audio_device_manager.h" +#include "audio/mixer/channel_interface.h" +#include "misc/glfw_misc.h" + +std::map> vst2_library_map; +VstTimeInfo vst2_plugin_host::vst_time_info{}; + +std::map can_do_map = +{ + {"sendVstEvents", true}, + {"sendVstMidiEvent", true}, + {"sendVstTimeInfo", true}, + {"receiveVstEvents", false}, + {"receiveVstMidiEvent", false}, + {"receiveVstTimeInfo", false}, + {"offline", false}, + {"reportConnectionChanges", false}, + {"acceptIOChanges", true}, + {"sizeWindow", true}, + {"asyncProcessing", true}, + {"supplyIdle", true}, + {"supportShell", false}, + {"openFileSelector", false}, + {"editFile", false}, + {"closeFileSelector", false}, + {"NIMKPIVendorSpecificCallbacks", false}, +}; + +std::shared_ptr get_vst2_library(const std::string& path) { + if (vst2_library_map.contains(path) && !vst2_library_map[path].expired()) { + return vst2_library_map[path].lock(); + } + auto library = std::make_shared(path); + vst2_library_map[path] = library; + return library; +} + +bool vst_host_can_do(const char* can_do) +{ + if (can_do_map.contains(can_do)) + return can_do_map[can_do]; + spdlog::warn("Unknown can do: {}", can_do); + return false; +} + +VstIntPtr vst_master_callback(AEffect* effect, VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt) +{ + switch (opcode) + { + case audioMasterAutomate: + return 1; + case audioMasterVersion: + return kVstVersion; // 返回插件版本号 + case audioMasterWantMidi: + return 1; + case audioMasterGetSampleRate: + return g_audio_device_manager.get_sample_rate(); // 返回采样率 + case audioMasterGetCurrentProcessLevel: + return kVstProcessLevelRealtime; // 返回当前处理级别 + case audioMasterGetBlockSize: + return g_audio_device_manager.get_buffer_size(); // 返回块大小 + case audioMasterSizeWindow: + { + // 设置插件窗口大小 + // FVST2PluginHost* Host = static_cast(Effect->user); + // if (const TSharedPtr Window = FWindowManager::Get().FindPluginEditor(Host)) + // Window->Resize(FVector2D(Index, Value)); + return 1; + } + case audioMasterGetTime: + return (VstIntPtr)&vst2_plugin_host::vst_time_info; + case audioMasterIdle: + // UE_LOG(LogTemp, Log, TEXT("Plugin Idle")); + return 1; + case audioMasterNeedIdle: + // UE_LOG(LogTemp, Log, TEXT("Plugin Need Idle")); + return 1; + case audioMasterGetVendorString: + { + const char* Ptr1 = (const char*)ptr; + Ptr1 = "Arona"; + return 1; + } + case audioMasterGetProductString: + { + const char* Ptr1 = (const char*)ptr; + Ptr1 = "Arona"; + return 1; + } + case audioMasterGetVendorVersion: + return 1000; + case audioMasterCanDo: + { + const char* Ptr1 = (const char*)ptr; + return vst_host_can_do(Ptr1) ? 1 : 0; + } + case audioMasterUpdateDisplay: + return 1; + case audioMasterBeginEdit: + { + // UE_LOG(LogTemp, Log, TEXT("Want Begin Edit")); + return 1; + } + case audioMasterEndEdit: + { + // UE_LOG(LogTemp, Log, TEXT("Want End Edit")); + return 1; + } + case audioMasterVendorSpecific: + return 0; + case audioMasterProcessEvents: + // TODO + { + VstEvents* Events = (VstEvents*)ptr; + Events->events[0]->type; + // FVST2PluginHost* Host = static_cast(Effect->user); + + } + return 1; + default: break; + // ensureMsgf(0, TEXT("No Implement OpCode: %d"), OpCode); + } + + return 1; +} + +typedef AEffect*(*vst_plugin_entry_proc)(audioMasterCallback AudioMaster); + +vst2_plugin_host::vst2_plugin_host() { + effect_ = nullptr; + library_ = nullptr; +} + +vst2_plugin_host::~vst2_plugin_host() { + spdlog::info("vst2 plugin {} destroyed", name); + if (effect_) { + dispatch(effClose); + } +} + +bool vst2_plugin_host::load_plugin(const char* path) { + // load vst + library_ = get_vst2_library(path); + // get main function + const auto entry_proc = static_cast(library_->get_function("VSTPluginMain")); + if (!entry_proc) { + spdlog::error("Failed to get entry point from {}", path); + return false; + } + // create effect + effect_ = entry_proc(&vst_master_callback); + if (!effect_) { + return false; + } + if (effect_->magic != kEffectMagic) + throw std::runtime_error("Not a VST2 plugin"); + effect_->user = this; + + name = load_name(); + vendor = load_vendor(); + + dispatch(effOpen); + return true; +} + +void vst2_plugin_host::set_enabled(bool enabled) { + enabled_ = enabled; + dispatch(effMainsChanged, 0, enabled); +} + +bool vst2_plugin_host::is_enabled() const { + return enabled_; +} + +void vst2_plugin_host::on_update_sample_rate(double sample_rate) { + dispatch(effSetSampleRate, 0, 0, nullptr, sample_rate); +} + +void vst2_plugin_host::on_update_buffer_size(int buffer_size) { + dispatch(effSetBlockSize, 0, buffer_size); +} + +uint32_t vst2_plugin_host::get_input_channels() const { + return effect_->numInputs; +} + +uint32_t vst2_plugin_host::get_output_channels() const { + return effect_->numOutputs; +} + +void vst2_plugin_host::update_channel_node_name() { + for (int i = 0; i < effect_->numInputs; ++i) + { + VstPinProperties pin_properties{}; + if (dispatch(effGetInputProperties, i, 0, &pin_properties) == 1) + { + channel->set_input_channel_node_name(i / 2, i, pin_properties.label); + } + } + + for (int i = 0; i < effect_->numOutputs; ++i) + { + VstPinProperties pin_properties{}; + if (dispatch(effGetOutputProperties, i, 0, &pin_properties) == 1) + { + channel->set_output_channel_node_name(i / 2, i, pin_properties.label); + } + } +} + +void vst2_plugin_host::process(uint32_t frame_num) { + // TODO send midi + + + effect_->processReplacing(effect_, channel->get_input_headers(), channel->get_output_headers(), frame_num); +} + +void vst2_plugin_host::open_editor(GLFWwindow* window) { + if (!has_editor()) + return; + void* window_handle = glfwGetWindowHandle(window); + + dispatch(effEditOpen, 0, 0, window_handle); +} + +void vst2_plugin_host::close_editor() { + if (!has_editor()) + return; + dispatch(effEditClose); +} + +void vst2_plugin_host::idle_editor() { + plugin_host::idle_editor(); + dispatch(effEditIdle); +} + +bool vst2_plugin_host::has_editor() const { + return effect_->flags & effFlagsHasEditor; +} + +ImVec2 vst2_plugin_host::get_editor_size() const { + ERect* EditorRect = nullptr; + dispatch(effEditGetRect, 0, 0, &EditorRect); + if (EditorRect) + return ImVec2(EditorRect->right - EditorRect->left, EditorRect->bottom - EditorRect->top); + return ImVec2(0, 0); +} + +std::string vst2_plugin_host::load_name() const { + char buffer[256]; + dispatch(effGetEffectName, 0, 0, buffer); + return buffer; +} + +std::string vst2_plugin_host::load_vendor() const { + char buffer[256]; + dispatch(effGetVendorString, 0, 0, buffer); + return buffer; +} + + +VstIntPtr vst2_plugin_host::dispatch(VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt) const { + return effect_->dispatcher(effect_, opcode, index, value, ptr, opt); +} diff --git a/core/audio/plugin_host/vst2/vst2_plugin_host.h b/core/audio/plugin_host/vst2/vst2_plugin_host.h new file mode 100644 index 0000000..19afc31 --- /dev/null +++ b/core/audio/plugin_host/vst2/vst2_plugin_host.h @@ -0,0 +1,38 @@ +#pragma once +#include "audio/plugin_host/plugin_host.h" +#include "misc/lib_load.h" +#include "pluginterfaces/vst2.x/aeffect.h" +#include "pluginterfaces/vst2.x/aeffectx.h" + +class vst2_plugin_host : public plugin_host { +public: + static VstTimeInfo vst_time_info; + vst2_plugin_host(); + ~vst2_plugin_host() override; + bool load_plugin(const char* path) override; + + void set_enabled(bool enabled) override; + bool is_enabled() const override; + + void on_update_sample_rate(double sample_rate) override; + void on_update_buffer_size(int buffer_size) override; + [[nodiscard]] uint32_t get_input_channels() const override; + [[nodiscard]] uint32_t get_output_channels() const override; + void update_channel_node_name() override; + + void process(uint32_t frame_num) override; + + void open_editor(GLFWwindow* window) override; + void close_editor() override; + void idle_editor() override; + [[nodiscard]] bool has_editor() const override; + [[nodiscard]] ImVec2 get_editor_size() const override; + + [[nodiscard]] std::string load_name() const override; + [[nodiscard]] std::string load_vendor() const override; +private: + VstIntPtr dispatch(VstInt32 opcode, VstInt32 index = 0, VstIntPtr value = 0, void* ptr = nullptr, float opt = 0) const; + AEffect* effect_; + std::shared_ptr library_; + bool enabled_ = false; +}; diff --git a/core/misc/glfw_misc.cpp b/core/misc/glfw_misc.cpp new file mode 100644 index 0000000..ea4c10b --- /dev/null +++ b/core/misc/glfw_misc.cpp @@ -0,0 +1,20 @@ +#include "glfw_misc.h" + +#ifdef WIN32 +#define GLFW_EXPOSE_NATIVE_WIN32 +#elif defined(__APPLE__) +#define GLFW_EXPOSE_NATIVE_COCOA +#else +#define GLFW_EXPOSE_NATIVE_X11 +#endif +#include + +void* glfwGetWindowHandle(GLFWwindow* window) { +#ifdef WIN32 + return glfwGetWin32Window(window); +#elif defined(__APPLE__) + return glfwGetCocoaWindow(window); +#else + return glfwGetX11Window(window); +#endif +} diff --git a/core/misc/glfw_misc.h b/core/misc/glfw_misc.h new file mode 100644 index 0000000..7015a68 --- /dev/null +++ b/core/misc/glfw_misc.h @@ -0,0 +1,7 @@ +#pragma once +#include "GLFW/glfw3.h" + +extern "C" +{ + CORE_API void* glfwGetWindowHandle(GLFWwindow* window); +} diff --git a/core/misc/lib_load.h b/core/misc/lib_load.h new file mode 100644 index 0000000..0902a20 --- /dev/null +++ b/core/misc/lib_load.h @@ -0,0 +1,62 @@ +#pragma once +#include +#include "spdlog/spdlog.h" + +#ifdef _WIN32 +#include +#else +#include +#endif + +class CORE_API dynamic_library { +public: + dynamic_library() { + + } + + explicit dynamic_library(const std::string& libraryPath) { +#ifdef _WIN32 + hModule = LoadLibraryA(libraryPath.c_str()); +#else + handle = dlopen(libraryPath.c_str(), RTLD_LAZY); +#endif + if (!get_handle()) { + spdlog::error("Failed to load library: {}", libraryPath); + throw std::runtime_error("Failed to load library"); + } + spdlog::info("Load library: {}", libraryPath); + } + + ~dynamic_library() { +#ifdef _WIN32 + if (hModule) FreeLibrary(hModule); +#else + if (handle) dlclose(handle); +#endif + } + + [[nodiscard]] void* get_function(const char* functionName) const { +#ifdef _WIN32 + return GetProcAddress(hModule, functionName); +#else + dlerror(); // 清除之前的错误 + void* function = dlsym(handle, functionName); + // 添加错误检查 + return function; +#endif + } + + [[nodiscard]] void* get_handle() const { +#ifdef _WIN32 + return hModule; +#else + return handle; +#endif + } +private: +#ifdef _WIN32 + HMODULE hModule = nullptr; +#else + void* handle = nullptr; +#endif +}; diff --git a/core/misc/singleton/singleton.h b/core/misc/singleton/singleton.h index 0ea43a2..a821994 100644 --- a/core/misc/singleton/singleton.h +++ b/core/misc/singleton/singleton.h @@ -41,3 +41,12 @@ public: singleton_manager::get()->add(this); } }; + +#if defined(core_EXPORTS) +#define DEFINE_SINGLETON_INSTANCE(T) \ + inline T g_##T; \ + extern "C" CORE_API inline T& get_##T() { return g_##T; } +#else +#define DEFINE_SINGLETON_INSTANCE(T) \ + extern "C" CORE_API inline T& get_##T(); +#endif diff --git a/core/rhi/renderer.h b/core/rhi/renderer.h index 9e5187b..9ad9dd7 100644 --- a/core/rhi/renderer.h +++ b/core/rhi/renderer.h @@ -7,9 +7,9 @@ #include -#ifdef _DEBUG -#define APP_USE_VULKAN_DEBUG_REPORT -#endif +// #ifdef _DEBUG +// #define APP_USE_VULKAN_DEBUG_REPORT +// #endif #define APP_USE_UNLIMITED_FRAME_RATE