From 9ecd9a8c01bea3c02f6e94cf67dd7c4ad12d1e34 Mon Sep 17 00:00:00 2001
From: Chris Johnson <jinx6568@sover.net>
Date: Sun, 9 Sep 2018 22:59:35 -0400
Subject: 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.
---
 plugins/WinVST/Wider/vst2.x/aeffeditor.h     |   61 -
 plugins/WinVST/Wider/vst2.x/audioeffect.cpp  |  703 ------------
 plugins/WinVST/Wider/vst2.x/audioeffect.h    |  177 ---
 plugins/WinVST/Wider/vst2.x/audioeffectx.cpp | 1546 --------------------------
 plugins/WinVST/Wider/vst2.x/audioeffectx.h   |  252 -----
 plugins/WinVST/Wider/vst2.x/vstplugmain.cpp  |   68 --
 6 files changed, 2807 deletions(-)
 delete mode 100755 plugins/WinVST/Wider/vst2.x/aeffeditor.h
 delete mode 100755 plugins/WinVST/Wider/vst2.x/audioeffect.cpp
 delete mode 100755 plugins/WinVST/Wider/vst2.x/audioeffect.h
 delete mode 100755 plugins/WinVST/Wider/vst2.x/audioeffectx.cpp
 delete mode 100755 plugins/WinVST/Wider/vst2.x/audioeffectx.h
 delete mode 100755 plugins/WinVST/Wider/vst2.x/vstplugmain.cpp

(limited to 'plugins/WinVST/Wider')

diff --git a/plugins/WinVST/Wider/vst2.x/aeffeditor.h b/plugins/WinVST/Wider/vst2.x/aeffeditor.h
deleted file mode 100755
index 04f7339..0000000
--- a/plugins/WinVST/Wider/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/Wider/vst2.x/audioeffect.cpp b/plugins/WinVST/Wider/vst2.x/audioeffect.cpp
deleted file mode 100755
index e7440d2..0000000
--- a/plugins/WinVST/Wider/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/Wider/vst2.x/audioeffect.h b/plugins/WinVST/Wider/vst2.x/audioeffect.h
deleted file mode 100755
index a506bde..0000000
--- a/plugins/WinVST/Wider/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/Wider/vst2.x/audioeffectx.cpp b/plugins/WinVST/Wider/vst2.x/audioeffectx.cpp
deleted file mode 100755
index 5f07f7c..0000000
--- a/plugins/WinVST/Wider/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/Wider/vst2.x/audioeffectx.h b/plugins/WinVST/Wider/vst2.x/audioeffectx.h
deleted file mode 100755
index c04a6a0..0000000
--- a/plugins/WinVST/Wider/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/Wider/vst2.x/vstplugmain.cpp b/plugins/WinVST/Wider/vst2.x/vstplugmain.cpp
deleted file mode 100755
index 7e1ae71..0000000
--- a/plugins/WinVST/Wider/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
-- 
cgit v1.2.3