296 lines
17 KiB
C
296 lines
17 KiB
C
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// VST Plug-Ins SDK
|
|||
|
|
// Version 2.3 Extension
|
|||
|
|
// <20> 2003, Steinberg Media Technologies, All Rights Reserved
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
#ifndef __audioeffectx__
|
|||
|
|
#define __audioeffectx__
|
|||
|
|
|
|||
|
|
#ifndef __AudioEffect__
|
|||
|
|
#include "AudioEffect.hpp" // Version 1.0 base class AudioEffect
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#ifndef __aeffectx__
|
|||
|
|
#include "aeffectx.h" // Version 2.0 'C' extensions and structures
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#define VST_2_1_EXTENSIONS 1 // Version 2.1 extensions
|
|||
|
|
#define VST_2_2_EXTENSIONS 1 // Version 2.2 extensions
|
|||
|
|
#define VST_2_3_EXTENSIONS 1 // Version 2.3 extensions
|
|||
|
|
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// AudioEffectX extends AudioEffect with new features. So you should derive
|
|||
|
|
// your Plugin from AudioEffectX
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
class AudioEffectX : public AudioEffect
|
|||
|
|
{
|
|||
|
|
public:
|
|||
|
|
// Constructor
|
|||
|
|
AudioEffectX (audioMasterCallback audioMaster, long numPrograms, long numParams);
|
|||
|
|
|
|||
|
|
// Destructor
|
|||
|
|
virtual ~AudioEffectX ();
|
|||
|
|
|
|||
|
|
// Dispatcher
|
|||
|
|
virtual long dispatcher (long opCode, long index, long value, void *ptr, float opt);
|
|||
|
|
|
|||
|
|
virtual AEffEditor* getEditor () { return editor; } // Returns the attached editor
|
|||
|
|
|
|||
|
|
// 'Plug -> Host' are methods which go from Plugin to Host, and are usually not overridden
|
|||
|
|
// 'Host -> Plug' are methods which you may override to implement the according functionality (to Host)
|
|||
|
|
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// Events + Time
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
// Plug -> Host
|
|||
|
|
virtual void wantEvents (long filter = 1); // Filter is currently ignored, midi channel data only (default)
|
|||
|
|
virtual VstTimeInfo* getTimeInfo (long filter); // Returns const VstTimeInfo* (or 0 if not supported)
|
|||
|
|
// filter should contain a mask indicating which fields are requested
|
|||
|
|
// (see valid masks in aeffectx.h), as some items may require extensive conversions
|
|||
|
|
virtual long tempoAt (long pos); // Returns tempo (in bpm * 10000) at sample frame location <pos>
|
|||
|
|
bool sendVstEventsToHost (VstEvents* events); // Returns true when success
|
|||
|
|
|
|||
|
|
// Host -> Plug
|
|||
|
|
virtual long processEvents (VstEvents* events) { return 0; }// 0 means 'wants no more'...else returns 1!
|
|||
|
|
// VstEvents and VstMidiEvents are declared in aeffectx.h
|
|||
|
|
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// Parameters and Programs
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
// Plug -> Host
|
|||
|
|
virtual long getNumAutomatableParameters (); // Returns the number of automatable Parameters (should be <= than numParams)
|
|||
|
|
virtual long getParameterQuantization (); // 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)
|
|||
|
|
// Host -> Plug
|
|||
|
|
virtual bool canParameterBeAutomated (long index) { return true; }
|
|||
|
|
virtual bool string2parameter (long index, char* text) { return false; } // Note: implies setParameter. text==0 is to be
|
|||
|
|
// expected to check the capability (returns true).
|
|||
|
|
virtual float getChannelParameter (long channel, long index) { return 0.f; }
|
|||
|
|
virtual long getNumCategories () { return 1L; }
|
|||
|
|
virtual bool getProgramNameIndexed (long category, long index, char* text) { return false; }
|
|||
|
|
virtual bool copyProgram (long destination) { return false; }
|
|||
|
|
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// Connections, Configuration
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
// Plug -> Host
|
|||
|
|
virtual bool ioChanged (); // Tell Host numInputs and/or numOutputs and/or initialDelay and/or numParameters has changed
|
|||
|
|
virtual bool needIdle (); // Plugin needs idle calls (outside its editor window), will call fxIdle ()
|
|||
|
|
virtual bool sizeWindow (long width, long height);
|
|||
|
|
|
|||
|
|
virtual double updateSampleRate (); // Returns sample rate from Host (may issue setSampleRate() )
|
|||
|
|
virtual long updateBlockSize (); // Same for block size
|
|||
|
|
virtual long getInputLatency (); // Returns input Latency
|
|||
|
|
virtual long getOutputLatency (); // Returns output Latency
|
|||
|
|
virtual AEffect* getPreviousPlug (long input); // Input can be -1 in which case the first found is returned
|
|||
|
|
virtual AEffect* getNextPlug (long output); // Output can be -1 in which case the first found is returned
|
|||
|
|
|
|||
|
|
// Host -> Plug
|
|||
|
|
virtual void inputConnected (long index, bool state) {} // Input at <index> has been (dis-)connected,
|
|||
|
|
virtual void outputConnected (long index, bool state) {} // Same as input; state == true: connected
|
|||
|
|
virtual bool getInputProperties (long index, VstPinProperties* properties) { return false; }
|
|||
|
|
virtual bool getOutputProperties (long index, VstPinProperties* properties) { return false; }
|
|||
|
|
|
|||
|
|
virtual VstPlugCategory getPlugCategory ()
|
|||
|
|
{ if (cEffect.flags & effFlagsIsSynth) return kPlugCategSynth; return kPlugCategUnknown; } // See aeffects.h for Category
|
|||
|
|
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// Realtime
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
// Plug -> Host
|
|||
|
|
virtual long willProcessReplacing (); // Returns 0: not implemented, 1: replacing, 2: accumulating
|
|||
|
|
virtual long getCurrentProcessLevel (); // Returns 0: not supported,
|
|||
|
|
// 1: currently in user thread (gui)
|
|||
|
|
// 2: currently in audio thread or irq (where process is called)
|
|||
|
|
// 3: currently in 'sequencer' thread or irq (midi, timer etc)
|
|||
|
|
// 4: currently offline processing and thus in user thread
|
|||
|
|
// other: not defined, but probably pre-empting user thread.
|
|||
|
|
virtual long getAutomationState (); // Returns 0: not supported, 1: off, 2:read, 3:write, 4:read/write
|
|||
|
|
virtual void wantAsyncOperation (bool state = true); // Notify Host that we want to operate asynchronously.
|
|||
|
|
// process () will return immediately; Host will poll getCurrentPosition
|
|||
|
|
// to see if data are available in time.
|
|||
|
|
virtual void hasExternalBuffer (bool state = true); // For external DSP, may have their own output buffer (32 bit float)
|
|||
|
|
// Host then requests this via effGetDestinationBuffer
|
|||
|
|
|
|||
|
|
// Host -> Plug
|
|||
|
|
virtual long reportCurrentPosition () { return 0; } // For external DSP, see wantAsyncOperation ()
|
|||
|
|
virtual float* reportDestinationBuffer () { return 0; } // For external DSP (dma option)
|
|||
|
|
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// Offline
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
// Plug -> Host
|
|||
|
|
virtual bool offlineRead (VstOfflineTask* offline, VstOfflineOption option, bool readSource = true);
|
|||
|
|
virtual bool offlineWrite (VstOfflineTask* offline, VstOfflineOption option);
|
|||
|
|
virtual bool offlineStart (VstAudioFile* ptr, long numAudioFiles, long numNewAudioFiles);
|
|||
|
|
virtual long offlineGetCurrentPass ();
|
|||
|
|
virtual long offlineGetCurrentMetaPass ();
|
|||
|
|
|
|||
|
|
// Host -> Plug
|
|||
|
|
virtual bool offlineNotify (VstAudioFile* ptr, long numAudioFiles, bool start) { return false; }
|
|||
|
|
virtual bool offlinePrepare (VstOfflineTask* offline, long count) { return false; }
|
|||
|
|
virtual bool offlineRun (VstOfflineTask* offline, long count) { return false; }
|
|||
|
|
|
|||
|
|
virtual long offlineGetNumPasses () { return 0; }
|
|||
|
|
virtual long offlineGetNumMetaPasses () { return 0; }
|
|||
|
|
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// Other
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
// Plug -> Host
|
|||
|
|
virtual void setOutputSamplerate (float samplerate);
|
|||
|
|
virtual VstSpeakerArrangement* getInputSpeakerArrangement ();
|
|||
|
|
virtual VstSpeakerArrangement* getOutputSpeakerArrangement ();
|
|||
|
|
|
|||
|
|
virtual bool getHostVendorString (char* text); // Fills <text> with a string identifying the vendor (max 64 char)
|
|||
|
|
virtual bool getHostProductString (char* text); // Fills <text> with a string with product name (max 64 char)
|
|||
|
|
virtual long getHostVendorVersion (); // Returns vendor-specific version
|
|||
|
|
virtual long hostVendorSpecific (long lArg1, long lArg2, void* ptrArg, float floatArg); // No specific definition
|
|||
|
|
virtual long canHostDo (char* text); // See 'hostCanDos' in audioeffectx.cpp
|
|||
|
|
// returns 0: don't know (default), 1: yes, -1: no
|
|||
|
|
|
|||
|
|
virtual void isSynth (bool state = true); // Will call wantEvents if true
|
|||
|
|
virtual void noTail (bool state = true); // true: tells Host we produce no output when silence comes in
|
|||
|
|
// enables Host to omit process() when no data are present on any one input.
|
|||
|
|
|
|||
|
|
virtual long getHostLanguage (); // Returns VstHostLanguage (see aeffectx.h)
|
|||
|
|
virtual void* openWindow (VstWindow*); // Create new window
|
|||
|
|
virtual bool closeWindow (VstWindow*); // Close a newly created window
|
|||
|
|
virtual void* getDirectory (); // Get the Plugin's directory, FSSpec on MAC, else char*
|
|||
|
|
virtual bool updateDisplay (); // Something has changed, update display like program list, parameter list
|
|||
|
|
// returns true if supported
|
|||
|
|
|
|||
|
|
// Host -> Plug
|
|||
|
|
virtual bool processVariableIo (VstVariableIo* varIo) { return false; } // If called with varIo == NULL, returning true indicates that this call is supported by the Plugin
|
|||
|
|
virtual bool setSpeakerArrangement (VstSpeakerArrangement* pluginInput, VstSpeakerArrangement* pluginOutput) { return false; }
|
|||
|
|
virtual bool getSpeakerArrangement (VstSpeakerArrangement** pluginInput, VstSpeakerArrangement** pluginOutput) { *pluginInput = 0; *pluginOutput = 0; return false; }
|
|||
|
|
virtual void setBlockSizeAndSampleRate (long blockSize, float sampleRate)
|
|||
|
|
{ this->blockSize = blockSize; this->sampleRate = sampleRate; }
|
|||
|
|
virtual bool setBypass (bool onOff) { return false; } // For 'soft-bypass; process () still called
|
|||
|
|
|
|||
|
|
virtual bool getEffectName (char* name) { return false; } // Name max 32 char
|
|||
|
|
virtual bool getErrorText (char* text) { return false; } // Text max 256 char
|
|||
|
|
virtual bool getVendorString (char* text) { return false; } // Fill text with a string identifying the vendor (max 64 char)
|
|||
|
|
virtual bool getProductString (char* text) { return false; }// Fill text with a string identifying the product name (max 64 char) // fills <ptr> with a string with product name (max 64 char)
|
|||
|
|
virtual long getVendorVersion () { return 0; } // Return vendor-specific version
|
|||
|
|
virtual long vendorSpecific (long lArg, long lArg2, void* ptrArg, float floatArg) { return 0; }
|
|||
|
|
// No definition, vendor specific handling
|
|||
|
|
virtual long canDo (char* text) { return 0; } // See 'plugCanDos' in audioeffectx.cpp
|
|||
|
|
// returns 0: don't know (default), 1: yes, -1: no
|
|||
|
|
virtual void* getIcon () { return 0; } // Not yet defined
|
|||
|
|
virtual bool setViewPosition (long x, long y) { return false; }
|
|||
|
|
virtual long getGetTailSize () { return 0; }
|
|||
|
|
virtual long fxIdle () { return 0; } // Called when NeedIdle () was called
|
|||
|
|
virtual bool getParameterProperties (long index, VstParameterProperties* p) { return false; }
|
|||
|
|
virtual bool keysRequired () { return false; } // Version 1 Plugins will return true
|
|||
|
|
|
|||
|
|
#if VST_2_3_EXTENSIONS
|
|||
|
|
virtual long getVstVersion () { return 2300; } // Returns the current VST Version
|
|||
|
|
#elif VST_2_2_EXTENSIONS
|
|||
|
|
virtual long getVstVersion () { return 2200; }
|
|||
|
|
#elif VST_2_1_EXTENSIONS
|
|||
|
|
virtual long getVstVersion () { return 2100; }
|
|||
|
|
#else
|
|||
|
|
virtual long getVstVersion () { return 2; }
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
//---------------------------------------------------------
|
|||
|
|
#if VST_2_1_EXTENSIONS
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
// Midi Program Names, are always defined per channel, valid channels are 0 - 15
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
// Host -> Plug
|
|||
|
|
virtual long getMidiProgramName (long channel, MidiProgramName* midiProgramName) { return 0; }
|
|||
|
|
// Struct will be filled with information for 'thisProgramIndex'.
|
|||
|
|
// returns number of used programIndexes.
|
|||
|
|
// If 0 is returned, no MidiProgramNames supported.
|
|||
|
|
virtual long getCurrentMidiProgram (long channel, MidiProgramName* currentProgram) { return -1; }
|
|||
|
|
// Struct will be filled with information for the current program.
|
|||
|
|
// Returns the programIndex of the current program. -1 means not supported.
|
|||
|
|
virtual long getMidiProgramCategory (long channel, MidiProgramCategory* category) { return 0; }
|
|||
|
|
// Struct will be filled with information for 'thisCategoryIndex'.
|
|||
|
|
// returns number of used categoryIndexes.
|
|||
|
|
// if 0 is returned, no MidiProgramCategories supported/used.
|
|||
|
|
virtual bool hasMidiProgramsChanged (long channel) { return false; }
|
|||
|
|
// Returns true if the MidiProgramNames, MidiKeyNames or
|
|||
|
|
// MidiControllerNames had changed on this channel.
|
|||
|
|
virtual bool getMidiKeyName (long channel, MidiKeyName* keyName) { return false; }
|
|||
|
|
// Struct will be filled with information for 'thisProgramIndex' and 'thisKeyNumber'
|
|||
|
|
// if keyName is "" the standard name of the key will be displayed.
|
|||
|
|
// if false is returned, no MidiKeyNames defined for 'thisProgramIndex'.
|
|||
|
|
|
|||
|
|
virtual bool beginSetProgram () { return false; } // Called before a program is loaded
|
|||
|
|
virtual bool endSetProgram () { return false; } // Called after...
|
|||
|
|
|
|||
|
|
// Plug -> Host
|
|||
|
|
virtual bool beginEdit (long index); // To be called before a setParameterAutomated with mouse move (one per Mouse Down)
|
|||
|
|
virtual bool endEdit (long index); // To be called after a setParameterAutomated (on Mouse Up)
|
|||
|
|
|
|||
|
|
virtual bool openFileSelector (VstFileSelect *ptr); // Open a Host File selector (see aeffectx.h for VstFileSelect definition)
|
|||
|
|
|
|||
|
|
#endif // VST_2_1_EXTENSIONS
|
|||
|
|
|
|||
|
|
//---------------------------------------------------------
|
|||
|
|
#if VST_2_2_EXTENSIONS
|
|||
|
|
|
|||
|
|
bool closeFileSelector (VstFileSelect *ptr); // Close the Host File selector which was opened by openFileSelector
|
|||
|
|
bool getChunkFile (void* nativePath); // Returns in platform format the path of the current chunk (could be called in setChunk ()) (FSSpec on MAC else char*)
|
|||
|
|
|
|||
|
|
#endif // VST_2_2_EXTENSIONS
|
|||
|
|
|
|||
|
|
//---------------------------------------------------------
|
|||
|
|
#if VST_2_3_EXTENSIONS
|
|||
|
|
|
|||
|
|
// Host -> Plug
|
|||
|
|
virtual long setTotalSampleToProcess (long value) { return value; } // Called in offline (non RealTime) Process before process is called, indicates how many sample will be processed
|
|||
|
|
|
|||
|
|
virtual long getNextShellPlugin (char* name) { return 0; }
|
|||
|
|
// Tthis opcode is only called, if Plugin is of type kPlugCategShell.
|
|||
|
|
// should return the next plugin's uniqueID.
|
|||
|
|
// name points to a char buffer of size 64, which is to be filled
|
|||
|
|
// with the name of the plugin including the terminating zero.
|
|||
|
|
virtual long startProcess () { return 0; } // Called one time before the start of process call
|
|||
|
|
virtual long stopProcess () { return 0; } // Called after the stop of process call
|
|||
|
|
|
|||
|
|
virtual bool setPanLaw (long type, float val) { return false; } // Set the Panning Law used by the Host
|
|||
|
|
|
|||
|
|
virtual long beginLoadBank (VstPatchChunkInfo* ptr) { return 0; }
|
|||
|
|
// Called before a Bank is loaded.
|
|||
|
|
// returns -1 if the Bank cannot be loaded, returns 1 if it can be loaded else 0 (for compatibility)
|
|||
|
|
virtual long beginLoadProgram (VstPatchChunkInfo* ptr) { return 0; }
|
|||
|
|
// Called before a Program is loaded. (called before beginSetProgram)
|
|||
|
|
// returns -1 if the Program cannot be loaded, returns 1 if it can be loaded else 0 (for compatibility)
|
|||
|
|
|
|||
|
|
// Tools
|
|||
|
|
virtual bool allocateArrangement (VstSpeakerArrangement** arrangement, long nbChannels);
|
|||
|
|
// Allocate memory for a VstSpeakerArrangement containing the given
|
|||
|
|
// number of channels
|
|||
|
|
virtual bool deallocateArrangement (VstSpeakerArrangement** arrangement);
|
|||
|
|
// Delete/free memory for a speaker arrangement
|
|||
|
|
virtual bool copySpeaker (VstSpeakerProperties* to, VstSpeakerProperties* from);
|
|||
|
|
// Feed the "to" speaker properties with the same values than "from"'s ones.
|
|||
|
|
// It is assumed here that "to" exists yet, ie this function won't
|
|||
|
|
// allocate memory for the speaker (this will prevent from having
|
|||
|
|
// a difference between an Arrangement's number of channels and
|
|||
|
|
// its actual speakers...)
|
|||
|
|
virtual bool matchArrangement (VstSpeakerArrangement** to, VstSpeakerArrangement* from);
|
|||
|
|
// "to" is deleted, then created and initialized with the same values as "from" ones ("from" must exist).
|
|||
|
|
#endif // VST_2_3_EXTENSIONS
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
#endif //__audioeffectx__
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|
|||
|
|
//-------------------------------------------------------------------------------------------------------
|