Initial upload of plugins

17 files changed, 3448 insertions, 0 deletions

diff --git a/plugins/WinVST/PurestConsoleChannel/.DS_Store b/plugins/WinVST/PurestConsoleChannel/.DS_Store
new file mode 100644
index 0000000..5008ddf
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/.DS_Store
diff --git a/plugins/WinVST/PurestConsoleChannel/.vs/Console4Channel64/v14/.suo b/plugins/WinVST/PurestConsoleChannel/.vs/Console4Channel64/v14/.suo
new file mode 100644
index 0000000..777b846
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/.vs/Console4Channel64/v14/.suo
diff --git a/plugins/WinVST/PurestConsoleChannel/.vs/VSTProject/v14/.suo b/plugins/WinVST/PurestConsoleChannel/.vs/VSTProject/v14/.suo
new file mode 100644
index 0000000..506b762
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/.vs/VSTProject/v14/.suo
diff --git a/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannel.cpp b/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannel.cpp
new file mode 100644
index 0000000..b9f3e04
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannel.cpp
@@ -0,0 +1,107 @@
+/* ========================================
+ *  PurestConsoleChannel - PurestConsoleChannel.h
+ *  Copyright (c) 2016 airwindows, All rights reserved
+ * ======================================== */
+
+#ifndef __PurestConsoleChannel_H
+#include "PurestConsoleChannel.h"
+#endif
+
+AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new PurestConsoleChannel(audioMaster);}
+
+PurestConsoleChannel::PurestConsoleChannel(audioMasterCallback audioMaster) :
+    AudioEffectX(audioMaster, kNumPrograms, kNumParameters)
+{
+	fpNShapeLA = 0.0;
+	fpNShapeLB = 0.0;
+	fpNShapeRA = 0.0;
+	fpNShapeRB = 0.0;
+	fpFlip = true;
+	//this is reset: values being initialized only once. Startup values, whatever they are.
+	
+    _canDo.insert("plugAsChannelInsert"); // plug-in can be used as a channel insert effect.
+    _canDo.insert("plugAsSend"); // plug-in can be used as a send effect.
+    _canDo.insert("x2in2out"); 
+    setNumInputs(kNumInputs);
+    setNumOutputs(kNumOutputs);
+    setUniqueID(kUniqueId);
+    canProcessReplacing();     // supports output replacing
+    canDoubleReplacing();      // supports double precision processing
+	programsAreChunks(true);
+    vst_strncpy (_programName, "Default", kVstMaxProgNameLen); // default program name
+}
+
+PurestConsoleChannel::~PurestConsoleChannel() {}
+VstInt32 PurestConsoleChannel::getVendorVersion () {return 1000;}
+void PurestConsoleChannel::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);}
+void PurestConsoleChannel::getProgramName(char *name) {vst_strncpy (name, _programName, kVstMaxProgNameLen);}
+//airwindows likes to ignore this stuff. Make your own programs, and make a different plugin rather than
+//trying to do versioning and preventing people from using older versions. Maybe they like the old one!
+
+VstInt32 PurestConsoleChannel::getChunk (void** data, bool isPreset)
+{
+	float *chunkData = (float *)calloc(kNumParameters, sizeof(float));
+	/* Note: The way this is set up, it will break if you manage to save settings on an Intel
+	 machine and load them on a PPC Mac. However, it's fine if you stick to the machine you 
+	 started with. */
+	
+	*data = chunkData;
+	return kNumParameters * sizeof(float);
+}
+
+VstInt32 PurestConsoleChannel::setChunk (void* data, VstInt32 byteSize, bool isPreset)
+{	
+	float *chunkData = (float *)data;
+	/* We're ignoring byteSize as we found it to be a filthy liar */
+	
+	/* calculate any other fields you need here - you could copy in 
+	 code from setParameter() here. */
+	return 0;
+}
+
+void PurestConsoleChannel::setParameter(VstInt32 index, float value) {
+    switch (index) {
+       default: throw; // unknown parameter, shouldn't happen!
+    }
+}
+
+float PurestConsoleChannel::getParameter(VstInt32 index) {
+    switch (index) {
+        default: break; // unknown parameter, shouldn't happen!
+    } return 0.0; //we only need to update the relevant name, this is simple to manage
+}
+
+void PurestConsoleChannel::getParameterName(VstInt32 index, char *text) {
+    switch (index) {
+        default: break; // unknown parameter, shouldn't happen!
+    } //this is our labels for displaying in the VST host
+}
+
+void PurestConsoleChannel::getParameterDisplay(VstInt32 index, char *text) {
+    switch (index) {
+        default: break; // unknown parameter, shouldn't happen!
+	} //this displays the values and handles 'popups' where it's discrete choices
+}
+
+void PurestConsoleChannel::getParameterLabel(VstInt32 index, char *text) {
+    switch (index) {
+		default: break; // unknown parameter, shouldn't happen!
+    }
+}
+
+VstInt32 PurestConsoleChannel::canDo(char *text) 
+{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know
+
+bool PurestConsoleChannel::getEffectName(char* name) {
+    vst_strncpy(name, "PurestConsoleChannel", kVstMaxProductStrLen); return true;
+}
+
+VstPlugCategory PurestConsoleChannel::getPlugCategory() {return kPlugCategEffect;}
+
+bool PurestConsoleChannel::getProductString(char* text) {
+  	vst_strncpy (text, "airwindows PurestConsoleChannel", kVstMaxProductStrLen); return true;
+}
+
+bool PurestConsoleChannel::getVendorString(char* text) {
+  	vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true;
+}
diff --git a/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannel.h b/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannel.h
new file mode 100644
index 0000000..c0a1648
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannel.h
@@ -0,0 +1,63 @@
+/* ========================================
+ *  PurestConsoleChannel - PurestConsoleChannel.h
+ *  Created 8/12/11 by SPIAdmin 
+ *  Copyright (c) 2011 __MyCompanyName__, All rights reserved
+ * ======================================== */
+
+#ifndef __PurestConsoleChannel_H
+#define __PurestConsoleChannel_H
+
+#ifndef __audioeffect__
+#include "audioeffectx.h"
+#endif
+
+#include <set>
+#include <string>
+#include <math.h>
+
+enum {
+  kNumParameters = 0
+}; //
+
+const int kNumPrograms = 0;
+const int kNumInputs = 2;
+const int kNumOutputs = 2;
+const unsigned long kUniqueId = 'pcoc';    //Change this to what the AU identity is!
+
+class PurestConsoleChannel : 
+    public AudioEffectX 
+{
+public:
+    PurestConsoleChannel(audioMasterCallback audioMaster);
+    ~PurestConsoleChannel();
+    virtual bool getEffectName(char* name);                       // The plug-in name
+    virtual VstPlugCategory getPlugCategory();                    // The general category for the plug-in
+    virtual bool getProductString(char* text);                    // This is a unique plug-in string provided by Steinberg
+    virtual bool getVendorString(char* text);                     // Vendor info
+    virtual VstInt32 getVendorVersion();                          // Version number
+    virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames);
+    virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames);
+    virtual void getProgramName(char *name);                      // read the name from the host
+    virtual void setProgramName(char *name);                      // changes the name of the preset displayed in the host
+	virtual VstInt32 getChunk (void** data, bool isPreset);
+	virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset);
+    virtual float getParameter(VstInt32 index);                   // get the parameter value at the specified index
+    virtual void setParameter(VstInt32 index, float value);       // set the parameter at index to value
+    virtual void getParameterLabel(VstInt32 index, char *text);  // label for the parameter (eg dB)
+    virtual void getParameterName(VstInt32 index, char *text);    // name of the parameter
+    virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value    
+    virtual VstInt32 canDo(char *text);
+private:
+    char _programName[kVstMaxProgNameLen + 1];
+    std::set< std::string > _canDo;
+    
+	long double fpNShapeLA;
+	long double fpNShapeLB;
+	long double fpNShapeRA;
+	long double fpNShapeRB;
+	bool fpFlip;
+	//default stuff
+
+};
+
+#endif
diff --git a/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannelProc.cpp b/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannelProc.cpp
new file mode 100644
index 0000000..630cba7
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/PurestConsoleChannelProc.cpp
@@ -0,0 +1,190 @@
+/* ========================================
+ *  PurestConsoleChannel - PurestConsoleChannel.h
+ *  Copyright (c) 2016 airwindows, All rights reserved
+ * ======================================== */
+
+#ifndef __PurestConsoleChannel_H
+#include "PurestConsoleChannel.h"
+#endif
+
+void PurestConsoleChannel::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) 
+{
+    float* in1  =  inputs[0];
+    float* in2  =  inputs[1];
+    float* out1 = outputs[0];
+    float* out2 = outputs[1];
+
+	float fpTemp;
+	long double fpOld = 0.618033988749894848204586; //golden ratio!
+	long double fpNew = 1.0 - fpOld;	
+
+	long double inputSampleL;
+	long double inputSampleR;
+
+    while (--sampleFrames >= 0)
+    {
+		inputSampleL = *in1;
+		inputSampleR = *in2;
+		if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
+			static int noisesource = 0;
+			//this declares a variable before anything else is compiled. It won't keep assigning
+			//it to 0 for every sample, it's as if the declaration doesn't exist in this context,
+			//but it lets me add this denormalization fix in a single place rather than updating
+			//it in three different locations. The variable isn't thread-safe but this is only
+			//a random seed and we can share it with whatever.
+			noisesource = noisesource % 1700021; noisesource++;
+			int residue = noisesource * noisesource;
+			residue = residue % 170003; residue *= residue;
+			residue = residue % 17011; residue *= residue;
+			residue = residue % 1709; residue *= residue;
+			residue = residue % 173; residue *= residue;
+			residue = residue % 17;
+			double applyresidue = residue;
+			applyresidue *= 0.00000001;
+			applyresidue *= 0.00000001;
+			inputSampleL = applyresidue;
+		}
+		if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
+			static int noisesource = 0;
+			noisesource = noisesource % 1700021; noisesource++;
+			int residue = noisesource * noisesource;
+			residue = residue % 170003; residue *= residue;
+			residue = residue % 17011; residue *= residue;
+			residue = residue % 1709; residue *= residue;
+			residue = residue % 173; residue *= residue;
+			residue = residue % 17;
+			double applyresidue = residue;
+			applyresidue *= 0.00000001;
+			applyresidue *= 0.00000001;
+			inputSampleR = applyresidue;
+			//this denormalization routine produces a white noise at -300 dB which the noise
+			//shaping will interact with to produce a bipolar output, but the noise is actually
+			//all positive. That should stop any variables from going denormal, and the routine
+			//only kicks in if digital black is input. As a final touch, if you save to 24-bit
+			//the silence will return to being digital black again.
+		}
+		
+		inputSampleL = sin(inputSampleL);
+		inputSampleR = sin(inputSampleR);
+		//amplitude aspect
+
+		//noise shaping to 32-bit floating point
+		if (fpFlip) {
+			fpTemp = inputSampleL;
+			fpNShapeLA = (fpNShapeLA*fpOld)+((inputSampleL-fpTemp)*fpNew);
+			inputSampleL += fpNShapeLA;
+			fpTemp = inputSampleR;
+			fpNShapeRA = (fpNShapeRA*fpOld)+((inputSampleR-fpTemp)*fpNew);
+			inputSampleR += fpNShapeRA;
+		}
+		else {
+			fpTemp = inputSampleL;
+			fpNShapeLB = (fpNShapeLB*fpOld)+((inputSampleL-fpTemp)*fpNew);
+			inputSampleL += fpNShapeLB;
+			fpTemp = inputSampleR;
+			fpNShapeRB = (fpNShapeRB*fpOld)+((inputSampleR-fpTemp)*fpNew);
+			inputSampleR += fpNShapeRB;
+		}
+		fpFlip = !fpFlip;
+		//end noise shaping on 32 bit output
+
+		*out1 = inputSampleL;
+		*out2 = inputSampleR;
+
+		*in1++;
+		*in2++;
+		*out1++;
+		*out2++;
+    }
+}
+
+void PurestConsoleChannel::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) 
+{
+    double* in1  =  inputs[0];
+    double* in2  =  inputs[1];
+    double* out1 = outputs[0];
+    double* out2 = outputs[1];
+
+	double fpTemp;
+	long double fpOld = 0.618033988749894848204586; //golden ratio!
+	long double fpNew = 1.0 - fpOld;	
+	
+	long double inputSampleL;
+	long double inputSampleR;
+
+    while (--sampleFrames >= 0)
+    {
+		inputSampleL = *in1;
+		inputSampleR = *in2;
+		if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
+			static int noisesource = 0;
+			//this declares a variable before anything else is compiled. It won't keep assigning
+			//it to 0 for every sample, it's as if the declaration doesn't exist in this context,
+			//but it lets me add this denormalization fix in a single place rather than updating
+			//it in three different locations. The variable isn't thread-safe but this is only
+			//a random seed and we can share it with whatever.
+			noisesource = noisesource % 1700021; noisesource++;
+			int residue = noisesource * noisesource;
+			residue = residue % 170003; residue *= residue;
+			residue = residue % 17011; residue *= residue;
+			residue = residue % 1709; residue *= residue;
+			residue = residue % 173; residue *= residue;
+			residue = residue % 17;
+			double applyresidue = residue;
+			applyresidue *= 0.00000001;
+			applyresidue *= 0.00000001;
+			inputSampleL = applyresidue;
+		}
+		if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
+			static int noisesource = 0;
+			noisesource = noisesource % 1700021; noisesource++;
+			int residue = noisesource * noisesource;
+			residue = residue % 170003; residue *= residue;
+			residue = residue % 17011; residue *= residue;
+			residue = residue % 1709; residue *= residue;
+			residue = residue % 173; residue *= residue;
+			residue = residue % 17;
+			double applyresidue = residue;
+			applyresidue *= 0.00000001;
+			applyresidue *= 0.00000001;
+			inputSampleR = applyresidue;
+			//this denormalization routine produces a white noise at -300 dB which the noise
+			//shaping will interact with to produce a bipolar output, but the noise is actually
+			//all positive. That should stop any variables from going denormal, and the routine
+			//only kicks in if digital black is input. As a final touch, if you save to 24-bit
+			//the silence will return to being digital black again.
+		}
+
+		inputSampleL = sin(inputSampleL);
+		inputSampleR = sin(inputSampleR);
+		//amplitude aspect
+		
+		//noise shaping to 64-bit floating point
+		if (fpFlip) {
+			fpTemp = inputSampleL;
+			fpNShapeLA = (fpNShapeLA*fpOld)+((inputSampleL-fpTemp)*fpNew);
+			inputSampleL += fpNShapeLA;
+			fpTemp = inputSampleR;
+			fpNShapeRA = (fpNShapeRA*fpOld)+((inputSampleR-fpTemp)*fpNew);
+			inputSampleR += fpNShapeRA;
+		}
+		else {
+			fpTemp = inputSampleL;
+			fpNShapeLB = (fpNShapeLB*fpOld)+((inputSampleL-fpTemp)*fpNew);
+			inputSampleL += fpNShapeLB;
+			fpTemp = inputSampleR;
+			fpNShapeRB = (fpNShapeRB*fpOld)+((inputSampleR-fpTemp)*fpNew);
+			inputSampleR += fpNShapeRB;
+		}
+		fpFlip = !fpFlip;
+		//end noise shaping on 64 bit output
+		
+		*out1 = inputSampleL;
+		*out2 = inputSampleR;
+
+		*in1++;
+		*in2++;
+		*out1++;
+		*out2++;
+    }
+}
\ No newline at end of file
diff --git a/plugins/WinVST/PurestConsoleChannel/VSTProject.sln b/plugins/WinVST/PurestConsoleChannel/VSTProject.sln
new file mode 100644
index 0000000..694b424
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/VSTProject.sln
@@ -0,0 +1,28 @@
+

