mirror of
https://github.com/airwindows/airwindows.git
synced 2026-05-21 06:46:21 -06:00
UnBox, and build folder cleanups
Note that I am compelled to break VST builds on Windows because my build folders have had some files in 'em: you'll have to find those yourself. Here's hoping anyone trying to develop for Windows VST (or any VST) is able to find what they need, but I cannot help you set up a build environment, I can only give you my code for the audio part.
This commit is contained in:
Chris Johnson
parent
3dd30d920a
commit
9ecd9a8c01
369 changed files with 12170 additions and 151580 deletions
|
|
@ -1,61 +0,0 @@
|
|||
//-------------------------------------------------------------------------------------------------------
|
||||
// VST Plug-Ins SDK
|
||||
// Version 2.4 $Date: 2006/01/12 09:05:31 $
|
||||
//
|
||||
// Category : VST 2.x Classes
|
||||
// Filename : aeffeditor.h
|
||||
// Created by : Steinberg Media Technologies
|
||||
// Description : Editor Class for VST Plug-Ins
|
||||
//
|
||||
// © 2006, Steinberg Media Technologies, All Rights Reserved
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
|
||||
#ifndef __aeffeditor__
|
||||
#define __aeffeditor__
|
||||
|
||||
#include "audioeffectx.h"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/** VST Effect Editor class. */
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
class AEffEditor
|
||||
{
|
||||
public:
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
AEffEditor (AudioEffect* effect = 0) ///< Editor class constructor. Requires pointer to associated effect instance.
|
||||
: effect (effect)
|
||||
, systemWindow (0)
|
||||
{}
|
||||
|
||||
virtual ~AEffEditor () ///< Editor class destructor.
|
||||
{}
|
||||
|
||||
virtual AudioEffect* getEffect () { return effect; } ///< Returns associated effect instance
|
||||
virtual bool getRect (ERect** rect) { *rect = 0; return false; } ///< Query editor size as #ERect
|
||||
virtual bool open (void* ptr) { systemWindow = ptr; return 0; } ///< Open editor, pointer to parent windows is platform-dependent (HWND on Windows, WindowRef on Mac).
|
||||
virtual void close () { systemWindow = 0; } ///< Close editor (detach from parent window)
|
||||
virtual bool isOpen () { return systemWindow != 0; } ///< Returns true if editor is currently open
|
||||
virtual void idle () {} ///< Idle call supplied by Host application
|
||||
|
||||
#if TARGET_API_MAC_CARBON
|
||||
virtual void DECLARE_VST_DEPRECATED (draw) (ERect* rect) {}
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (mouse) (VstInt32 x, VstInt32 y) { return 0; }
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (key) (VstInt32 keyCode) { return 0; }
|
||||
virtual void DECLARE_VST_DEPRECATED (top) () {}
|
||||
virtual void DECLARE_VST_DEPRECATED (sleep) () {}
|
||||
#endif
|
||||
|
||||
#if VST_2_1_EXTENSIONS
|
||||
virtual bool onKeyDown (VstKeyCode& keyCode) { return false; } ///< Receive key down event. Return true only if key was really used!
|
||||
virtual bool onKeyUp (VstKeyCode& keyCode) { return false; } ///< Receive key up event. Return true only if key was really used!
|
||||
virtual bool onWheel (float distance) { return false; } ///< Handle mouse wheel event, distance is positive or negative to indicate wheel direction.
|
||||
virtual bool setKnobMode (VstInt32 val) { return false; } ///< Set knob mode (if supported by Host). See CKnobMode in VSTGUI.
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
protected:
|
||||
AudioEffect* effect; ///< associated effect instance
|
||||
void* systemWindow; ///< platform-dependent parent window (HWND or WindowRef)
|
||||
};
|
||||
|
||||
#endif // __aeffeditor__
|
||||
|
|
@ -1,703 +0,0 @@
|
|||
//-------------------------------------------------------------------------------------------------------
|
||||
// VST Plug-Ins SDK
|
||||
// Version 2.4 $Date: 2006/06/07 08:22:01 $
|
||||
//
|
||||
// Category : VST 2.x Classes
|
||||
// Filename : audioeffect.cpp
|
||||
// Created by : Steinberg Media Technologies
|
||||
// Description : Class AudioEffect (VST 1.0)
|
||||
//
|
||||
// © 2006, Steinberg Media Technologies, All Rights Reserved
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
|
||||
#include "audioeffect.h"
|
||||
#include "aeffeditor.h"
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
VstIntPtr AudioEffect::dispatchEffectClass (AEffect* e, VstInt32 opCode, VstInt32 index, VstIntPtr value, void* ptr, float opt)
|
||||
{
|
||||
AudioEffect* ae = (AudioEffect*)(e->object);
|
||||
|
||||
if (opCode == effClose)
|
||||
{
|
||||
ae->dispatcher (opCode, index, value, ptr, opt);
|
||||
delete ae;
|
||||
return 1;
|
||||
}
|
||||
|
||||
return ae->dispatcher (opCode, index, value, ptr, opt);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
float AudioEffect::getParameterClass (AEffect* e, VstInt32 index)
|
||||
{
|
||||
AudioEffect* ae = (AudioEffect*)(e->object);
|
||||
return ae->getParameter (index);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::setParameterClass (AEffect* e, VstInt32 index, float value)
|
||||
{
|
||||
AudioEffect* ae = (AudioEffect*)(e->object);
|
||||
ae->setParameter (index, value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::DECLARE_VST_DEPRECATED (processClass) (AEffect* e, float** inputs, float** outputs, VstInt32 sampleFrames)
|
||||
{
|
||||
AudioEffect* ae = (AudioEffect*)(e->object);
|
||||
ae->DECLARE_VST_DEPRECATED (process) (inputs, outputs, sampleFrames);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::processClassReplacing (AEffect* e, float** inputs, float** outputs, VstInt32 sampleFrames)
|
||||
{
|
||||
AudioEffect* ae = (AudioEffect*)(e->object);
|
||||
ae->processReplacing (inputs, outputs, sampleFrames);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
#if VST_2_4_EXTENSIONS
|
||||
void AudioEffect::processClassDoubleReplacing (AEffect* e, double** inputs, double** outputs, VstInt32 sampleFrames)
|
||||
{
|
||||
AudioEffect* ae = (AudioEffect*)(e->object);
|
||||
ae->processDoubleReplacing (inputs, outputs, sampleFrames);
|
||||
}
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
// Class AudioEffect Implementation
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
The constructor of your class is passed a parameter of the type \e audioMasterCallback. The actual
|
||||
mechanism in which your class gets constructed is not important right now. Effectively your class is
|
||||
constructed by the hosting application, which passes an object of type \e audioMasterCallback that
|
||||
handles the interaction with the plug-in. You pass this on to the base class' constructor and then
|
||||
can forget about it.
|
||||
|
||||
\param audioMaster Passed by the Host and handles interaction
|
||||
\param numPrograms Pass the number of programs the plug-in provides
|
||||
\param numParams Pass the number of parameters the plug-in provides
|
||||
|
||||
\code
|
||||
MyPlug::MyPlug (audioMasterCallback audioMaster)
|
||||
: AudioEffectX (audioMaster, 1, 1) // 1 program, 1 parameter only
|
||||
{
|
||||
setNumInputs (2); // stereo in
|
||||
setNumOutputs (2); // stereo out
|
||||
setUniqueID ('MyPl'); // you must change this for other plug-ins!
|
||||
canProcessReplacing (); // supports replacing mode
|
||||
}
|
||||
\endcode
|
||||
|
||||
\sa setNumInputs, setNumOutputs, setUniqueID, canProcessReplacing
|
||||
*/
|
||||
AudioEffect::AudioEffect (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams)
|
||||
: audioMaster (audioMaster)
|
||||
, editor (0)
|
||||
, sampleRate (44100.f)
|
||||
, blockSize (1024)
|
||||
, numPrograms (numPrograms)
|
||||
, numParams (numParams)
|
||||
, curProgram (0)
|
||||
{
|
||||
memset (&cEffect, 0, sizeof (cEffect));
|
||||
|
||||
cEffect.magic = kEffectMagic;
|
||||
cEffect.dispatcher = dispatchEffectClass;
|
||||
cEffect.DECLARE_VST_DEPRECATED (process) = DECLARE_VST_DEPRECATED (processClass);
|
||||
cEffect.setParameter = setParameterClass;
|
||||
cEffect.getParameter = getParameterClass;
|
||||
cEffect.numPrograms = numPrograms;
|
||||
cEffect.numParams = numParams;
|
||||
cEffect.numInputs = 1; // mono input
|
||||
cEffect.numOutputs = 2; // stereo output
|
||||
cEffect.DECLARE_VST_DEPRECATED (ioRatio) = 1.f;
|
||||
cEffect.object = this;
|
||||
cEffect.uniqueID = CCONST ('N', 'o', 'E', 'f');
|
||||
cEffect.version = 1;
|
||||
cEffect.processReplacing = processClassReplacing;
|
||||
|
||||
#if VST_2_4_EXTENSIONS
|
||||
canProcessReplacing (); // mandatory in VST 2.4!
|
||||
cEffect.processDoubleReplacing = processClassDoubleReplacing;
|
||||
#endif
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
AudioEffect::~AudioEffect ()
|
||||
{
|
||||
if (editor)
|
||||
delete editor;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::setEditor (AEffEditor* editor)
|
||||
{
|
||||
this->editor = editor;
|
||||
if (editor)
|
||||
cEffect.flags |= effFlagsHasEditor;
|
||||
else
|
||||
cEffect.flags &= ~effFlagsHasEditor;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
VstIntPtr AudioEffect::dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt)
|
||||
{
|
||||
VstIntPtr v = 0;
|
||||
|
||||
switch (opcode)
|
||||
{
|
||||
case effOpen: open (); break;
|
||||
case effClose: close (); break;
|
||||
case effSetProgram: if (value < numPrograms) setProgram ((VstInt32)value); break;
|
||||
case effGetProgram: v = getProgram (); break;
|
||||
case effSetProgramName: setProgramName ((char*)ptr); break;
|
||||
case effGetProgramName: getProgramName ((char*)ptr); break;
|
||||
case effGetParamLabel: getParameterLabel (index, (char*)ptr); break;
|
||||
case effGetParamDisplay: getParameterDisplay (index, (char*)ptr); break;
|
||||
case effGetParamName: getParameterName (index, (char*)ptr); break;
|
||||
|
||||
case effSetSampleRate: setSampleRate (opt); break;
|
||||
case effSetBlockSize: setBlockSize ((VstInt32)value); break;
|
||||
case effMainsChanged: if (!value) suspend (); else resume (); break;
|
||||
#if !VST_FORCE_DEPRECATED
|
||||
case effGetVu: v = (VstIntPtr)(getVu () * 32767.); break;
|
||||
#endif
|
||||
|
||||
//---Editor------------
|
||||
case effEditGetRect: if (editor) v = editor->getRect ((ERect**)ptr) ? 1 : 0; break;
|
||||
case effEditOpen: if (editor) v = editor->open (ptr) ? 1 : 0; break;
|
||||
case effEditClose: if (editor) editor->close (); break;
|
||||
case effEditIdle: if (editor) editor->idle (); break;
|
||||
|
||||
#if (TARGET_API_MAC_CARBON && !VST_FORCE_DEPRECATED)
|
||||
case effEditDraw: if (editor) editor->draw ((ERect*)ptr); break;
|
||||
case effEditMouse: if (editor) v = editor->mouse (index, value); break;
|
||||
case effEditKey: if (editor) v = editor->key (value); break;
|
||||
case effEditTop: if (editor) editor->top (); break;
|
||||
case effEditSleep: if (editor) editor->sleep (); break;
|
||||
#endif
|
||||
|
||||
case DECLARE_VST_DEPRECATED (effIdentify): v = CCONST ('N', 'v', 'E', 'f'); break;
|
||||
|
||||
//---Persistence-------
|
||||
case effGetChunk: v = getChunk ((void**)ptr, index ? true : false); break;
|
||||
case effSetChunk: v = setChunk (ptr, (VstInt32)value, index ? true : false); break;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
Use to ask for the Host's version
|
||||
\return The Host's version
|
||||
*/
|
||||
VstInt32 AudioEffect::getMasterVersion ()
|
||||
{
|
||||
VstInt32 version = 1;
|
||||
if (audioMaster)
|
||||
{
|
||||
version = (VstInt32)audioMaster (&cEffect, audioMasterVersion, 0, 0, 0, 0);
|
||||
if (!version) // old
|
||||
version = 1;
|
||||
}
|
||||
return version;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\sa AudioEffectX::getNextShellPlugin
|
||||
*/
|
||||
VstInt32 AudioEffect::getCurrentUniqueId ()
|
||||
{
|
||||
VstInt32 id = 0;
|
||||
if (audioMaster)
|
||||
id = (VstInt32)audioMaster (&cEffect, audioMasterCurrentId, 0, 0, 0, 0);
|
||||
return id;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
Give idle time to Host application, e.g. if plug-in editor is doing mouse tracking in a modal loop.
|
||||
*/
|
||||
void AudioEffect::masterIdle ()
|
||||
{
|
||||
if (audioMaster)
|
||||
audioMaster (&cEffect, audioMasterIdle, 0, 0, 0, 0);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
bool AudioEffect::DECLARE_VST_DEPRECATED (isInputConnected) (VstInt32 input)
|
||||
{
|
||||
VstInt32 ret = 0;
|
||||
if (audioMaster)
|
||||
ret = (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterPinConnected), input, 0, 0, 0);
|
||||
return ret ? false : true; // return value is 0 for true
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
bool AudioEffect::DECLARE_VST_DEPRECATED (isOutputConnected) (VstInt32 output)
|
||||
{
|
||||
VstInt32 ret = 0;
|
||||
if (audioMaster)
|
||||
ret = (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterPinConnected), output, 1, 0, 0);
|
||||
return ret ? false : true; // return value is 0 for true
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param index parameter index
|
||||
\param float parameter value
|
||||
|
||||
\note An important thing to notice is that if the user changes a parameter in your editor, which is
|
||||
out of the Host's control if you are not using the default string based interface, you should
|
||||
call setParameterAutomated (). This ensures that the Host is notified of the parameter change, which
|
||||
allows it to record these changes for automation.
|
||||
|
||||
\sa setParameter
|
||||
*/
|
||||
void AudioEffect::setParameterAutomated (VstInt32 index, float value)
|
||||
{
|
||||
setParameter (index, value);
|
||||
if (audioMaster)
|
||||
audioMaster (&cEffect, audioMasterAutomate, index, 0, 0, value); // value is in opt
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
// Flags
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::DECLARE_VST_DEPRECATED (hasVu) (bool state)
|
||||
{
|
||||
if (state)
|
||||
cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsHasVu);
|
||||
else
|
||||
cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsHasVu);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::DECLARE_VST_DEPRECATED (hasClip) (bool state)
|
||||
{
|
||||
if (state)
|
||||
cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsHasClip);
|
||||
else
|
||||
cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsHasClip);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::DECLARE_VST_DEPRECATED (canMono) (bool state)
|
||||
{
|
||||
if (state)
|
||||
cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsCanMono);
|
||||
else
|
||||
cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsCanMono);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param state Set to \e true if supported
|
||||
|
||||
\note Needs to be called in the plug-in's constructor
|
||||
*/
|
||||
void AudioEffect::canProcessReplacing (bool state)
|
||||
{
|
||||
if (state)
|
||||
cEffect.flags |= effFlagsCanReplacing;
|
||||
else
|
||||
cEffect.flags &= ~effFlagsCanReplacing;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param state Set to \e true if supported
|
||||
|
||||
\note Needs to be called in the plug-in's constructor
|
||||
*/
|
||||
#if VST_2_4_EXTENSIONS
|
||||
void AudioEffect::canDoubleReplacing (bool state)
|
||||
{
|
||||
if (state)
|
||||
cEffect.flags |= effFlagsCanDoubleReplacing;
|
||||
else
|
||||
cEffect.flags &= ~effFlagsCanDoubleReplacing;
|
||||
}
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param state Set \e true if programs are chunks
|
||||
|
||||
\note Needs to be called in the plug-in's constructor
|
||||
*/
|
||||
void AudioEffect::programsAreChunks (bool state)
|
||||
{
|
||||
if (state)
|
||||
cEffect.flags |= effFlagsProgramChunks;
|
||||
else
|
||||
cEffect.flags &= ~effFlagsProgramChunks;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::DECLARE_VST_DEPRECATED (setRealtimeQualities) (VstInt32 qualities)
|
||||
{
|
||||
cEffect.DECLARE_VST_DEPRECATED (realQualities) = qualities;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
void AudioEffect::DECLARE_VST_DEPRECATED (setOfflineQualities) (VstInt32 qualities)
|
||||
{
|
||||
cEffect.DECLARE_VST_DEPRECATED (offQualities) = qualities;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
Use to report the Plug-in's latency (Group Delay)
|
||||
|
||||
\param delay Plug-ins delay in samples
|
||||
*/
|
||||
void AudioEffect::setInitialDelay (VstInt32 delay)
|
||||
{
|
||||
cEffect.initialDelay = delay;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
// Strings Conversion
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param value Value to convert
|
||||
\param text String up to length char
|
||||
\param maxLen Maximal length of the string
|
||||
*/
|
||||
void AudioEffect::dB2string (float value, char* text, VstInt32 maxLen)
|
||||
{
|
||||
if (value <= 0)
|
||||
vst_strncpy (text, "-oo", maxLen);
|
||||
else
|
||||
float2string ((float)(20. * log10 (value)), text, maxLen);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param samples Number of samples
|
||||
\param text String up to length char
|
||||
\param maxLen Maximal length of the string
|
||||
*/
|
||||
void AudioEffect::Hz2string (float samples, char* text, VstInt32 maxLen)
|
||||
{
|
||||
float sampleRate = getSampleRate ();
|
||||
if (!samples)
|
||||
float2string (0, text, maxLen);
|
||||
else
|
||||
float2string (sampleRate / samples, text, maxLen);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param samples Number of samples
|
||||
\param text String up to length char
|
||||
\param maxLen Maximal length of the string
|
||||
*/
|
||||
void AudioEffect::ms2string (float samples, char* text, VstInt32 maxLen)
|
||||
{
|
||||
float2string ((float)(samples * 1000. / getSampleRate ()), text, maxLen);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param value Value to convert
|
||||
\param text String up to length char
|
||||
\param maxLen Maximal length of the string
|
||||
*/
|
||||
void AudioEffect::float2string (float value, char* text, VstInt32 maxLen)
|
||||
{
|
||||
VstInt32 c = 0, neg = 0;
|
||||
char string[32];
|
||||
char* s;
|
||||
double v, integ, i10, mantissa, m10, ten = 10.;
|
||||
|
||||
v = (double)value;
|
||||
if (v < 0)
|
||||
{
|
||||
neg = 1;
|
||||
value = -value;
|
||||
v = -v;
|
||||
c++;
|
||||
if (v > 9999999.)
|
||||
{
|
||||
vst_strncpy (string, "Huge!", 31);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else if (v > 99999999.)
|
||||
{
|
||||
vst_strncpy (string, "Huge!", 31);
|
||||
return;
|
||||
}
|
||||
|
||||
s = string + 31;
|
||||
*s-- = 0;
|
||||
*s-- = '.';
|
||||
c++;
|
||||
|
||||
integ = floor (v);
|
||||
i10 = fmod (integ, ten);
|
||||
*s-- = (char)((VstInt32)i10 + '0');
|
||||
integ /= ten;
|
||||
c++;
|
||||
while (integ >= 1. && c < 8)
|
||||
{
|
||||
i10 = fmod (integ, ten);
|
||||
*s-- = (char)((VstInt32)i10 + '0');
|
||||
integ /= ten;
|
||||
c++;
|
||||
}
|
||||
if (neg)
|
||||
*s-- = '-';
|
||||
vst_strncpy (text, s + 1, maxLen);
|
||||
if (c >= 8)
|
||||
return;
|
||||
|
||||
s = string + 31;
|
||||
*s-- = 0;
|
||||
mantissa = fmod (v, 1.);
|
||||
mantissa *= pow (ten, (double)(8 - c));
|
||||
while (c < 8)
|
||||
{
|
||||
if (mantissa <= 0)
|
||||
*s-- = '0';
|
||||
else
|
||||
{
|
||||
m10 = fmod (mantissa, ten);
|
||||
*s-- = (char)((VstInt32)m10 + '0');
|
||||
mantissa /= 10.;
|
||||
}
|
||||
c++;
|
||||
}
|
||||
vst_strncat (text, s + 1, maxLen);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\param value Value to convert
|
||||
\param text String up to length char
|
||||
\param maxLen Maximal length of the string
|
||||
*/
|
||||
void AudioEffect::int2string (VstInt32 value, char* text, VstInt32 maxLen)
|
||||
{
|
||||
if (value >= 100000000)
|
||||
{
|
||||
vst_strncpy (text, "Huge!", maxLen);
|
||||
return;
|
||||
}
|
||||
|
||||
if (value < 0)
|
||||
{
|
||||
vst_strncpy (text, "-", maxLen);
|
||||
value = -value;
|
||||
}
|
||||
else
|
||||
vst_strncpy (text, "", maxLen);
|
||||
|
||||
bool state = false;
|
||||
for (VstInt32 div = 100000000; div >= 1; div /= 10)
|
||||
{
|
||||
VstInt32 digit = value / div;
|
||||
value -= digit * div;
|
||||
if (state || digit > 0)
|
||||
{
|
||||
char temp[2] = {'0' + (char)digit, '\0'};
|
||||
vst_strncat (text, temp, maxLen);
|
||||
state = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames)
|
||||
|
||||
This process method must be provided. It takes input data, applies its pocessing algorithm, and then puts the
|
||||
result to the output by overwriting the output buffer.
|
||||
|
||||
\param inputs An array of pointers to the data
|
||||
\param outputs An array of pointers to where the data can be written to
|
||||
\param sampleFrames Number of sample frames to process
|
||||
|
||||
\warning Never call any Mac OS 9 functions (or other functions which call into the OS) inside your
|
||||
audio process function! This will crash the system when your plug-in is run in MP (multiprocessor) mode.
|
||||
If you must call into the OS, you must use MPRemoteCall () (see Apples' documentation), or
|
||||
explicitly use functions which are documented by Apple to be MP safe. On Mac OS X read the system
|
||||
header files to be sure that you only call thread safe functions.
|
||||
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::setBlockSize (VstInt32 blockSize)
|
||||
|
||||
This is called by the Host, and tells the plug-in that the maximum block size passed to
|
||||
processReplacing() will be \e blockSize.
|
||||
|
||||
\param blockSize Maximum number of sample frames
|
||||
|
||||
\warning You <b>must</b> process <b>exactly</b> \e sampleFrames number of samples in inside processReplacing, not more!
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::setParameter (VstInt32 index, float value)
|
||||
|
||||
Parameters are the individual parameter settings the user can adjust. A VST Host can automate these
|
||||
parameters. Set parameter \e index to \e value.
|
||||
|
||||
\param index Index of the parameter to change
|
||||
\param value A float value between 0.0 and 1.0 inclusive
|
||||
|
||||
\note Parameter values, like all VST parameters, are declared as floats with an inclusive range of
|
||||
0.0 to 1.0. How data is presented to the user is merely in the user-interface handling. This is a
|
||||
convention, but still worth regarding. Maybe the VST-Host's automation system depends on this range.
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn float AudioEffect::getParameter (VstInt32 index)
|
||||
|
||||
Return the \e value of parameter \e index
|
||||
|
||||
\param index Index of the parameter
|
||||
\return A float value between 0.0 and 1.0 inclusive
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::getParameterLabel (VstInt32 index, char* label)
|
||||
|
||||
\param index Index of the parameter
|
||||
\param label A string up to 8 char
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::getParameterDisplay (VstInt32 index, char* text)
|
||||
|
||||
\param index Index of the parameter
|
||||
\param text A string up to 8 char
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn VstInt32 AudioEffect::getProgram ()
|
||||
|
||||
\return Index of the current program
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::setProgram (VstInt32 program)
|
||||
|
||||
\param Program of the current program
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::getParameterName (VstInt32 index, char* text)
|
||||
|
||||
\param index Index of the parameter
|
||||
\param text A string up to 8 char
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::setProgramName (char* name)
|
||||
|
||||
The program name is displayed in the rack, and can be edited by the user.
|
||||
|
||||
\param name A string up to 24 char
|
||||
|
||||
\warning Please be aware that the string lengths supported by the default VST interface are normally
|
||||
limited to 24 characters. If you copy too much data into the buffers provided, you will break the
|
||||
Host application.
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::getProgramName (char* name)
|
||||
|
||||
The program name is displayed in the rack, and can be edited by the user.
|
||||
|
||||
\param name A string up to 24 char
|
||||
|
||||
\warning Please be aware that the string lengths supported by the default VST interface are normally
|
||||
limited to 24 characters. If you copy too much data into the buffers provided, you will break the
|
||||
Host application.
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn VstInt32 AudioEffect::getChunk (void** data, bool isPreset)
|
||||
|
||||
\param data should point to the newly allocated memory block containg state data. You can savely release it in next suspend/resume call.
|
||||
\param isPreset true when saving a single program, false for all programs
|
||||
|
||||
\note
|
||||
If your plug-in is configured to use chunks (see AudioEffect::programsAreChunks), the Host
|
||||
will ask for a block of memory describing the current plug-in state for saving.
|
||||
To restore the state at a later stage, the same data is passed back to AudioEffect::setChunk.
|
||||
Alternatively, when not using chunk, the Host will simply save all parameter values.
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn VstInt32 AudioEffect::setChunk (void* data, VstInt32 byteSize, bool isPreset)
|
||||
|
||||
\param data pointer to state data (owned by Host)
|
||||
\param byteSize size of state data
|
||||
\param isPreset true when restoring a single program, false for all programs
|
||||
|
||||
\sa getChunk
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::setNumInputs (VstInt32 inputs)
|
||||
|
||||
This number is fixed at construction time and can't change until the plug-in is destroyed.
|
||||
|
||||
\param inputs The number of inputs
|
||||
|
||||
\sa isInputConnected()
|
||||
|
||||
\note Needs to be called in the plug-in's constructor
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::setNumOutputs (VstInt32 outputs)
|
||||
|
||||
This number is fixed at construction time and can't change until the plug-in is destroyed.
|
||||
|
||||
\param outputs The number of outputs
|
||||
|
||||
\sa isOutputConnected()
|
||||
|
||||
\note Needs to be called in the plug-in's constructor
|
||||
*/
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/*!
|
||||
\fn void AudioEffect::setUniqueID (VstInt32 iD)
|
||||
|
||||
Must call this! Set the plug-in's unique identifier. The Host uses this to identify the plug-in, for
|
||||
instance when it is loading effect programs and banks. On Steinberg Web Page you can find an UniqueID
|
||||
Database where you can record your UniqueID, it will check if the ID is already used by an another
|
||||
vendor. You can use CCONST('a','b','c','d') (defined in VST 2.0) to be platform independent to
|
||||
initialize an UniqueID.
|
||||
|
||||
\param iD Plug-in's unique ID
|
||||
|
||||
\note Needs to be called in the plug-in's constructor
|
||||
*/
|
||||
|
|
@ -1,177 +0,0 @@
|
|||
//-------------------------------------------------------------------------------------------------------
|
||||
// VST Plug-Ins SDK
|
||||
// Version 2.4 $Date: 2006/06/06 16:01:34 $
|
||||
//
|
||||
// Category : VST 2.x Classes
|
||||
// Filename : audioeffect.h
|
||||
// Created by : Steinberg Media Technologies
|
||||
// Description : Class AudioEffect (VST 1.0)
|
||||
//
|
||||
// © 2006, Steinberg Media Technologies, All Rights Reserved
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
|
||||
#ifndef __audioeffect__
|
||||
#define __audioeffect__
|
||||
|
||||
#include "pluginterfaces/vst2.x/aeffect.h" // "c" interface
|
||||
|
||||
class AEffEditor;
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/** VST Effect Base Class (VST 1.0). */
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
class AudioEffect
|
||||
{
|
||||
public:
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
AudioEffect (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams); ///< Create an \e AudioEffect object
|
||||
virtual ~AudioEffect (); ///< Destroy an \e AudioEffect object
|
||||
|
||||
virtual VstIntPtr dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt); ///< Opcodes dispatcher
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name State Transitions
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual void open () {} ///< Called when plug-in is initialized
|
||||
virtual void close () {} ///< Called when plug-in will be released
|
||||
virtual void suspend () {} ///< Called when plug-in is switched to off
|
||||
virtual void resume () {} ///< Called when plug-in is switched to on
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Processing
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual void setSampleRate (float sampleRate) { this->sampleRate = sampleRate; } ///< Called when the sample rate changes (always in a suspend state)
|
||||
virtual void setBlockSize (VstInt32 blockSize) { this->blockSize = blockSize; } ///< Called when the Maximun block size changes (always in a suspend state). Note that the sampleFrames in Process Calls could be smaller than this block size, but NOT bigger.
|
||||
|
||||
virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames) = 0; ///< Process 32 bit (single precision) floats (always in a resume state)
|
||||
|
||||
#if VST_2_4_EXTENSIONS
|
||||
virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames) {} ///< Process 64 bit (double precision) floats (always in a resume state) \sa processReplacing
|
||||
#endif // VST_2_4_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Parameters
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual void setParameter (VstInt32 index, float value) {} ///< Called when a parameter changed
|
||||
virtual float getParameter (VstInt32 index) { return 0; } ///< Return the value of the parameter with \e index
|
||||
virtual void setParameterAutomated (VstInt32 index, float value);///< Called after a control has changed in the editor and when the associated parameter should be automated
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Programs and Persistence
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual VstInt32 getProgram () { return curProgram; } ///< Return the index to the current program
|
||||
virtual void setProgram (VstInt32 program) { curProgram = program; } ///< Set the current program to \e program
|
||||
|
||||
virtual void setProgramName (char* name) {} ///< Stuff the name field of the current program with \e name. Limited to #kVstMaxProgNameLen.
|
||||
virtual void getProgramName (char* name) { *name = 0; } ///< Stuff \e name with the name of the current program. Limited to #kVstMaxProgNameLen.
|
||||
|
||||
virtual void getParameterLabel (VstInt32 index, char* label) { *label = 0; } ///< Stuff \e label with the units in which parameter \e index is displayed (i.e. "sec", "dB", "type", etc...). Limited to #kVstMaxParamStrLen.
|
||||
virtual void getParameterDisplay (VstInt32 index, char* text) { *text = 0; } ///< Stuff \e text with a string representation ("0.5", "-3", "PLATE", etc...) of the value of parameter \e index. Limited to #kVstMaxParamStrLen.
|
||||
virtual void getParameterName (VstInt32 index, char* text) { *text = 0; } ///< Stuff \e text with the name ("Time", "Gain", "RoomType", etc...) of parameter \e index. Limited to #kVstMaxParamStrLen.
|
||||
|
||||
virtual VstInt32 getChunk (void** data, bool isPreset = false) { return 0; } ///< Host stores plug-in state. Returns the size in bytes of the chunk (plug-in allocates the data array)
|
||||
virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset = false) { return 0; } ///< Host restores plug-in state
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Internal Setup
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual void setUniqueID (VstInt32 iD) { cEffect.uniqueID = iD; } ///< Must be called to set the plug-ins unique ID!
|
||||
virtual void setNumInputs (VstInt32 inputs) { cEffect.numInputs = inputs; } ///< Set the number of inputs the plug-in will handle. For a plug-in which could change its IO configuration, this number is the maximun available inputs.
|
||||
virtual void setNumOutputs (VstInt32 outputs) { cEffect.numOutputs = outputs; } ///< Set the number of outputs the plug-in will handle. For a plug-in which could change its IO configuration, this number is the maximun available ouputs.
|
||||
|
||||
virtual void canProcessReplacing (bool state = true); ///< Tells that processReplacing() could be used. Mandatory in VST 2.4!
|
||||
|
||||
#if VST_2_4_EXTENSIONS
|
||||
virtual void canDoubleReplacing (bool state = true); ///< Tells that processDoubleReplacing() is implemented.
|
||||
#endif // VST_2_4_EXTENSIONS
|
||||
|
||||
virtual void programsAreChunks (bool state = true); ///< Program data is handled in formatless chunks (using getChunk-setChunks)
|
||||
virtual void setInitialDelay (VstInt32 delay); ///< Use to report the plug-in's latency (Group Delay)
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Editor
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
void setEditor (AEffEditor* editor); ///< Should be called if you want to define your own editor
|
||||
virtual AEffEditor* getEditor () { return editor; } ///< Returns the attached editor
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Inquiry
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual AEffect* getAeffect () { return &cEffect; } ///< Returns the #AEffect structure
|
||||
virtual float getSampleRate () { return sampleRate; } ///< Returns the current sample rate
|
||||
virtual VstInt32 getBlockSize () { return blockSize; } ///< Returns the current Maximum block size
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Host Communication
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual VstInt32 getMasterVersion (); ///< Returns the Host's version (for example 2400 for VST 2.4)
|
||||
virtual VstInt32 getCurrentUniqueId (); ///< Returns current unique identifier when loading shell plug-ins
|
||||
virtual void masterIdle (); ///< Give idle time to Host application
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Tools (helpers)
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual void dB2string (float value, char* text, VstInt32 maxLen); ///< Stuffs \e text with an amplitude on the [0.0, 1.0] scale converted to its value in decibels.
|
||||
virtual void Hz2string (float samples, char* text, VstInt32 maxLen); ///< Stuffs \e text with the frequency in Hertz that has a period of \e samples.
|
||||
virtual void ms2string (float samples, char* text, VstInt32 maxLen); ///< Stuffs \e text with the duration in milliseconds of \e samples frames.
|
||||
virtual void float2string (float value, char* text, VstInt32 maxLen); ///< Stuffs \e text with a string representation on the floating point \e value.
|
||||
virtual void int2string (VstInt32 value, char* text, VstInt32 maxLen); ///< Stuffs \e text with a string representation on the integer \e value.
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
// Deprecated methods
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// @cond ignore
|
||||
virtual void DECLARE_VST_DEPRECATED (process) (float** inputs, float** outputs, VstInt32 sampleFrames) {}
|
||||
virtual float DECLARE_VST_DEPRECATED (getVu) () { return 0; }
|
||||
virtual void DECLARE_VST_DEPRECATED (hasVu) (bool state = true);
|
||||
virtual void DECLARE_VST_DEPRECATED (hasClip) (bool state = true);
|
||||
virtual void DECLARE_VST_DEPRECATED (canMono) (bool state = true);
|
||||
virtual void DECLARE_VST_DEPRECATED (setRealtimeQualities) (VstInt32 qualities);
|
||||
virtual void DECLARE_VST_DEPRECATED (setOfflineQualities) (VstInt32 qualities);
|
||||
virtual bool DECLARE_VST_DEPRECATED (isInputConnected) (VstInt32 input);
|
||||
virtual bool DECLARE_VST_DEPRECATED (isOutputConnected) (VstInt32 output);
|
||||
/// @endcond
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
protected:
|
||||
audioMasterCallback audioMaster; ///< Host callback
|
||||
AEffEditor* editor; ///< Pointer to the plug-in's editor
|
||||
float sampleRate; ///< Current sample rate
|
||||
VstInt32 blockSize; ///< Maximum block size
|
||||
VstInt32 numPrograms; ///< Number of programs
|
||||
VstInt32 numParams; ///< Number of parameters
|
||||
VstInt32 curProgram; ///< Current program
|
||||
AEffect cEffect; ///< #AEffect object
|
||||
|
||||
/// @cond ignore
|
||||
static VstIntPtr dispatchEffectClass (AEffect* e, VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt);
|
||||
static float getParameterClass (AEffect* e, VstInt32 index);
|
||||
static void setParameterClass (AEffect* e, VstInt32 index, float value);
|
||||
static void DECLARE_VST_DEPRECATED (processClass) (AEffect* e, float** inputs, float** outputs, VstInt32 sampleFrames);
|
||||
static void processClassReplacing (AEffect* e, float** inputs, float** outputs, VstInt32 sampleFrames);
|
||||
|
||||
#if VST_2_4_EXTENSIONS
|
||||
static void processClassDoubleReplacing (AEffect* e, double** inputs, double** outputs, VstInt32 sampleFrames);
|
||||
#endif // VST_2_4_EXTENSIONS
|
||||
/// @endcond
|
||||
};
|
||||
|
||||
#endif // __audioeffect__
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,252 +0,0 @@
|
|||
//-------------------------------------------------------------------------------------------------------
|
||||
// VST Plug-Ins SDK
|
||||
// Version 2.4 $Date: 2006/06/20 12:42:46 $
|
||||
//
|
||||
// Category : VST 2.x Classes
|
||||
// Filename : audioeffectx.h
|
||||
// Created by : Steinberg Media Technologies
|
||||
// Description : Class AudioEffectX extends AudioEffect with new features. You should derive
|
||||
// your plug-in from AudioEffectX.
|
||||
//
|
||||
// © 2006, Steinberg Media Technologies, All Rights Reserved
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
|
||||
#ifndef __audioeffectx__
|
||||
#define __audioeffectx__
|
||||
|
||||
#include "audioeffect.h" // Version 1.0 base class AudioEffect
|
||||
|
||||
#include "pluginterfaces/vst2.x/aeffectx.h" // Version 2.x 'C' Extensions and Structures
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/** Extended VST Effect Class (VST 2.x). */
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
class AudioEffectX : public AudioEffect
|
||||
{
|
||||
public:
|
||||
AudioEffectX (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams); ///< Create an \e AudioEffectX object
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Parameters
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual bool canParameterBeAutomated (VstInt32 index) { return true; } ///< Indicates if a parameter can be automated
|
||||
virtual bool string2parameter (VstInt32 index, char* text) { return false; } ///< Convert a string representation to a parameter value
|
||||
virtual bool getParameterProperties (VstInt32 index, VstParameterProperties* p) { return false; } ///< Return parameter properties
|
||||
|
||||
#if VST_2_1_EXTENSIONS
|
||||
virtual bool beginEdit (VstInt32 index); ///< To be called before #setParameterAutomated (on Mouse Down). This will be used by the Host for specific Automation Recording.
|
||||
virtual bool endEdit (VstInt32 index); ///< To be called after #setParameterAutomated (on Mouse Up)
|
||||
#endif // VST_2_1_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Programs and Persistence
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual bool getProgramNameIndexed (VstInt32 category, VstInt32 index, char* text) { return false; } ///< Fill \e text with name of program \e index (\e category deprecated in VST 2.4)
|
||||
|
||||
#if VST_2_1_EXTENSIONS
|
||||
virtual bool beginSetProgram () { return false; } ///< Called before a program is loaded
|
||||
virtual bool endSetProgram () { return false; } ///< Called after a program was loaded
|
||||
#endif // VST_2_1_EXTENSIONS
|
||||
|
||||
#if VST_2_3_EXTENSIONS
|
||||
virtual VstInt32 beginLoadBank (VstPatchChunkInfo* ptr) { return 0; } ///< Called before a Bank is loaded.
|
||||
virtual VstInt32 beginLoadProgram (VstPatchChunkInfo* ptr) { return 0; } ///< Called before a Program is loaded. (called before #beginSetProgram).
|
||||
#endif // VST_2_3_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Connections and Configuration
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual bool ioChanged (); ///< Tell Host numInputs and/or numOutputs and/or initialDelay (and/or numParameters: to be avoid) have changed
|
||||
|
||||
virtual double updateSampleRate (); ///< Returns sample rate from Host (may issue setSampleRate())
|
||||
virtual VstInt32 updateBlockSize (); ///< Returns block size from Host (may issue getBlockSize())
|
||||
virtual VstInt32 getInputLatency (); ///< Returns the Audio (maybe ASIO) input latency values
|
||||
virtual VstInt32 getOutputLatency (); ///< Returns the Audio (maybe ASIO) output latency values
|
||||
|
||||
virtual bool getInputProperties (VstInt32 index, VstPinProperties* properties) { return false; } ///< Return the \e properties of output \e index
|
||||
virtual bool getOutputProperties (VstInt32 index, VstPinProperties* properties) { return false; }///< Return the \e properties of input \e index
|
||||
|
||||
virtual bool setSpeakerArrangement (VstSpeakerArrangement* pluginInput, VstSpeakerArrangement* pluginOutput) { return false; } ///< Set the plug-in's speaker arrangements
|
||||
virtual bool getSpeakerArrangement (VstSpeakerArrangement** pluginInput, VstSpeakerArrangement** pluginOutput) { *pluginInput = 0; *pluginOutput = 0; return false; } ///< Return the plug-in's speaker arrangements
|
||||
virtual bool setBypass (bool onOff) { return false; } ///< For 'soft-bypass' (this could be automated (in Audio Thread) that why you could NOT call iochanged (if needed) in this function, do it in fxidle).
|
||||
|
||||
#if VST_2_3_EXTENSIONS
|
||||
virtual bool setPanLaw (VstInt32 type, float val) { return false; } ///< Set the Panning Law used by the Host @see VstPanLawType.
|
||||
#endif // VST_2_3_EXTENSIONS
|
||||
|
||||
#if VST_2_4_EXTENSIONS
|
||||
virtual bool setProcessPrecision (VstInt32 precision) { return false; } ///< Set floating-point precision used for processing (32 or 64 bit)
|
||||
|
||||
virtual VstInt32 getNumMidiInputChannels () { return 0; } ///< Returns number of MIDI input channels used [0, 16]
|
||||
virtual VstInt32 getNumMidiOutputChannels () { return 0; } ///< Returns number of MIDI output channels used [0, 16]
|
||||
#endif // VST_2_4_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Realtime
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual VstTimeInfo* getTimeInfo (VstInt32 filter); ///< Get time information from Host
|
||||
virtual VstInt32 getCurrentProcessLevel (); ///< Returns the Host's process level
|
||||
virtual VstInt32 getAutomationState (); ///< Returns the Host's automation state
|
||||
|
||||
virtual VstInt32 processEvents (VstEvents* events) { return 0; } ///< Called when new MIDI events come in
|
||||
bool sendVstEventsToHost (VstEvents* events); ///< Send MIDI events back to Host application
|
||||
|
||||
#if VST_2_3_EXTENSIONS
|
||||
virtual VstInt32 startProcess () { return 0; } ///< Called one time before the start of process call. This indicates that the process call will be interrupted (due to Host reconfiguration or bypass state when the plug-in doesn't support softBypass)
|
||||
virtual VstInt32 stopProcess () { return 0;} ///< Called after the stop of process call
|
||||
#endif // VST_2_3_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Variable I/O (Offline)
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual bool processVariableIo (VstVariableIo* varIo) { return false; } ///< Used for variable I/O processing (offline processing like timestreching)
|
||||
|
||||
#if VST_2_3_EXTENSIONS
|
||||
virtual VstInt32 setTotalSampleToProcess (VstInt32 value) { return value; } ///< Called in offline mode before process() or processVariableIo ()
|
||||
#endif // VST_2_3_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Host Properties
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual bool getHostVendorString (char* text); ///< Fills \e text with a string identifying the vendor
|
||||
virtual bool getHostProductString (char* text); ///< Fills \e text with a string with product name
|
||||
virtual VstInt32 getHostVendorVersion (); ///< Returns vendor-specific version (for example 3200 for Nuendo 3.2)
|
||||
virtual VstIntPtr hostVendorSpecific (VstInt32 lArg1, VstIntPtr lArg2, void* ptrArg, float floatArg); ///< No specific definition
|
||||
virtual VstInt32 canHostDo (char* text); ///< Reports what the Host is able to do (#hostCanDos in audioeffectx.cpp)
|
||||
virtual VstInt32 getHostLanguage (); ///< Returns the Host's language (#VstHostLanguage)
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Plug-in Properties
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual void isSynth (bool state = true); ///< Set if plug-in is a synth
|
||||
virtual void noTail (bool state = true); ///< Plug-in won't produce output signals while there is no input
|
||||
virtual VstInt32 getGetTailSize () { return 0; }///< Returns tail size; 0 is default (return 1 for 'no tail'), used in offline processing too
|
||||
virtual void* getDirectory (); ///< Returns the plug-in's directory
|
||||
virtual bool getEffectName (char* name) { return false; } ///< Fill \e text with a string identifying the effect
|
||||
virtual bool getVendorString (char* text) { return false; } ///< Fill \e text with a string identifying the vendor
|
||||
virtual bool getProductString (char* text) { return false; }///< Fill \e text with a string identifying the product name
|
||||
virtual VstInt32 getVendorVersion () { return 0; } ///< Return vendor-specific version
|
||||
virtual VstIntPtr vendorSpecific (VstInt32 lArg, VstIntPtr lArg2, void* ptrArg, float floatArg) { return 0; } ///< No definition, vendor specific handling
|
||||
virtual VstInt32 canDo (char* text) { return 0; } ///< Reports what the plug-in is able to do (#plugCanDos in audioeffectx.cpp)
|
||||
virtual VstInt32 getVstVersion () { return kVstVersion; } ///< Returns the current VST Version (#kVstVersion)
|
||||
virtual VstPlugCategory getPlugCategory (); ///< Specify a category that fits the plug (#VstPlugCategory)
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name MIDI Channel Programs
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
#if VST_2_1_EXTENSIONS
|
||||
virtual VstInt32 getMidiProgramName (VstInt32 channel, MidiProgramName* midiProgramName) { return 0; } ///< Fill \e midiProgramName with information for 'thisProgramIndex'.
|
||||
virtual VstInt32 getCurrentMidiProgram (VstInt32 channel, MidiProgramName* currentProgram) { return -1; } ///< Fill \e currentProgram with information for the current MIDI program.
|
||||
virtual VstInt32 getMidiProgramCategory (VstInt32 channel, MidiProgramCategory* category) { return 0; } ///< Fill \e category with information for 'thisCategoryIndex'.
|
||||
virtual bool hasMidiProgramsChanged (VstInt32 channel) { return false; } ///< Return true if the #MidiProgramNames, #MidiKeyNames or #MidiControllerNames had changed on this MIDI channel.
|
||||
virtual bool getMidiKeyName (VstInt32 channel, MidiKeyName* keyName) { return false; } ///< Fill \e keyName with information for 'thisProgramIndex' and 'thisKeyNumber'
|
||||
#endif // VST_2_1_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Others
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
virtual bool updateDisplay (); ///< Something has changed in plug-in, request an update display like program (MIDI too) and parameters list in Host
|
||||
virtual bool sizeWindow (VstInt32 width, VstInt32 height); ///< Requests to resize the editor window
|
||||
|
||||
#if VST_2_1_EXTENSIONS
|
||||
virtual bool openFileSelector (VstFileSelect* ptr); ///< Open a Host File selector (see aeffectx.h for #VstFileSelect definition)
|
||||
#endif // VST_2_1_EXTENSIONS
|
||||
|
||||
#if VST_2_2_EXTENSIONS
|
||||
virtual bool closeFileSelector (VstFileSelect* ptr); ///< Close the Host File selector which was opened by #openFileSelector
|
||||
#endif // VST_2_2_EXTENSIONS
|
||||
|
||||
#if VST_2_3_EXTENSIONS
|
||||
virtual VstInt32 getNextShellPlugin (char* name) { return 0; } ///< This opcode is only called, if the plug-in is of type #kPlugCategShell, in order to extract all included sub-plugin´s names.
|
||||
#endif // VST_2_3_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// \name Tools
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
//@{
|
||||
#if VST_2_3_EXTENSIONS
|
||||
virtual bool allocateArrangement (VstSpeakerArrangement** arrangement, VstInt32 nbChannels);///< Allocate memory for a #VstSpeakerArrangement
|
||||
virtual bool deallocateArrangement (VstSpeakerArrangement** arrangement); ///< Delete/free memory for an allocated speaker arrangement
|
||||
virtual bool copySpeaker (VstSpeakerProperties* to, VstSpeakerProperties* from); ///< Copy properties \e from to \e to
|
||||
virtual bool matchArrangement (VstSpeakerArrangement** to, VstSpeakerArrangement* from); ///< "to" is deleted, then created and initialized with the same values as "from" ones ("from" must exist).
|
||||
#endif // VST_2_3_EXTENSIONS
|
||||
//@}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
// Offline
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
/// @cond ignore
|
||||
virtual bool offlineRead (VstOfflineTask* offline, VstOfflineOption option, bool readSource = true);
|
||||
virtual bool offlineWrite (VstOfflineTask* offline, VstOfflineOption option);
|
||||
virtual bool offlineStart (VstAudioFile* ptr, VstInt32 numAudioFiles, VstInt32 numNewAudioFiles);
|
||||
virtual VstInt32 offlineGetCurrentPass ();
|
||||
virtual VstInt32 offlineGetCurrentMetaPass ();
|
||||
virtual bool offlineNotify (VstAudioFile* ptr, VstInt32 numAudioFiles, bool start) { return false; }
|
||||
virtual bool offlinePrepare (VstOfflineTask* offline, VstInt32 count) { return false; }
|
||||
virtual bool offlineRun (VstOfflineTask* offline, VstInt32 count) { return false; }
|
||||
virtual VstInt32 offlineGetNumPasses () { return 0; }
|
||||
virtual VstInt32 offlineGetNumMetaPasses () { return 0; }
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
// AudioEffect overrides
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
virtual VstIntPtr dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt);
|
||||
virtual void resume ();
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
// Deprecated methods
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
virtual void DECLARE_VST_DEPRECATED (wantEvents) (VstInt32 filter = 1);
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (tempoAt) (VstInt32 pos);
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (getNumAutomatableParameters) ();
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (getParameterQuantization) ();
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (getNumCategories) () { return 1L; }
|
||||
virtual bool DECLARE_VST_DEPRECATED (copyProgram) (VstInt32 destination) { return false; }
|
||||
virtual bool DECLARE_VST_DEPRECATED (needIdle) ();
|
||||
virtual AEffect* DECLARE_VST_DEPRECATED (getPreviousPlug) (VstInt32 input);
|
||||
virtual AEffect* DECLARE_VST_DEPRECATED (getNextPlug) (VstInt32 output);
|
||||
virtual void DECLARE_VST_DEPRECATED (inputConnected) (VstInt32 index, bool state) {}
|
||||
virtual void DECLARE_VST_DEPRECATED (outputConnected) (VstInt32 index, bool state) {}
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (willProcessReplacing) ();
|
||||
virtual void DECLARE_VST_DEPRECATED (wantAsyncOperation) (bool state = true);
|
||||
virtual void DECLARE_VST_DEPRECATED (hasExternalBuffer) (bool state = true);
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (reportCurrentPosition) () { return 0; }
|
||||
virtual float* DECLARE_VST_DEPRECATED (reportDestinationBuffer) () { return 0; }
|
||||
virtual void DECLARE_VST_DEPRECATED (setOutputSamplerate) (float samplerate);
|
||||
virtual VstSpeakerArrangement* DECLARE_VST_DEPRECATED (getInputSpeakerArrangement) ();
|
||||
virtual VstSpeakerArrangement* DECLARE_VST_DEPRECATED (getOutputSpeakerArrangement) ();
|
||||
virtual void* DECLARE_VST_DEPRECATED (openWindow) (DECLARE_VST_DEPRECATED (VstWindow)*);
|
||||
virtual bool DECLARE_VST_DEPRECATED (closeWindow) (DECLARE_VST_DEPRECATED (VstWindow)*);
|
||||
virtual void DECLARE_VST_DEPRECATED (setBlockSizeAndSampleRate) (VstInt32 _blockSize, float _sampleRate) { blockSize = _blockSize; sampleRate = _sampleRate; }
|
||||
virtual bool DECLARE_VST_DEPRECATED (getErrorText) (char* text) { return false; }
|
||||
virtual void* DECLARE_VST_DEPRECATED (getIcon) () { return 0; }
|
||||
virtual bool DECLARE_VST_DEPRECATED (setViewPosition) (VstInt32 x, VstInt32 y) { return false; }
|
||||
virtual VstInt32 DECLARE_VST_DEPRECATED (fxIdle) () { return 0; }
|
||||
virtual bool DECLARE_VST_DEPRECATED (keysRequired) () { return false; }
|
||||
|
||||
#if VST_2_2_EXTENSIONS
|
||||
virtual bool DECLARE_VST_DEPRECATED (getChunkFile) (void* nativePath); ///< Returns in platform format the path of the current chunk (could be called in #setChunk ()) (FSSpec on MAC else char*)
|
||||
#endif // VST_2_2_EXTENSIONS
|
||||
/// @endcond
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
};
|
||||
|
||||
#endif //__audioeffectx__
|
||||
|
|
@ -1,68 +0,0 @@
|
|||
//-------------------------------------------------------------------------------------------------------
|
||||
// VST Plug-Ins SDK
|
||||
// Version 2.4 $Date: 2006/08/29 12:08:50 $
|
||||
//
|
||||
// Category : VST 2.x Classes
|
||||
// Filename : vstplugmain.cpp
|
||||
// Created by : Steinberg Media Technologies
|
||||
// Description : VST Plug-In Main Entry
|
||||
//
|
||||
// © 2006, Steinberg Media Technologies, All Rights Reserved
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
|
||||
#include "audioeffect.h"
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
/** Must be implemented externally. */
|
||||
extern AudioEffect* createEffectInstance (audioMasterCallback audioMaster);
|
||||
|
||||
extern "C" {
|
||||
|
||||
#if defined (__GNUC__) && ((__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)))
|
||||
#define VST_EXPORT __attribute__ ((visibility ("default")))
|
||||
#else
|
||||
#define VST_EXPORT
|
||||
#endif
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
/** Prototype of the export function main */
|
||||
//------------------------------------------------------------------------
|
||||
VST_EXPORT AEffect* VSTPluginMain (audioMasterCallback audioMaster)
|
||||
{
|
||||
// Get VST Version of the Host
|
||||
if (!audioMaster (0, audioMasterVersion, 0, 0, 0, 0))
|
||||
return 0; // old version
|
||||
|
||||
// Create the AudioEffect
|
||||
AudioEffect* effect = createEffectInstance (audioMaster);
|
||||
if (!effect)
|
||||
return 0;
|
||||
|
||||
// Return the VST AEffect structur
|
||||
return effect->getAeffect ();
|
||||
}
|
||||
|
||||
// support for old hosts not looking for VSTPluginMain
|
||||
#if (TARGET_API_MAC_CARBON && __ppc__)
|
||||
VST_EXPORT AEffect* main_macho (audioMasterCallback audioMaster) { return VSTPluginMain (audioMaster); }
|
||||
#elif WIN32
|
||||
VST_EXPORT AEffect* MAIN (audioMasterCallback audioMaster) { return VSTPluginMain (audioMaster); }
|
||||
#elif BEOS
|
||||
VST_EXPORT AEffect* main_plugin (audioMasterCallback audioMaster) { return VSTPluginMain (audioMaster); }
|
||||
#endif
|
||||
|
||||
} // extern "C"
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
#if WIN32
|
||||
#include <windows.h>
|
||||
void* hInstance;
|
||||
|
||||
extern "C" {
|
||||
BOOL WINAPI DllMain (HINSTANCE hInst, DWORD dwReason, LPVOID lpvReserved)
|
||||
{
|
||||
hInstance = hInst;
|
||||
return 1;
|
||||
}
|
||||
} // extern "C"
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue