UnBox, and build folder cleanups

Note that I am compelled to break VST builds on Windows because my build folders have had some files in 'em: you'll have to find those yourself. Here's hoping anyone trying to develop for Windows VST (or any VST) is able to find what they need, but I cannot help you set up a build environment, I can only give you my code for the audio part.

6 files changed, 0 insertions, 2807 deletions

diff --git a/plugins/WinVST/Spiral2/vst2.x/aeffeditor.h b/plugins/WinVST/Spiral2/vst2.x/aeffeditor.h
deleted file mode 100755
index 04f7339..0000000
--- a/plugins/WinVST/Spiral2/vst2.x/aeffeditor.h
+++ /dev/null
@@ -1,61 +0,0 @@
-//-------------------------------------------------------------------------------------------------------

-// VST Plug-Ins SDK

-// Version 2.4       $Date: 2006/01/12 09:05:31 $

-//

-// Category     : VST 2.x Classes

-// Filename     : aeffeditor.h

-// Created by   : Steinberg Media Technologies

-// Description  : Editor Class for VST Plug-Ins

-//

-// © 2006, Steinberg Media Technologies, All Rights Reserved

-//-------------------------------------------------------------------------------------------------------

-

-#ifndef __aeffeditor__

-#define __aeffeditor__

-

-#include "audioeffectx.h"

-

-//-------------------------------------------------------------------------------------------------------

-/** VST Effect Editor class. */

-//-------------------------------------------------------------------------------------------------------

-class AEffEditor

-{

-public:

-//-------------------------------------------------------------------------------------------------------

-	AEffEditor (AudioEffect* effect = 0)	///< Editor class constructor. Requires pointer to associated effect instance.

-	: effect (effect)

-	, systemWindow (0)

-	{}

-

-	virtual ~AEffEditor () ///< Editor class destructor.

-	{}

-

-	virtual AudioEffect* getEffect ()	{ return effect; }					///< Returns associated effect instance

-	virtual bool getRect (ERect** rect)	{ *rect = 0; return false; }		///< Query editor size as #ERect

-	virtual bool open (void* ptr)		{ systemWindow = ptr; return 0; }	///< Open editor, pointer to parent windows is platform-dependent (HWND on Windows, WindowRef on Mac).

-	virtual void close ()				{ systemWindow = 0; }				///< Close editor (detach from parent window)

-	virtual bool isOpen ()				{ return systemWindow != 0; }		///< Returns true if editor is currently open

-	virtual void idle ()				{}									///< Idle call supplied by Host application

-

-#if TARGET_API_MAC_CARBON

-	virtual void DECLARE_VST_DEPRECATED (draw) (ERect* rect) {}

-	virtual VstInt32 DECLARE_VST_DEPRECATED (mouse) (VstInt32 x, VstInt32 y) { return 0; }

-	virtual VstInt32 DECLARE_VST_DEPRECATED (key) (VstInt32 keyCode) { return 0; }

-	virtual void DECLARE_VST_DEPRECATED (top) () {}

-	virtual void DECLARE_VST_DEPRECATED (sleep) () {}

-#endif

-

-#if VST_2_1_EXTENSIONS

-	virtual bool onKeyDown (VstKeyCode& keyCode)	{ return false; }		///< Receive key down event. Return true only if key was really used!

-	virtual bool onKeyUp (VstKeyCode& keyCode)		{ return false; }		///< Receive key up event. Return true only if key was really used!

-	virtual bool onWheel (float distance)			{ return false; }		///< Handle mouse wheel event, distance is positive or negative to indicate wheel direction.

-	virtual bool setKnobMode (VstInt32 val)			{ return false; }		///< Set knob mode (if supported by Host). See CKnobMode in VSTGUI.

-#endif

-

-//-------------------------------------------------------------------------------------------------------

-protected:

-	AudioEffect* effect;	///< associated effect instance

-	void* systemWindow;		///< platform-dependent parent window (HWND or WindowRef)

-};

-

-#endif // __aeffeditor__

diff --git a/plugins/WinVST/Spiral2/vst2.x/audioeffect.cpp b/plugins/WinVST/Spiral2/vst2.x/audioeffect.cpp
deleted file mode 100755
index e7440d2..0000000
--- a/plugins/WinVST/Spiral2/vst2.x/audioeffect.cpp
+++ /dev/null
@@ -1,703 +0,0 @@
-//-------------------------------------------------------------------------------------------------------

-// VST Plug-Ins SDK

-// Version 2.4       $Date: 2006/06/07 08:22:01 $

-//

-// Category     : VST 2.x Classes

-// Filename     : audioeffect.cpp

-// Created by   : Steinberg Media Technologies

-// Description  : Class AudioEffect (VST 1.0)

-//

-// © 2006, Steinberg Media Technologies, All Rights Reserved

-//-------------------------------------------------------------------------------------------------------

-

-#include "audioeffect.h"

-#include "aeffeditor.h"

-

-#include <stddef.h>

-#include <stdio.h>

-#include <math.h>

-

-//-------------------------------------------------------------------------------------------------------

-VstIntPtr AudioEffect::dispatchEffectClass (AEffect* e, VstInt32 opCode, VstInt32 index, VstIntPtr value, void* ptr, float opt)

-{

-	AudioEffect* ae = (AudioEffect*)(e->object);

-

-	if (opCode == effClose)

-	{

-		ae->dispatcher (opCode, index, value, ptr, opt);

-		delete ae;

-		return 1;

-	}

-

-	return ae->dispatcher (opCode, index, value, ptr, opt);

-}

-

-//-------------------------------------------------------------------------------------------------------

-float AudioEffect::getParameterClass (AEffect* e, VstInt32 index)

-{

-	AudioEffect* ae = (AudioEffect*)(e->object);

-	return ae->getParameter (index);

-}

-

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::setParameterClass (AEffect* e, VstInt32 index, float value)

-{

-	AudioEffect* ae = (AudioEffect*)(e->object);

-	ae->setParameter (index, value);

-}

-

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::DECLARE_VST_DEPRECATED (processClass) (AEffect* e, float** inputs, float** outputs, VstInt32 sampleFrames)

-{

-	AudioEffect* ae = (AudioEffect*)(e->object);

-	ae->DECLARE_VST_DEPRECATED (process) (inputs, outputs, sampleFrames);

-}

-

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::processClassReplacing (AEffect* e, float** inputs, float** outputs, VstInt32 sampleFrames)

-{

-	AudioEffect* ae = (AudioEffect*)(e->object);

-	ae->processReplacing (inputs, outputs, sampleFrames);

-}

-

-//-------------------------------------------------------------------------------------------------------

-#if VST_2_4_EXTENSIONS

-void AudioEffect::processClassDoubleReplacing (AEffect* e, double** inputs, double** outputs, VstInt32 sampleFrames)

-{

-	AudioEffect* ae = (AudioEffect*)(e->object);

-	ae->processDoubleReplacing (inputs, outputs, sampleFrames);

-}

-#endif

-

-//-------------------------------------------------------------------------------------------------------

-// Class AudioEffect Implementation

-//-------------------------------------------------------------------------------------------------------