+Microsoft Visual Studio Solution File, Format Version 12.00

+# Visual Studio 14

+VisualStudioVersion = 14.0.25420.1

+MinimumVisualStudioVersion = 10.0.40219.1

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VSTProject", "VSTProject.vcxproj", "{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}"

+EndProject

+Global

+	GlobalSection(SolutionConfigurationPlatforms) = preSolution

+		Debug|x64 = Debug|x64

+		Debug|x86 = Debug|x86

+		Release|x64 = Release|x64

+		Release|x86 = Release|x86

+	EndGlobalSection

+	GlobalSection(ProjectConfigurationPlatforms) = postSolution

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x64.ActiveCfg = Debug|x64

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x64.Build.0 = Debug|x64

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x86.ActiveCfg = Debug|Win32

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x86.Build.0 = Debug|Win32

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x64.ActiveCfg = Release|x64

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x64.Build.0 = Release|x64

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x86.ActiveCfg = Release|Win32

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x86.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(SolutionProperties) = preSolution

+		HideSolutionNode = FALSE

+	EndGlobalSection

+EndGlobal

diff --git a/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj b/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj
new file mode 100644
index 0000000..8ed20f5
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj
@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <ItemGroup Label="ProjectConfigurations">

+    <ProjectConfiguration Include="Debug|Win32">

+      <Configuration>Debug</Configuration>

+      <Platform>Win32</Platform>

+    </ProjectConfiguration>

+    <ProjectConfiguration Include="Release|Win32">

+      <Configuration>Release</Configuration>

+      <Platform>Win32</Platform>

+    </ProjectConfiguration>

+    <ProjectConfiguration Include="Debug|x64">

+      <Configuration>Debug</Configuration>

+      <Platform>x64</Platform>

+    </ProjectConfiguration>

+    <ProjectConfiguration Include="Release|x64">

+      <Configuration>Release</Configuration>

+      <Platform>x64</Platform>

+    </ProjectConfiguration>

+  </ItemGroup>

+  <ItemGroup>

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffect.cpp" />

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffectx.cpp" />

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\vstplugmain.cpp" />

+    <ClCompile Include="PurestConsoleChannel.cpp" />

+    <ClCompile Include="PurestConsoleChannelProc.cpp" />

+  </ItemGroup>

+  <ItemGroup>

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\aeffeditor.h" />

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffect.h" />

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffectx.h" />

+    <ClInclude Include="PurestConsoleChannel.h" />

+  </ItemGroup>

+  <PropertyGroup Label="Globals">

+    <ProjectGuid>{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}</ProjectGuid>

+    <RootNamespace>VSTProject</RootNamespace>

