//------------------------------------------------------------------------------------------------------- // 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__