-/*!

-	The constructor of your class is passed a parameter of the type \e audioMasterCallback. The actual 

-	mechanism in which your class gets constructed is not important right now. Effectively your class is 

-	constructed by the hosting application, which passes an object of type \e audioMasterCallback that 

-	handles the interaction with the plug-in. You pass this on to the base class' constructor and then 

-	can forget about it.

-

-	\param audioMaster Passed by the Host and handles interaction

-	\param numPrograms Pass the number of programs the plug-in provides

-	\param numParams Pass the number of parameters the plug-in provides

-	

-\code

-MyPlug::MyPlug (audioMasterCallback audioMaster)

-: AudioEffectX (audioMaster, 1, 1)    // 1 program, 1 parameter only

-{

-	setNumInputs (2); // stereo in

-	setNumOutputs (2); // stereo out

-	setUniqueID ('MyPl'); // you must change this for other plug-ins!

-	canProcessReplacing (); // supports replacing mode

-}

-\endcode

-

-	\sa setNumInputs, setNumOutputs, setUniqueID, canProcessReplacing

-*/

-AudioEffect::AudioEffect (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams)

-: audioMaster (audioMaster)

-, editor (0)

-, sampleRate (44100.f)

-, blockSize (1024)

-, numPrograms (numPrograms)

-, numParams (numParams)

-, curProgram (0)

-{

-	memset (&cEffect, 0, sizeof (cEffect));

-

-	cEffect.magic = kEffectMagic;

-	cEffect.dispatcher = dispatchEffectClass;

-	cEffect.DECLARE_VST_DEPRECATED (process) = DECLARE_VST_DEPRECATED (processClass);

-	cEffect.setParameter = setParameterClass;

-	cEffect.getParameter = getParameterClass;

-	cEffect.numPrograms  = numPrograms;

-	cEffect.numParams    = numParams;

-	cEffect.numInputs  = 1;		// mono input

-	cEffect.numOutputs = 2;		// stereo output

-	cEffect.DECLARE_VST_DEPRECATED (ioRatio) = 1.f;

-	cEffect.object = this;

-	cEffect.uniqueID = CCONST ('N', 'o', 'E', 'f');

-	cEffect.version  = 1;

-	cEffect.processReplacing = processClassReplacing;

-

-#if VST_2_4_EXTENSIONS

-	canProcessReplacing (); // mandatory in VST 2.4!

-	cEffect.processDoubleReplacing = processClassDoubleReplacing;

-#endif

-}

-

-//-------------------------------------------------------------------------------------------------------

-AudioEffect::~AudioEffect ()

-{

-	if (editor)

-		delete editor;

-}

-

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::setEditor (AEffEditor* editor)

-{

-	this->editor = editor;

-	if (editor) 

-		cEffect.flags |= effFlagsHasEditor;

-	else 

-		cEffect.flags &= ~effFlagsHasEditor;

-}

-

-//-------------------------------------------------------------------------------------------------------

-VstIntPtr AudioEffect::dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt)

-{

-	VstIntPtr v = 0;

-	

-	switch (opcode)

-	{

-		case effOpen:				open ();											break;

-		case effClose:				close ();											break;

-		case effSetProgram:			if (value < numPrograms) setProgram ((VstInt32)value); break;

-		case effGetProgram:			v = getProgram ();									break;

-		case effSetProgramName: 	setProgramName ((char*)ptr);						break;

-		case effGetProgramName: 	getProgramName ((char*)ptr);						break;

-		case effGetParamLabel:		getParameterLabel (index, (char*)ptr);				break;

-		case effGetParamDisplay:	getParameterDisplay (index, (char*)ptr);			break;

-		case effGetParamName:		getParameterName (index, (char*)ptr);				break;

-

-		case effSetSampleRate:		setSampleRate (opt);								break;

-		case effSetBlockSize:		setBlockSize ((VstInt32)value);						break;

-		case effMainsChanged:		if (!value) suspend (); else resume ();				break;

-	#if !VST_FORCE_DEPRECATED

-		case effGetVu:				v = (VstIntPtr)(getVu () * 32767.);					break;

-	#endif

-

-		//---Editor------------

-		case effEditGetRect:		if (editor) v = editor->getRect ((ERect**)ptr) ? 1 : 0;	break;

-		case effEditOpen:			if (editor) v = editor->open (ptr) ? 1 : 0;			break;

-		case effEditClose:			if (editor) editor->close ();						break;		

-		case effEditIdle:			if (editor) editor->idle ();						break;

-		

-	#if (TARGET_API_MAC_CARBON && !VST_FORCE_DEPRECATED)

-		case effEditDraw:			if (editor) editor->draw ((ERect*)ptr);				break;

-		case effEditMouse:			if (editor) v = editor->mouse (index, value);		break;

-		case effEditKey:			if (editor) v = editor->key (value);				break;

-		case effEditTop:			if (editor) editor->top ();							break;

-		case effEditSleep:			if (editor) editor->sleep ();						break;

-	#endif

-		

-		case DECLARE_VST_DEPRECATED (effIdentify):	v = CCONST ('N', 'v', 'E', 'f');	break;

-

-		//---Persistence-------

-		case effGetChunk:			v = getChunk ((void**)ptr, index ? true : false);	break;

-		case effSetChunk:			v = setChunk (ptr, (VstInt32)value, index ? true : false);	break;

-	}

-	return v;

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	Use to ask for the Host's version

-	\return The Host's version

-*/

-VstInt32 AudioEffect::getMasterVersion ()

-{

-	VstInt32 version = 1;

-	if (audioMaster)

-	{

-		version = (VstInt32)audioMaster (&cEffect, audioMasterVersion, 0, 0, 0, 0);

-		if (!version)	// old

-			version = 1;

-	}

-	return version;

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\sa AudioEffectX::getNextShellPlugin

-*/

-VstInt32 AudioEffect::getCurrentUniqueId ()

-{

-	VstInt32 id = 0;

-	if (audioMaster)

-		id = (VstInt32)audioMaster (&cEffect, audioMasterCurrentId, 0, 0, 0, 0);

-	return id;

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	Give idle time to Host application, e.g. if plug-in editor is doing mouse tracking in a modal loop.

-*/

-void AudioEffect::masterIdle ()

-{

-	if (audioMaster)

-		audioMaster (&cEffect, audioMasterIdle, 0, 0, 0, 0);

-}

-

-//-------------------------------------------------------------------------------------------------------

-bool AudioEffect::DECLARE_VST_DEPRECATED (isInputConnected) (VstInt32 input)

-{

-	VstInt32 ret = 0;

-	if (audioMaster)

-		ret = (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterPinConnected), input, 0, 0, 0);

-	return ret ? false : true;		// return value is 0 for true

-}

-

-//-------------------------------------------------------------------------------------------------------

-bool AudioEffect::DECLARE_VST_DEPRECATED (isOutputConnected) (VstInt32 output)

-{

-	VstInt32 ret = 0;

-	if (audioMaster)

-		ret = (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterPinConnected), output, 1, 0, 0);

-	return ret ? false : true;		// return value is 0 for true

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\param index parameter index

-	\param float parameter value

-

-	\note An important thing to notice is that if the user changes a parameter in your editor, which is 

-	out of the Host's control if you are not using the default string based interface, you should 

-	call setParameterAutomated (). This ensures that the Host is notified of the parameter change, which 

-	allows it to record these changes for automation.

-

-	\sa setParameter

-*/

-void AudioEffect::setParameterAutomated (VstInt32 index, float value)

-{

-	setParameter (index, value);

-	if (audioMaster)

-		audioMaster (&cEffect, audioMasterAutomate, index, 0, 0, value);	// value is in opt

-}

-

-//-------------------------------------------------------------------------------------------------------

-// Flags

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::DECLARE_VST_DEPRECATED (hasVu) (bool state)

-{

-	if (state)

-		cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsHasVu);

-	else

-		cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsHasVu);

-}