+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>

+    <ProjectName>PurestConsoleChannel64</ProjectName>

+  </PropertyGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

+    <ConfigurationType>DynamicLibrary</ConfigurationType>

+    <UseDebugLibraries>true</UseDebugLibraries>

+    <PlatformToolset>v140</PlatformToolset>

+    <CharacterSet>NotSet</CharacterSet>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

+    <ConfigurationType>DynamicLibrary</ConfigurationType>

+    <UseDebugLibraries>false</UseDebugLibraries>

+    <PlatformToolset>v140</PlatformToolset>

+    <WholeProgramOptimization>false</WholeProgramOptimization>

+    <CharacterSet>NotSet</CharacterSet>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

+    <ConfigurationType>DynamicLibrary</ConfigurationType>

+    <UseDebugLibraries>true</UseDebugLibraries>

+    <PlatformToolset>v140</PlatformToolset>

+    <CharacterSet>NotSet</CharacterSet>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

+    <ConfigurationType>DynamicLibrary</ConfigurationType>

+    <UseDebugLibraries>false</UseDebugLibraries>

+    <PlatformToolset>v140</PlatformToolset>

+    <WholeProgramOptimization>false</WholeProgramOptimization>

+    <CharacterSet>NotSet</CharacterSet>

+  </PropertyGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

