//------------------------------------------------------------------------------------------------------- // VST Plug-Ins SDK // Version 2.3 Extension // © 2003, Steinberg Media Technologies, All Rights Reserved //------------------------------------------------------------------------------------------------------- #ifndef __aeffectx__ #define __aeffectx__ #ifndef __AEffect__ #include "AEffect.h" #endif #include // for strcpy #if PRAGMA_STRUCT_ALIGN || __MWERKS__ #pragma options align=mac68k #elif defined __BORLANDC__ #pragma -a8 #elif defined(WIN32) || defined(__FLAT__) #pragma pack(push) #pragma pack(8) #endif //------------------------------------------------- // VstEvent //------------------------------------------------- typedef struct VstEvent VstEvent; typedef struct VstMidiEvent VstMidiEvent; typedef struct VstEvents VstEvents; struct VstEvent // a generic timestamped event { long type; // see enum below long byteSize; // of this event, excl. type and byteSize long deltaFrames; // sample frames related to the current block start sample position long flags; // generic flags, none defined yet (0) char data[16]; // size may vary but is usually 16 }; //----VstEvent Types------------------------------- enum { kVstMidiType = 1, // midi event, can be cast as VstMidiEvent (see below) kVstAudioType, // audio kVstVideoType, // video kVstParameterType, // parameter kVstTriggerType, // trigger kVstSysExType // midi system exclusive // ...etc }; struct VstEvents // a block of events for the current audio block { long numEvents; long reserved; // zero VstEvent* events[2]; // variable }; //---Defined Events-------------------------------- struct VstMidiEvent // to be casted from a VstEvent { long type; // kVstMidiType long byteSize; // 24 long deltaFrames; // sample frames related to the current block start sample position long flags; // none defined yet long noteLength; // (in sample frames) of entire note, if available, else 0 long noteOffset; // offset into note from note start if available, else 0 char midiData[4]; // 1 thru 3 midi bytes; midiData[3] is reserved (zero) char detune; // -64 to +63 cents; for scales other than 'well-tempered' ('microtuning') char noteOffVelocity; char reserved1; // zero char reserved2; // zero }; //------------------------------------------------- // VstTimeInfo //------------------------------------------------- typedef struct VstTimeInfo VstTimeInfo; // VstTimeInfo as requested via audioMasterGetTime (getTimeInfo()) // refers to the current time slice. note the new slice is // already started when processEvents() is called struct VstTimeInfo { double samplePos; // current location double sampleRate; double nanoSeconds; // system time double ppqPos; // 1 ppq double tempo; // in bpm double barStartPos; // last bar start, in 1 ppq double cycleStartPos; // 1 ppq double cycleEndPos; // 1 ppq long timeSigNumerator; // time signature long timeSigDenominator; long smpteOffset; long smpteFrameRate; // 0:24, 1:25, 2:29.97, 3:30, 4:29.97 df, 5:30 df long samplesToNextClock; // midi clock resolution (24 ppq), can be negative long flags; // see below }; enum { kVstTransportChanged = 1, // Indicates that Playing, Cycle or Recording has changed kVstTransportPlaying = 1 << 1, kVstTransportCycleActive = 1 << 2, kVstTransportRecording = 1 << 3, kVstAutomationWriting = 1 << 6, kVstAutomationReading = 1 << 7, // flags which indicate which of the fields in this VstTimeInfo // are valid; samplePos and sampleRate are always valid kVstNanosValid = 1 << 8, kVstPpqPosValid = 1 << 9, kVstTempoValid = 1 << 10, kVstBarsValid = 1 << 11, kVstCyclePosValid = 1 << 12, // start and end kVstTimeSigValid = 1 << 13, kVstSmpteValid = 1 << 14, kVstClockValid = 1 << 15 }; //------------------------------------------------- // Variable IO for Offline Processing //------------------------------------------------- typedef struct VstVariableIo VstVariableIo; struct VstVariableIo { float **inputs; float **outputs; long numSamplesInput; long numSamplesOutput; long *numSamplesInputProcessed; long *numSamplesOutputProcessed; }; //------------------------------------------------- // AudioMaster OpCodes //------------------------------------------------- enum { //---from here VST 2.0 extension opcodes------------------------------------------------------ // VstEvents + VstTimeInfo audioMasterWantMidi = audioMasterPinConnected + 2, // is a filter which is currently ignored audioMasterGetTime, // returns const VstTimeInfo* (or 0 if not supported) // should contain a mask indicating which fields are required // (see valid masks above), as some items may require extensive // conversions audioMasterProcessEvents, // VstEvents* in audioMasterSetTime, // VstTimenfo* in , filter in , not supported audioMasterTempoAt, // returns tempo (in bpm * 10000) at sample frame location passed in // parameters audioMasterGetNumAutomatableParameters, audioMasterGetParameterQuantization, // returns the integer value for +1.0 representation, // or 1 if full single float precision is maintained // in automation. parameter index in (-1: all, any) // connections, configuration audioMasterIOChanged, // numInputs and/or numOutputs has changed audioMasterNeedIdle, // plug needs idle calls (outside its editor window) audioMasterSizeWindow, // index: width, value: height audioMasterGetSampleRate, audioMasterGetBlockSize, audioMasterGetInputLatency, audioMasterGetOutputLatency, audioMasterGetPreviousPlug, // input pin in (-1: first to come), returns cEffect* audioMasterGetNextPlug, // output pin in (-1: first to come), returns cEffect* // realtime info audioMasterWillReplaceOrAccumulate, // returns: 0: not supported, 1: replace, 2: accumulate audioMasterGetCurrentProcessLevel, // returns: 0: not supported, // 1: currently in user thread (gui) // 2: currently in audio thread (where process is called) // 3: currently in 'sequencer' thread (midi, timer etc) // 4: currently offline processing and thus in user thread // other: not defined, but probably pre-empting user thread. audioMasterGetAutomationState, // returns 0: not supported, 1: off, 2:read, 3:write, 4:read/write // offline audioMasterOfflineStart, audioMasterOfflineRead, // ptr points to offline structure, see below. return 0: error, 1 ok audioMasterOfflineWrite, // same as read audioMasterOfflineGetCurrentPass, audioMasterOfflineGetCurrentMetaPass, // other audioMasterSetOutputSampleRate, // for variable i/o, sample rate in audioMasterGetSpeakerArrangement, // result in ret audioMasterGetOutputSpeakerArrangement = audioMasterGetSpeakerArrangement, audioMasterGetVendorString, // fills with a string identifying the vendor (max 64 char) audioMasterGetProductString, // fills with a string with product name (max 64 char) audioMasterGetVendorVersion, // returns vendor-specific version audioMasterVendorSpecific, // no definition, vendor specific handling audioMasterSetIcon, // void* in , format not defined yet audioMasterCanDo, // string in ptr, see below audioMasterGetLanguage, // see enum audioMasterOpenWindow, // returns platform specific ptr audioMasterCloseWindow, // close window, platform specific handle in audioMasterGetDirectory, // get plug directory, FSSpec on MAC, else char* audioMasterUpdateDisplay, // something has changed, update 'multi-fx' display //---from here VST 2.1 extension opcodes------------------------------------------------------ audioMasterBeginEdit, // begin of automation session (when mouse down), parameter index in audioMasterEndEdit, // end of automation session (when mouse up), parameter index in audioMasterOpenFileSelector, // open a fileselector window with VstFileSelect* in //---from here VST 2.2 extension opcodes------------------------------------------------------ audioMasterCloseFileSelector, // close a fileselector operation with VstFileSelect* in : Must be always called after an open ! audioMasterEditFile, // open an editor for audio (defined by XML text in ptr) audioMasterGetChunkFile, // get the native path of currently loading bank or project // (called from writeChunk) void* in (char[2048], or sizeof(FSSpec)) //---from here VST 2.3 extension opcodes------------------------------------------------------ audioMasterGetInputSpeakerArrangement // result a VstSpeakerArrangement in ret }; //------------------------------------------------- // Language //------------------------------------------------- enum VstHostLanguage { kVstLangEnglish = 1, kVstLangGerman, kVstLangFrench, kVstLangItalian, kVstLangSpanish, kVstLangJapanese }; //------------------------------------------------- // Dispatcher OpCodes //------------------------------------------------- enum { //---from here VST 2.0 extension opcodes--------------------------------------------------------- // VstEvents effProcessEvents = effSetChunk + 1, // VstEvents* in // parameters and programs effCanBeAutomated, // parameter index in effString2Parameter, // parameter index in , string in effGetNumProgramCategories, // no arguments. this is for dividing programs into groups (like GM) effGetProgramNameIndexed, // get program name of category , program into . // category (that is, ) may be -1, in which case program indices // are enumerated linearily (as usual); otherwise, each category starts // over with index 0. effCopyProgram, // copy current program to destination // note: implies setParameter // connections, configuration effConnectInput, // input at has been (dis-)connected; // == 0: disconnected, else connected effConnectOutput, // same as input effGetInputProperties, // , VstPinProperties* in ptr, return != 0 => true effGetOutputProperties, // dto effGetPlugCategory, // no parameter, return value is category // realtime effGetCurrentPosition, // for external dsp, see flag bits below effGetDestinationBuffer, // for external dsp, see flag bits below. returns float* // offline effOfflineNotify, // ptr = VstAudioFile array, value = count, index = start flag effOfflinePrepare, // ptr = VstOfflineTask array, value = count effOfflineRun, // dto // other effProcessVarIo, // VstVariableIo* in effSetSpeakerArrangement, // VstSpeakerArrangement* pluginInput in // VstSpeakerArrangement* pluginOutput in effSetBlockSizeAndSampleRate, // block size in , sampleRate in effSetBypass, // onOff in (0 = off) effGetEffectName, // char* name (max 32 bytes) in effGetErrorText, // char* text (max 256 bytes) in effGetVendorString, // fills with a string identifying the vendor (max 64 char) effGetProductString, // fills with a string with product name (max 64 char) effGetVendorVersion, // returns vendor-specific version effVendorSpecific, // no definition, vendor specific handling effCanDo, // effGetTailSize, // returns tail size; 0 is default (return 1 for 'no tail') effIdle, // idle call in response to audioMasterneedIdle. must // return 1 to keep idle calls beeing issued // gui effGetIcon, // void* in , not yet defined effSetViewPosition, // set view position (in window) to x y // and... effGetParameterProperties, // of param , VstParameterProperties* in effKeysRequired, // returns 0: needs keys (default for 1.0 plugs), 1: don't need effGetVstVersion, // returns 2 for VST 2; older versions return 0; 2100 for VST 2.1 effNumV2Opcodes, // note that effNumOpcodes doesn't apply anymore //---from here VST 2.1 extension opcodes--------------------------------------------------------- effEditKeyDown = effNumV2Opcodes, // Character in , virtual in , modifiers in , // return -1 if not used, return 1 if used effEditKeyUp, // Character in , virtual in , modifiers in // return -1 if not used, return 1 if used effSetEditKnobMode, // Mode in : 0: circular, 1:circular relativ, 2:linear // midi plugins channeldependent programs effGetMidiProgramName, // Passed points to MidiProgramName struct. // struct will be filled with information for 'thisProgramIndex'. // returns number of used programIndexes. // if 0 is returned, no MidiProgramNames supported. effGetCurrentMidiProgram, // Returns the programIndex of the current program. // passed points to MidiProgramName struct. // struct will be filled with information for the current program. effGetMidiProgramCategory, // Passed points to MidiProgramCategory struct. // struct will be filled with information for 'thisCategoryIndex'. // returns number of used categoryIndexes. // if 0 is returned, no MidiProgramCategories supported. effHasMidiProgramsChanged, // Returns 1 if the MidiProgramNames or MidiKeyNames // had changed on this channel, 0 otherwise. ignored. effGetMidiKeyName, // Passed points to MidiKeyName struct. // struct will be filled with information for 'thisProgramIndex' and // 'thisKeyNumber'. If keyName is "" the standard name of the key // will be displayed. If 0 is returned, no MidiKeyNames are // defined for 'thisProgramIndex'. effBeginSetProgram, // Called before a new program is loaded effEndSetProgram, // Called when the program is loaded effNumV2_1Opcodes, //---from here VST 2.3 extension opcodes--------------------------------------------------------- effGetSpeakerArrangement = effNumV2_1Opcodes, // VstSpeakerArrangement** pluginInput in // VstSpeakerArrangement** pluginOutput in effShellGetNextPlugin, // This opcode is only called, if plugin is of type kPlugCategShell. // returns the next plugin's uniqueID. // points to a char buffer of size 64, which is to be filled // with the name of the plugin including the terminating zero. effStartProcess, // Called before the start of process call effStopProcess, // Called after the stop of process call effSetTotalSampleToProcess, // Called in offline (non RealTime) Process before process is called, indicates how many sample will be processed effSetPanLaw, // PanLaw : Type (Linear, Equal Power,.. see enum PanLaw Type) in , // Gain in : for Linear : [1.0 => 0dB PanLaw], [~0.58 => -4.5dB], [0.5 => -6.02dB] effBeginLoadBank, // Called before a Bank is loaded, points to VstPatchChunkInfo structure // return -1 if the Bank can not be loaded, return 1 if it can be loaded else 0 (for compatibility) effBeginLoadProgram, // Called before a Program is loaded, points to VstPatchChunkInfo structure // return -1 if the Program can not be loaded, return 1 if it can be loaded else 0 (for compatibility) effNumV2_3Opcodes }; //------------------------------------------------- // Parameter Properties //------------------------------------------------- typedef struct VstParameterProperties VstParameterProperties; struct VstParameterProperties { float stepFloat; float smallStepFloat; float largeStepFloat; char label[64]; long flags; // see below long minInteger; long maxInteger; long stepInteger; long largeStepInteger; char shortLabel[8]; // 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: short displayIndex; // for remote controllers, the 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 supports it (flag kVstParameterSupportsDisplayCategory) short category; // 0: no category, else group index + 1 short numParametersInCategory; short reserved; char categoryLabel[24]; // for instance, "Osc 1" char future[16]; }; //---Parameter Properties Flags-------------------- enum { kVstParameterIsSwitch = 1 << 0, kVstParameterUsesIntegerMinMax = 1 << 1, kVstParameterUsesFloatStep = 1 << 2, kVstParameterUsesIntStep = 1 << 3, kVstParameterSupportsDisplayIndex = 1 << 4, kVstParameterSupportsDisplayCategory = 1 << 5, kVstParameterCanRamp = 1 << 6 }; //------------------------------------------------- // Pin Properties //------------------------------------------------- typedef struct VstPinProperties VstPinProperties; struct VstPinProperties { char label[64]; long flags; // see pin properties flags long arrangementType; char shortLabel[8]; // recommended: 6 + delimiter char future[48]; }; //---Pin Properties Flags-------------------------- enum { kVstPinIsActive = 1 << 0, kVstPinIsStereo = 1 << 1, kVstPinUseSpeaker = 1 << 2 }; //------------------------------------------------- // Plugin Category //------------------------------------------------- enum VstPlugCategory { kPlugCategUnknown = 0, kPlugCategEffect, kPlugCategSynth, kPlugCategAnalysis, kPlugCategMastering, kPlugCategSpacializer, // 'panners' kPlugCategRoomFx, // delays and reverbs kPlugSurroundFx, // dedicated surround processor kPlugCategRestoration, kPlugCategOfflineProcess, kPlugCategShell, // plugin which is only a container of plugins. kPlugCategGenerator }; //------------------------------------------------- // Midi Plugins Channel Dependent Programs //------------------------------------------------- typedef struct MidiProgramName MidiProgramName; typedef struct MidiProgramCategory MidiProgramCategory; typedef struct MidiKeyName MidiKeyName; struct MidiProgramName { long thisProgramIndex; // >= 0. fill struct for this program index. char name[64]; char midiProgram; // -1:off, 0-127 char midiBankMsb; // -1:off, 0-127 char midiBankLsb; // -1:off, 0-127 char reserved; // zero long parentCategoryIndex; // -1:no parent category long flags; // omni etc, see below }; //---MidiProgramName Flags------------------------- enum { kMidiIsOmni = 1 // default is multi. for omni mode, channel 0 // is used for inquiries and program changes }; //---MidiProgramName------------------------------- struct MidiProgramCategory { long thisCategoryIndex; // >= 0. fill struct for this category index. char name[64]; long parentCategoryIndex; // -1:no parent category long flags; // reserved, none defined yet, zero. }; //---MidiKeyName----------------------------------- struct MidiKeyName { long thisProgramIndex; // >= 0. fill struct for this program index. long thisKeyNumber; // 0 - 127. fill struct for this key number. char keyName[64]; long reserved; // zero long flags; // reserved, none defined yet, zero. }; //------------------------------------------------- // Flags Bits //------------------------------------------------- enum { effFlagsIsSynth = 1 << 8, // host may assign mixer channels for its outputs effFlagsNoSoundInStop = 1 << 9, // does not produce sound when input is all silence effFlagsExtIsAsync = 1 << 10, // for external dsp; plug returns immedeately from process() // host polls plug position (current block) via effGetCurrentPosition effFlagsExtHasBuffer = 1 << 11 // external dsp, may have their own output buffe (32 bit float) // host then requests this via effGetDestinationBuffer }; //------------------------------------------------- // Surround Setup //------------------------------------------------- typedef struct VstSpeakerProperties VstSpeakerProperties; typedef struct VstSpeakerArrangement VstSpeakerArrangement; //---Speaker Properties---------------------------- struct VstSpeakerProperties { // units: range: except: float azimuth; // rad -PI...PI 10.f for LFE channel float elevation; // rad -PI/2...PI/2 10.f for LFE channel float radius; // meter 0.f for LFE channel float reserved; // 0. char name[64]; // for new setups, new names should be given (L/R/C... won't do) long type; // speaker type char future[28]; }; // note: 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. //---Speaker Arrangement--------------------------- struct VstSpeakerArrangement { long type; // (was float lfeGain; // LFE channel gain is adjusted [dB] higher than other channels) long numChannels; // number of channels in this speaker arrangement VstSpeakerProperties speakers[8]; // variable }; //---Speaker Types--------------------------------- enum { kSpeakerUndefined = 0x7fffffff, // Undefinded 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 { 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 { kSpeakerArrUserDefined = -2, kSpeakerArrEmpty = -1, 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 //------------------------------------------------- typedef struct VstOfflineTask VstOfflineTask; typedef struct VstAudioFile VstAudioFile; typedef struct VstAudioFileMarker VstAudioFileMarker; struct VstOfflineTask { char processName[96]; // set by plug // audio access double readPosition; // set by plug/host double writePosition; // set by plug/host long readCount; // set by plug/host long writeCount; // set by plug long sizeInputBuffer; // set by host long 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 // other data access void* extraBuffer; // set by plug long value; // set by host or plug long index; // set by host or plug // file attributes double numFramesInSourceFile; // set by host double sourceSampleRate; // set by host or plug double destinationSampleRate; // set by host or plug long numSourceChannels; // set by host or plug long numDestinationChannels; // set by host or plug long sourceFormat; // set by host long destinationFormat; // set by plug char outputText[512]; // set by plug or host // progress notification double progress; // set by plug long progressMode; // reserved for future char progressText[100]; // set by plug long flags; // set by host and plug; see VstOfflineTaskFlags long returnValue; // reserved for future void* hostOwned; // set by host void* plugOwned; // set by plug char future[1024]; }; //---VstOfflineTask Flags-------------------------- enum VstOfflineTaskFlags { // set by host kVstOfflineUnvalidParameter = 1 << 0, kVstOfflineNewFile = 1 << 1, // set by plug kVstOfflinePlugError = 1 << 10, kVstOfflineInterleavedAudio = 1 << 11, kVstOfflineTempOutputFile = 1 << 12, kVstOfflineFloatOutputFile = 1 << 13, kVstOfflineRandomWrite = 1 << 14, kVstOfflineStretch = 1 << 15, kVstOfflineNoThread = 1 << 16 }; //---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 { long flags; // see enum VstAudioFileFlags void* hostOwned; // any data private to host void* plugOwned; // any data private to plugin char name[100]; // file title long uniqueId; // uniquely identify a file during a session double sampleRate; // file sample rate long numChannels; // number of channels (1 for mono, 2 for stereo...) double numFrames; // number of frames in the audio file long format; // reserved for future 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 long selectedChannelsMask; // 1 bit per channel long numMarkers; // number of markers in the file long timeRulerUnit; // see doc for possible values double timeRulerOffset; // offset in time ruler (positive or negative) double tempo; // as bpm long timeSigNumerator; // time signature numerator long timeSigDenominator; // time signature denominator long ticksPerBlackNote; // resolution long smpteFrameRate; // smpte rate (set as in VstTimeInfo) char future[64]; }; //---VstAudioFile Flags---------------------------- enum VstAudioFileFlags { // set by host (in call offlineNotify) kVstOfflineReadOnly = 1 << 0, kVstOfflineNoRateConversion = 1 << 1, kVstOfflineNoChannelChange = 1 << 2, // Set by plug (in function offlineStart) kVstOfflineCanProcessSelection = 1 << 10, kVstOfflineNoCrossfade = 1 << 11, kVstOfflineWantRead = 1 << 12, kVstOfflineWantWrite = 1 << 13, kVstOfflineWantWriteMarker = 1 << 14, kVstOfflineWantMoveCursor = 1 << 15, kVstOfflineWantSelect = 1 << 16 }; //---VstAudioFileMarker---------------------------- struct VstAudioFileMarker { double position; char name[32]; long type; long id; long reserved; }; //------------------------------------------------- // Others //------------------------------------------------- //---Structure used for openWindow and closeWindow struct VstWindow { char title[128]; // title short xPos; // position and size short yPos; short width; short height; long style; // 0: with title, 1: without title void *parent; // parent of this window void *userHandle; // reserved void *winHandle; // reserved char future[104]; }; //---Structure and enum used for keyUp/keyDown----- struct VstKeyCode { long character; unsigned char virt; // see enum VstVirtualKey unsigned char modifier; // see enum VstModifierKey }; //---Used by member virt of 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 }; //---Used by member modifier of 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 }; //---Used by audioMasterOpenFileSelector----------- struct VstFileType { VstFileType (char* _name, char *_macType, char *_dosType, char *_unixType = 0, char *_mimeType1 = 0, char *_mimeType2 = 0) { if (_name) strcpy (name, _name); if (_macType) strcpy (macType, _macType); if (_dosType) strcpy (dosType, _dosType); if (_unixType) strcpy (unixType, _unixType); if (_mimeType1) strcpy (mimeType1, _mimeType1); if (_mimeType2) strcpy (mimeType2, _mimeType2); } char name[128]; char macType[8]; char dosType[8]; char unixType[8]; char mimeType1[128]; char mimeType2[128]; }; struct VstFileSelect { long command; // see enum kVstFileLoad.... long type; // see enum kVstFileType... long macCreator; // optional: 0 = no creator long nbFileTypes; // nb of fileTypes to used VstFileType *fileTypes; // list of fileTypes char title[1024]; // text display in the file selector's title char *initialPath; // initial path char *returnPath; // use with kVstFileLoad and kVstDirectorySelect // if null is passed, the host will allocated memory // the plugin should then called closeOpenFileSelector for freeing memory long sizeReturnPath; char **returnMultiplePaths; // use with kVstMultipleFilesLoad // the host allocates this array. The plugin should then called closeOpenFileSelector for freeing memory long nbReturnPath; // number of selected paths long reserved; // reserved for host application char future[116]; // future use }; enum { kVstFileLoad = 0, kVstFileSave, kVstMultipleFilesLoad, kVstDirectorySelect, kVstFileType = 0 }; //---Structure used for effBeginLoadBank/effBeginLoadProgram-- struct VstPatchChunkInfo { long version; // Format Version (should be 1) long pluginUniqueID;// UniqueID of the plugin long pluginVersion; // Plugin Version long numElements; // Number of Programs (Bank) or Parameters (Program) char future[48]; }; //---PanLaw Type----------------------------------- enum { kLinearPanLaw = 0, // L = pan * M; R = (1 - pan) * M; kEqualPowerPanLaw // L = pow (pan, 0.5) * M; R = pow ((1 - pan), 0.5) * M; }; #if PRAGMA_STRUCT_ALIGN || __MWERKS__ #pragma options align=reset #elif defined(WIN32) || defined(__FLAT__) #pragma pack(pop) #elif defined __BORLANDC__ #pragma -a- #endif #endif