-

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::DECLARE_VST_DEPRECATED (hasClip) (bool state)

-{

-	if (state)

-		cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsHasClip);

-	else

-		cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsHasClip);

-}

-

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::DECLARE_VST_DEPRECATED (canMono) (bool state)

-{

-	if (state)

-		cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsCanMono);

-	else

-		cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsCanMono);

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\param state Set to \e true if supported

-

-	\note Needs to be called in the plug-in's constructor

-*/

-void AudioEffect::canProcessReplacing (bool state)

-{

-	if (state)

-		cEffect.flags |= effFlagsCanReplacing;

-	else

-		cEffect.flags &= ~effFlagsCanReplacing;

-}

-

-//-----------------------------------------------------------------------------------------------------------------

-/*!

-	\param state Set to \e true if supported

-

-	\note Needs to be called in the plug-in's constructor

-*/

-#if VST_2_4_EXTENSIONS

-void AudioEffect::canDoubleReplacing (bool state)

-{

-	if (state)

-		cEffect.flags |= effFlagsCanDoubleReplacing;

-	else

-		cEffect.flags &= ~effFlagsCanDoubleReplacing;

-}

-#endif

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\param state Set \e true if programs are chunks

-

-	\note Needs to be called in the plug-in's constructor

-*/

-void AudioEffect::programsAreChunks (bool state)

-{

-	if (state)

-		cEffect.flags |= effFlagsProgramChunks;

-	else

-		cEffect.flags &= ~effFlagsProgramChunks;

-}

-

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::DECLARE_VST_DEPRECATED (setRealtimeQualities) (VstInt32 qualities)

-{

-	cEffect.DECLARE_VST_DEPRECATED (realQualities) = qualities;

-}

-

-//-------------------------------------------------------------------------------------------------------

-void AudioEffect::DECLARE_VST_DEPRECATED (setOfflineQualities) (VstInt32 qualities)