+  <ImportGroup Label="ExtensionSettings">

+  </ImportGroup>

+  <ImportGroup Label="Shared">

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <PropertyGroup Label="UserMacros" />

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <TargetExt>.dll</TargetExt>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+    <OutDir>$(SolutionDir)$(Configuration)\</OutDir>

+    <IntDir>$(Configuration)\</IntDir>

+    <ExecutablePath>$(VC_ExecutablePath_x64);$(WindowsSDK_ExecutablePath);$(VS_ExecutablePath);$(MSBuild_ExecutablePath);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH)</ExecutablePath>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+    <OutDir>$(SolutionDir)$(Configuration)\</OutDir>

+    <IntDir>$(Configuration)\</IntDir>

+    <ExecutablePath>$(VC_ExecutablePath_x64);$(WindowsSDK_ExecutablePath);$(VS_ExecutablePath);$(MSBuild_ExecutablePath);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH)</ExecutablePath>

+  </PropertyGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>MaxSpeed</Optimization>

+      <SDLCheck>true</SDLCheck>

+      <AdditionalIncludeDirectories>C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <PreprocessorDefinitions>WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

+      <MinimalRebuild>false</MinimalRebuild>

+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>

+      <FunctionLevelLinking>false</FunctionLevelLinking>

+      <DebugInformationFormat>None</DebugInformationFormat>

+    </ClCompile>

+    <Link>

+      <ModuleDefinitionFile>vstplug.def</ModuleDefinitionFile>

+      <IgnoreSpecificDefaultLibraries>libcmt.dll;libcmtd.dll;msvcrt.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>

+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+    </Link>

+  </ItemDefinitionGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>MaxSpeed</Optimization>

