//-------------------------------------------------------------------------------------------------------
// VST Plug-Ins SDK
// Version 2.4      $Date: 2006/06/20 12:43:42 $
//
// Category     : VST 2.x Interfaces
// Filename     : aeffectx.h
// Created by   : Steinberg Media Technologies
// Description  : Definition of auxiliary structures, extensions from VST 1.0 to VST 2.4
//
// © 2006, Steinberg Media Technologies, All Rights Reserved
//-------------------------------------------------------------------------------------------------------

#ifndef __aeffectx__
#define __aeffectx__

#ifndef __aeffect__
#include "aeffect.h"
#endif

//-------------------------------------------------------------------------------------------------------
#if TARGET_API_MAC_CARBON
    #ifdef __LP64__
    #pragma options align=power
    #else
    #pragma options align=mac68k
    #endif
#elif defined __BORLANDC__
    #pragma -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. */
//-------------------------------------------------------------------------------------------------------
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 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. */
//-------------------------------------------------------------------------------------------------------
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
//-------------------------------------------------------------------------------------------------------
};

//-------------------------------------------------------------------------------------------------------
/** 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. */
//-------------------------------------------------------------------------------------------------------
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

    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);
    }
//-------------------------------------------------------------------------------------------------------
};

//-------------------------------------------------------------------------------------------------------
/** 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
//-------------------------------------------------------------------------------------------------------
};

//-------------------------------------------------------------------------------------------------------
#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 //__aeffectx__