-{

-	cEffect.DECLARE_VST_DEPRECATED (offQualities) = qualities;

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	Use to report the Plug-in's latency (Group Delay)

-

-	\param delay Plug-ins delay in samples

-*/

-void AudioEffect::setInitialDelay (VstInt32 delay)

-{

-	cEffect.initialDelay = delay;

-}

-

-//-------------------------------------------------------------------------------------------------------

-// Strings Conversion

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\param value Value to convert

-	\param text	String up to length char

-	\param maxLen Maximal length of the string

-*/

-void AudioEffect::dB2string (float value, char* text, VstInt32 maxLen)

-{

-	if (value <= 0)

-		vst_strncpy (text, "-oo", maxLen);

-	else

-		float2string ((float)(20. * log10 (value)), text, maxLen);

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\param samples Number of samples

-	\param text	String up to length char

-	\param maxLen Maximal length of the string

-*/

-void AudioEffect::Hz2string (float samples, char* text, VstInt32 maxLen)

-{

-	float sampleRate = getSampleRate ();

-	if (!samples)

-		float2string (0, text, maxLen);

-	else

-		float2string (sampleRate / samples, text, maxLen);

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\param samples Number of samples

-	\param text	String up to length char

-	\param maxLen Maximal length of the string

-*/

-void AudioEffect::ms2string (float samples, char* text, VstInt32 maxLen)

-{

-	float2string ((float)(samples * 1000. / getSampleRate ()), text, maxLen);

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\param value Value to convert

-	\param text	String up to length char

-	\param maxLen Maximal length of the string

-*/

-void AudioEffect::float2string (float value, char* text, VstInt32 maxLen)

-{

-	VstInt32 c = 0, neg = 0;

-	char string[32];

-	char* s;

-	double v, integ, i10, mantissa, m10, ten = 10.;

-	

-	v = (double)value;

-	if (v < 0)

-	{

-		neg = 1;

-		value = -value;

-		v = -v;

-		c++;

-		if (v > 9999999.)

-		{

-			vst_strncpy (string, "Huge!", 31);

-			return;

-		}

-	}

-	else if (v > 99999999.)

-	{

-		vst_strncpy (string, "Huge!", 31);

-		return;

-	}

-

-	s = string + 31;

-	*s-- = 0;

-	*s-- = '.';

-	c++;

-	

-	integ = floor (v);

-	i10 = fmod (integ, ten);

-	*s-- = (char)((VstInt32)i10 + '0');

-	integ /= ten;

-	c++;

-	while (integ >= 1. && c < 8)

-	{

-		i10 = fmod (integ, ten);

-		*s-- = (char)((VstInt32)i10 + '0');

-		integ /= ten;

-		c++;

-	}

-	if (neg)

-		*s-- = '-';

-	vst_strncpy (text, s + 1, maxLen);

-	if (c >= 8)

-		return;

-

-	s = string + 31;

-	*s-- = 0;

-	mantissa = fmod (v, 1.);

-	mantissa *= pow (ten, (double)(8 - c));

-	while (c < 8)

-	{

-		if (mantissa <= 0)

-			*s-- = '0';

-		else

-		{

-			m10 = fmod (mantissa, ten);

-			*s-- = (char)((VstInt32)m10 + '0');

-			mantissa /= 10.;

-		}

-		c++;

-	}

-	vst_strncat (text, s + 1, maxLen);

-}

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\param value Value to convert

-	\param text	String up to length char

-	\param maxLen Maximal length of the string

-*/

-void AudioEffect::int2string (VstInt32 value, char* text, VstInt32 maxLen)

-{

-	if (value >= 100000000)

-	{

-		vst_strncpy (text, "Huge!", maxLen);

-		return;

-	}

-

-	if (value < 0)

-	{

-		vst_strncpy (text, "-", maxLen);

-		value = -value;

-	}

-	else

-		vst_strncpy (text, "", maxLen);

-

-	bool state = false;

-	for (VstInt32 div = 100000000; div >= 1; div /= 10)

-	{

-		VstInt32 digit = value / div;

-		value -= digit * div;

-		if (state || digit > 0)

-		{

-			char temp[2] = {'0' + (char)digit, '\0'};

-			vst_strncat (text, temp, maxLen);

-			state = true;

-		}

-	}

-}

-//-------------------------------------------------------------------------------------------------------

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames)

-	

-	This process method must be provided. It takes input data, applies its pocessing algorithm, and then puts the 

-	result to the output by overwriting the output buffer.

-

-	\param inputs An array of pointers to the data

-	\param outputs An array of pointers to where the data can be written to

-	\param sampleFrames Number of sample frames to process

-

-	\warning Never call any Mac OS 9 functions (or other functions which call into the OS) inside your 

-	audio process function! This will crash the system when your plug-in is run in MP (multiprocessor) mode.

-	If you must call into the OS, you must use MPRemoteCall () (see Apples' documentation), or 

-	explicitly use functions which are documented by Apple to be MP safe. On Mac OS X read the system 

-	header files to be sure that you only call thread safe functions.

-

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::setBlockSize (VstInt32 blockSize)

-

-	This is called by the Host, and tells the plug-in that the maximum block size passed to 

-	processReplacing() will be \e blockSize.

-

-	\param blockSize Maximum number of sample frames

-

-	\warning You <b>must</b> process <b>exactly</b> \e sampleFrames number of samples in inside processReplacing, not more!

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::setParameter (VstInt32 index, float value)

-

-	Parameters are the individual parameter settings the user can adjust. A VST Host can automate these 

-	parameters. Set parameter \e index to \e value.

-

-	\param index Index of the parameter to change

-	\param value A float value between 0.0 and 1.0 inclusive

-

-	\note Parameter values, like all VST parameters, are declared as floats with an inclusive range of 

-	0.0 to 1.0. How data is presented to the user is merely in the user-interface handling. This is a 

-	convention, but still worth regarding. Maybe the VST-Host's automation system depends on this range.

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn float AudioEffect::getParameter (VstInt32 index)

-

-	Return the \e value of parameter \e index

-

-	\param index Index of the parameter

-	\return A float value between 0.0 and 1.0 inclusive

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::getParameterLabel (VstInt32 index, char* label)

-

-	\param index Index of the parameter

-	\param label A string up to 8 char

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::getParameterDisplay (VstInt32 index, char* text)

-

-	\param index Index of the parameter

-	\param text A string up to 8 char

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn VstInt32 AudioEffect::getProgram ()

-

-	\return Index of the current program

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::setProgram (VstInt32 program)

-

-	\param Program of the current program

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::getParameterName (VstInt32 index, char* text)

-

-	\param index Index of the parameter

-	\param text A string up to 8 char

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::setProgramName (char* name)

-

-	The program name is displayed in the rack, and can be edited by the user.

-

-	\param name A string up to 24 char

-

-	\warning Please be aware that the string lengths supported by the default VST interface are normally 

-	limited to 24 characters. If you copy too much data into the buffers provided, you will break the 

-	Host application.

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::getProgramName (char* name)

-

-	The program name is displayed in the rack, and can be edited by the user.

-

-	\param name A string up to 24 char

-

-	\warning Please be aware that the string lengths supported by the default VST interface are normally 

-	limited to 24 characters. If you copy too much data into the buffers provided, you will break the 

-	Host application.

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn VstInt32 AudioEffect::getChunk (void** data, bool isPreset)

-	

-	\param data should point to the newly allocated memory block containg state data. You can savely release it in next suspend/resume call.

-	\param isPreset true when saving a single program, false for all programs

-

-	\note

-	If your plug-in is configured to use chunks (see AudioEffect::programsAreChunks), the Host

-	will ask for a block of memory describing the current plug-in state for saving.

-	To restore the state at a later stage, the same data is passed back to AudioEffect::setChunk.

-	Alternatively, when not using chunk, the Host will simply save all parameter values.

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn VstInt32 AudioEffect::setChunk (void* data, VstInt32 byteSize, bool isPreset)

-	

-	\param data pointer to state data (owned by Host)

-	\param byteSize size of state data

-	\param isPreset true when restoring a single program, false for all programs

-

-	\sa getChunk

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::setNumInputs (VstInt32 inputs)

-

-	This number is fixed at construction time and can't change until the plug-in is destroyed.

-

-	\param inputs The number of inputs

-

-	\sa isInputConnected()

-

-	\note Needs to be called in the plug-in's constructor

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::setNumOutputs (VstInt32 outputs)

-

-	This number is fixed at construction time and can't change until the plug-in is destroyed.

-

-	\param outputs The number of outputs

-

-	\sa isOutputConnected()

-

-	\note Needs to be called in the plug-in's constructor

-*/

-

-//-------------------------------------------------------------------------------------------------------

-/*!

-	\fn void AudioEffect::setUniqueID (VstInt32 iD)

-

-	Must call this! Set the plug-in's unique identifier. The Host uses this to identify the plug-in, for

-	instance when it is loading effect programs and banks. On Steinberg Web Page you can find an UniqueID

-	Database where you can record your UniqueID, it will check if the ID is already used by an another 

-	vendor. You can use CCONST('a','b','c','d') (defined in VST 2.0) to be platform independent to 

-	initialize an UniqueID.

-

-	\param iD Plug-in's unique ID

-

-	\note Needs to be called in the plug-in's constructor

-*/

diff --git a/plugins/WinVST/Spiral2/vst2.x/audioeffect.h b/plugins/WinVST/Spiral2/vst2.x/audioeffect.h
deleted file mode 100755
index a506bde..0000000
--- a/plugins/WinVST/Spiral2/vst2.x/audioeffect.h
+++ /dev/null
@@ -1,177 +0,0 @@
-//-------------------------------------------------------------------------------------------------------

-// VST Plug-Ins SDK

-// Version 2.4       $Date: 2006/06/06 16:01:34 $

-//

-// Category     : VST 2.x Classes

-// Filename     : audioeffect.h

-// Created by   : Steinberg Media Technologies

-// Description  : Class AudioEffect (VST 1.0)

-//

-// © 2006, Steinberg Media Technologies, All Rights Reserved

-//-------------------------------------------------------------------------------------------------------

-

-#ifndef __audioeffect__

-#define __audioeffect__

-

-#include "pluginterfaces/vst2.x/aeffect.h"	// "c" interface

-

-class AEffEditor;

-

-//-------------------------------------------------------------------------------------------------------

-/** VST Effect Base Class (VST 1.0). */

-//-------------------------------------------------------------------------------------------------------

-class AudioEffect

-{

-public:

-//-------------------------------------------------------------------------------------------------------

-	AudioEffect (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams); ///< Create an \e AudioEffect object

-	virtual ~AudioEffect (); ///< Destroy an \e AudioEffect object

-

-	virtual VstIntPtr dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt);	///< Opcodes dispatcher

-

-//-------------------------------------------------------------------------------------------------------

-/// \name State Transitions

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual void open () {}		///< Called when plug-in is initialized

-	virtual void close () {}	///< Called when plug-in will be released

-	virtual void suspend () {}	///< Called when plug-in is switched to off

-	virtual void resume () {}	///< Called when plug-in is switched to on

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Processing

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual void setSampleRate (float sampleRate)  { this->sampleRate = sampleRate; }	///< Called when the sample rate changes (always in a suspend state)

-	virtual void setBlockSize (VstInt32 blockSize) { this->blockSize = blockSize; }		///< Called when the Maximun block size changes (always in a suspend state). Note that the sampleFrames in Process Calls could be smaller than this block size, but NOT bigger.

-

-	virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames) = 0; ///< Process 32 bit (single precision) floats (always in a resume state)

-

-#if VST_2_4_EXTENSIONS

-	virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames) {} ///< Process 64 bit (double precision) floats (always in a resume state) \sa processReplacing

-#endif // VST_2_4_EXTENSIONS

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Parameters

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual void setParameter (VstInt32 index, float value) {}	///< Called when a parameter changed

-	virtual float getParameter (VstInt32 index) { return 0; }	///< Return the value of the parameter with \e index

-	virtual void setParameterAutomated (VstInt32 index, float value);///< Called after a control has changed in the editor and when the associated parameter should be automated

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Programs and Persistence

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual VstInt32 getProgram () { return curProgram; }					///< Return the index to the current program

-	virtual void setProgram (VstInt32 program) { curProgram = program; }	///< Set the current program to \e program

-	

-	virtual void setProgramName (char* name) {}				///< Stuff the name field of the current program with \e name. Limited to #kVstMaxProgNameLen.

-	virtual void getProgramName (char* name) { *name = 0; }	///< Stuff \e name with the name of the current program. Limited to #kVstMaxProgNameLen.

-	

-	virtual void getParameterLabel (VstInt32 index, char* label)  { *label = 0; }	///< Stuff \e label with the units in which parameter \e index is displayed (i.e. "sec", "dB", "type", etc...). Limited to #kVstMaxParamStrLen.

-	virtual void getParameterDisplay (VstInt32 index, char* text) { *text = 0; }	///< Stuff \e text with a string representation ("0.5", "-3", "PLATE", etc...) of the value of parameter \e index. Limited to #kVstMaxParamStrLen.

-	virtual void getParameterName (VstInt32 index, char* text)    { *text = 0; }    ///< Stuff \e text with the name ("Time", "Gain", "RoomType", etc...) of parameter \e index. Limited to #kVstMaxParamStrLen.

-	

-	virtual VstInt32 getChunk (void** data, bool isPreset = false) { return 0; } ///< Host stores plug-in state. Returns the size in bytes of the chunk (plug-in allocates the data array)

-	virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset = false) { return 0; }	///< Host restores plug-in state

-//@}

-	

-//-------------------------------------------------------------------------------------------------------

-/// \name Internal Setup

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual void setUniqueID (VstInt32 iD)        { cEffect.uniqueID = iD; }		///< Must be called to set the plug-ins unique ID!

-	virtual void setNumInputs (VstInt32 inputs)   { cEffect.numInputs = inputs; }	///< Set the number of inputs the plug-in will handle. For a plug-in which could change its IO configuration, this number is the maximun available inputs.

-	virtual void setNumOutputs (VstInt32 outputs) { cEffect.numOutputs = outputs; }	///< Set the number of outputs the plug-in will handle. For a plug-in which could change its IO configuration, this number is the maximun available ouputs.

-

-	virtual void canProcessReplacing (bool state = true);	///< Tells that processReplacing() could be used. Mandatory in VST 2.4!

-

-#if VST_2_4_EXTENSIONS

-	virtual void canDoubleReplacing (bool state = true);	///< Tells that processDoubleReplacing() is implemented.

-#endif // VST_2_4_EXTENSIONS

-

-	virtual void programsAreChunks (bool state = true);	///< Program data is handled in formatless chunks (using getChunk-setChunks)

-	virtual void setInitialDelay (VstInt32 delay);		///< Use to report the plug-in's latency (Group Delay)

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Editor

-//-------------------------------------------------------------------------------------------------------

-//@{

-	void setEditor (AEffEditor* editor);				///< Should be called if you want to define your own editor

-	virtual AEffEditor* getEditor () { return editor; }	///< Returns the attached editor

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Inquiry

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual AEffect* getAeffect ()   { return &cEffect; }		///< Returns the #AEffect structure

-	virtual float getSampleRate ()   { return sampleRate; }		///< Returns the current sample rate

-	virtual VstInt32 getBlockSize () { return blockSize; }		///< Returns the current Maximum block size

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Host Communication

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual VstInt32 getMasterVersion ();		///< Returns the Host's version (for example 2400 for VST 2.4)

-	virtual VstInt32 getCurrentUniqueId ();		///< Returns current unique identifier when loading shell plug-ins

-	virtual void masterIdle ();					///< Give idle time to Host application

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Tools (helpers)

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual void dB2string (float value, char* text, VstInt32 maxLen);		///< Stuffs \e text with an amplitude on the [0.0, 1.0] scale converted to its value in decibels.

-	virtual void Hz2string (float samples, char* text, VstInt32 maxLen);	///< Stuffs \e text with the frequency in Hertz that has a period of \e samples.

-	virtual void ms2string (float samples, char* text, VstInt32 maxLen);	///< Stuffs \e text with the duration in milliseconds of \e samples frames.

-	virtual void float2string (float value, char* text, VstInt32 maxLen);	///< Stuffs \e text with a string representation on the floating point \e value.

-	virtual void int2string (VstInt32 value, char* text, VstInt32 maxLen);	///< Stuffs \e text with a string representation on the integer \e value.

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-// Deprecated methods

-//-------------------------------------------------------------------------------------------------------

-/// @cond ignore

-	virtual void DECLARE_VST_DEPRECATED (process) (float** inputs, float** outputs, VstInt32 sampleFrames) {}

-	virtual float DECLARE_VST_DEPRECATED (getVu) () { return 0; }

-	virtual void DECLARE_VST_DEPRECATED (hasVu) (bool state = true);

-	virtual void DECLARE_VST_DEPRECATED (hasClip) (bool state = true);

-	virtual void DECLARE_VST_DEPRECATED (canMono) (bool state = true);

-	virtual void DECLARE_VST_DEPRECATED (setRealtimeQualities) (VstInt32 qualities);

-	virtual void DECLARE_VST_DEPRECATED (setOfflineQualities) (VstInt32 qualities);

-	virtual bool DECLARE_VST_DEPRECATED (isInputConnected) (VstInt32 input);

-	virtual bool DECLARE_VST_DEPRECATED (isOutputConnected) (VstInt32 output);

-/// @endcond

-

-//-------------------------------------------------------------------------------------------------------

-protected:	

-	audioMasterCallback audioMaster;	///< Host callback

-	AEffEditor* editor;					///< Pointer to the plug-in's editor

-	float sampleRate;					///< Current sample rate

-	VstInt32 blockSize;					///< Maximum block size

-	VstInt32 numPrograms;				///< Number of programs

-	VstInt32 numParams;					///< Number of parameters

-	VstInt32 curProgram;				///< Current program

-	AEffect  cEffect;					///< #AEffect object

-

-/// @cond ignore

-	static VstIntPtr dispatchEffectClass (AEffect* e, VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt);

-	static float getParameterClass (AEffect* e, VstInt32 index);

-	static void setParameterClass (AEffect* e, VstInt32 index, float value);

-	static void DECLARE_VST_DEPRECATED (processClass) (AEffect* e, float** inputs, float** outputs, VstInt32 sampleFrames);

-	static void processClassReplacing (AEffect* e, float** inputs, float** outputs, VstInt32 sampleFrames);

-

-#if VST_2_4_EXTENSIONS

-	static void processClassDoubleReplacing (AEffect* e, double** inputs, double** outputs, VstInt32 sampleFrames);

-#endif // VST_2_4_EXTENSIONS

-/// @endcond

-};

