1004 lines
33 KiB
C
Executable file
1004 lines
33 KiB
C
Executable file
//-------------------------------------------------------------------------------------------------------
|
|
// 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 <string.h> // 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, // <value> is a filter which is currently ignored
|
|
audioMasterGetTime, // returns const VstTimeInfo* (or 0 if not supported)
|
|
// <value> should contain a mask indicating which fields are required
|
|
// (see valid masks above), as some items may require extensive
|
|
// conversions
|
|
audioMasterProcessEvents, // VstEvents* in <ptr>
|
|
audioMasterSetTime, // VstTimenfo* in <ptr>, filter in <value>, not supported
|
|
audioMasterTempoAt, // returns tempo (in bpm * 10000) at sample frame location passed in <value>
|
|
|
|
// 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 <value> (-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 <value> (-1: first to come), returns cEffect*
|
|
audioMasterGetNextPlug, // output pin in <value> (-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 <opt>
|
|
audioMasterGetSpeakerArrangement, // result in ret
|
|
audioMasterGetOutputSpeakerArrangement = audioMasterGetSpeakerArrangement,
|
|
audioMasterGetVendorString, // fills <ptr> with a string identifying the vendor (max 64 char)
|
|
audioMasterGetProductString, // fills <ptr> with a string with product name (max 64 char)
|
|
audioMasterGetVendorVersion, // returns vendor-specific version
|
|
audioMasterVendorSpecific, // no definition, vendor specific handling
|
|
audioMasterSetIcon, // void* in <ptr>, 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 <ptr>
|
|
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 <index>
|
|
audioMasterEndEdit, // end of automation session (when mouse up), parameter index in <index>
|
|
audioMasterOpenFileSelector, // open a fileselector window with VstFileSelect* in <ptr>
|
|
|
|
//---from here VST 2.2 extension opcodes------------------------------------------------------
|
|
audioMasterCloseFileSelector, // close a fileselector operation with VstFileSelect* in <ptr>: 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 <ptr> (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 <ptr>
|
|
|
|
// parameters and programs
|
|
effCanBeAutomated, // parameter index in <index>
|
|
effString2Parameter, // parameter index in <index>, string in <ptr>
|
|
effGetNumProgramCategories, // no arguments. this is for dividing programs into groups (like GM)
|
|
effGetProgramNameIndexed, // get program name of category <value>, program <index> into <ptr>.
|
|
// category (that is, <value>) 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 <index>
|
|
// note: implies setParameter
|
|
// connections, configuration
|
|
effConnectInput, // input at <index> has been (dis-)connected;
|
|
// <value> == 0: disconnected, else connected
|
|
effConnectOutput, // same as input
|
|
effGetInputProperties, // <index>, 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 <ptr>
|
|
effSetSpeakerArrangement, // VstSpeakerArrangement* pluginInput in <value>
|
|
// VstSpeakerArrangement* pluginOutput in <ptr>
|
|
effSetBlockSizeAndSampleRate, // block size in <value>, sampleRate in <opt>
|
|
effSetBypass, // onOff in <value> (0 = off)
|
|
effGetEffectName, // char* name (max 32 bytes) in <ptr>
|
|
effGetErrorText, // char* text (max 256 bytes) in <ptr>
|
|
effGetVendorString, // fills <ptr> with a string identifying the vendor (max 64 char)
|
|
effGetProductString, // fills <ptr> with a string with product name (max 64 char)
|
|
effGetVendorVersion, // returns vendor-specific version
|
|
effVendorSpecific, // no definition, vendor specific handling
|
|
effCanDo, // <ptr>
|
|
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 <ptr>, not yet defined
|
|
effSetViewPosition, // set view position (in window) to x <index> y <value>
|
|
|
|
// and...
|
|
effGetParameterProperties, // of param <index>, VstParameterProperties* in <ptr>
|
|
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 <index>, virtual in <value>, modifiers in <opt>,
|
|
// return -1 if not used, return 1 if used
|
|
effEditKeyUp, // Character in <index>, virtual in <value>, modifiers in <opt>
|
|
// return -1 if not used, return 1 if used
|
|
effSetEditKnobMode, // Mode in <value>: 0: circular, 1:circular relativ, 2:linear
|
|
|
|
// midi plugins channeldependent programs
|
|
effGetMidiProgramName, // Passed <ptr> 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 <ptr> points to MidiProgramName struct.
|
|
// struct will be filled with information for the current program.
|
|
|
|
effGetMidiProgramCategory, // Passed <ptr> 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. <ptr> ignored.
|
|
|
|
effGetMidiKeyName, // Passed <ptr> 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 <value>
|
|
// VstSpeakerArrangement** pluginOutput in <ptr>
|
|
|
|
effShellGetNextPlugin, // This opcode is only called, if plugin is of type kPlugCategShell.
|
|
// returns the next plugin's uniqueID.
|
|
// <ptr> 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 <value>,
|
|
// Gain in <opt>: for Linear : [1.0 => 0dB PanLaw], [~0.58 => -4.5dB], [0.5 => -6.02dB]
|
|
effBeginLoadBank, // Called before a Bank is loaded, <ptr> 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, <ptr> 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
|