From ee090696621521aaa9475b5a3b3015b3b7511800 Mon Sep 17 00:00:00 2001 From: airwindows Date: Sun, 6 May 2018 20:11:50 -0400 Subject: Wider --- .../WinVST/Wider/.vs/Console4Channel64/v14/.suo | Bin 0 -> 32768 bytes plugins/WinVST/Wider/.vs/VSTProject/v14/.suo | Bin 0 -> 22528 bytes plugins/WinVST/Wider/VSTProject.sln | 28 + plugins/WinVST/Wider/VSTProject.vcxproj | 183 +++ plugins/WinVST/Wider/VSTProject.vcxproj.filters | 48 + plugins/WinVST/Wider/VSTProject.vcxproj.user | 19 + plugins/WinVST/Wider/Wider.cpp | 140 ++ plugins/WinVST/Wider/Wider.h | 72 + plugins/WinVST/Wider/WiderProc.cpp | 336 +++++ plugins/WinVST/Wider/vst2.x/aeffeditor.h | 61 + plugins/WinVST/Wider/vst2.x/audioeffect.cpp | 703 +++++++++ plugins/WinVST/Wider/vst2.x/audioeffect.h | 177 +++ plugins/WinVST/Wider/vst2.x/audioeffectx.cpp | 1546 ++++++++++++++++++++ plugins/WinVST/Wider/vst2.x/audioeffectx.h | 252 ++++ plugins/WinVST/Wider/vst2.x/vstplugmain.cpp | 68 + plugins/WinVST/Wider/vstplug.def | 3 + 16 files changed, 3636 insertions(+) create mode 100755 plugins/WinVST/Wider/.vs/Console4Channel64/v14/.suo create mode 100755 plugins/WinVST/Wider/.vs/VSTProject/v14/.suo create mode 100755 plugins/WinVST/Wider/VSTProject.sln create mode 100755 plugins/WinVST/Wider/VSTProject.vcxproj create mode 100755 plugins/WinVST/Wider/VSTProject.vcxproj.filters create mode 100755 plugins/WinVST/Wider/VSTProject.vcxproj.user create mode 100755 plugins/WinVST/Wider/Wider.cpp create mode 100755 plugins/WinVST/Wider/Wider.h create mode 100755 plugins/WinVST/Wider/WiderProc.cpp create mode 100755 plugins/WinVST/Wider/vst2.x/aeffeditor.h create mode 100755 plugins/WinVST/Wider/vst2.x/audioeffect.cpp create mode 100755 plugins/WinVST/Wider/vst2.x/audioeffect.h create mode 100755 plugins/WinVST/Wider/vst2.x/audioeffectx.cpp create mode 100755 plugins/WinVST/Wider/vst2.x/audioeffectx.h create mode 100755 plugins/WinVST/Wider/vst2.x/vstplugmain.cpp create mode 100755 plugins/WinVST/Wider/vstplug.def (limited to 'plugins/WinVST/Wider') diff --git a/plugins/WinVST/Wider/.vs/Console4Channel64/v14/.suo b/plugins/WinVST/Wider/.vs/Console4Channel64/v14/.suo new file mode 100755 index 0000000..777b846 Binary files /dev/null and b/plugins/WinVST/Wider/.vs/Console4Channel64/v14/.suo differ diff --git a/plugins/WinVST/Wider/.vs/VSTProject/v14/.suo b/plugins/WinVST/Wider/.vs/VSTProject/v14/.suo new file mode 100755 index 0000000..6a45209 Binary files /dev/null and b/plugins/WinVST/Wider/.vs/VSTProject/v14/.suo differ diff --git a/plugins/WinVST/Wider/VSTProject.sln b/plugins/WinVST/Wider/VSTProject.sln new file mode 100755 index 0000000..694b424 --- /dev/null +++ b/plugins/WinVST/Wider/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/Wider/VSTProject.vcxproj b/plugins/WinVST/Wider/VSTProject.vcxproj new file mode 100755 index 0000000..b74f453 --- /dev/null +++ b/plugins/WinVST/Wider/VSTProject.vcxproj @@ -0,0 +1,183 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C} + VSTProject + 8.1 + Wider64 + + + + DynamicLibrary + true + v140 + NotSet + + + DynamicLibrary + false + v140 + false + NotSet + + + DynamicLibrary + true + v140 + NotSet + + + DynamicLibrary + false + v140 + false + NotSet + + + + + + + + + + + + + + + + + + + + + .dll + + + $(SolutionDir)$(Configuration)\ + $(Configuration)\ + $(VC_ExecutablePath_x64);$(WindowsSDK_ExecutablePath);$(VS_ExecutablePath);$(MSBuild_ExecutablePath);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH) + + + $(SolutionDir)$(Configuration)\ + $(Configuration)\ + $(VC_ExecutablePath_x64);$(WindowsSDK_ExecutablePath);$(VS_ExecutablePath);$(MSBuild_ExecutablePath);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH) + + + + Level3 + MaxSpeed + true + C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories) + WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions) + MultiThreadedDebug + Speed + false + Default + false + None + + + vstplug.def + libcmt.dll;libcmtd.dll;msvcrt.lib;%(IgnoreSpecificDefaultLibraries) + 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) + + + + + Level3 + MaxSpeed + true + C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories) + Speed + WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions) + false + MultiThreadedDebug + Default + false + None + + + 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) + libcmt.dll;libcmtd.dll;msvcrt.lib;%(IgnoreSpecificDefaultLibraries) + vstplug.def + + + + + Level3 + MaxSpeed + false + false + true + MultiThreaded + C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories) + None + Speed + WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions) + + + true + true + libcmt.dll;libcmtd.dll;msvcrt.lib;libc.lib;libcd.lib;libcmt.lib;msvcrtd.lib;%(IgnoreSpecificDefaultLibraries) + 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) + vstplug.def + + + + + Level3 + MaxSpeed + false + false + true + C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories) + None + Speed + WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions) + MultiThreaded + + + true + true + libcmt.dll;libcmtd.dll;msvcrt.lib;libc.lib;libcd.lib;libcmt.lib;msvcrtd.lib;%(IgnoreSpecificDefaultLibraries) + 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) + vstplug.def + + + + + + \ No newline at end of file diff --git a/plugins/WinVST/Wider/VSTProject.vcxproj.filters b/plugins/WinVST/Wider/VSTProject.vcxproj.filters new file mode 100755 index 0000000..53e540d --- /dev/null +++ b/plugins/WinVST/Wider/VSTProject.vcxproj.filters @@ -0,0 +1,48 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/plugins/WinVST/Wider/VSTProject.vcxproj.user b/plugins/WinVST/Wider/VSTProject.vcxproj.user new file mode 100755 index 0000000..2216267 --- /dev/null +++ b/plugins/WinVST/Wider/VSTProject.vcxproj.user @@ -0,0 +1,19 @@ + + + + {ADEFF70D-84BF-47A1-91C3-FF6B0FC71218} + WindowsLocalDebugger + + + {ADEFF70D-84BF-47A1-91C3-FF6B0FC71218} + WindowsLocalDebugger + + + {ADEFF70D-84BF-47A1-91C3-FF6B0FC71218} + WindowsLocalDebugger + + + {ADEFF70D-84BF-47A1-91C3-FF6B0FC71218} + WindowsLocalDebugger + + \ No newline at end of file diff --git a/plugins/WinVST/Wider/Wider.cpp b/plugins/WinVST/Wider/Wider.cpp new file mode 100755 index 0000000..c1e57d0 --- /dev/null +++ b/plugins/WinVST/Wider/Wider.cpp @@ -0,0 +1,140 @@ +/* ======================================== + * Wider - Wider.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __Wider_H +#include "Wider.h" +#endif + +AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new Wider(audioMaster);} + +Wider::Wider(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 0.5; + B = 0.5; + C = 1.0; + for(int fcount = 0; fcount < 4098; fcount++) {p[fcount] = 0.0;} + count = 0; + 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 +} + +Wider::~Wider() {} +VstInt32 Wider::getVendorVersion () {return 1000;} +void Wider::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void Wider::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! + +static float pinParameter(float data) +{ + if (data < 0.0f) return 0.0f; + if (data > 1.0f) return 1.0f; + return data; +} + +VstInt32 Wider::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + chunkData[1] = B; + chunkData[2] = C; + /* 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 Wider::setChunk (void* data, VstInt32 byteSize, bool isPreset) +{ + float *chunkData = (float *)data; + A = pinParameter(chunkData[0]); + B = pinParameter(chunkData[1]); + C = pinParameter(chunkData[2]); + /* 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 Wider::setParameter(VstInt32 index, float value) { + switch (index) { + case kParamA: A = value; break; + case kParamB: B = value; break; + case kParamC: C = value; break; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float Wider::getParameter(VstInt32 index) { + switch (index) { + case kParamA: return A; break; + case kParamB: return B; break; + case kParamC: return C; break; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void Wider::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Width", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Center", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this is our labels for displaying in the VST host +} + +void Wider::getParameterDisplay(VstInt32 index, char *text) { + switch (index) { + case kParamA: float2string ((A*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamB: float2string ((B*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamC: float2string (C, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void Wider::getParameterLabel(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 Wider::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool Wider::getEffectName(char* name) { + vst_strncpy(name, "Wider", kVstMaxProductStrLen); return true; +} + +VstPlugCategory Wider::getPlugCategory() {return kPlugCategEffect;} + +bool Wider::getProductString(char* text) { + vst_strncpy (text, "airwindows Wider", kVstMaxProductStrLen); return true; +} + +bool Wider::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugins/WinVST/Wider/Wider.h b/plugins/WinVST/Wider/Wider.h new file mode 100755 index 0000000..8b04cfb --- /dev/null +++ b/plugins/WinVST/Wider/Wider.h @@ -0,0 +1,72 @@ +/* ======================================== + * Wider - Wider.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, All rights reserved + * ======================================== */ + +#ifndef __Wider_H +#define __Wider_H + +#ifndef __audioeffect__ +#include "audioeffectx.h" +#endif + +#include +#include +#include + +enum { + kParamA = 0, + kParamB = 1, + kParamC = 2, + kNumParameters = 3 +}; // + +const int kNumPrograms = 0; +const int kNumInputs = 2; +const int kNumOutputs = 2; +const unsigned long kUniqueId = 'widr'; //Change this to what the AU identity is! + +class Wider : + public AudioEffectX +{ +public: + Wider(audioMasterCallback audioMaster); + ~Wider(); + 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 + + double p[4099]; + int count; + + float A; + float B; + float C; +}; + +#endif diff --git a/plugins/WinVST/Wider/WiderProc.cpp b/plugins/WinVST/Wider/WiderProc.cpp new file mode 100755 index 0000000..618e651 --- /dev/null +++ b/plugins/WinVST/Wider/WiderProc.cpp @@ -0,0 +1,336 @@ +/* ======================================== + * Wider - Wider.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __Wider_H +#include "Wider.h" +#endif + +void Wider::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + float fpTemp; + long double fpOld = 0.618033988749894848204586; //golden ratio! + long double fpNew = 1.0 - fpOld; + + long double inputSampleL; + long double inputSampleR; + double drySampleL; + double drySampleR; + long double mid; + long double side; + double out; + double densityside = (A*2.0)-1.0; + double densitymid = (B*2.0)-1.0; + double wet = C; + double dry = 1.0 - wet; + wet *= 0.5; //we make mid-side by adding/subtracting both channels into each channel + //and that's why we gotta divide it by 2: otherwise everything's doubled. So, premultiply it to save an extra 'math' + double offset = (densityside-densitymid)/2; + if (offset > 0) offset = sin(offset); + if (offset < 0) offset = -sin(-offset); + offset = -(pow(offset,4) * 20 * overallscale); + int near = (int)floor(fabs(offset)); + double farLevel = fabs(offset) - near; + int far = near + 1; + double nearLevel = 1.0 - farLevel; + double bridgerectifier; + //interpolating the sample + + 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. + } + drySampleL = inputSampleL; + drySampleR = inputSampleR; + //assign working variables + mid = inputSampleL + inputSampleR; + side = inputSampleL - inputSampleR; + //assign mid and side. Now, High Impact code + + if (densityside != 0.0) + { + out = fabs(densityside); + bridgerectifier = fabs(side)*1.57079633; + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + //max value for sine function + if (densityside > 0) bridgerectifier = sin(bridgerectifier); + else bridgerectifier = 1-cos(bridgerectifier); + //produce either boosted or starved version + if (side > 0) side = (side*(1-out))+(bridgerectifier*out); + else side = (side*(1-out))-(bridgerectifier*out); + //blend according to density control + } + + if (densitymid != 0.0) + { + out = fabs(densitymid); + bridgerectifier = fabs(mid)*1.57079633; + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + //max value for sine function + if (densitymid > 0) bridgerectifier = sin(bridgerectifier); + else bridgerectifier = 1-cos(bridgerectifier); + //produce either boosted or starved version + if (mid > 0) mid = (mid*(1-out))+(bridgerectifier*out); + else mid = (mid*(1-out))-(bridgerectifier*out); + //blend according to density control + } + + if (count < 1 || count > 2048) {count = 2048;} + if (offset > 0) + { + p[count+2048] = p[count] = mid; + mid = p[count+near]*nearLevel; + mid += p[count+far]*farLevel; + } + + if (offset < 0) + { + p[count+2048] = p[count] = side; + side = p[count+near]*nearLevel; + side += p[count+far]*farLevel; + } + count -= 1; + + inputSampleL = (drySampleL * dry) + ((mid+side) * wet); + inputSampleR = (drySampleR * dry) + ((mid-side) * wet); + + //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 Wider::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + double fpTemp; + long double fpOld = 0.618033988749894848204586; //golden ratio! + long double fpNew = 1.0 - fpOld; + + long double inputSampleL; + long double inputSampleR; + double drySampleL; + double drySampleR; + long double mid; + long double side; + double out; + double densityside = (A*2.0)-1.0; + double densitymid = (B*2.0)-1.0; + double wet = C; + double dry = 1.0 - wet; + wet *= 0.5; //we make mid-side by adding/subtracting both channels into each channel + //and that's why we gotta divide it by 2: otherwise everything's doubled. So, premultiply it to save an extra 'math' + double offset = (densityside-densitymid)/2; + if (offset > 0) offset = sin(offset); + if (offset < 0) offset = -sin(-offset); + offset = -(pow(offset,4) * 20 * overallscale); + int near = (int)floor(fabs(offset)); + double farLevel = fabs(offset) - near; + int far = near + 1; + double nearLevel = 1.0 - farLevel; + double bridgerectifier; + //interpolating the sample + + 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. + } + drySampleL = inputSampleL; + drySampleR = inputSampleR; + //assign working variables + mid = inputSampleL + inputSampleR; + side = inputSampleL - inputSampleR; + //assign mid and side. Now, High Impact code + + if (densityside != 0.0) + { + out = fabs(densityside); + bridgerectifier = fabs(side)*1.57079633; + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + //max value for sine function + if (densityside > 0) bridgerectifier = sin(bridgerectifier); + else bridgerectifier = 1-cos(bridgerectifier); + //produce either boosted or starved version + if (side > 0) side = (side*(1-out))+(bridgerectifier*out); + else side = (side*(1-out))-(bridgerectifier*out); + //blend according to density control + } + + if (densitymid != 0.0) + { + out = fabs(densitymid); + bridgerectifier = fabs(mid)*1.57079633; + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + //max value for sine function + if (densitymid > 0) bridgerectifier = sin(bridgerectifier); + else bridgerectifier = 1-cos(bridgerectifier); + //produce either boosted or starved version + if (mid > 0) mid = (mid*(1-out))+(bridgerectifier*out); + else mid = (mid*(1-out))-(bridgerectifier*out); + //blend according to density control + } + + if (count < 1 || count > 2048) {count = 2048;} + if (offset > 0) + { + p[count+2048] = p[count] = mid; + mid = p[count+near]*nearLevel; + mid += p[count+far]*farLevel; + } + + if (offset < 0) + { + p[count+2048] = p[count] = side; + side = p[count+near]*nearLevel; + side += p[count+far]*farLevel; + } + count -= 1; + + inputSampleL = (drySampleL * dry) + ((mid+side) * wet); + inputSampleR = (drySampleR * dry) + ((mid-side) * wet); + + //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/Wider/vst2.x/aeffeditor.h b/plugins/WinVST/Wider/vst2.x/aeffeditor.h new file mode 100755 index 0000000..04f7339 --- /dev/null +++ b/plugins/WinVST/Wider/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/Wider/vst2.x/audioeffect.cpp b/plugins/WinVST/Wider/vst2.x/audioeffect.cpp new file mode 100755 index 0000000..e7440d2 --- /dev/null +++ b/plugins/WinVST/Wider/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 +#include +#include + +//------------------------------------------------------------------------------------------------------- +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 must process exactly \e sampleFrames number of samples in inside processReplacing, not more! +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::setParameter (VstInt32 index, float value) + + Parameters are the individual parameter settings the user can adjust. A VST Host can automate these + parameters. Set parameter \e index to \e value. + + \param index Index of the parameter to change + \param value A float value between 0.0 and 1.0 inclusive + + \note Parameter values, like all VST parameters, are declared as floats with an inclusive range of + 0.0 to 1.0. How data is presented to the user is merely in the user-interface handling. This is a + convention, but still worth regarding. Maybe the VST-Host's automation system depends on this range. +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn float AudioEffect::getParameter (VstInt32 index) + + Return the \e value of parameter \e index + + \param index Index of the parameter + \return A float value between 0.0 and 1.0 inclusive +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::getParameterLabel (VstInt32 index, char* label) + + \param index Index of the parameter + \param label A string up to 8 char +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::getParameterDisplay (VstInt32 index, char* text) + + \param index Index of the parameter + \param text A string up to 8 char +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffect::getProgram () + + \return Index of the current program +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::setProgram (VstInt32 program) + + \param Program of the current program +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::getParameterName (VstInt32 index, char* text) + + \param index Index of the parameter + \param text A string up to 8 char +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::setProgramName (char* name) + + The program name is displayed in the rack, and can be edited by the user. + + \param name A string up to 24 char + + \warning Please be aware that the string lengths supported by the default VST interface are normally + limited to 24 characters. If you copy too much data into the buffers provided, you will break the + Host application. +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::getProgramName (char* name) + + The program name is displayed in the rack, and can be edited by the user. + + \param name A string up to 24 char + + \warning Please be aware that the string lengths supported by the default VST interface are normally + limited to 24 characters. If you copy too much data into the buffers provided, you will break the + Host application. +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffect::getChunk (void** data, bool isPreset) + + \param data should point to the newly allocated memory block containg state data. You can savely release it in next suspend/resume call. + \param isPreset true when saving a single program, false for all programs + + \note + If your plug-in is configured to use chunks (see AudioEffect::programsAreChunks), the Host + will ask for a block of memory describing the current plug-in state for saving. + To restore the state at a later stage, the same data is passed back to AudioEffect::setChunk. + Alternatively, when not using chunk, the Host will simply save all parameter values. +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffect::setChunk (void* data, VstInt32 byteSize, bool isPreset) + + \param data pointer to state data (owned by Host) + \param byteSize size of state data + \param isPreset true when restoring a single program, false for all programs + + \sa getChunk +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::setNumInputs (VstInt32 inputs) + + This number is fixed at construction time and can't change until the plug-in is destroyed. + + \param inputs The number of inputs + + \sa isInputConnected() + + \note Needs to be called in the plug-in's constructor +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::setNumOutputs (VstInt32 outputs) + + This number is fixed at construction time and can't change until the plug-in is destroyed. + + \param outputs The number of outputs + + \sa isOutputConnected() + + \note Needs to be called in the plug-in's constructor +*/ + +//------------------------------------------------------------------------------------------------------- +/*! + \fn void AudioEffect::setUniqueID (VstInt32 iD) + + Must call this! Set the plug-in's unique identifier. The Host uses this to identify the plug-in, for + instance when it is loading effect programs and banks. On Steinberg Web Page you can find an UniqueID + Database where you can record your UniqueID, it will check if the ID is already used by an another + vendor. You can use CCONST('a','b','c','d') (defined in VST 2.0) to be platform independent to + initialize an UniqueID. + + \param iD Plug-in's unique ID + + \note Needs to be called in the plug-in's constructor +*/ diff --git a/plugins/WinVST/Wider/vst2.x/audioeffect.h b/plugins/WinVST/Wider/vst2.x/audioeffect.h new file mode 100755 index 0000000..a506bde --- /dev/null +++ b/plugins/WinVST/Wider/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/Wider/vst2.x/audioeffectx.cpp b/plugins/WinVST/Wider/vst2.x/audioeffectx.cpp new file mode 100755 index 0000000..5f07f7c --- /dev/null +++ b/plugins/WinVST/Wider/vst2.x/audioeffectx.cpp @@ -0,0 +1,1546 @@ +//------------------------------------------------------------------------------------------------------- +// VST Plug-Ins SDK +// Version 2.4 $Date: 2006/10/05 14:23:59 $ +// +// Category : VST 2.x Classes +// Filename : audioeffectx.cpp +// Created by : Steinberg Media Technologies +// Description : Class AudioEffectX extends AudioEffect with new features. You should derive +// your plug-in from AudioEffectX. +// +// © 2006, Steinberg Media Technologies, All Rights Reserved +//------------------------------------------------------------------------------------------------------- + +#include "audioeffectx.h" +#include "aeffeditor.h" + +//------------------------------------------------------------------------------------------------------- +/*! hostCanDos strings Plug-in -> Host */ +namespace HostCanDos +{ + const char* canDoSendVstEvents = "sendVstEvents"; ///< Host supports send of Vst events to plug-in + const char* canDoSendVstMidiEvent = "sendVstMidiEvent"; ///< Host supports send of MIDI events to plug-in + const char* canDoSendVstTimeInfo = "sendVstTimeInfo"; ///< Host supports send of VstTimeInfo to plug-in + const char* canDoReceiveVstEvents = "receiveVstEvents"; ///< Host can receive Vst events from plug-in + const char* canDoReceiveVstMidiEvent = "receiveVstMidiEvent"; ///< Host can receive MIDI events from plug-in + const char* canDoReportConnectionChanges = "reportConnectionChanges"; ///< Host will indicates the plug-in when something change in plug-in´s routing/connections with #suspend/#resume/#setSpeakerArrangement + const char* canDoAcceptIOChanges = "acceptIOChanges"; ///< Host supports #ioChanged () + const char* canDoSizeWindow = "sizeWindow"; ///< used by VSTGUI + const char* canDoOffline = "offline"; ///< Host supports offline feature + const char* canDoOpenFileSelector = "openFileSelector"; ///< Host supports function #openFileSelector () + const char* canDoCloseFileSelector = "closeFileSelector"; ///< Host supports function #closeFileSelector () + const char* canDoStartStopProcess = "startStopProcess"; ///< Host supports functions #startProcess () and #stopProcess () + const char* canDoShellCategory = "shellCategory"; ///< 'shell' handling via uniqueID. If supported by the Host and the Plug-in has the category #kPlugCategShell + const char* canDoSendVstMidiEventFlagIsRealtime = "sendVstMidiEventFlagIsRealtime"; ///< Host supports flags for #VstMidiEvent +} + +//------------------------------------------------------------------------------------------------------- +/*! plugCanDos strings Host -> Plug-in */ +namespace PlugCanDos +{ + const char* canDoSendVstEvents = "sendVstEvents"; ///< plug-in will send Vst events to Host + const char* canDoSendVstMidiEvent = "sendVstMidiEvent"; ///< plug-in will send MIDI events to Host + const char* canDoReceiveVstEvents = "receiveVstEvents"; ///< plug-in can receive MIDI events from Host + const char* canDoReceiveVstMidiEvent = "receiveVstMidiEvent"; ///< plug-in can receive MIDI events from Host + const char* canDoReceiveVstTimeInfo = "receiveVstTimeInfo"; ///< plug-in can receive Time info from Host + const char* canDoOffline = "offline"; ///< plug-in supports offline functions (#offlineNotify, #offlinePrepare, #offlineRun) + const char* canDoMidiProgramNames = "midiProgramNames"; ///< plug-in supports function #getMidiProgramName () + const char* canDoBypass = "bypass"; ///< plug-in supports function #setBypass () +} + +//----------------------------------------------------------------------------------------------------------------- +// Class AudioEffectX Implementation +//----------------------------------------------------------------------------------------------------------------- +/*! + \sa AudioEffect() +*/ +AudioEffectX::AudioEffectX (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams) +: AudioEffect (audioMaster, numPrograms, numParams) +{} + +//----------------------------------------------------------------------------------------------------------------- +VstIntPtr AudioEffectX::dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt) +{ + VstIntPtr v = 0; + switch (opcode) + { + //---VstEvents---------------------- + case effProcessEvents: + v = processEvents ((VstEvents*)ptr); + break; + + //---Parameters and Programs---------------------- + case effCanBeAutomated: + v = canParameterBeAutomated (index) ? 1 : 0; + break; + case effString2Parameter: + v = string2parameter (index, (char*)ptr) ? 1 : 0; + break; + + case effGetProgramNameIndexed: + v = getProgramNameIndexed ((VstInt32)value, index, (char*)ptr) ? 1 : 0; + break; + #if !VST_FORCE_DEPRECATED + case effGetNumProgramCategories: + v = getNumCategories (); + break; + case effCopyProgram: + v = copyProgram (index) ? 1 : 0; + break; + + //---Connections, Configuration---------------------- + case effConnectInput: + inputConnected (index, value ? true : false); + v = 1; + break; + case effConnectOutput: + outputConnected (index, value ? true : false); + v = 1; + break; + #endif // !VST_FORCE_DEPRECATED + + case effGetInputProperties: + v = getInputProperties (index, (VstPinProperties*)ptr) ? 1 : 0; + break; + case effGetOutputProperties: + v = getOutputProperties (index, (VstPinProperties*)ptr) ? 1 : 0; + break; + case effGetPlugCategory: + v = (VstIntPtr)getPlugCategory (); + break; + + #if !VST_FORCE_DEPRECATED + //---Realtime---------------------- + case effGetCurrentPosition: + v = reportCurrentPosition (); + break; + + case effGetDestinationBuffer: + v = ToVstPtr (reportDestinationBuffer ()); + break; + #endif // !VST_FORCE_DEPRECATED + + //---Offline---------------------- + case effOfflineNotify: + v = offlineNotify ((VstAudioFile*)ptr, (VstInt32)value, index != 0); + break; + case effOfflinePrepare: + v = offlinePrepare ((VstOfflineTask*)ptr, (VstInt32)value); + break; + case effOfflineRun: + v = offlineRun ((VstOfflineTask*)ptr, (VstInt32)value); + break; + + //---Others---------------------- + case effSetSpeakerArrangement: + v = setSpeakerArrangement (FromVstPtr (value), (VstSpeakerArrangement*)ptr) ? 1 : 0; + break; + case effProcessVarIo: + v = processVariableIo ((VstVariableIo*)ptr) ? 1 : 0; + break; + #if !VST_FORCE_DEPRECATED + case effSetBlockSizeAndSampleRate: + setBlockSizeAndSampleRate ((VstInt32)value, opt); + v = 1; + break; + #endif // !VST_FORCE_DEPRECATED + case effSetBypass: + v = setBypass (value ? true : false) ? 1 : 0; + break; + case effGetEffectName: + v = getEffectName ((char*)ptr) ? 1 : 0; + break; + case effGetVendorString: + v = getVendorString ((char*)ptr) ? 1 : 0; + break; + case effGetProductString: + v = getProductString ((char*)ptr) ? 1 : 0; + break; + case effGetVendorVersion: + v = getVendorVersion (); + break; + case effVendorSpecific: + v = vendorSpecific (index, value, ptr, opt); + break; + case effCanDo: + v = canDo ((char*)ptr); + break; + + case effGetTailSize: + v = getGetTailSize (); + break; + + #if !VST_FORCE_DEPRECATED + case effGetErrorText: + v = getErrorText ((char*)ptr) ? 1 : 0; + break; + + case effGetIcon: + v = ToVstPtr (getIcon ()); + break; + + case effSetViewPosition: + v = setViewPosition (index, (VstInt32)value) ? 1 : 0; + break; + + case effIdle: + v = fxIdle (); + break; + + case effKeysRequired: + v = (keysRequired () ? 0 : 1); // reversed to keep v1 compatibility + break; + #endif // !VST_FORCE_DEPRECATED + + case effGetParameterProperties: + v = getParameterProperties (index, (VstParameterProperties*)ptr) ? 1 : 0; + break; + + case effGetVstVersion: + v = getVstVersion (); + break; + + //---Others---------------------- + #if VST_2_1_EXTENSIONS + case effEditKeyDown: + if (editor) + { + VstKeyCode keyCode = {index, (unsigned char)value, (unsigned char)opt}; + v = editor->onKeyDown (keyCode) ? 1 : 0; + } + break; + + case effEditKeyUp: + if (editor) + { + VstKeyCode keyCode = {index, (unsigned char)value, (unsigned char)opt}; + v = editor->onKeyUp (keyCode) ? 1 : 0; + } + break; + + case effSetEditKnobMode: + if (editor) + v = editor->setKnobMode ((VstInt32)value) ? 1 : 0; + break; + + case effGetMidiProgramName: + v = getMidiProgramName (index, (MidiProgramName*)ptr); + break; + case effGetCurrentMidiProgram: + v = getCurrentMidiProgram (index, (MidiProgramName*)ptr); + break; + case effGetMidiProgramCategory: + v = getMidiProgramCategory (index, (MidiProgramCategory*)ptr); + break; + case effHasMidiProgramsChanged: + v = hasMidiProgramsChanged (index) ? 1 : 0; + break; + case effGetMidiKeyName: + v = getMidiKeyName (index, (MidiKeyName*)ptr) ? 1 : 0; + break; + case effBeginSetProgram: + v = beginSetProgram () ? 1 : 0; + break; + case effEndSetProgram: + v = endSetProgram () ? 1 : 0; + break; + #endif // VST_2_1_EXTENSIONS + + #if VST_2_3_EXTENSIONS + case effGetSpeakerArrangement: + v = getSpeakerArrangement (FromVstPtr (value), (VstSpeakerArrangement**)ptr) ? 1 : 0; + break; + + case effSetTotalSampleToProcess: + v = setTotalSampleToProcess ((VstInt32)value); + break; + + case effShellGetNextPlugin: + v = getNextShellPlugin ((char*)ptr); + break; + + case effStartProcess: + v = startProcess (); + break; + case effStopProcess: + v = stopProcess (); + break; + + case effSetPanLaw: + v = setPanLaw ((VstInt32)value, opt) ? 1 : 0; + break; + + case effBeginLoadBank: + v = beginLoadBank ((VstPatchChunkInfo*)ptr); + break; + case effBeginLoadProgram: + v = beginLoadProgram ((VstPatchChunkInfo*)ptr); + break; + #endif // VST_2_3_EXTENSIONS + + #if VST_2_4_EXTENSIONS + case effSetProcessPrecision : + v = setProcessPrecision ((VstInt32)value) ? 1 : 0; + break; + + case effGetNumMidiInputChannels : + v = getNumMidiInputChannels (); + break; + + case effGetNumMidiOutputChannels : + v = getNumMidiOutputChannels (); + break; + #endif // VST_2_4_EXTENSIONS + + //---Version 1.0 or unknown----------------- + default: + v = AudioEffect::dispatcher (opcode, index, value, ptr, opt); + } + return v; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! if this effect is a synth or can receive midi events, we call the deprecated wantEvents() as some host rely on it. +*/ +void AudioEffectX::resume () +{ + if (cEffect.flags & effFlagsIsSynth || canDo ("receiveVstMidiEvent") == 1) + DECLARE_VST_DEPRECATED (wantEvents) (); +} + +//----------------------------------------------------------------------------------------------------------------- +void AudioEffectX::DECLARE_VST_DEPRECATED (wantEvents) (VstInt32 filter) +{ + if (audioMaster) + audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterWantMidi), 0, filter, 0, 0); +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + A plug-in will request time info by calling the function getTimeInfo() which returns a \e #VstTimeInfo + pointer (or NULL if not implemented by the Host). The mask parameter is composed of the same flags which + will be found in the flags field of \e #VstTimeInfo when returned, that is, if you need information about tempo. + The parameter passed to getTimeInfo() should have the \e #kVstTempoValid flag set. This request and delivery + system is important, as a request like this may cause significant calculations at the application's end, which + may take a lot of our precious time. This obviously means you should only set those flags that are required to + get the information you need. Also please be aware that requesting information does not necessarily mean that + that information is provided in return. Check the \e flags field in the \e #VstTimeInfo structure to see if your + request was actually met. + + \param filter A mask indicating which fields are requested, as some items may require extensive conversions. + See the \e flags in #VstTimeInfo + \return A pointer to a #VstTimeInfo structure or NULL if not implemented by the Host +*/ +VstTimeInfo* AudioEffectX::getTimeInfo (VstInt32 filter) +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, audioMasterGetTime, 0, filter, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (tempoAt) (VstInt32 pos) +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterTempoAt), 0, pos, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::sendVstEventsToHost (VstEvents* events) +/*! + Can be called inside processReplacing. + + \param events Fill with VST events + \return Returns \e true on success +*/ +{ + if (audioMaster) + return audioMaster (&cEffect, audioMasterProcessEvents, 0, 0, events, 0) == 1; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::processEvents (VstEvents* events) + + \return return value is ignored + + \remarks Events are always related to the current audio block. For each process cycle, processEvents() is called + once before a processReplacing() call (if new events are available). + + \sa VstEvents, VstMidiEvent +*/ + +//----------------------------------------------------------------------------------------------------------------- +// Parameters Functions +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::canParameterBeAutomated (VstInt32 index) + + Obviously only useful when the application supports this. + + \param index Index of the parameter + \return \true if supported +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::string2parameter (VstInt32 index, char* text) + + Especially useful for plug-ins without user interface. The application can then implement a text edit field for + the user to set a parameter by entering text. + + \param index Index of the parameter + \param text A textual description of the parameter's value. A NULL pointer is used to check the capability + (return true). + \return \e true on success + + \note Implies setParameter (). text==0 is to be expected to check the capability (returns true) +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getProgramNameIndexed (VstInt32 category, VstInt32 index, char* text) + + Allows a Host application to list the plug-in's programs (presets). + + \param category unused in VST 2.4 + \param index Index of the program in a given category, starting with 0. + \param text A string up to 24 chars. + \return \e true on success +*/ +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (getNumAutomatableParameters) () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetNumAutomatableParameters), 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (getParameterQuantization) () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetParameterQuantization), 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +// Configuration/Settings Functions +//----------------------------------------------------------------------------------------------------------------- + +//----------------------------------------------------------------------------------------------------------------- +/*! + The Host could call a suspend() (if the plug-in was enabled (in resume() state)) and then ask for + getSpeakerArrangement() and/or check the \e numInputs and \e numOutputs and \e initialDelay and then call a + resume(). + + \return \e true on success + + \sa setSpeakerArrangement(), getSpeakerArrangement() +*/ +bool AudioEffectX::ioChanged () +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterIOChanged, 0, 0, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::DECLARE_VST_DEPRECATED (needIdle) () +{ + if (audioMaster) + return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterNeedIdle), 0, 0, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param width The window's width in pixel + \param height The window's height in pixel + \return \e true on success +*/ +bool AudioEffectX::sizeWindow (VstInt32 width, VstInt32 height) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterSizeWindow, width, height, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +double AudioEffectX::updateSampleRate () +/*! + \return The Host's sample rate +*/ +{ + if (audioMaster) + { + VstIntPtr res = audioMaster (&cEffect, audioMasterGetSampleRate, 0, 0, 0, 0); + if (res > 0) + sampleRate = (float)res; + } + return sampleRate; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::updateBlockSize () +/*! + \return The Host's block size + + \note Will cause application to call AudioEffect's setSampleRate() to be called (when implemented). +*/ +{ + if (audioMaster) + { + VstInt32 res = (VstInt32)audioMaster (&cEffect, audioMasterGetBlockSize, 0, 0, 0, 0); + if (res > 0) + blockSize = res; + } + return blockSize; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return ASIO input latency + \sa getOutputLatency() +*/ +VstInt32 AudioEffectX::getInputLatency () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetInputLatency, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + While inputLatency is probably not of concern, outputLatency may be used in conjunction with getTimeInfo(). + \e samplePos of VstTimeInfo is ahead of the 'visual' sequencer play time by the output latency, such that + when outputLatency samples have passed by, our processing result becomes audible. + + \return ASIO output latency + \sa getInputLatency() +*/ +VstInt32 AudioEffectX::getOutputLatency () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetOutputLatency, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getInputProperties (VstInt32 index, VstPinProperties* properties) + + \param index The index to the input, starting with 0 + \param properties A pointer to a VstPinProperties structure + \return \e true on success + \sa getOutputProperties() + \note Example + 
+	bool MyPlug::getInputProperties (VstInt32 index, VstPinProperties* properties)
+	{
+		bool returnCode = false;
+		if (index < kNumInputs)
+		{
+			sprintf (properties->label, "My %1d In", index + 1);
+			properties->flags = kVstPinIsStereo | kVstPinIsActive;
+			returnCode = true;
+		}
+		return returnCode;
+	}
+
+*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getOutputProperties (VstInt32 index, VstPinProperties* properties) + + \param index The index to the output, starting with 0 + \param properties A pointer to a VstPinProperties structure + \return \e true on success + \sa getInputProperties() + \note Example 1 + 
+	bool MyPlug::getOutputProperties (VstInt32 index, VstPinProperties* properties)
+	{
+		bool returnCode = false;
+		if (index < kNumOutputs)
+		{
+			sprintf (properties->label, "My %1d Out", index + 1);
+			properties->flags = kVstPinIsStereo | kVstPinIsActive;
+			returnCode = true;
+		}
+		return (returnCode);
+	}
+
+ + \note Example 2 : plug-in with 1 mono, 1 stereo and one 5.1 outputs (kNumOutputs = 9): + 
+	bool MyPlug::getOutputProperties (VstInt32 index, VstPinProperties* properties)
+	{
+		bool returnCode = false;
+		if (index >= 0 && index < kNumOutputs)
+		{
+			properties->flags = kVstPinIsActive;
+			if (index == 0) // mono
+			{
+				strcpy (properties->label, "Mono Out");
+				properties->arrangementType = kSpeakerArrMono;
+			}
+			else if (index == 1) // stereo (1 -> 2)
+			{
+				strcpy (properties->label, "Stereo Out");
+				properties->flags |= kVstPinIsStereo;
+				properties->arrangementType = kSpeakerArrStereo;
+			}
+			else if (index >= 3) // 5.1 (3 -> 8)
+			{
+				strcpy (properties->label, "5.1 Out");
+				properties->flags |= kVstPinUseSpeaker;
+				properties->arrangementType = kSpeakerArr51;
+				// for old VST Host < 2.3, make 5.1 to stereo/mono/mono/stereo (L R C Lfe Ls Rs)
+				if (index == 3 || index == 7)
+					properties->flags |= kVstPinIsStereo;
+				if (index == 5)
+					strcpy (properties->label, "Center");	
+				else if (index == 6)
+					strcpy (properties->label, "Lfe");	
+				else if (index == 7) // (7 -> 8)
+					strcpy (properties->label, "Stereo Back");
+			}
+			returnCode = true;
+		}
+		return returnCode;
+	}
+
+*/ + +//----------------------------------------------------------------------------------------------------------------- +AEffect* AudioEffectX::DECLARE_VST_DEPRECATED (getPreviousPlug) (VstInt32 input) +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetPreviousPlug), 0, 0, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +AEffect* AudioEffectX::DECLARE_VST_DEPRECATED (getNextPlug) (VstInt32 output) +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetNextPlug), 0, 0, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return Plug-in's category defined in VstPlugCategory +*/ +VstPlugCategory AudioEffectX::getPlugCategory () +{ + if (cEffect.flags & effFlagsIsSynth) + return kPlugCategSynth; + return kPlugCategUnknown; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (willProcessReplacing) () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterWillReplaceOrAccumulate), 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + A plug-in is like a black box processing some audio coming in on some inputs (if any) and going out of some + outputs (if any). This may be used to do offline or real-time processing, and sometimes it may be desirable to + know the current context. + + \return #VstProcessLevels in aeffectx.h + +*/ +VstInt32 AudioEffectX::getCurrentProcessLevel () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetCurrentProcessLevel, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return #VstAutomationStates in aeffectx.h +*/ +VstInt32 AudioEffectX::getAutomationState () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetAutomationState, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +void AudioEffectX::DECLARE_VST_DEPRECATED (wantAsyncOperation) (bool state) +{ + if (state) + cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsExtIsAsync); + else + cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsExtIsAsync); +} + +//----------------------------------------------------------------------------------------------------------------- +void AudioEffectX::DECLARE_VST_DEPRECATED (hasExternalBuffer) (bool state) +{ + if (state) + cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsExtHasBuffer); + else + cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsExtHasBuffer); +} + +//----------------------------------------------------------------------------------------------------------------- +// Offline Functions +//----------------------------------------------------------------------------------------------------------------- + +//----------------------------------------------------------------------------------------------------------------- +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::offlineRead (VstOfflineTask* offline, VstOfflineOption option, bool readSource) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineRead, readSource, option, offline, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::offlineWrite (VstOfflineTask* offline, VstOfflineOption option) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineWrite, 0, option, offline, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::offlineStart (VstAudioFile* audioFiles, VstInt32 numAudioFiles, VstInt32 numNewAudioFiles) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineStart, numNewAudioFiles, numAudioFiles, audioFiles, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::offlineGetCurrentPass () +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineGetCurrentPass, 0, 0, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +VstInt32 AudioEffectX::offlineGetCurrentMetaPass () +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterOfflineGetCurrentMetaPass, 0, 0, 0, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +// Other +//----------------------------------------------------------------------------------------------------------------- + +//----------------------------------------------------------------------------------------------------------------- +void AudioEffectX::DECLARE_VST_DEPRECATED (setOutputSamplerate) (float sampleRate) +{ + if (audioMaster) + audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterSetOutputSampleRate), 0, 0, 0, sampleRate); +} + +//----------------------------------------------------------------------------------------------------------------- +VstSpeakerArrangement* AudioEffectX::DECLARE_VST_DEPRECATED (getInputSpeakerArrangement) () +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetInputSpeakerArrangement), 0, 0, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +VstSpeakerArrangement* AudioEffectX::DECLARE_VST_DEPRECATED (getOutputSpeakerArrangement) () +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetOutputSpeakerArrangement), 0, 0, 0, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param text String of maximum 64 char + \return \e true if supported +*/ +bool AudioEffectX::getHostVendorString (char* text) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterGetVendorString, 0, 0, text, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param text String of maximum 64 char + \return \e true if supported +*/ +bool AudioEffectX::getHostProductString (char* text) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterGetProductString, 0, 0, text, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return Host vendor version +*/ +VstInt32 AudioEffectX::getHostVendorVersion () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetVendorVersion, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +VstIntPtr AudioEffectX::hostVendorSpecific (VstInt32 lArg1, VstIntPtr lArg2, void* ptrArg, float floatArg) +{ + if (audioMaster) + return audioMaster (&cEffect, audioMasterVendorSpecific, lArg1, lArg2, ptrArg, floatArg); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + Asks Host if it implements the feature text. A plug-in cannot assume a 2.x feature is available from the Host. + Use this method to ascertain the environment in which the plug-in finds itself. Ignoring this inquiry methods and + trying to access a 2.x feature in a 1.0 Host will mean your plug-in or Host application will break. It is not + the end-users job to pick and choose which plug-ins can be supported by which Host. + + \param text A string from #hostCanDos + \return + - 0 : don't know (default) + - 1 : yes + - -1: no +*/ +VstInt32 AudioEffectX::canHostDo (char* text) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterCanDo, 0, 0, text, 0) != 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + Tells the Host that the plug-in is an instrument, i.e. that it will call wantEvents(). + + \param state + - true: is an instrument (default) + - false: is a simple audio effect +*/ +void AudioEffectX::isSynth (bool state) +{ + if (state) + cEffect.flags |= effFlagsIsSynth; + else + cEffect.flags &= ~effFlagsIsSynth; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + Enables Host to omit processReplacing() when no data is present on any input. +*/ +void AudioEffectX::noTail (bool state) +{ + if (state) + cEffect.flags |= effFlagsNoSoundInStop; + else + cEffect.flags &= ~effFlagsNoSoundInStop; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return #VstHostLanguage in aeffectx.h +*/ +VstInt32 AudioEffectX::getHostLanguage () +{ + if (audioMaster) + return (VstInt32)audioMaster (&cEffect, audioMasterGetLanguage, 0, 0, 0, 0); + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +void* AudioEffectX::DECLARE_VST_DEPRECATED (openWindow) (DECLARE_VST_DEPRECATED (VstWindow)* window) +{ + if (audioMaster) + { + VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterOpenWindow), 0, 0, window, 0); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +bool AudioEffectX::DECLARE_VST_DEPRECATED (closeWindow) (DECLARE_VST_DEPRECATED (VstWindow)* window) +{ + if (audioMaster) + return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterCloseWindow), 0, 0, window, 0) != 0); + return false; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return FSSpec on MAC, else char* +*/ +void* AudioEffectX::getDirectory () +{ + if (audioMaster) + { + VstIntPtr ret = (audioMaster (&cEffect, audioMasterGetDirectory, 0, 0, 0, 0)); + return FromVstPtr (ret); + } + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \return \e true if supported +*/ +bool AudioEffectX::updateDisplay () +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterUpdateDisplay, 0, 0, 0, 0)) ? true : false; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::processVariableIo (VstVariableIo* varIo) + + If called with \e varIo NULL, returning \e true indicates that this call is supported by the plug-in. + Host will use processReplacing otherwise. The Host should call setTotalSampleToProcess before starting the processIO + to inform the plug-in about how many samples will be processed in total. The Host should provide an output buffer at least 5 times bigger than input buffer. + + \param varIo + \return \true on success +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::setSpeakerArrangement (VstSpeakerArrangement* pluginInput, VstSpeakerArrangement* pluginOutput) + + Set the plug-in's speaker arrangements. If a (VST >= 2.3) plug-in returns \e true, it means that it accepts this IO + arrangement. The Host doesn't need to ask for getSpeakerArrangement(). If the plug-in returns \e false it means that it + doesn't accept this arrangement, the Host should then ask for getSpeakerArrangement() and then can (optional) + recall setSpeakerArrangement(). + + \param pluginInput A pointer to the input's #VstSpeakerArrangement structure. + \param pluginOutput A pointer to the output's #VstSpeakerArrangement structure. + \return \e true on success + + \note setSpeakerArrangement() and getSpeakerArrangement() are always called in suspended state. + (like setSampleRate() or setBlockSize()). + + \sa getSpeakerArrangement() +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getSpeakerArrangement (VstSpeakerArrangement** pluginInput, VstSpeakerArrangement** pluginOutput) + + \param pluginInput A pointer to the input's #VstSpeakerArrangement structure. + \param pluginOutput A pointer to the output's #VstSpeakerArrangement structure. + \return \e true on success + + \note setSpeakerArrangement() and getSpeakerArrangement() are always called in suspended state. + (like setSampleRate() or setBlockSize()).\n + 
Here an example code to show how the host uses getSpeakerArrangement()
+	VstSpeakerArrangement *plugInputVstArr = 0;
+	VstSpeakerArrangement *plugOutputVstArr = 0;
+	if (getFormatVersion () >= 2300 && #getSpeakerArrangement (&plugInputVstArr, &plugOutputVstArr))
+		....
+
+ + \sa setSpeakerArrangement() +*/ +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::setBypass (bool onOff) + + process still called (if Supported) although the plug-in was bypassed. Some plugs need to stay 'alive' even + when bypassed. An example is a surround decoder which has more inputs than outputs and must maintain some + reasonable signal distribution even when being bypassed. A CanDo 'bypass' allows to ask the plug-in if it + supports soft bypass or not. + + \note This bypass feature could be automated by the Host (this means avoid to much CPU requirement in this call) + \note If the plug-in supports SoftBypass and it has a latency (initialDelay), in Bypassed state the plug-in has to used + the same latency value. + + \param onOff + \return + - true: supports SoftBypass, process will be called, the plug-in should compensate its latency, and copy inputs to outputs + - false: doesn't support SoftBypass, process will not be called, the Host should bypass the process call + + \sa processReplacing() +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getEffectName (char* name) + + \param name A string up to 32 chars + \return \e true on success +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getVendorString (char* text) + + \param text A string up to 64 chars + \return \e true on success +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getProductString (char* text) + + \param text A string up to 64 chars + \return \e true on success +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getVendorVersion () + + \return The version of the plug-in + + \note This should be upported +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::canDo (char* text) + + Report what the plug-in is able to do. In general you can but don't have to report whatever you support or not + support via canDo. Some application functionality may require some specific reply, but in that case you will + probably know. Best is to report whatever you know for sure. A Host application cannot make assumptions about + the presence of the new 2.x features of a plug-in. Ignoring this inquiry methods and trying to access a 2.x + feature from a 1.0 plug, or vice versa, will mean the plug-in or Host application will break. It is not the + end-users job to pick and choose which plug-ins can be supported by which Host. + + \param text A string from #plugCanDos + \return + - 0: don't know (default) + - 1: yes + - -1: no + + \note This should be supported. +*/ + +//---------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::canDo (char* text) + + \param text A string from #plugCanDos + \return + - 0: don't know (default). + - 1: yes. + - -1: no +*/ + +//---------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getParameterProperties (VstInt32 index, VstParameterProperties* p) + + \param index Index of the parameter + \param p Pointer to #VstParameterProperties + \return Return \e true on success +*/ + +//---------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getVstVersion () + \return + - 2xxx : the last VST 2.x plug-in version (by default) + - 0 : older versions + +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getMidiProgramName (VstInt32 channel, MidiProgramName* midiProgramName) + Ask plug-in if MidiPrograms are used and if so, query for names, numbers + (ProgramChange-Number + BankSelect-Number), categories and keynames of each + MIDI Program, on each MIDI-channel. If this function is called, your plug-in has to read + MidiProgramName::thisProgramIndex, fill out the other fields with the information + assigned to a certain MIDI Program and return the number of available MIDI Programs on + that MIDI Channel. + + \note plug-in canDo "midiProgramNames". No effect, if 0 is returned. + + \warning don't mix concepts: the MIDI Programs are totally independent from all other + programs present in VST. The main difference is, that there are upto 16 simultaneous + active MIDI Programs (one per channel), while there can be only one active "VST"-Program. + (You should see the "VST"-Program as the one single main global program, which contains + the entire current state of the plug-in.) This function can be called in any sequence. + + \param channel MidiChannel: 0-15 + \param midiProgramName Points to \e #MidiProgramName struct + \return Number of available MIDI Programs on that \e channel + - number of used programIndexes + - 0 if no MidiProgramNames supported + + \note Example : plug-in has 3 MidiPrograms on MidiChannel 0. + 
+	Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 0.
+	Plug fills out:
+	MidiProgramName::name[64] = "Program A"
+	MidiProgramName::midiProgram = 0
+	MidiProgramName::midiBankMsb = -1
+	MidiProgramName::midiBankLsb = -1
+	MidiProgramName::parentCategoryIndex = -1
+	MidiProgramName::flags = 0 (if plug isn't "Omni").
+	Plug returns 3.
+	Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 1.
+	Plug fills out:
+	MidiProgramName::name[64] = "Program B"
+	MidiProgramName::midiProgram = 1
+	MidiProgramName::midiBankMsb = -1
+	MidiProgramName::midiBankLsb = -1
+	MidiProgramName::parentCategoryIndex = -1
+	MidiProgramName::flags = 0 (if plug isn't "Omni").
+	Plug returns 3.
+	Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 2.
+	Plug fills out:
+	MidiProgramName::name[64] = "Program C"
+	MidiProgramName::midiProgram = 2
+	MidiProgramName::midiBankMsb = -1
+	MidiProgramName::midiBankLsb = -1
+	MidiProgramName::parentCategoryIndex = -1
+	MidiProgramName::flags = 0 (if plug isn't "Omni").
+	Plug returns 3.
+
+*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getCurrentMidiProgram (VstInt32 channel, MidiProgramName* currentProgram) + + \param channel + \param currentProgram + \return + - programIndex of the current program + - -1 if not supported +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getMidiProgramCategory (VstInt32 channel, MidiProgramCategory* category) + + \param channel + \param category + \return + - number of used categoryIndexes. + - 0 if no #MidiProgramCategory supported/used. +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::hasMidiProgramsChanged (VstInt32 channel) + + Ask plug-in for the currently active program on a certain MIDI Channel. Just like + getMidiProgramName(), but MidiProgramName::thisProgramIndex has to be filled out with + the currently active MIDI Program-index, which also has to be returned. + + \param channel + \return + - true: if the #MidiProgramNames, #MidiKeyNames or #MidiControllerNames had changed on + this channel +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::getMidiKeyName (VstInt32 channel, MidiKeyName* keyName) + + \param channel + \param keyName If keyName is "" the standard name of the key will be displayed + \return Return \e false if no #MidiKeyNames defined for 'thisProgramIndex' +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::beginSetProgram () + + \return + - true: the plug-in took the notification into account + - false: it did not... + + \sa endSetProgram() +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::endSetProgram () + + \return + - true: the plug-in took the notification into account + - false: it did not... + + \sa beginSetProgram() +*/ + +#if VST_2_1_EXTENSIONS +//----------------------------------------------------------------------------------------------------------------- +/*! + It tells the Host that if it needs to, it has to record automation data for this control. + + \param index Index of the parameter + \return Returns \e true on success + + \sa endEdit() +*/ +bool AudioEffectX::beginEdit (VstInt32 index) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterBeginEdit, index, 0, 0, 0)) ? true : false; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + It notifies the Host that this control is no longer moved by the mouse. + + \param index Index of the parameter + \return Returns \e true on success + + \sa beginEdit() +*/ +bool AudioEffectX::endEdit (VstInt32 index) +{ + if (audioMaster) + return (audioMaster (&cEffect, audioMasterEndEdit, index, 0, 0, 0)) ? true : false; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param ptr + \return Returns \e true on success + + \sa closeFileSelector() +*/ +bool AudioEffectX::openFileSelector (VstFileSelect* ptr) +{ + if (audioMaster && ptr) + return (audioMaster (&cEffect, audioMasterOpenFileSelector, 0, 0, ptr, 0)) ? true : false; + return 0; +} +#endif // VST_2_1_EXTENSIONS + +#if VST_2_2_EXTENSIONS +//----------------------------------------------------------------------------------------------------------------- +/*! + \param ptr + \return Returns \e true on success + + \sa openFileSelector() +*/ +bool AudioEffectX::closeFileSelector (VstFileSelect* ptr) +{ + if (audioMaster && ptr) + return (audioMaster (&cEffect, audioMasterCloseFileSelector, 0, 0, ptr, 0)) ? true : false; + return 0; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + It indicates how many samples will be processed. + + \param nativePath + \return Returns \e true on success + + \sa getChunk(), setChunk() +*/ +bool AudioEffectX::DECLARE_VST_DEPRECATED (getChunkFile) (void* nativePath) +{ + if (audioMaster && nativePath) + return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetChunkFile), 0, 0, nativePath, 0)) ? true : false; + return 0; +} +#endif // VST_2_2_EXTENSIONS + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::setTotalSampleToProcess (VstInt32 value) + + It indicates how many samples will be processed in total. + + \param value Number of samples to process +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getNextShellPlugin (char* name) { return 0; } + + \param name Points to a char buffer of size 64, which is to be filled with the name of the + plug-in including the terminating zero + \return Return the next plug-in's uniqueID + \note Example of Implementation +
+	//---From the Host side : if found plugin is a Shell category-----------
+	if (effect->getCategory () == kPlugCategShell)
+	{ 
+		// scan shell for subplugins
+		char tempName[64] = {0}; 
+		VstInt32 plugUniqueID = 0;
+		while ((plugUniqueID = effect->dispatchEffect (effShellGetNextPlugin, 0, 0, tempName)) != 0)
+		{ 
+			// subplug needs a name 
+			if (tempName[0] != 0)
+			{
+				...do what you want with this tempName and plugUniqueID
+			}
+		}
+	}
+	//---From the Host side : Intanciate a subplugin of a shell plugin---
+	// retreive the uniqueID of this subplugin the host wants to load
+	// set it to the host currentID
+	currentID = subplugInfo->uniqueID;
+	// call the its shell plugin (main function)
+	main ();
+	// the shell plugin will ask for the currentUniqueID
+	// and should return the chosen subplugin
+	...
+	//---From the plugin-Shell Side: for enumeration of subplugins---------
+	category = kPlugCategShell;
+	->can ask the host if "shellCategory" is supported
+	// at start (instanciation) reset the index for the getNextShellPlugin call.
+	myPluginShell::index = 0;
+	// implementation of getNextShellPlugin (char* name);
+	VstInt32 myPluginShell::getNextShellPlugin (char* name)
+	{
+		strcpy (name, MyNameTable[index]);
+		return MyUniqueIDTable[index++];
+	}
+	....
+	//---From the plugin-Shell Side: when instanciation-----
+	VstInt32 uniqueID = host->getCurrentUniqueID ();
+	if (uniqueID == 0) // the host instanciates the shell
+	{}
+	else // host try to instanciate one of my subplugin...identified by the uniqueID
+	{}
+
+*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::setPanLaw (VstInt32 type, float val) + + \param type + \param val + + \return Returns \e true on success + + \note Gain: for Linear : [1.0 => 0dB PanLaw], [~0.58 => -4.5dB], [0.5 => -6.02dB] +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::beginLoadBank (VstPatchChunkInfo* ptr) + + \param ptr + \return + - -1: if the Bank cannot be loaded, + - 1: if it can be loaded + - 0: else (for compatibility) + + \sa beginLoadProgram() + +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::beginLoadProgram (VstPatchChunkInfo* ptr) + + \param ptr + \return + - -1: if the Program cannot be loaded, + - 1: it can be loaded else, + - 0: else (for compatibility) + + \sa beginLoadBank() +*/ + +//----------------------------------------------------------------------------------------------------------------- +// Speaker Arrangement Helpers +//----------------------------------------------------------------------------------------------------------------- + +#if VST_2_3_EXTENSIONS +//----------------------------------------------------------------------------------------------------------------- +/*! + \param arrangement Pointer to a \e #VstSpeakerArrangement structure + \param nbChannels Number of Channels + \return Returns \e true on success + + \sa deallocateArrangement(), copySpeaker(), matchArrangement() +*/ +bool AudioEffectX::allocateArrangement (VstSpeakerArrangement** arrangement, VstInt32 nbChannels) +{ + if (*arrangement) + { + char *ptr = (char*)(*arrangement); + delete [] ptr; + } + + VstInt32 size = 2 * sizeof (VstInt32) + nbChannels * sizeof (VstSpeakerProperties); + char* ptr = new char[size]; + if (!ptr) + return false; + + memset (ptr, 0, size); + *arrangement = (VstSpeakerArrangement*)ptr; + (*arrangement)->numChannels = nbChannels; + return true; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \param arrangement Pointer to a \e #VstSpeakerArrangement structure + \return Returns \e true on success + + \sa allocateArrangement(), copySpeaker(), matchArrangement() +*/ +bool AudioEffectX::deallocateArrangement (VstSpeakerArrangement** arrangement) +{ + if (*arrangement) + { + char *ptr = (char*)(*arrangement); + delete [] ptr; + *arrangement = 0; + } + return true; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + Feed the \e to speaker properties with the same values than \e from 's ones. + It is assumed here that \e to exists yet, ie this function won't + allocate memory for the speaker (this will prevent from having + a difference between an Arrangement's number of channels and + its actual speakers...) + + \param to + \param from + \return Returns \e true on success + + \sa allocateArrangement(), deallocateArrangement(), matchArrangement() +*/ +bool AudioEffectX::copySpeaker (VstSpeakerProperties* to, VstSpeakerProperties* from) +{ + if ((from == NULL) || (to == NULL)) + return false; + + vst_strncpy (to->name, from->name, 63); + to->type = from->type; + to->azimuth = from->azimuth; + to->elevation = from->elevation; + to->radius = from->radius; + to->reserved = from->reserved; + memcpy (to->future, from->future, 28); + + return true; +} + +//----------------------------------------------------------------------------------------------------------------- +/*! + \e to is deleted, then created and initialized with the same values as \e from (must exist!). + It's notably useful when setSpeakerArrangement() is called by the Host. + + \param to + \param from + \return Returns \e true on success + + \sa allocateArrangement(), deallocateArrangement(), copySpeaker() +*/ + +bool AudioEffectX::matchArrangement (VstSpeakerArrangement** to, VstSpeakerArrangement* from) +{ + if (from == NULL) + return false; + + if ((!deallocateArrangement (to)) || (!allocateArrangement (to, from->numChannels))) + return false; + + (*to)->type = from->type; + for (VstInt32 i = 0; i < (*to)->numChannels; i++) + { + if (!copySpeaker (&((*to)->speakers[i]), &(from->speakers[i]))) + return false; + } + + return true; +} +#endif // VST_2_3_EXTENSIONS + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn bool AudioEffectX::setProcessPrecision (VstInt32 precision) + + Is called in suspended state, similar to #setBlockSize. Default (if not called) is single precision float. + + \param precision kVstProcessPrecision32 or kVstProcessPrecision64 + \return Returns \e true on success + \sa VstProcessPrecision +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getNumMidiInputChannels () + + Called by the host application to determine how many MIDI input channels are actually used by a plugin + e.g. to hide unused channels from the user. + For compatibility with VST 2.3 and below, the default return value 0 means 'not implemented' - + in this case the host assumes 16 MIDI channels to be present (or none at all). + + \return Number of MIDI input channels: 1-15, otherwise: 16 or no MIDI channels at all (0) + + \note The VST 2.x protocol is limited to a maximum of 16 MIDI channels as defined by the MIDI Standard. This might change in future revisions of the API. + + \sa + getNumMidiOutputChannels() @n + PlugCanDos::canDoReceiveVstMidiEvent +*/ + +//----------------------------------------------------------------------------------------------------------------- +/*! + \fn VstInt32 AudioEffectX::getNumMidiOutputChannels () + + Called by the host application to determine how many MIDI output channels are actually used by a plugin + e.g. to hide unused channels from the user. + For compatibility with VST 2.3 and below, the default return value 0 means 'not implemented' - + in this case the host assumes 16 MIDI channels to be present (or none at all). + + \return Number of MIDI output channels: 1-15, otherwise: 16 or no MIDI channels at all (0) + + \note The VST 2.x protocol is limited to a maximum of 16 MIDI channels as defined by the MIDI Standard. This might change in future revisions of the API. + + \sa + getNumMidiInputChannels() @n + PlugCanDos::canDoSendVstMidiEvent +*/ diff --git a/plugins/WinVST/Wider/vst2.x/audioeffectx.h b/plugins/WinVST/Wider/vst2.x/audioeffectx.h new file mode 100755 index 0000000..c04a6a0 --- /dev/null +++ b/plugins/WinVST/Wider/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/Wider/vst2.x/vstplugmain.cpp b/plugins/WinVST/Wider/vst2.x/vstplugmain.cpp new file mode 100755 index 0000000..7e1ae71 --- /dev/null +++ b/plugins/WinVST/Wider/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 +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/Wider/vstplug.def b/plugins/WinVST/Wider/vstplug.def new file mode 100755 index 0000000..5bf499a --- /dev/null +++ b/plugins/WinVST/Wider/vstplug.def @@ -0,0 +1,3 @@ +EXPORTS + VSTPluginMain + main=VSTPluginMain \ No newline at end of file -- cgit v1.2.3