+      <SDLCheck>true</SDLCheck>

+      <AdditionalIncludeDirectories>C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

+      <PreprocessorDefinitions>WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <MinimalRebuild>false</MinimalRebuild>

+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>

+      <FunctionLevelLinking>false</FunctionLevelLinking>

+      <DebugInformationFormat>None</DebugInformationFormat>

+    </ClCompile>

+    <Link>

+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <IgnoreSpecificDefaultLibraries>libcmt.dll;libcmtd.dll;msvcrt.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>

+      <ModuleDefinitionFile>vstplug.def</ModuleDefinitionFile>

+    </Link>

+  </ItemDefinitionGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>MaxSpeed</Optimization>

+      <FunctionLevelLinking>false</FunctionLevelLinking>

+      <IntrinsicFunctions>false</IntrinsicFunctions>

+      <SDLCheck>true</SDLCheck>

+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+      <AdditionalIncludeDirectories>C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <DebugInformationFormat>None</DebugInformationFormat>

+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

+      <PreprocessorDefinitions>WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+    </ClCompile>

+    <Link>

+      <EnableCOMDATFolding>true</EnableCOMDATFolding>

+      <OptimizeReferences>true</OptimizeReferences>

+      <IgnoreSpecificDefaultLibraries>libcmt.dll;libcmtd.dll;msvcrt.lib;libc.lib;libcd.lib;libcmt.lib;msvcrtd.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>

+      <AdditionalDependencies>libcmt.lib;uuid.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <ModuleDefinitionFile>vstplug.def</ModuleDefinitionFile>

+    </Link>

+  </ItemDefinitionGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>MaxSpeed</Optimization>

+      <FunctionLevelLinking>false</FunctionLevelLinking>

+      <IntrinsicFunctions>false</IntrinsicFunctions>

+      <SDLCheck>true</SDLCheck>

+      <AdditionalIncludeDirectories>C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <DebugInformationFormat>None</DebugInformationFormat>

+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

+      <PreprocessorDefinitions>WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+    </ClCompile>

+    <Link>

+      <EnableCOMDATFolding>true</EnableCOMDATFolding>

+      <OptimizeReferences>true</OptimizeReferences>

+      <IgnoreSpecificDefaultLibraries>libcmt.dll;libcmtd.dll;msvcrt.lib;libc.lib;libcd.lib;libcmt.lib;msvcrtd.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>

+      <AdditionalDependencies>libcmt.lib;uuid.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <ModuleDefinitionFile>vstplug.def</ModuleDefinitionFile>

+    </Link>

+  </ItemDefinitionGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

+  <ImportGroup Label="ExtensionTargets">

+  </ImportGroup>

+</Project>
\ No newline at end of file
diff --git a/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj.filters b/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj.filters
new file mode 100644
index 0000000..2e64344
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj.filters
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <ItemGroup>

+    <Filter Include="Source Files">

+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>

+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

+    </Filter>

+    <Filter Include="Header Files">

+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>

+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>

+    </Filter>

+    <Filter Include="Resource Files">

+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>

+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>

+    </Filter>

+  </ItemGroup>

+  <ItemGroup>

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffect.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffectx.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\vstplugmain.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+    <ClCompile Include="PurestConsoleChannel.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+    <ClCompile Include="PurestConsoleChannelProc.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+  </ItemGroup>

+  <ItemGroup>

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\aeffeditor.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffect.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffectx.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

+    <ClInclude Include="PurestConsoleChannel.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

+  </ItemGroup>

+</Project>
\ No newline at end of file
diff --git a/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj.user b/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj.user
new file mode 100644
index 0000000..2216267
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/VSTProject.vcxproj.user
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <LocalDebuggerAmpDefaultAccelerator>{ADEFF70D-84BF-47A1-91C3-FF6B0FC71218}</LocalDebuggerAmpDefaultAccelerator>

+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <LocalDebuggerAmpDefaultAccelerator>{ADEFF70D-84BF-47A1-91C3-FF6B0FC71218}</LocalDebuggerAmpDefaultAccelerator>

+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+    <LocalDebuggerAmpDefaultAccelerator>{ADEFF70D-84BF-47A1-91C3-FF6B0FC71218}</LocalDebuggerAmpDefaultAccelerator>

+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+    <LocalDebuggerAmpDefaultAccelerator>{ADEFF70D-84BF-47A1-91C3-FF6B0FC71218}</LocalDebuggerAmpDefaultAccelerator>