-

-#endif // __audioeffect__

diff --git a/plugins/WinVST/Spiral2/vst2.x/audioeffectx.cpp b/plugins/WinVST/Spiral2/vst2.x/audioeffectx.cpp
deleted file mode 100755
index 5f07f7c..0000000
--- a/plugins/WinVST/Spiral2/vst2.x/audioeffectx.cpp
+++ /dev/null
@@ -1,1546 +0,0 @@
-//-------------------------------------------------------------------------------------------------------

-// 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<float> (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<VstSpeakerArrangement> (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<void> (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<VstSpeakerArrangement*> (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<VstTimeInfo> (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 

-			<b>once</b> 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

-	<pre>

-	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;

-	}

-	</pre>

-*/

-

-//-----------------------------------------------------------------------------------------------------------------

-/*!

-	\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

-	<pre>

-	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);

-	}

-	</pre>

-

-	\note Example 2 : plug-in with 1 mono, 1 stereo and one 5.1 outputs (kNumOutputs = 9):

-	<pre>

-	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;

-	}

-	</pre>

-*/

-

-//-----------------------------------------------------------------------------------------------------------------

-AEffect* AudioEffectX::DECLARE_VST_DEPRECATED (getPreviousPlug) (VstInt32 input)

-{

-	if (audioMaster)

-	{

-		VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetPreviousPlug), 0, 0, 0, 0);

