From 58f8437f4b8b741ddc8e7bcde21bf983cc618430 Mon Sep 17 00:00:00 2001 From: pepper Date: Sat, 10 Jan 2015 21:37:24 -0800 Subject: added vstsdk --- .../public.sdk/source/vst2.x/audioeffectx.cpp | 1546 ++++++++++++++++++++ 1 file changed, 1546 insertions(+) create mode 100644 vendor/vstsdk2.4/public.sdk/source/vst2.x/audioeffectx.cpp (limited to 'vendor/vstsdk2.4/public.sdk/source/vst2.x/audioeffectx.cpp') diff --git a/vendor/vstsdk2.4/public.sdk/source/vst2.x/audioeffectx.cpp b/vendor/vstsdk2.4/public.sdk/source/vst2.x/audioeffectx.cpp new file mode 100644 index 0000000..1f98919 --- /dev/null +++ b/vendor/vstsdk2.4/public.sdk/source/vst2.x/audioeffectx.cpp @@ -0,0 +1,1546 @@ +//------------------------------------------------------------------------------------------------------- +// VST Plug-Ins SDK +// Version 2.4 $Date: 2006/10/05 14:23:59 $ +// +// Category : VST 2.x Classes +// Filename : audioeffectx.cpp +// Created by : Steinberg Media Technologies +// Description : Class AudioEffectX extends AudioEffect with new features. You should derive +// your plug-in from AudioEffectX. +// +// © 2006, Steinberg Media Technologies, All Rights Reserved +//------------------------------------------------------------------------------------------------------- + +#include "audioeffectx.h" +#include "aeffeditor.h" + +//------------------------------------------------------------------------------------------------------- +/*! hostCanDos strings Plug-in -> Host */ +namespace HostCanDos +{ + const char* canDoSendVstEvents = "sendVstEvents"; ///< Host supports send of Vst events to plug-in + const char* canDoSendVstMidiEvent = "sendVstMidiEvent"; ///< Host supports send of MIDI events to plug-in + const char* canDoSendVstTimeInfo = "sendVstTimeInfo"; ///< Host supports send of VstTimeInfo to plug-in + const char* canDoReceiveVstEvents = "receiveVstEvents"; ///< Host can receive Vst events from plug-in + const char* canDoReceiveVstMidiEvent = "receiveVstMidiEvent"; ///< Host can receive MIDI events from plug-in + const char* canDoReportConnectionChanges = "reportConnectionChanges"; ///< Host will indicates the plug-in when something change in plug-in´s routing/connections with #suspend/#resume/#setSpeakerArrangement + const char* canDoAcceptIOChanges = "acceptIOChanges"; ///< Host supports #ioChanged () + const char* canDoSizeWindow = "sizeWindow"; ///< used by VSTGUI + const char* canDoOffline = "offline"; ///< Host supports offline feature + const char* canDoOpenFileSelector = "openFileSelector"; ///< Host supports function #openFileSelector () + const char* canDoCloseFileSelector = "closeFileSelector"; ///< Host supports function #closeFileSelector () + const char* canDoStartStopProcess = "startStopProcess"; ///< Host supports functions #startProcess () and #stopProcess () + const char* canDoShellCategory = "shellCategory"; ///< 'shell' handling via uniqueID. If supported by the Host and the Plug-in has the category #kPlugCategShell + const char* canDoSendVstMidiEventFlagIsRealtime = "sendVstMidiEventFlagIsRealtime"; ///< Host supports flags for #VstMidiEvent +} + +//------------------------------------------------------------------------------------------------------- +/*! plugCanDos strings Host -> Plug-in */ +namespace PlugCanDos +{ + const char* canDoSendVstEvents = "sendVstEvents"; ///< plug-in will send Vst events to Host + const char* canDoSendVstMidiEvent = "sendVstMidiEvent"; ///< plug-in will send MIDI events to Host + const char* canDoReceiveVstEvents = "receiveVstEvents"; ///< plug-in can receive MIDI events from Host + const char* canDoReceiveVstMidiEvent = "receiveVstMidiEvent"; ///< plug-in can receive MIDI events from Host + const char* canDoReceiveVstTimeInfo = "receiveVstTimeInfo"; ///< plug-in can receive Time info from Host + const char* canDoOffline = "offline"; ///< plug-in supports offline functions (#offlineNotify, #offlinePrepare, #offlineRun) + const char* canDoMidiProgramNames = "midiProgramNames"; ///< plug-in supports function #getMidiProgramName () + const char* canDoBypass = "bypass"; ///< plug-in supports function #setBypass () +} + +//----------------------------------------------------------------------------------------------------------------- +// Class AudioEffectX Implementation +//----------------------------------------------------------------------------------------------------------------- +/*! + \sa AudioEffect() +*/ +AudioEffectX::AudioEffectX (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams) +: AudioEffect (audioMaster, numPrograms, numParams) +{} + +//----------------------------------------------------------------------------------------------------------------- +VstIntPtr AudioEffectX::dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt) +{ + VstIntPtr v = 0; + switch (opcode) + { + //---VstEvents---------------------- + case effProcessEvents: + v = processEvents ((VstEvents*)ptr); + break; + + //---Parameters and Programs---------------------- + case effCanBeAutomated: + v = canParameterBeAutomated (index) ? 1 : 0; + break; + case effString2Parameter: + v = string2parameter (index, (char*)ptr) ? 1 : 0; + break; + + case effGetProgramNameIndexed: + v = getProgramNameIndexed ((VstInt32)value, index, (char*)ptr) ? 1 : 0; + break; + #if !VST_FORCE_DEPRECATED + case effGetNumProgramCategories: + v = getNumCategories (); + break; + case effCopyProgram: + v = copyProgram (index) ? 1 : 0; + break; + + //---Connections, Configuration---------------------- + case effConnectInput: + inputConnected (index, value ? true : false); + v = 1; + break; + case effConnectOutput: + outputConnected (index, value ? true : false); + v = 1; + break; + #endif // !VST_FORCE_DEPRECATED + + case effGetInputProperties: + v = getInputProperties (index, (VstPinProperties*)ptr) ? 1 : 0; + break; + case effGetOutputProperties: + v = getOutputProperties (index, (VstPinProperties*)ptr) ? 1 : 0; + break; + case effGetPlugCategory: + v = (VstIntPtr)getPlugCategory (); + break; + + #if !VST_FORCE_DEPRECATED + //---Realtime---------------------- + case effGetCurrentPosition: + v = reportCurrentPosition (); + break; + + case effGetDestinationBuffer: + v = ToVstPtr (reportDestinationBuffer ()); + break; + #endif // !VST_FORCE_DEPRECATED + + //---Offline---------------------- + case effOfflineNotify: + v = offlineNotify ((VstAudioFile*)ptr, (VstInt32)value, index != 0); + break; + case effOfflinePrepare: + v = offlinePrepare ((VstOfflineTask*)ptr, (VstInt32)value); + break; + case effOfflineRun: + v = offlineRun ((VstOfflineTask*)ptr, (VstInt32)value); + break; + + //---Others---------------------- + case effSetSpeakerArrangement: + v = setSpeakerArrangement (FromVstPtr (value), (VstSpeakerArrangement*)ptr) ? 1 : 0; + break; + case effProcessVarIo: + v = processVariableIo ((VstVariableIo*)ptr) ? 1 : 0; + break; + #if !VST_FORCE_DEPRECATED + case effSetBlockSizeAndSampleRate: + setBlockSizeAndSampleRate ((VstInt32)value, opt); + v = 1; + break; + #endif // !VST_FORCE_DEPRECATED + case effSetBypass: + v = setBypass (value ? true : false) ? 1 : 0; + break; + case effGetEffectName: + v = getEffectName ((char*)ptr) ? 1 : 0; + break; + case effGetVendorString: + v = getVendorString ((char*)ptr) ? 1 : 0; + break; + case effGetProductString: + v = getProductString ((char*)ptr) ? 1 : 0; + break; + case effGetVendorVersion: + v = getVendorVersion (); + break; + case effVendorSpecific: + v = vendorSpecific (index, value, ptr, opt); + break; + case effCanDo: + v = canDo ((char*)ptr); + break; + + case effGetTailSize: + v = getGetTailSize (); + break; + + #if !VST_FORCE_DEPRECATED + case effGetErrorText: + v = getErrorText ((char*)ptr) ? 1 : 0; + break; + + case effGetIcon: + v = ToVstPtr (getIcon ()); + break; + + case effSetViewPosition: + v = setViewPosition (index, (VstInt32)value) ? 1 : 0; + break; + + case effIdle: + v = fxIdle (); + break; + + case effKeysRequired: + v = (keysRequired () ? 0 : 1); // reversed to keep v1 compatibility + break; + #endif // !VST_FORCE_DEPRECATED + + case effGetParameterProperties: + v = getParameterProperties (index, (VstParameterProperties*)ptr) ? 1 : 0; + break; + + case effGetVstVersion: + v = getVstVersion (); + break; + + //---Others---------------------- + #if VST_2_1_EXTENSIONS + case effEditKeyDown: + if (editor) + { + VstKeyCode keyCode = {index, (unsigned char)value, (unsigned char)opt}; + v = editor->onKeyDown (keyCode) ? 1 : 0; + } + break; + + case effEditKeyUp: + if (editor) + { + VstKeyCode keyCode = {index, (unsigned char)value, (unsigned char)opt}; + v = editor->onKeyUp (keyCode) ? 1 : 0; + } + break; + + case effSetEditKnobMode: + if (editor) + v = editor->setKnobMode ((VstInt32)value) ? 1 : 0; + break; + + case effGetMidiProgramName: + v = getMidiProgramName (index, (MidiProgramName*)ptr); + break; + case effGetCurrentMidiProgram: + v = getCurrentMidiProgram (index, (MidiProgramName*)ptr); + break; + case effGetMidiProgramCategory: + v = getMidiProgramCategory (index, (MidiProgramCategory*)ptr); + break; + case effHasMidiProgramsChanged: + v = hasMidiProgramsChanged (index) ? 1 : 0; + break; + case effGetMidiKeyName: + v = getMidiKeyName (index, (MidiKeyName*)ptr) ? 1 : 0; + break; + case effBeginSetProgram: + v = beginSetProgram () ? 1 : 0; + break; + case effEndSetProgram: + v = endSetProgram () ? 1 : 0; + break; + #endif // VST_2_1_EXTENSIONS + + #if VST_2_3_EXTENSIONS + case effGetSpeakerArrangement: + v = getSpeakerArrangement (FromVstPtr (value), (VstSpeakerArrangement**)ptr) ? 1 : 0; + break; + + case effSetTotalSampleToProcess: + v = setTotalSampleToProcess ((VstInt32)value); + break; + + case effShellGetNextPlugin: + v = getNextShellPlugin ((char*)ptr); + break; + + case effStartProcess: + v = startProcess (); + break; + case effStopProcess: + v = stopProcess (); + break; + + case effSetPanLaw: + v = setPanLaw ((VstInt32)value, opt) ? 1 : 0; + break; + + case effBeginLoadBank: + v = beginLoadBank ((VstPatchChunkInfo*)ptr); + break; + case effBeginLoadProgram: + v = beginLoadProgram ((VstPatchChunkInfo*)ptr); + break; + #endif // VST_2_3_EXTENSIONS + + #if VST_2_4_EXTENSIONS + case effSetProcessPrecision : + v = setProcessPrecision ((VstInt32)value) ? 1 : 0; + break; + + case effGetNumMidiInputChannels : + v = getNumMidiInputChannels (); + break; + + case effGetNumMidiOutputChannels : + v = getNumMidiOutputChannels (); + break; + #endif // VST_2_4_EXTENSIONS + + //---Version 1.0 or unknown----------------- + default: + v = AudioEffect::dispatcher (opcode, index, value, ptr, opt); + } + return v; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! if this effect is a synth or can receive midi events, we call the deprecated wantEvents() as some host rely on it. +*/ +void AudioEffectX::resume () +{ + if (cEffect.flags & effFlagsIsSynth || canDo ("receiveVstMidiEvent") == 1) + DECLARE_VST_DEPRECATED (wantEvents) (); +} + +//----------------------------------------------------------------------------------------------------------------- +void AudioEffectX::DECLARE_VST_DEPRECATED (wantEvents) (VstInt32 filter) +{ + if (audioMaster) + audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterWantMidi), 0, filter, 0, 0); +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + A plug-in will request time info by calling the function getTimeInfo() which returns a \e #VstTimeInfo + pointer (or NULL if not implemented by the Host). The mask parameter is composed of the same flags which + will be found in the flags field of \e #VstTimeInfo when returned, that is, if you need information about tempo. + The parameter passed to getTimeInfo() should have the \e #kVstTempoValid flag set. This request and delivery + system is important, as a request like this may cause significant calculations at the application's end, which + may take a lot of our precious time. This obviously means you should only set those flags that are required to + get the information you need. Also please be aware that requesting information does not necessarily mean that + that information is provided in return. Check the \e flags field in the \e #VstTimeInfo structure to see if your + request was actually met. + + \param filter A mask indicating which fields are requested, as some items may require extensive conversions. + See the \e flags in #VstTimeInfo + \return A pointer to a #VstTimeInfo structure or NULL if not implemented by the Host +*/ +VstTimeInfo* AudioEffectX::getTimeInfo (VstInt32 filter) +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, audioMasterGetTime, 0, filter, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (tempoAt) (VstInt32 pos) +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterTempoAt), 0, pos, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::sendVstEventsToHost (VstEvents* events) +/*! + Can be called inside processReplacing. + + \param events Fill with VST events + \return Returns \e true on success +*/ +{ + if (audioMaster) + return audioMaster (&cEffect, audioMasterProcessEvents, 0, 0, events, 0) == 1; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::processEvents (VstEvents* events) + + \return return value is ignored + + \remarks Events are always related to the current audio block. For each process cycle, processEvents() is called + once before a processReplacing() call (if new events are available). + + \sa VstEvents, VstMidiEvent +*/ + +//----------------------------------------------------------------------------------------------------------------- +// Parameters Functions +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::canParameterBeAutomated (VstInt32 index) + + Obviously only useful when the application supports this. + + \param index Index of the parameter + \return \true if supported +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::string2parameter (VstInt32 index, char* text) + + Especially useful for plug-ins without user interface. The application can then implement a text edit field for + the user to set a parameter by entering text. + + \param index Index of the parameter + \param text A textual description of the parameter's value. A NULL pointer is used to check the capability + (return true). + \return \e true on success + + \note Implies setParameter (). text==0 is to be expected to check the capability (returns true) +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getProgramNameIndexed (VstInt32 category, VstInt32 index, char* text) + + Allows a Host application to list the plug-in's programs (presets). + + \param category unused in VST 2.4 + \param index Index of the program in a given category, starting with 0. + \param text A string up to 24 chars. + \return \e true on success +*/ +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (getNumAutomatableParameters) () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetNumAutomatableParameters), 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (getParameterQuantization) () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetParameterQuantization), 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +// Configuration/Settings Functions +//----------------------------------------------------------------------------------------------------------------- + +//----------------------------------------------------------------------------------------------------------------- +/*! + The Host could call a suspend() (if the plug-in was enabled (in resume() state)) and then ask for + getSpeakerArrangement() and/or check the \e numInputs and \e numOutputs and \e initialDelay and then call a + resume(). + + \return \e true on success + + \sa setSpeakerArrangement(), getSpeakerArrangement() +*/ +bool AudioEffectX::ioChanged () +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterIOChanged, 0, 0, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::DECLARE_VST_DEPRECATED (needIdle) () +{ + if (audioMaster) + return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterNeedIdle), 0, 0, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param width The window's width in pixel + \param height The window's height in pixel + \return \e true on success +*/ +bool AudioEffectX::sizeWindow (VstInt32 width, VstInt32 height) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterSizeWindow, width, height, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +double AudioEffectX::updateSampleRate () +/*! + \return The Host's sample rate +*/ +{ + if (audioMaster) + { + VstIntPtr res = audioMaster (&cEffect, audioMasterGetSampleRate, 0, 0, 0, 0); + if (res > 0) + sampleRate = (float)res; + } + return sampleRate; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::updateBlockSize () +/*! + \return The Host's block size + + \note Will cause application to call AudioEffect's setSampleRate() to be called (when implemented). +*/ +{ + if (audioMaster) + { + VstInt32 res = (VstInt32)audioMaster (&cEffect, audioMasterGetBlockSize, 0, 0, 0, 0); + if (res > 0) + blockSize = res; + } + return blockSize; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return ASIO input latency + \sa getOutputLatency() +*/ +VstInt32 AudioEffectX::getInputLatency () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetInputLatency, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + While inputLatency is probably not of concern, outputLatency may be used in conjunction with getTimeInfo(). + \e samplePos of VstTimeInfo is ahead of the 'visual' sequencer play time by the output latency, such that + when outputLatency samples have passed by, our processing result becomes audible. + + \return ASIO output latency + \sa getInputLatency() +*/ +VstInt32 AudioEffectX::getOutputLatency () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetOutputLatency, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getInputProperties (VstInt32 index, VstPinProperties* properties) + + \param index The index to the input, starting with 0 + \param properties A pointer to a VstPinProperties structure + \return \e true on success + \sa getOutputProperties() + \note Example + 
+	bool MyPlug::getInputProperties (VstInt32 index, VstPinProperties* properties)
+	{
+		bool returnCode = false;
+		if (index < kNumInputs)
+		{
+			sprintf (properties->label, "My %1d In", index + 1);
+			properties->flags = kVstPinIsStereo | kVstPinIsActive;
+			returnCode = true;
+		}
+		return returnCode;
+	}
+
+*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getOutputProperties (VstInt32 index, VstPinProperties* properties) + + \param index The index to the output, starting with 0 + \param properties A pointer to a VstPinProperties structure + \return \e true on success + \sa getInputProperties() + \note Example 1 + 
+	bool MyPlug::getOutputProperties (VstInt32 index, VstPinProperties* properties)
+	{
+		bool returnCode = false;
+		if (index < kNumOutputs)
+		{
+			sprintf (properties->label, "My %1d Out", index + 1);
+			properties->flags = kVstPinIsStereo | kVstPinIsActive;
+			returnCode = true;
+		}
+		return (returnCode);
+	}
+
+ + \note Example 2 : plug-in with 1 mono, 1 stereo and one 5.1 outputs (kNumOutputs = 9): + 
+	bool MyPlug::getOutputProperties (VstInt32 index, VstPinProperties* properties)
+	{
+		bool returnCode = false;
+		if (index >= 0 && index < kNumOutputs)
+		{
+			properties->flags = kVstPinIsActive;
+			if (index == 0) // mono
+			{
+				strcpy (properties->label, "Mono Out");
+				properties->arrangementType = kSpeakerArrMono;
+			}
+			else if (index == 1) // stereo (1 -> 2)
+			{
+				strcpy (properties->label, "Stereo Out");
+				properties->flags |= kVstPinIsStereo;
+				properties->arrangementType = kSpeakerArrStereo;
+			}
+			else if (index >= 3) // 5.1 (3 -> 8)
+			{
+				strcpy (properties->label, "5.1 Out");
+				properties->flags |= kVstPinUseSpeaker;
+				properties->arrangementType = kSpeakerArr51;
+				// for old VST Host < 2.3, make 5.1 to stereo/mono/mono/stereo (L R C Lfe Ls Rs)
+				if (index == 3 || index == 7)
+					properties->flags |= kVstPinIsStereo;
+				if (index == 5)
+					strcpy (properties->label, "Center");	
+				else if (index == 6)
+					strcpy (properties->label, "Lfe");	
+				else if (index == 7) // (7 -> 8)
+					strcpy (properties->label, "Stereo Back");
+			}
+			returnCode = true;
+		}
+		return returnCode;
+	}
+
+*/ + +//----------------------------------------------------------------------------------------------------------------- +AEffect* AudioEffectX::DECLARE_VST_DEPRECATED (getPreviousPlug) (VstInt32 input) +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetPreviousPlug), 0, 0, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +AEffect* AudioEffectX::DECLARE_VST_DEPRECATED (getNextPlug) (VstInt32 output) +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetNextPlug), 0, 0, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return Plug-in's category defined in VstPlugCategory +*/ +VstPlugCategory AudioEffectX::getPlugCategory () +{ + if (cEffect.flags & effFlagsIsSynth) + return kPlugCategSynth; + return kPlugCategUnknown; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (willProcessReplacing) () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterWillReplaceOrAccumulate), 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + A plug-in is like a black box processing some audio coming in on some inputs (if any) and going out of some + outputs (if any). This may be used to do offline or real-time processing, and sometimes it may be desirable to + know the current context. + + \return #VstProcessLevels in aeffectx.h + +*/ +VstInt32 AudioEffectX::getCurrentProcessLevel () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetCurrentProcessLevel, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return #VstAutomationStates in aeffectx.h +*/ +VstInt32 AudioEffectX::getAutomationState () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetAutomationState, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +void AudioEffectX::DECLARE_VST_DEPRECATED (wantAsyncOperation) (bool state) +{ + if (state) + cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsExtIsAsync); + else + cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsExtIsAsync); +} + +//----------------------------------------------------------------------------------------------------------------- +void AudioEffectX::DECLARE_VST_DEPRECATED (hasExternalBuffer) (bool state) +{ + if (state) + cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsExtHasBuffer); + else + cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsExtHasBuffer); +} + +//----------------------------------------------------------------------------------------------------------------- +// Offline Functions +//----------------------------------------------------------------------------------------------------------------- + +//----------------------------------------------------------------------------------------------------------------- +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::offlineRead (VstOfflineTask* offline, VstOfflineOption option, bool readSource) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineRead, readSource, option, offline, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::offlineWrite (VstOfflineTask* offline, VstOfflineOption option) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineWrite, 0, option, offline, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::offlineStart (VstAudioFile* audioFiles, VstInt32 numAudioFiles, VstInt32 numNewAudioFiles) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineStart, numNewAudioFiles, numAudioFiles, audioFiles, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::offlineGetCurrentPass () +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineGetCurrentPass, 0, 0, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::offlineGetCurrentMetaPass () +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineGetCurrentMetaPass, 0, 0, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +// Other +//----------------------------------------------------------------------------------------------------------------- + +//----------------------------------------------------------------------------------------------------------------- +void AudioEffectX::DECLARE_VST_DEPRECATED (setOutputSamplerate) (float sampleRate) +{ + if (audioMaster) + audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterSetOutputSampleRate), 0, 0, 0, sampleRate); +} + +//----------------------------------------------------------------------------------------------------------------- +VstSpeakerArrangement* AudioEffectX::DECLARE_VST_DEPRECATED (getInputSpeakerArrangement) () +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetInputSpeakerArrangement), 0, 0, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +VstSpeakerArrangement* AudioEffectX::DECLARE_VST_DEPRECATED (getOutputSpeakerArrangement) () +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetOutputSpeakerArrangement), 0, 0, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param text String of maximum 64 char + \return \e true if supported +*/ +bool AudioEffectX::getHostVendorString (char* text) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterGetVendorString, 0, 0, text, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param text String of maximum 64 char + \return \e true if supported +*/ +bool AudioEffectX::getHostProductString (char* text) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterGetProductString, 0, 0, text, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return Host vendor version +*/ +VstInt32 AudioEffectX::getHostVendorVersion () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetVendorVersion, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +VstIntPtr AudioEffectX::hostVendorSpecific (VstInt32 lArg1, VstIntPtr lArg2, void* ptrArg, float floatArg) +{ + if (audioMaster) + return audioMaster (&cEffect, audioMasterVendorSpecific, lArg1, lArg2, ptrArg, floatArg); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + Asks Host if it implements the feature text. A plug-in cannot assume a 2.x feature is available from the Host. + Use this method to ascertain the environment in which the plug-in finds itself. Ignoring this inquiry methods and + trying to access a 2.x feature in a 1.0 Host will mean your plug-in or Host application will break. It is not + the end-users job to pick and choose which plug-ins can be supported by which Host. + + \param text A string from #hostCanDos + \return + - 0 : don't know (default) + - 1 : yes + - -1: no +*/ +VstInt32 AudioEffectX::canHostDo (char* text) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterCanDo, 0, 0, text, 0) != 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + Tells the Host that the plug-in is an instrument, i.e. that it will call wantEvents(). + + \param state + - true: is an instrument (default) + - false: is a simple audio effect +*/ +void AudioEffectX::isSynth (bool state) +{ + if (state) + cEffect.flags |= effFlagsIsSynth; + else + cEffect.flags &= ~effFlagsIsSynth; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + Enables Host to omit processReplacing() when no data is present on any input. +*/ +void AudioEffectX::noTail (bool state) +{ + if (state) + cEffect.flags |= effFlagsNoSoundInStop; + else + cEffect.flags &= ~effFlagsNoSoundInStop; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return #VstHostLanguage in aeffectx.h +*/ +VstInt32 AudioEffectX::getHostLanguage () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetLanguage, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +void* AudioEffectX::DECLARE_VST_DEPRECATED (openWindow) (DECLARE_VST_DEPRECATED (VstWindow)* window) +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterOpenWindow), 0, 0, window, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::DECLARE_VST_DEPRECATED (closeWindow) (DECLARE_VST_DEPRECATED (VstWindow)* window) +{ + if (audioMaster) + return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterCloseWindow), 0, 0, window, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return FSSpec on MAC, else char* +*/ +void* AudioEffectX::getDirectory () +{ + if (audioMaster) + { + VstIntPtr ret = (audioMaster (&cEffect, audioMasterGetDirectory, 0, 0, 0, 0)); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return \e true if supported +*/ +bool AudioEffectX::updateDisplay () +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterUpdateDisplay, 0, 0, 0, 0)) ? true : false; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::processVariableIo (VstVariableIo* varIo) + + If called with \e varIo NULL, returning \e true indicates that this call is supported by the plug-in. + Host will use processReplacing otherwise. The Host should call setTotalSampleToProcess before starting the processIO + to inform the plug-in about how many samples will be processed in total. The Host should provide an output buffer at least 5 times bigger than input buffer. + + \param varIo + \return \true on success +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::setSpeakerArrangement (VstSpeakerArrangement* pluginInput, VstSpeakerArrangement* pluginOutput) + + Set the plug-in's speaker arrangements. If a (VST >= 2.3) plug-in returns \e true, it means that it accepts this IO + arrangement. The Host doesn't need to ask for getSpeakerArrangement(). If the plug-in returns \e false it means that it + doesn't accept this arrangement, the Host should then ask for getSpeakerArrangement() and then can (optional) + recall setSpeakerArrangement(). + + \param pluginInput A pointer to the input's #VstSpeakerArrangement structure. + \param pluginOutput A pointer to the output's #VstSpeakerArrangement structure. + \return \e true on success + + \note setSpeakerArrangement() and getSpeakerArrangement() are always called in suspended state. + (like setSampleRate() or setBlockSize()). + + \sa getSpeakerArrangement() +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getSpeakerArrangement (VstSpeakerArrangement** pluginInput, VstSpeakerArrangement** pluginOutput) + + \param pluginInput A pointer to the input's #VstSpeakerArrangement structure. + \param pluginOutput A pointer to the output's #VstSpeakerArrangement structure. + \return \e true on success + + \note setSpeakerArrangement() and getSpeakerArrangement() are always called in suspended state. + (like setSampleRate() or setBlockSize()).\n + 
Here an example code to show how the host uses getSpeakerArrangement()
+	VstSpeakerArrangement *plugInputVstArr = 0;
+	VstSpeakerArrangement *plugOutputVstArr = 0;
+	if (getFormatVersion () >= 2300 && #getSpeakerArrangement (&plugInputVstArr, &plugOutputVstArr))
+		....
+
+ + \sa setSpeakerArrangement() +*/ +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::setBypass (bool onOff) + + process still called (if Supported) although the plug-in was bypassed. Some plugs need to stay 'alive' even + when bypassed. An example is a surround decoder which has more inputs than outputs and must maintain some + reasonable signal distribution even when being bypassed. A CanDo 'bypass' allows to ask the plug-in if it + supports soft bypass or not. + + \note This bypass feature could be automated by the Host (this means avoid to much CPU requirement in this call) + \note If the plug-in supports SoftBypass and it has a latency (initialDelay), in Bypassed state the plug-in has to used + the same latency value. + + \param onOff + \return + - true: supports SoftBypass, process will be called, the plug-in should compensate its latency, and copy inputs to outputs + - false: doesn't support SoftBypass, process will not be called, the Host should bypass the process call + + \sa processReplacing() +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getEffectName (char* name) + + \param name A string up to 32 chars + \return \e true on success +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getVendorString (char* text) + + \param text A string up to 64 chars + \return \e true on success +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getProductString (char* text) + + \param text A string up to 64 chars + \return \e true on success +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getVendorVersion () + + \return The version of the plug-in + + \note This should be upported +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::canDo (char* text) + + Report what the plug-in is able to do. In general you can but don't have to report whatever you support or not + support via canDo. Some application functionality may require some specific reply, but in that case you will + probably know. Best is to report whatever you know for sure. A Host application cannot make assumptions about + the presence of the new 2.x features of a plug-in. Ignoring this inquiry methods and trying to access a 2.x + feature from a 1.0 plug, or vice versa, will mean the plug-in or Host application will break. It is not the + end-users job to pick and choose which plug-ins can be supported by which Host. + + \param text A string from #plugCanDos + \return + - 0: don't know (default) + - 1: yes + - -1: no + + \note This should be supported. +*/ + +//---------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::canDo (char* text) + + \param text A string from #plugCanDos + \return + - 0: don't know (default). + - 1: yes. + - -1: no +*/ + +//---------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getParameterProperties (VstInt32 index, VstParameterProperties* p) + + \param index Index of the parameter + \param p Pointer to #VstParameterProperties + \return Return \e true on success +*/ + +//---------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getVstVersion () + \return + - 2xxx : the last VST 2.x plug-in version (by default) + - 0 : older versions + +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getMidiProgramName (VstInt32 channel, MidiProgramName* midiProgramName) + Ask plug-in if MidiPrograms are used and if so, query for names, numbers + (ProgramChange-Number + BankSelect-Number), categories and keynames of each + MIDI Program, on each MIDI-channel. If this function is called, your plug-in has to read + MidiProgramName::thisProgramIndex, fill out the other fields with the information + assigned to a certain MIDI Program and return the number of available MIDI Programs on + that MIDI Channel. + + \note plug-in canDo "midiProgramNames". No effect, if 0 is returned. + + \warning don't mix concepts: the MIDI Programs are totally independent from all other + programs present in VST. The main difference is, that there are upto 16 simultaneous + active MIDI Programs (one per channel), while there can be only one active "VST"-Program. + (You should see the "VST"-Program as the one single main global program, which contains + the entire current state of the plug-in.) This function can be called in any sequence. + + \param channel MidiChannel: 0-15 + \param midiProgramName Points to \e #MidiProgramName struct + \return Number of available MIDI Programs on that \e channel + - number of used programIndexes + - 0 if no MidiProgramNames supported + + \note Example : plug-in has 3 MidiPrograms on MidiChannel 0. + 
+	Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 0.
+	Plug fills out:
+	MidiProgramName::name[64] = "Program A"
+	MidiProgramName::midiProgram = 0
+	MidiProgramName::midiBankMsb = -1
+	MidiProgramName::midiBankLsb = -1
+	MidiProgramName::parentCategoryIndex = -1
+	MidiProgramName::flags = 0 (if plug isn't "Omni").
+	Plug returns 3.
+	Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 1.
+	Plug fills out:
+	MidiProgramName::name[64] = "Program B"
+	MidiProgramName::midiProgram = 1
+	MidiProgramName::midiBankMsb = -1
+	MidiProgramName::midiBankLsb = -1
+	MidiProgramName::parentCategoryIndex = -1
+	MidiProgramName::flags = 0 (if plug isn't "Omni").
+	Plug returns 3.
+	Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 2.
+	Plug fills out:
+	MidiProgramName::name[64] = "Program C"
+	MidiProgramName::midiProgram = 2
+	MidiProgramName::midiBankMsb = -1
+	MidiProgramName::midiBankLsb = -1
+	MidiProgramName::parentCategoryIndex = -1
+	MidiProgramName::flags = 0 (if plug isn't "Omni").
+	Plug returns 3.
+
+*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getCurrentMidiProgram (VstInt32 channel, MidiProgramName* currentProgram) + + \param channel + \param currentProgram + \return + - programIndex of the current program + - -1 if not supported +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getMidiProgramCategory (VstInt32 channel, MidiProgramCategory* category) + + \param channel + \param category + \return + - number of used categoryIndexes. + - 0 if no #MidiProgramCategory supported/used. +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::hasMidiProgramsChanged (VstInt32 channel) + + Ask plug-in for the currently active program on a certain MIDI Channel. Just like + getMidiProgramName(), but MidiProgramName::thisProgramIndex has to be filled out with + the currently active MIDI Program-index, which also has to be returned. + + \param channel + \return + - true: if the #MidiProgramNames, #MidiKeyNames or #MidiControllerNames had changed on + this channel +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getMidiKeyName (VstInt32 channel, MidiKeyName* keyName) + + \param channel + \param keyName If keyName is "" the standard name of the key will be displayed + \return Return \e false if no #MidiKeyNames defined for 'thisProgramIndex' +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::beginSetProgram () + + \return + - true: the plug-in took the notification into account + - false: it did not... + + \sa endSetProgram() +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::endSetProgram () + + \return + - true: the plug-in took the notification into account + - false: it did not... + + \sa beginSetProgram() +*/ + +#if VST_2_1_EXTENSIONS +//----------------------------------------------------------------------------------------------------------------- +/*! + It tells the Host that if it needs to, it has to record automation data for this control. + + \param index Index of the parameter + \return Returns \e true on success + + \sa endEdit() +*/ +bool AudioEffectX::beginEdit (VstInt32 index) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterBeginEdit, index, 0, 0, 0)) ? true : false; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + It notifies the Host that this control is no longer moved by the mouse. + + \param index Index of the parameter + \return Returns \e true on success + + \sa beginEdit() +*/ +bool AudioEffectX::endEdit (VstInt32 index) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterEndEdit, index, 0, 0, 0)) ? true : false; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param ptr + \return Returns \e true on success + + \sa closeFileSelector() +*/ +bool AudioEffectX::openFileSelector (VstFileSelect* ptr) +{ + if (audioMaster && ptr) + return (audioMaster (&cEffect, audioMasterOpenFileSelector, 0, 0, ptr, 0)) ? true : false; + return 0; +} +#endif // VST_2_1_EXTENSIONS + +#if VST_2_2_EXTENSIONS +//----------------------------------------------------------------------------------------------------------------- +/*! + \param ptr + \return Returns \e true on success + + \sa openFileSelector() +*/ +bool AudioEffectX::closeFileSelector (VstFileSelect* ptr) +{ + if (audioMaster && ptr) + return (audioMaster (&cEffect, audioMasterCloseFileSelector, 0, 0, ptr, 0)) ? true : false; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + It indicates how many samples will be processed. + + \param nativePath + \return Returns \e true on success + + \sa getChunk(), setChunk() +*/ +bool AudioEffectX::DECLARE_VST_DEPRECATED (getChunkFile) (void* nativePath) +{ + if (audioMaster && nativePath) + return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetChunkFile), 0, 0, nativePath, 0)) ? true : false; + return 0; +} +#endif // VST_2_2_EXTENSIONS + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::setTotalSampleToProcess (VstInt32 value) + + It indicates how many samples will be processed in total. + + \param value Number of samples to process +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getNextShellPlugin (char* name) { return 0; } + + \param name Points to a char buffer of size 64, which is to be filled with the name of the + plug-in including the terminating zero + \return Return the next plug-in's uniqueID + \note Example of Implementation +
+	//---From the Host side : if found plugin is a Shell category-----------
+	if (effect->getCategory () == kPlugCategShell)
+	{ 
+		// scan shell for subplugins
+		char tempName[64] = {0}; 
+		VstInt32 plugUniqueID = 0;
+		while ((plugUniqueID = effect->dispatchEffect (effShellGetNextPlugin, 0, 0, tempName)) != 0)
+		{ 
+			// subplug needs a name 
+			if (tempName[0] != 0)
+			{
+				...do what you want with this tempName and plugUniqueID
+			}
+		}
+	}
+	//---From the Host side : Intanciate a subplugin of a shell plugin---
+	// retreive the uniqueID of this subplugin the host wants to load
+	// set it to the host currentID
+	currentID = subplugInfo->uniqueID;
+	// call the its shell plugin (main function)
+	main ();
+	// the shell plugin will ask for the currentUniqueID
+	// and should return the chosen subplugin
+	...
+	//---From the plugin-Shell Side: for enumeration of subplugins---------
+	category = kPlugCategShell;
+	->can ask the host if "shellCategory" is supported
+	// at start (instanciation) reset the index for the getNextShellPlugin call.
+	myPluginShell::index = 0;
+	// implementation of getNextShellPlugin (char* name);
+	VstInt32 myPluginShell::getNextShellPlugin (char* name)
+	{
+		strcpy (name, MyNameTable[index]);
+		return MyUniqueIDTable[index++];
+	}
+	....
+	//---From the plugin-Shell Side: when instanciation-----
+	VstInt32 uniqueID = host->getCurrentUniqueID ();
+	if (uniqueID == 0) // the host instanciates the shell
+	{}
+	else // host try to instanciate one of my subplugin...identified by the uniqueID
+	{}
+
+*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::setPanLaw (VstInt32 type, float val) + + \param type + \param val + + \return Returns \e true on success + + \note Gain: for Linear : [1.0 => 0dB PanLaw], [~0.58 => -4.5dB], [0.5 => -6.02dB] +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::beginLoadBank (VstPatchChunkInfo* ptr) + + \param ptr + \return + - -1: if the Bank cannot be loaded, + - 1: if it can be loaded + - 0: else (for compatibility) + + \sa beginLoadProgram() + +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::beginLoadProgram (VstPatchChunkInfo* ptr) + + \param ptr + \return + - -1: if the Program cannot be loaded, + - 1: it can be loaded else, + - 0: else (for compatibility) + + \sa beginLoadBank() +*/ + +//----------------------------------------------------------------------------------------------------------------- +// Speaker Arrangement Helpers +//----------------------------------------------------------------------------------------------------------------- + +#if VST_2_3_EXTENSIONS +//----------------------------------------------------------------------------------------------------------------- +/*! + \param arrangement Pointer to a \e #VstSpeakerArrangement structure + \param nbChannels Number of Channels + \return Returns \e true on success + + \sa deallocateArrangement(), copySpeaker(), matchArrangement() +*/ +bool AudioEffectX::allocateArrangement (VstSpeakerArrangement** arrangement, VstInt32 nbChannels) +{ + if (*arrangement) + { + char *ptr = (char*)(*arrangement); + delete [] ptr; + } + + VstInt32 size = 2 * sizeof (VstInt32) + nbChannels * sizeof (VstSpeakerProperties); + char* ptr = new char[size]; + if (!ptr) + return false; + + memset (ptr, 0, size); + *arrangement = (VstSpeakerArrangement*)ptr; + (*arrangement)->numChannels = nbChannels; + return true; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param arrangement Pointer to a \e #VstSpeakerArrangement structure + \return Returns \e true on success + + \sa allocateArrangement(), copySpeaker(), matchArrangement() +*/ +bool AudioEffectX::deallocateArrangement (VstSpeakerArrangement** arrangement) +{ + if (*arrangement) + { + char *ptr = (char*)(*arrangement); + delete [] ptr; + *arrangement = 0; + } + return true; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + Feed the \e to speaker properties with the same values than \e from 's ones. + It is assumed here that \e 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...) + + \param to + \param from + \return Returns \e true on success + + \sa allocateArrangement(), deallocateArrangement(), matchArrangement() +*/ +bool AudioEffectX::copySpeaker (VstSpeakerProperties* to, VstSpeakerProperties* from) +{ + if ((from == NULL) || (to == NULL)) + return false; + + vst_strncpy (to->name, from->name, 63); + to->type = from->type; + to->azimuth = from->azimuth; + to->elevation = from->elevation; + to->radius = from->radius; + to->reserved = from->reserved; + memcpy (to->future, from->future, 28); + + return true; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \e to is deleted, then created and initialized with the same values as \e from (must exist!). + It's notably useful when setSpeakerArrangement() is called by the Host. + + \param to + \param from + \return Returns \e true on success + + \sa allocateArrangement(), deallocateArrangement(), copySpeaker() +*/ + +bool AudioEffectX::matchArrangement (VstSpeakerArrangement** to, VstSpeakerArrangement* from) +{ + if (from == NULL) + return false; + + if ((!deallocateArrangement (to)) || (!allocateArrangement (to, from->numChannels))) + return false; + + (*to)->type = from->type; + for (VstInt32 i = 0; i < (*to)->numChannels; i++) + { + if (!copySpeaker (&((*to)->speakers[i]), &(from->speakers[i]))) + return false; + } + + return true; +} +#endif // VST_2_3_EXTENSIONS + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::setProcessPrecision (VstInt32 precision) + + Is called in suspended state, similar to #setBlockSize. Default (if not called) is single precision float. + + \param precision kVstProcessPrecision32 or kVstProcessPrecision64 + \return Returns \e true on success + \sa VstProcessPrecision +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getNumMidiInputChannels () + + Called by the host application to determine how many MIDI input channels are actually used by a plugin + e.g. to hide unused channels from the user. + For compatibility with VST 2.3 and below, the default return value 0 means 'not implemented' - + in this case the host assumes 16 MIDI channels to be present (or none at all). + + \return Number of MIDI input channels: 1-15, otherwise: 16 or no MIDI channels at all (0) + + \note The VST 2.x protocol is limited to a maximum of 16 MIDI channels as defined by the MIDI Standard. This might change in future revisions of the API. + + \sa + getNumMidiOutputChannels() @n + PlugCanDos::canDoReceiveVstMidiEvent +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getNumMidiOutputChannels () + + Called by the host application to determine how many MIDI output channels are actually used by a plugin + e.g. to hide unused channels from the user. + For compatibility with VST 2.3 and below, the default return value 0 means 'not implemented' - + in this case the host assumes 16 MIDI channels to be present (or none at all). + + \return Number of MIDI output channels: 1-15, otherwise: 16 or no MIDI channels at all (0) + + \note The VST 2.x protocol is limited to a maximum of 16 MIDI channels as defined by the MIDI Standard. This might change in future revisions of the API. + + \sa + getNumMidiInputChannels() @n + PlugCanDos::canDoSendVstMidiEvent +*/ -- cgit v1.2.3-70-g09d2