+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>

+  </PropertyGroup>

+</Project>
\ No newline at end of file
diff --git a/plugins/WinVST/PurestConsoleChannel/vst2.x/aeffeditor.h b/plugins/WinVST/PurestConsoleChannel/vst2.x/aeffeditor.h
new file mode 100644
index 0000000..04f7339
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/vst2.x/aeffeditor.h
@@ -0,0 +1,61 @@
+//-------------------------------------------------------------------------------------------------------

+// 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/PurestConsoleChannel/vst2.x/audioeffect.cpp b/plugins/WinVST/PurestConsoleChannel/vst2.x/audioeffect.cpp
new file mode 100644
index 0000000..e7440d2
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/vst2.x/audioeffect.cpp
@@ -0,0 +1,703 @@
+//-------------------------------------------------------------------------------------------------------

+// 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/PurestConsoleChannel/vst2.x/audioeffect.h b/plugins/WinVST/PurestConsoleChannel/vst2.x/audioeffect.h
new file mode 100644
index 0000000..a506bde
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/vst2.x/audioeffect.h
@@ -0,0 +1,177 @@
+//-------------------------------------------------------------------------------------------------------

+// 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/PurestConsoleChannel/vst2.x/audioeffectx.cpp b/plugins/WinVST/PurestConsoleChannel/vst2.x/audioeffectx.cpp
new file mode 100644
index 0000000..5f07f7c
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/vst2.x/audioeffectx.cpp
@@ -0,0 +1,1546 @@
+//-------------------------------------------------------------------------------------------------------

+// VST Plug-Ins SDK

+// Version 2.4       $Date: 2006/10/05 14:23:59 $

+//

+// Category     : VST 2.x Classes

+// Filename     : audioeffectx.cpp

+// Created by   : Steinberg Media Technologies

+// Description  : Class AudioEffectX extends AudioEffect with new features. You should derive

+//                your plug-in from AudioEffectX.

+//

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

+//-------------------------------------------------------------------------------------------------------

+

+#include "audioeffectx.h"

+#include "aeffeditor.h"

+

+//-------------------------------------------------------------------------------------------------------

+/*! hostCanDos strings Plug-in -> Host */

+namespace HostCanDos

+{

+	const char* canDoSendVstEvents = "sendVstEvents"; ///< Host supports send of Vst events to plug-in

+	const char* canDoSendVstMidiEvent = "sendVstMidiEvent"; ///< Host supports send of MIDI events to plug-in

+	const char* canDoSendVstTimeInfo = "sendVstTimeInfo"; ///< Host supports send of VstTimeInfo to plug-in

+	const char* canDoReceiveVstEvents = "receiveVstEvents"; ///< Host can receive Vst events from plug-in

+	const char* canDoReceiveVstMidiEvent = "receiveVstMidiEvent"; ///< Host can receive MIDI events from plug-in 

+	const char* canDoReportConnectionChanges = "reportConnectionChanges"; ///< Host will indicates the plug-in when something change in plug-in´s routing/connections with #suspend/#resume/#setSpeakerArrangement 

+	const char* canDoAcceptIOChanges = "acceptIOChanges"; ///< Host supports #ioChanged ()

+	const char* canDoSizeWindow = "sizeWindow"; ///< used by VSTGUI

+	const char* canDoOffline = "offline"; ///< Host supports offline feature

+	const char* canDoOpenFileSelector = "openFileSelector"; ///< Host supports function #openFileSelector ()

+	const char* canDoCloseFileSelector = "closeFileSelector"; ///< Host supports function #closeFileSelector ()

+	const char* canDoStartStopProcess = "startStopProcess"; ///< Host supports functions #startProcess () and #stopProcess ()

+	const char* canDoShellCategory = "shellCategory"; ///< 'shell' handling via uniqueID. If supported by the Host and the Plug-in has the category #kPlugCategShell

+	const char* canDoSendVstMidiEventFlagIsRealtime = "sendVstMidiEventFlagIsRealtime"; ///< Host supports flags for #VstMidiEvent

+}

+

+//-------------------------------------------------------------------------------------------------------

+/*! plugCanDos strings Host -> Plug-in */

+namespace PlugCanDos