-		return FromVstPtr<AEffect> (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<AEffect> (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<VstSpeakerArrangement> (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<VstSpeakerArrangement> (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<void> (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<void> (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

-	<pre>Here an example code to show how the host uses getSpeakerArrangement()

-	VstSpeakerArrangement *plugInputVstArr = 0;

-	VstSpeakerArrangement *plugOutputVstArr = 0;

-	if (getFormatVersion () >= 2300 && #getSpeakerArrangement (&plugInputVstArr, &plugOutputVstArr))

-		....

-	</pre>	

-

-	\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.

-	<pre>

-	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.

-	</pre>

-*/

-

-//-----------------------------------------------------------------------------------------------------------------

-/*!

-	\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 

-<pre>

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

-	{}

-</pre>

-*/

-

-//-----------------------------------------------------------------------------------------------------------------

-/*!

-	\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

-*/

diff --git a/plugins/WinVST/Spiral2/vst2.x/audioeffectx.h b/plugins/WinVST/Spiral2/vst2.x/audioeffectx.h
deleted file mode 100755
index c04a6a0..0000000
--- a/plugins/WinVST/Spiral2/vst2.x/audioeffectx.h
+++ /dev/null
@@ -1,252 +0,0 @@
-//-------------------------------------------------------------------------------------------------------

-// VST Plug-Ins SDK

-// Version 2.4       $Date: 2006/06/20 12:42:46 $

-//

-// Category     : VST 2.x Classes

-// Filename     : audioeffectx.h

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

-//-------------------------------------------------------------------------------------------------------

-

-#ifndef __audioeffectx__

-#define __audioeffectx__

-

-#include "audioeffect.h"	// Version 1.0 base class AudioEffect

-

-#include "pluginterfaces/vst2.x/aeffectx.h"	// Version 2.x 'C' Extensions and Structures

-

-//-------------------------------------------------------------------------------------------------------

-/** Extended VST Effect Class (VST 2.x). */

-//-------------------------------------------------------------------------------------------------------

-class AudioEffectX : public AudioEffect

-{

-public:

-	AudioEffectX (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams); ///< Create an \e AudioEffectX object

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Parameters

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual bool canParameterBeAutomated (VstInt32 index) { return true; }			///< Indicates if a parameter can be automated

-	virtual bool string2parameter (VstInt32 index, char* text) { return false; }	///< Convert a string representation to a parameter value

-	virtual bool getParameterProperties (VstInt32 index, VstParameterProperties* p) { return false; } ///< Return parameter properties

-

-#if VST_2_1_EXTENSIONS

-	virtual bool beginEdit (VstInt32 index);  ///< To be called before #setParameterAutomated (on Mouse Down). This will be used by the Host for specific Automation Recording.

-	virtual bool endEdit (VstInt32 index);    ///< To be called after #setParameterAutomated (on Mouse Up)

-#endif // VST_2_1_EXTENSIONS

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Programs and Persistence

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual bool getProgramNameIndexed (VstInt32 category, VstInt32 index, char* text) { return false; } ///< Fill \e text with name of program \e index (\e category deprecated in VST 2.4)

-

-#if VST_2_1_EXTENSIONS

-	virtual bool beginSetProgram () { return false; }	///< Called before a program is loaded

-	virtual bool endSetProgram () { return false; }		///< Called after a program was loaded

-#endif // VST_2_1_EXTENSIONS

-

-#if VST_2_3_EXTENSIONS

-	virtual VstInt32 beginLoadBank (VstPatchChunkInfo* ptr) { return 0; }		///< Called before a Bank is loaded.

-	virtual VstInt32 beginLoadProgram (VstPatchChunkInfo* ptr) { return 0; }	///< Called before a Program is loaded. (called before #beginSetProgram).

-#endif // VST_2_3_EXTENSIONS

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Connections and Configuration

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual bool ioChanged ();				///< Tell Host numInputs and/or numOutputs and/or initialDelay (and/or numParameters: to be avoid) have changed

-

-	virtual double updateSampleRate ();		///< Returns sample rate from Host (may issue setSampleRate())

-	virtual VstInt32 updateBlockSize ();	///< Returns block size from Host (may issue getBlockSize())

-	virtual VstInt32 getInputLatency ();	///< Returns the Audio (maybe ASIO) input latency values

-	virtual VstInt32 getOutputLatency ();	///< Returns the Audio (maybe ASIO) output latency values

-

-	virtual bool getInputProperties (VstInt32 index, VstPinProperties* properties) { return false; } ///< Return the \e properties of output \e index

-	virtual bool getOutputProperties (VstInt32 index, VstPinProperties* properties) { return false; }///< Return the \e properties of input \e index

-

-	virtual bool setSpeakerArrangement (VstSpeakerArrangement* pluginInput, VstSpeakerArrangement* pluginOutput) { return false; } ///< Set the plug-in's speaker arrangements

-	virtual bool getSpeakerArrangement (VstSpeakerArrangement** pluginInput, VstSpeakerArrangement** pluginOutput) { *pluginInput = 0; *pluginOutput = 0; return false; } ///< Return the plug-in's speaker arrangements

-	virtual bool setBypass (bool onOff) { return false; }				///< For 'soft-bypass' (this could be automated (in Audio Thread) that why you could NOT call iochanged (if needed) in this function, do it in fxidle).

-

-#if VST_2_3_EXTENSIONS

-	virtual bool setPanLaw (VstInt32 type, float val) { return false; }	///< Set the Panning Law used by the Host @see VstPanLawType.

-#endif // VST_2_3_EXTENSIONS

-

-#if VST_2_4_EXTENSIONS

-	virtual bool setProcessPrecision (VstInt32 precision) { return false; }	///< Set floating-point precision used for processing (32 or 64 bit)

-

-	virtual VstInt32 getNumMidiInputChannels ()  { return 0; }				///< Returns number of MIDI input channels used [0, 16]

-	virtual VstInt32 getNumMidiOutputChannels () { return 0; }				///< Returns number of MIDI output channels used [0, 16]

-#endif // VST_2_4_EXTENSIONS

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Realtime

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual VstTimeInfo* getTimeInfo (VstInt32 filter);	///< Get time information from Host

-	virtual VstInt32 getCurrentProcessLevel ();			///< Returns the Host's process level

-	virtual VstInt32 getAutomationState ();				///< Returns the Host's automation state

-

-	virtual VstInt32 processEvents (VstEvents* events) { return 0; }	///< Called when new MIDI events come in

-	bool sendVstEventsToHost (VstEvents* events);						///< Send MIDI events back to Host application

-

-#if VST_2_3_EXTENSIONS

-	virtual VstInt32 startProcess () { return 0; }		///< Called one time before the start of process call. This indicates that the process call will be interrupted (due to Host reconfiguration or bypass state when the plug-in doesn't support softBypass)

-	virtual VstInt32 stopProcess () { return 0;}		///< Called after the stop of process call

-#endif // VST_2_3_EXTENSIONS

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Variable I/O (Offline)

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual bool processVariableIo (VstVariableIo* varIo) { return false; }		///< Used for variable I/O processing (offline processing like timestreching)

-

-#if VST_2_3_EXTENSIONS

-	virtual VstInt32 setTotalSampleToProcess (VstInt32 value) {	return value; }	///< Called in offline mode before process() or processVariableIo ()

-#endif // VST_2_3_EXTENSIONS

-	//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Host Properties

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual bool getHostVendorString (char* text);	///< Fills \e text with a string identifying the vendor

-	virtual bool getHostProductString (char* text);	///< Fills \e text with a string with product name

-	virtual VstInt32 getHostVendorVersion ();		///< Returns vendor-specific version (for example 3200 for Nuendo 3.2)

-	virtual VstIntPtr hostVendorSpecific (VstInt32 lArg1, VstIntPtr lArg2, void* ptrArg, float floatArg);	///< No specific definition

-	virtual VstInt32 canHostDo (char* text);		///< Reports what the Host is able to do (#hostCanDos in audioeffectx.cpp)

-	virtual VstInt32 getHostLanguage ();			///< Returns the Host's language (#VstHostLanguage)

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Plug-in Properties

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual void isSynth (bool state = true);		///< Set if plug-in is a synth

-	virtual void noTail (bool state = true);		///< Plug-in won't produce output signals while there is no input

-	virtual VstInt32 getGetTailSize () { return 0; }///< Returns tail size; 0 is default (return 1 for 'no tail'), used in offline processing too

-	virtual void* getDirectory ();					///< Returns the plug-in's directory

-	virtual bool getEffectName (char* name) { return false; }	///< Fill \e text with a string identifying the effect

-	virtual bool getVendorString (char* text) { return false; }	///< Fill \e text with a string identifying the vendor

-	virtual bool getProductString (char* text) { return false; }///< Fill \e text with a string identifying the product name

-	virtual VstInt32 getVendorVersion () { return 0; }			///< Return vendor-specific version

-	virtual VstIntPtr vendorSpecific (VstInt32 lArg, VstIntPtr lArg2, void* ptrArg, float floatArg) { return 0; } ///< No definition, vendor specific handling

-	virtual VstInt32 canDo (char* text) { return 0; }			///< Reports what the plug-in is able to do (#plugCanDos in audioeffectx.cpp)

-	virtual VstInt32 getVstVersion () { return kVstVersion; }	///< Returns the current VST Version (#kVstVersion)

-	virtual VstPlugCategory getPlugCategory ();		///< Specify a category that fits the plug (#VstPlugCategory)

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name MIDI Channel Programs

-//-------------------------------------------------------------------------------------------------------

-//@{

-#if VST_2_1_EXTENSIONS

-	virtual VstInt32 getMidiProgramName (VstInt32 channel, MidiProgramName* midiProgramName) { return 0; }		///< Fill \e midiProgramName with information for 'thisProgramIndex'.

-	virtual VstInt32 getCurrentMidiProgram (VstInt32 channel, MidiProgramName* currentProgram) { return -1; }	///< Fill \e currentProgram with information for the current MIDI program.

-	virtual VstInt32 getMidiProgramCategory (VstInt32 channel, MidiProgramCategory* category) { return 0; }		///< Fill \e category with information for 'thisCategoryIndex'.

-	virtual bool hasMidiProgramsChanged (VstInt32 channel) { return false; } ///< Return true if the #MidiProgramNames, #MidiKeyNames or #MidiControllerNames had changed on this MIDI channel.

-	virtual bool getMidiKeyName (VstInt32 channel, MidiKeyName* keyName) { return false; } ///< Fill \e keyName with information for 'thisProgramIndex' and 'thisKeyNumber'

-#endif // VST_2_1_EXTENSIONS

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Others

-//-------------------------------------------------------------------------------------------------------

-//@{

-	virtual bool updateDisplay (); ///< Something has changed in plug-in, request an update display like program (MIDI too) and parameters list in Host

-	virtual bool sizeWindow (VstInt32 width, VstInt32 height);	///< Requests to resize the editor window

-

-#if VST_2_1_EXTENSIONS

-	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

-	virtual bool closeFileSelector (VstFileSelect* ptr);		///< Close the Host File selector which was opened by #openFileSelector

-#endif // VST_2_2_EXTENSIONS

-

-#if VST_2_3_EXTENSIONS

-	virtual VstInt32 getNextShellPlugin (char* name) { return 0; }	 ///< This opcode is only called, if the plug-in is of type #kPlugCategShell, in order to extract all included sub-plugin´s names.

-#endif // VST_2_3_EXTENSIONS

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-/// \name Tools

-//-------------------------------------------------------------------------------------------------------

-//@{

-#if VST_2_3_EXTENSIONS

-	virtual bool allocateArrangement (VstSpeakerArrangement** arrangement, VstInt32 nbChannels);///< Allocate memory for a #VstSpeakerArrangement

-	virtual bool deallocateArrangement (VstSpeakerArrangement** arrangement);			///< Delete/free memory for an allocated speaker arrangement

-	virtual bool copySpeaker (VstSpeakerProperties* to, VstSpeakerProperties* from);	///< Copy properties \e from to \e to

-	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

-//@}

-

-//-------------------------------------------------------------------------------------------------------

-// Offline

-//-------------------------------------------------------------------------------------------------------

-/// @cond ignore

-	virtual bool offlineRead (VstOfflineTask* offline, VstOfflineOption option, bool readSource = true);

-	virtual bool offlineWrite (VstOfflineTask* offline, VstOfflineOption option);

-	virtual bool offlineStart (VstAudioFile* ptr, VstInt32 numAudioFiles, VstInt32 numNewAudioFiles);

-	virtual VstInt32 offlineGetCurrentPass ();

-	virtual VstInt32 offlineGetCurrentMetaPass ();

-	virtual bool offlineNotify (VstAudioFile* ptr, VstInt32 numAudioFiles, bool start) { return false; }

-	virtual bool offlinePrepare (VstOfflineTask* offline, VstInt32 count) { return false; }

-	virtual bool offlineRun (VstOfflineTask* offline, VstInt32 count) { return false; }

-	virtual VstInt32 offlineGetNumPasses () { return 0; }

-	virtual VstInt32 offlineGetNumMetaPasses () { return 0; }

-

-//-------------------------------------------------------------------------------------------------------

-// AudioEffect overrides

-//-------------------------------------------------------------------------------------------------------

-	virtual VstIntPtr dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt);

-	virtual void resume ();

-

-//-------------------------------------------------------------------------------------------------------

-// Deprecated methods

-//-------------------------------------------------------------------------------------------------------

-	virtual void DECLARE_VST_DEPRECATED (wantEvents) (VstInt32 filter = 1);

-	virtual VstInt32 DECLARE_VST_DEPRECATED (tempoAt) (VstInt32 pos);

-	virtual VstInt32 DECLARE_VST_DEPRECATED (getNumAutomatableParameters) ();

-	virtual VstInt32 DECLARE_VST_DEPRECATED (getParameterQuantization) ();

-	virtual VstInt32 DECLARE_VST_DEPRECATED (getNumCategories) () { return 1L; }

-	virtual bool DECLARE_VST_DEPRECATED (copyProgram) (VstInt32 destination) { return false; }

-	virtual bool DECLARE_VST_DEPRECATED (needIdle) ();

-	virtual AEffect* DECLARE_VST_DEPRECATED (getPreviousPlug) (VstInt32 input);

-	virtual AEffect* DECLARE_VST_DEPRECATED (getNextPlug) (VstInt32 output);

-	virtual void DECLARE_VST_DEPRECATED (inputConnected) (VstInt32 index, bool state) {}

-	virtual void DECLARE_VST_DEPRECATED (outputConnected) (VstInt32 index, bool state) {}

-	virtual VstInt32 DECLARE_VST_DEPRECATED (willProcessReplacing) ();

-	virtual void DECLARE_VST_DEPRECATED (wantAsyncOperation) (bool state = true);

-	virtual void DECLARE_VST_DEPRECATED (hasExternalBuffer) (bool state = true);

-	virtual VstInt32 DECLARE_VST_DEPRECATED (reportCurrentPosition) () { return 0; }

-	virtual float* DECLARE_VST_DEPRECATED (reportDestinationBuffer) () { return 0; }

-	virtual void DECLARE_VST_DEPRECATED (setOutputSamplerate) (float samplerate);

-	virtual VstSpeakerArrangement* DECLARE_VST_DEPRECATED (getInputSpeakerArrangement) ();

-	virtual VstSpeakerArrangement* DECLARE_VST_DEPRECATED (getOutputSpeakerArrangement) ();

-	virtual void* DECLARE_VST_DEPRECATED (openWindow) (DECLARE_VST_DEPRECATED (VstWindow)*);

-	virtual bool DECLARE_VST_DEPRECATED (closeWindow) (DECLARE_VST_DEPRECATED (VstWindow)*);

-	virtual void DECLARE_VST_DEPRECATED (setBlockSizeAndSampleRate) (VstInt32 _blockSize, float _sampleRate) { blockSize = _blockSize; sampleRate = _sampleRate; }

-	virtual bool DECLARE_VST_DEPRECATED (getErrorText) (char* text) { return false; }

-	virtual void* DECLARE_VST_DEPRECATED (getIcon) () { return 0; }

-	virtual bool DECLARE_VST_DEPRECATED (setViewPosition) (VstInt32 x, VstInt32 y) { return false; }

-	virtual VstInt32 DECLARE_VST_DEPRECATED (fxIdle) () { return 0; }

-	virtual bool DECLARE_VST_DEPRECATED (keysRequired) () { return false; }

-

-#if VST_2_2_EXTENSIONS

-	virtual bool DECLARE_VST_DEPRECATED (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

-/// @endcond

-//-------------------------------------------------------------------------------------------------------

-};

-

-#endif //__audioeffectx__

diff --git a/plugins/WinVST/Spiral2/vst2.x/vstplugmain.cpp b/plugins/WinVST/Spiral2/vst2.x/vstplugmain.cpp
deleted file mode 100755
index 7e1ae71..0000000
--- a/plugins/WinVST/Spiral2/vst2.x/vstplugmain.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//-------------------------------------------------------------------------------------------------------

-// VST Plug-Ins SDK

-// Version 2.4       $Date: 2006/08/29 12:08:50 $

-//

-// Category     : VST 2.x Classes

-// Filename     : vstplugmain.cpp

-// Created by   : Steinberg Media Technologies

-// Description  : VST Plug-In Main Entry

-//

-// © 2006, Steinberg Media Technologies, All Rights Reserved

-//-------------------------------------------------------------------------------------------------------

-

-#include "audioeffect.h"

-

-//------------------------------------------------------------------------

-/** Must be implemented externally. */

-extern AudioEffect* createEffectInstance (audioMasterCallback audioMaster);

-

-extern "C" {

-

-#if defined (__GNUC__) && ((__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)))

-	#define VST_EXPORT	__attribute__ ((visibility ("default")))

-#else

-	#define VST_EXPORT

-#endif

-

-//------------------------------------------------------------------------

-/** Prototype of the export function main */

-//------------------------------------------------------------------------

-VST_EXPORT AEffect* VSTPluginMain (audioMasterCallback audioMaster)

-{

-	// Get VST Version of the Host

-	if (!audioMaster (0, audioMasterVersion, 0, 0, 0, 0))

-		return 0;  // old version

-

-	// Create the AudioEffect

-	AudioEffect* effect = createEffectInstance (audioMaster);

-	if (!effect)

-		return 0;

-

-	// Return the VST AEffect structur

-	return effect->getAeffect ();

-}

-

-// support for old hosts not looking for VSTPluginMain

-#if (TARGET_API_MAC_CARBON && __ppc__)

-VST_EXPORT AEffect* main_macho (audioMasterCallback audioMaster) { return VSTPluginMain (audioMaster); }

-#elif WIN32

-VST_EXPORT AEffect* MAIN (audioMasterCallback audioMaster) { return VSTPluginMain (audioMaster); }

-#elif BEOS

-VST_EXPORT AEffect* main_plugin (audioMasterCallback audioMaster) { return VSTPluginMain (audioMaster); }

-#endif

-

-} // extern "C"

-

-//------------------------------------------------------------------------

-#if WIN32

-#include <windows.h>

-void* hInstance;

-

-extern "C" {

-BOOL WINAPI DllMain (HINSTANCE hInst, DWORD dwReason, LPVOID lpvReserved)

-{

-	hInstance = hInst;

-	return 1;

-}

-} // extern "C"

-#endif