+{

+	const char* canDoSendVstEvents = "sendVstEvents"; ///< plug-in will send Vst events to Host

+	const char* canDoSendVstMidiEvent = "sendVstMidiEvent"; ///< plug-in will send MIDI events to Host

+	const char* canDoReceiveVstEvents = "receiveVstEvents"; ///< plug-in can receive MIDI events from Host

+	const char* canDoReceiveVstMidiEvent = "receiveVstMidiEvent"; ///< plug-in can receive MIDI events from Host 

+	const char* canDoReceiveVstTimeInfo = "receiveVstTimeInfo"; ///< plug-in can receive Time info from Host 

+	const char* canDoOffline = "offline"; ///< plug-in supports offline functions (#offlineNotify, #offlinePrepare, #offlineRun)

+	const char* canDoMidiProgramNames = "midiProgramNames"; ///< plug-in supports function #getMidiProgramName ()

+	const char* canDoBypass = "bypass"; ///< plug-in supports function #setBypass ()

+}

+

+//-----------------------------------------------------------------------------------------------------------------

+// Class AudioEffectX Implementation

+//-----------------------------------------------------------------------------------------------------------------

+/*!

+	\sa AudioEffect()

+*/

+AudioEffectX::AudioEffectX (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams)

+: AudioEffect (audioMaster, numPrograms, numParams)

+{}

+

+//-----------------------------------------------------------------------------------------------------------------

+VstIntPtr AudioEffectX::dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt)

+{

+	VstIntPtr v = 0;

+	switch (opcode)

+	{

+		//---VstEvents----------------------

+		case effProcessEvents:

+			v = processEvents ((VstEvents*)ptr);

+			break;

+

+		//---Parameters and Programs----------------------

+		case effCanBeAutomated:

+			v = canParameterBeAutomated (index) ? 1 : 0;

+			break;

+		case effString2Parameter:

+			v = string2parameter (index, (char*)ptr) ? 1 : 0;

+			break;

+

+		case effGetProgramNameIndexed:

+			v = getProgramNameIndexed ((VstInt32)value, index, (char*)ptr) ? 1 : 0;

+			break;

+	#if !VST_FORCE_DEPRECATED

+		case effGetNumProgramCategories:

+			v = getNumCategories ();

+			break;

+		case effCopyProgram:

+			v = copyProgram (index) ? 1 : 0;

+			break;

+

+		//---Connections, Configuration----------------------

+		case effConnectInput:

+			inputConnected (index, value ? true : false);

+			v = 1;

+			break;	

+		case effConnectOutput:

+			outputConnected (index, value ? true : false);

+			v = 1;

+			break;	

+	#endif // !VST_FORCE_DEPRECATED

+

+		case effGetInputProperties:

+			v = getInputProperties (index, (VstPinProperties*)ptr) ? 1 : 0;

+			break;

+		case effGetOutputProperties:

+			v = getOutputProperties (index, (VstPinProperties*)ptr) ? 1 : 0;

+			break;

+		case effGetPlugCategory:

+			v = (VstIntPtr)getPlugCategory ();

+			break;

+

+	#if !VST_FORCE_DEPRECATED

+		//---Realtime----------------------

+		case effGetCurrentPosition:

+			v = reportCurrentPosition ();

+			break;

+			

+		case effGetDestinationBuffer:

+			v = ToVstPtr<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/PurestConsoleChannel/vst2.x/audioeffectx.h b/plugins/WinVST/PurestConsoleChannel/vst2.x/audioeffectx.h
new file mode 100644
index 0000000..c04a6a0
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/vst2.x/audioeffectx.h
@@ -0,0 +1,252 @@
+//-------------------------------------------------------------------------------------------------------

+// 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/PurestConsoleChannel/vst2.x/vstplugmain.cpp b/plugins/WinVST/PurestConsoleChannel/vst2.x/vstplugmain.cpp
new file mode 100644
index 0000000..7e1ae71
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/vst2.x/vstplugmain.cpp
@@ -0,0 +1,68 @@
+//-------------------------------------------------------------------------------------------------------

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

diff --git a/plugins/WinVST/PurestConsoleChannel/vstplug.def b/plugins/WinVST/PurestConsoleChannel/vstplug.def
new file mode 100644
index 0000000..5bf499a
--- /dev/null
+++ b/plugins/WinVST/PurestConsoleChannel/vstplug.def
@@ -0,0 +1,3 @@
+EXPORTS

+	VSTPluginMain

+	main=VSTPluginMain
\ No newline at end of file