Logo Search packages:      
Sourcecode: cadencii version File versions  Download package

audioeffectx.cpp

//-------------------------------------------------------------------------------------------------------
// 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 <vst2.x/audioeffectx.h>
#include <vst2.x/aeffeditor.h>

//-------------------------------------------------------------------------------------------------------
/*! hostCanDos strings Plug-in -> Host */
00019 namespace HostCanDos
{
00021       const char* canDoSendVstEvents = "sendVstEvents"; ///< Host supports send of Vst events to plug-in
00022       const char* canDoSendVstMidiEvent = "sendVstMidiEvent"; ///< Host supports send of MIDI events to plug-in
00023       const char* canDoSendVstTimeInfo = "sendVstTimeInfo"; ///< Host supports send of VstTimeInfo to plug-in
00024       const char* canDoReceiveVstEvents = "receiveVstEvents"; ///< Host can receive Vst events from plug-in
00025       const char* canDoReceiveVstMidiEvent = "receiveVstMidiEvent"; ///< Host can receive MIDI events from plug-in 
00026       const char* canDoReportConnectionChanges = "reportConnectionChanges"; ///< Host will indicates the plug-in when something change in plug-inīs routing/connections with #suspend/#resume/#setSpeakerArrangement 
00027       const char* canDoAcceptIOChanges = "acceptIOChanges"; ///< Host supports #ioChanged ()
00028       const char* canDoSizeWindow = "sizeWindow"; ///< used by VSTGUI
00029       const char* canDoOffline = "offline"; ///< Host supports offline feature
00030       const char* canDoOpenFileSelector = "openFileSelector"; ///< Host supports function #openFileSelector ()
00031       const char* canDoCloseFileSelector = "closeFileSelector"; ///< Host supports function #closeFileSelector ()
00032       const char* canDoStartStopProcess = "startStopProcess"; ///< Host supports functions #startProcess () and #stopProcess ()
00033       const char* canDoShellCategory = "shellCategory"; ///< 'shell' handling via uniqueID. If supported by the Host and the Plug-in has the category #kPlugCategShell
00034       const char* canDoSendVstMidiEventFlagIsRealtime = "sendVstMidiEventFlagIsRealtime"; ///< Host supports flags for #VstMidiEvent
}

//-------------------------------------------------------------------------------------------------------
/*! plugCanDos strings Host -> Plug-in */
00039 namespace PlugCanDos
{
00041       const char* canDoSendVstEvents = "sendVstEvents"; ///< plug-in will send Vst events to Host
00042       const char* canDoSendVstMidiEvent = "sendVstMidiEvent"; ///< plug-in will send MIDI events to Host
00043       const char* canDoReceiveVstEvents = "receiveVstEvents"; ///< plug-in can receive MIDI events from Host
00044       const char* canDoReceiveVstMidiEvent = "receiveVstMidiEvent"; ///< plug-in can receive MIDI events from Host 
00045       const char* canDoReceiveVstTimeInfo = "receiveVstTimeInfo"; ///< plug-in can receive Time info from Host 
00046       const char* canDoOffline = "offline"; ///< plug-in supports offline functions (#offlineNotify, #offlinePrepare, #offlineRun)
00047       const char* canDoMidiProgramNames = "midiProgramNames"; ///< plug-in supports function #getMidiProgramName ()
00048       const char* canDoBypass = "bypass"; ///< plug-in supports function #setBypass ()
}

//-----------------------------------------------------------------------------------------------------------------
// Class AudioEffectX Implementation
//-----------------------------------------------------------------------------------------------------------------
/*!
      \sa AudioEffect()
*/
AudioEffectX::AudioEffectX (audioMasterCallback audioMaster, VstInt32 numPrograms, VstInt32 numParams)
: AudioEffect (audioMaster, numPrograms, numParams)
{}

//-----------------------------------------------------------------------------------------------------------------
VstIntPtr AudioEffectX::dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt)
{
      VstIntPtr v = 0;
      switch (opcode)
      {
            //---VstEvents----------------------
            case effProcessEvents:
                  v = processEvents ((VstEvents*)ptr);
                  break;

            //---Parameters and Programs----------------------
            case effCanBeAutomated:
                  v = canParameterBeAutomated (index) ? 1 : 0;
                  break;
            case effString2Parameter:
                  v = string2parameter (index, (char*)ptr) ? 1 : 0;
                  break;

            case effGetProgramNameIndexed:
                  v = getProgramNameIndexed ((VstInt32)value, index, (char*)ptr) ? 1 : 0;
                  break;
      #if !VST_FORCE_DEPRECATED
            case effGetNumProgramCategories:
                  v = getNumCategories ();
                  break;
            case effCopyProgram:
                  v = copyProgram (index) ? 1 : 0;
                  break;

            //---Connections, Configuration----------------------
            case effConnectInput:
                  inputConnected (index, value ? true : false);
                  v = 1;
                  break;      
            case effConnectOutput:
                  outputConnected (index, value ? true : false);
                  v = 1;
                  break;      
      #endif // !VST_FORCE_DEPRECATED

            case effGetInputProperties:
                  v = getInputProperties (index, (VstPinProperties*)ptr) ? 1 : 0;
                  break;
            case effGetOutputProperties:
                  v = getOutputProperties (index, (VstPinProperties*)ptr) ? 1 : 0;
                  break;
            case effGetPlugCategory:
                  v = (VstIntPtr)getPlugCategory ();
                  break;

      #if !VST_FORCE_DEPRECATED
            //---Realtime----------------------
            case effGetCurrentPosition:
                  v = reportCurrentPosition ();
                  break;
                  
            case effGetDestinationBuffer:
                  v = ToVstPtr<float> (reportDestinationBuffer ());
                  break;
      #endif // !VST_FORCE_DEPRECATED

            //---Offline----------------------
            case effOfflineNotify:
                  v = offlineNotify ((VstAudioFile*)ptr, (VstInt32)value, index != 0);
                  break;
            case effOfflinePrepare:
                  v = offlinePrepare ((VstOfflineTask*)ptr, (VstInt32)value);
                  break;
            case effOfflineRun:
                  v = offlineRun ((VstOfflineTask*)ptr, (VstInt32)value);
                  break;

            //---Others----------------------
            case effSetSpeakerArrangement:
                  v = setSpeakerArrangement (FromVstPtr<VstSpeakerArrangement> (value), (VstSpeakerArrangement*)ptr) ? 1 : 0;
                  break;
            case effProcessVarIo:
                  v = processVariableIo ((VstVariableIo*)ptr) ? 1 : 0;
                  break;
      #if !VST_FORCE_DEPRECATED
            case effSetBlockSizeAndSampleRate:
                  setBlockSizeAndSampleRate ((VstInt32)value, opt);
                  v = 1;
                  break;
      #endif // !VST_FORCE_DEPRECATED
            case effSetBypass:
                  v = setBypass (value ? true : false) ? 1 : 0;
                  break;
            case effGetEffectName:
                  v = getEffectName ((char*)ptr) ? 1 : 0;
                  break;
            case effGetVendorString:
                  v = getVendorString ((char*)ptr) ? 1 : 0;
                  break;
            case effGetProductString:
                  v = getProductString ((char*)ptr) ? 1 : 0;
                  break;
            case effGetVendorVersion:
                  v = getVendorVersion ();
                  break;
            case effVendorSpecific:
                  v = vendorSpecific (index, value, ptr, opt);
                  break;
            case effCanDo:
                  v = canDo ((char*)ptr);
                  break;

            case effGetTailSize:
                  v = getGetTailSize ();
                  break;

      #if !VST_FORCE_DEPRECATED
            case effGetErrorText:
                  v = getErrorText ((char*)ptr) ? 1 : 0;
                  break;

            case effGetIcon:
                  v = ToVstPtr<void> (getIcon ());
                  break;

            case effSetViewPosition:
                  v = setViewPosition (index, (VstInt32)value) ? 1 : 0;
                  break;            

            case effIdle:
                  v = fxIdle ();
                  break;

            case effKeysRequired:
                  v = (keysRequired () ? 0 : 1);      // reversed to keep v1 compatibility
                  break;
      #endif // !VST_FORCE_DEPRECATED

            case effGetParameterProperties:
                  v = getParameterProperties (index, (VstParameterProperties*)ptr) ? 1 : 0;
                  break;

            case effGetVstVersion:
                  v = getVstVersion ();
                  break;

            //---Others----------------------
      #if VST_2_1_EXTENSIONS
            case effEditKeyDown:
                  if (editor)
                  {
                        VstKeyCode keyCode = {index, (unsigned char)value, (unsigned char)opt};
                        v = editor->onKeyDown (keyCode) ? 1 : 0;
                  }
                  break;

            case effEditKeyUp:
                  if (editor)
                  {
                        VstKeyCode keyCode = {index, (unsigned char)value, (unsigned char)opt};
                        v = editor->onKeyUp (keyCode) ? 1 : 0;
                  }
                  break;

            case effSetEditKnobMode:
                  if (editor)
                        v = editor->setKnobMode ((VstInt32)value) ? 1 : 0;
                  break;

            case effGetMidiProgramName:
                  v = getMidiProgramName (index, (MidiProgramName*)ptr);
                  break;
            case effGetCurrentMidiProgram:
                  v = getCurrentMidiProgram (index, (MidiProgramName*)ptr);
                  break;
            case effGetMidiProgramCategory:
                  v = getMidiProgramCategory (index, (MidiProgramCategory*)ptr);
                  break;
            case effHasMidiProgramsChanged:
                  v = hasMidiProgramsChanged (index) ? 1 : 0;
                  break;
            case effGetMidiKeyName:
                  v = getMidiKeyName (index, (MidiKeyName*)ptr) ? 1 : 0;
                  break;
            case effBeginSetProgram:
                  v = beginSetProgram () ? 1 : 0;
                  break;
            case effEndSetProgram:
                  v = endSetProgram () ? 1 : 0;
                  break;      
      #endif // VST_2_1_EXTENSIONS

      #if VST_2_3_EXTENSIONS
            case effGetSpeakerArrangement:
                  v = getSpeakerArrangement (FromVstPtr<VstSpeakerArrangement*> (value), (VstSpeakerArrangement**)ptr) ? 1 : 0;
                  break;

            case effSetTotalSampleToProcess:
                  v = setTotalSampleToProcess ((VstInt32)value);
                  break;

            case effShellGetNextPlugin:
                  v = getNextShellPlugin ((char*)ptr);
                  break;

            case effStartProcess:
                  v = startProcess ();
                  break;
            case effStopProcess:
                  v = stopProcess ();
                  break;

            case effSetPanLaw:
                  v = setPanLaw ((VstInt32)value, opt) ? 1 : 0;
                  break;

            case effBeginLoadBank:
                  v = beginLoadBank ((VstPatchChunkInfo*)ptr);
                  break;
            case effBeginLoadProgram:
                  v = beginLoadProgram ((VstPatchChunkInfo*)ptr);
                  break;
      #endif // VST_2_3_EXTENSIONS

      #if VST_2_4_EXTENSIONS
            case effSetProcessPrecision :
                  v = setProcessPrecision ((VstInt32)value) ? 1 : 0;
                  break;

            case effGetNumMidiInputChannels :
                  v = getNumMidiInputChannels ();
                  break;

            case effGetNumMidiOutputChannels :
                  v = getNumMidiOutputChannels ();
                  break;
      #endif // VST_2_4_EXTENSIONS

            //---Version 1.0 or unknown-----------------
            default:
                  v = AudioEffect::dispatcher (opcode, index, value, ptr, opt);
      }
      return v;
}

//-----------------------------------------------------------------------------------------------------------------
/*! if this effect is a synth or can receive midi events, we call the deprecated wantEvents() as some host rely on it.
*/
void AudioEffectX::resume ()
{
      if (cEffect.flags & effFlagsIsSynth || canDo ("receiveVstMidiEvent") == 1)
            DECLARE_VST_DEPRECATED (wantEvents) ();
}

//-----------------------------------------------------------------------------------------------------------------
void AudioEffectX::DECLARE_VST_DEPRECATED (wantEvents) (VstInt32 filter)
{
      if (audioMaster)
            audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterWantMidi), 0, filter, 0, 0);
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      A plug-in will request time info by calling the function getTimeInfo() which returns a \e #VstTimeInfo
      pointer (or NULL if not implemented by the Host). The mask parameter is composed of the same flags which 
      will be found in the flags field of \e #VstTimeInfo when returned, that is, if you need information about tempo.
      The parameter passed to getTimeInfo() should have the \e #kVstTempoValid flag set. This request and delivery 
      system is important, as a request like this may cause significant calculations at the application's end, which 
      may take a lot of our precious time. This obviously means you should only set those flags that are required to 
      get the information you need. Also please be aware that requesting information does not necessarily mean that 
      that information is provided in return. Check the \e flags field in the \e #VstTimeInfo structure to see if your
      request was actually met.

      \param filter A mask indicating which fields are requested, as some items may require extensive conversions. 
      See the \e flags in #VstTimeInfo
      \return A pointer to a #VstTimeInfo structure or NULL if not implemented by the Host
*/
VstTimeInfo* AudioEffectX::getTimeInfo (VstInt32 filter)
{
      if (audioMaster)
      {
            VstIntPtr ret = audioMaster (&cEffect, audioMasterGetTime, 0, filter, 0, 0);
            return FromVstPtr<VstTimeInfo> (ret);
      }
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (tempoAt) (VstInt32 pos)
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterTempoAt), 0, pos, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
bool AudioEffectX::sendVstEventsToHost (VstEvents* events)
/*!
      Can be called inside processReplacing.

      \param events Fill with VST events 
      \return Returns \e true on success
*/
{
      if (audioMaster)
            return audioMaster (&cEffect, audioMasterProcessEvents, 0, 0, events, 0) == 1;
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::processEvents (VstEvents* events)

      \return     return value is ignored

      \remarks    Events are always related to the current audio block. For each process cycle, processEvents() is called 
                  <b>once</b> before a processReplacing() call (if new events are available).
      
      \sa VstEvents, VstMidiEvent
*/

//-----------------------------------------------------------------------------------------------------------------
// Parameters Functions
//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::canParameterBeAutomated (VstInt32 index)
 
      Obviously only useful when the application supports this.

      \param index Index of the parameter
      \return     \true if supported
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::string2parameter (VstInt32 index, char* text)

      Especially useful for plug-ins without user interface. The application can then implement a text edit field for
      the user to set a parameter by entering text.

    \param index Index of the parameter
      \param text A textual description of the parameter's value. A NULL pointer is used to check the capability
      (return true).
      \return \e true on success

      \note Implies setParameter (). text==0 is to be expected to check the capability (returns true) 
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getProgramNameIndexed (VstInt32 category, VstInt32 index, char* text)

      Allows a Host application to list the plug-in's programs (presets).

      \param category unused in VST 2.4
      \param index Index of the program in a given category, starting with 0.
      \param text A string up to 24 chars.
      \return \e true on success
*/
//-----------------------------------------------------------------------------------------------------------------
VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (getNumAutomatableParameters) ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetNumAutomatableParameters), 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (getParameterQuantization) ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetParameterQuantization), 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
// Configuration/Settings Functions
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
/*!
      The Host could call a suspend() (if the plug-in was enabled (in resume() state)) and then ask for 
      getSpeakerArrangement() and/or check the \e numInputs and \e numOutputs and \e initialDelay and then call a 
      resume().

      \return \e true on success

      \sa setSpeakerArrangement(), getSpeakerArrangement() 
*/
bool AudioEffectX::ioChanged ()
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterIOChanged, 0, 0, 0, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
bool AudioEffectX::DECLARE_VST_DEPRECATED (needIdle) ()
{
      if (audioMaster)
            return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterNeedIdle), 0, 0, 0, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \param width The window's width in pixel
      \param height The window's height in pixel
      \return \e true on success
*/
bool AudioEffectX::sizeWindow (VstInt32 width, VstInt32 height)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterSizeWindow, width, height, 0, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
double AudioEffectX::updateSampleRate ()
/*!
      \return The Host's sample rate
*/
{
      if (audioMaster)
      {
            VstIntPtr res = audioMaster (&cEffect, audioMasterGetSampleRate, 0, 0, 0, 0);
            if (res > 0)
                  sampleRate = (float)res;
      }
      return sampleRate;
}

//-----------------------------------------------------------------------------------------------------------------
VstInt32 AudioEffectX::updateBlockSize ()
/*!
      \return The Host's block size

      \note Will cause application to call AudioEffect's setSampleRate() to be called (when implemented).
*/
{
      if (audioMaster)
      {
            VstInt32 res = (VstInt32)audioMaster (&cEffect, audioMasterGetBlockSize, 0, 0, 0, 0);
            if (res > 0)
                  blockSize = res;
      }
      return blockSize;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \return ASIO input latency
      \sa getOutputLatency()
*/
VstInt32 AudioEffectX::getInputLatency ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, audioMasterGetInputLatency, 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      While inputLatency is probably not of concern, outputLatency may be used in conjunction with getTimeInfo().
      \e samplePos of VstTimeInfo is ahead of the 'visual' sequencer play time by the output latency, such that 
      when outputLatency samples have passed by, our processing result becomes audible.

      \return ASIO output latency
      \sa getInputLatency()
*/
VstInt32 AudioEffectX::getOutputLatency ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, audioMasterGetOutputLatency, 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getInputProperties (VstInt32 index, VstPinProperties* properties)

      \param index The index to the input, starting with 0
      \param properties A pointer to a VstPinProperties structure
      \return \e true on success
      \sa getOutputProperties()
      \note Example
      <pre>
      bool MyPlug::getInputProperties (VstInt32 index, VstPinProperties* properties)
      {
            bool returnCode = false;
            if (index < kNumInputs)
            {
                  sprintf (properties->label, "My %1d In", index + 1);
                  properties->flags = kVstPinIsStereo | kVstPinIsActive;
                  returnCode = true;
            }
            return returnCode;
      }
      </pre>
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getOutputProperties (VstInt32 index, VstPinProperties* properties)

      \param index The index to the output, starting with 0
      \param properties A pointer to a VstPinProperties structure
      \return \e true on success
      \sa getInputProperties()
      \note Example 1
      <pre>
      bool MyPlug::getOutputProperties (VstInt32 index, VstPinProperties* properties)
      {
            bool returnCode = false;
            if (index < kNumOutputs)
            {
                  sprintf (properties->label, "My %1d Out", index + 1);
                  properties->flags = kVstPinIsStereo | kVstPinIsActive;
                  returnCode = true;
            }
            return (returnCode);
      }
      </pre>

      \note Example 2 : plug-in with 1 mono, 1 stereo and one 5.1 outputs (kNumOutputs = 9):
      <pre>
      bool MyPlug::getOutputProperties (VstInt32 index, VstPinProperties* properties)
      {
            bool returnCode = false;
            if (index >= 0 && index < kNumOutputs)
            {
                  properties->flags = kVstPinIsActive;
                  if (index == 0) // mono
                  {
                        strcpy (properties->label, "Mono Out");
                        properties->arrangementType = kSpeakerArrMono;
                  }
                  else if (index == 1) // stereo (1 -> 2)
                  {
                        strcpy (properties->label, "Stereo Out");
                        properties->flags |= kVstPinIsStereo;
                        properties->arrangementType = kSpeakerArrStereo;
                  }
                  else if (index >= 3) // 5.1 (3 -> 8)
                  {
                        strcpy (properties->label, "5.1 Out");
                        properties->flags |= kVstPinUseSpeaker;
                        properties->arrangementType = kSpeakerArr51;
                        // for old VST Host < 2.3, make 5.1 to stereo/mono/mono/stereo (L R C Lfe Ls Rs)
                        if (index == 3 || index == 7)
                              properties->flags |= kVstPinIsStereo;
                        if (index == 5)
                              strcpy (properties->label, "Center");     
                        else if (index == 6)
                              strcpy (properties->label, "Lfe");  
                        else if (index == 7) // (7 -> 8)
                              strcpy (properties->label, "Stereo Back");
                  }
                  returnCode = true;
            }
            return returnCode;
      }
      </pre>
*/

//-----------------------------------------------------------------------------------------------------------------
AEffect* AudioEffectX::DECLARE_VST_DEPRECATED (getPreviousPlug) (VstInt32 input)
{
      if (audioMaster)
      {
            VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetPreviousPlug), 0, 0, 0, 0);
            return FromVstPtr<AEffect> (ret);
      }
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
AEffect* AudioEffectX::DECLARE_VST_DEPRECATED (getNextPlug) (VstInt32 output)
{
      if (audioMaster)
      {
            VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetNextPlug), 0, 0, 0, 0);
            return FromVstPtr<AEffect> (ret);
      }
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \return Plug-in's category defined in VstPlugCategory
*/
VstPlugCategory AudioEffectX::getPlugCategory ()
{ 
      if (cEffect.flags & effFlagsIsSynth)
            return kPlugCategSynth;
      return kPlugCategUnknown; 
}

//-----------------------------------------------------------------------------------------------------------------
VstInt32 AudioEffectX::DECLARE_VST_DEPRECATED (willProcessReplacing) ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterWillReplaceOrAccumulate), 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      A plug-in is like a black box processing some audio coming in on some inputs (if any) and going out of some 
      outputs (if any). This may be used to do offline or real-time processing, and sometimes it may be desirable to
      know the current context.

      \return #VstProcessLevels in aeffectx.h
 
*/
VstInt32 AudioEffectX::getCurrentProcessLevel ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, audioMasterGetCurrentProcessLevel, 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \return #VstAutomationStates in aeffectx.h
*/
VstInt32 AudioEffectX::getAutomationState ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, audioMasterGetAutomationState, 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
void AudioEffectX::DECLARE_VST_DEPRECATED (wantAsyncOperation) (bool state)
{
      if (state)
            cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsExtIsAsync);
      else
            cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsExtIsAsync);
}

//-----------------------------------------------------------------------------------------------------------------
void AudioEffectX::DECLARE_VST_DEPRECATED (hasExternalBuffer) (bool state)
{
      if (state)
            cEffect.flags |= DECLARE_VST_DEPRECATED (effFlagsExtHasBuffer);
      else
            cEffect.flags &= ~DECLARE_VST_DEPRECATED (effFlagsExtHasBuffer);
}

//-----------------------------------------------------------------------------------------------------------------
// Offline Functions
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------
bool AudioEffectX::offlineRead (VstOfflineTask* offline, VstOfflineOption option, bool readSource)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterOfflineRead, readSource, option, offline, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
bool AudioEffectX::offlineWrite (VstOfflineTask* offline, VstOfflineOption option)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterOfflineWrite, 0, option, offline, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
bool AudioEffectX::offlineStart (VstAudioFile* audioFiles, VstInt32 numAudioFiles, VstInt32 numNewAudioFiles)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterOfflineStart, numNewAudioFiles, numAudioFiles, audioFiles, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
VstInt32 AudioEffectX::offlineGetCurrentPass ()
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterOfflineGetCurrentPass, 0, 0, 0, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
VstInt32 AudioEffectX::offlineGetCurrentMetaPass ()
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterOfflineGetCurrentMetaPass, 0, 0, 0, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
// Other
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
void AudioEffectX::DECLARE_VST_DEPRECATED (setOutputSamplerate) (float sampleRate)
{
      if (audioMaster)
            audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterSetOutputSampleRate), 0, 0, 0, sampleRate);
}

//-----------------------------------------------------------------------------------------------------------------
VstSpeakerArrangement* AudioEffectX::DECLARE_VST_DEPRECATED (getInputSpeakerArrangement) ()
{
      if (audioMaster)
      {
            VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetInputSpeakerArrangement), 0, 0, 0, 0);
            return FromVstPtr<VstSpeakerArrangement> (ret);
      }
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
VstSpeakerArrangement* AudioEffectX::DECLARE_VST_DEPRECATED (getOutputSpeakerArrangement) ()
{
      if (audioMaster)
      {
            VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetOutputSpeakerArrangement), 0, 0, 0, 0);
            return FromVstPtr<VstSpeakerArrangement> (ret);
      }
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \param text  String of maximum 64 char
      \return \e true if supported
*/
bool AudioEffectX::getHostVendorString (char* text)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterGetVendorString, 0, 0, text, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \param text  String of maximum 64 char
      \return \e true if supported
*/
bool AudioEffectX::getHostProductString (char* text)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterGetProductString, 0, 0, text, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \return Host vendor version
*/
VstInt32 AudioEffectX::getHostVendorVersion ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, audioMasterGetVendorVersion, 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
VstIntPtr AudioEffectX::hostVendorSpecific (VstInt32 lArg1, VstIntPtr lArg2, void* ptrArg, float floatArg)
{
      if (audioMaster)
            return audioMaster (&cEffect, audioMasterVendorSpecific, lArg1, lArg2, ptrArg, floatArg);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      Asks Host if it implements the feature text. A plug-in cannot assume a 2.x feature is available from the Host. 
      Use this method to ascertain the environment in which the plug-in finds itself. Ignoring this inquiry methods and 
      trying to access a 2.x feature in a 1.0 Host will mean your plug-in or Host application will break. It is not 
      the end-users job to pick and choose which plug-ins can be supported by which Host.

      \param text A string from #hostCanDos
      \return
      - 0 : don't know (default)
      - 1 : yes
      - -1: no
*/
VstInt32 AudioEffectX::canHostDo (char* text)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterCanDo, 0, 0, text, 0) != 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      Tells the Host that the plug-in is an instrument, i.e. that it will call wantEvents().
      
      \param state
      - true: is an instrument (default)
      - false: is a simple audio effect
*/
void AudioEffectX::isSynth (bool state)
{
      if (state)
            cEffect.flags |= effFlagsIsSynth;
      else
            cEffect.flags &= ~effFlagsIsSynth;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      Enables Host to omit processReplacing() when no data is present on any input.
*/
void AudioEffectX::noTail (bool state)
{
      if (state)
            cEffect.flags |= effFlagsNoSoundInStop;
      else
            cEffect.flags &= ~effFlagsNoSoundInStop;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \return #VstHostLanguage in aeffectx.h
*/
VstInt32 AudioEffectX::getHostLanguage ()
{
      if (audioMaster)
            return (VstInt32)audioMaster (&cEffect, audioMasterGetLanguage, 0, 0, 0, 0);
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
void* AudioEffectX::DECLARE_VST_DEPRECATED (openWindow) (DECLARE_VST_DEPRECATED (VstWindow)* window)
{
      if (audioMaster)
      {
            VstIntPtr ret = audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterOpenWindow), 0, 0, window, 0);
            return FromVstPtr<void> (ret);
      }
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
bool AudioEffectX::DECLARE_VST_DEPRECATED (closeWindow) (DECLARE_VST_DEPRECATED (VstWindow)* window)
{
      if (audioMaster)
            return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterCloseWindow), 0, 0, window, 0) != 0);
      return false;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \return FSSpec on MAC, else char*
*/
void* AudioEffectX::getDirectory ()
{
      if (audioMaster)
      {
            VstIntPtr ret = (audioMaster (&cEffect, audioMasterGetDirectory, 0, 0, 0, 0));
            return FromVstPtr<void> (ret);
      }
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \return \e true if supported
*/
bool AudioEffectX::updateDisplay ()
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterUpdateDisplay, 0, 0, 0, 0)) ? true : false;
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::processVariableIo (VstVariableIo* varIo)

      If called with \e varIo NULL, returning \e true indicates that this call is supported by the plug-in.
      Host will use processReplacing otherwise. The Host should call setTotalSampleToProcess before starting the processIO
      to inform the plug-in about how many samples will be processed in total. The Host should provide an output buffer at least 5 times bigger than input buffer.

      \param varIo
      \return \true on success
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::setSpeakerArrangement (VstSpeakerArrangement* pluginInput, VstSpeakerArrangement* pluginOutput)

      Set the plug-in's speaker arrangements. If a (VST >= 2.3) plug-in returns \e true, it means that it accepts this IO 
      arrangement. The Host doesn't need to ask for getSpeakerArrangement(). If the plug-in returns \e false it means that it 
      doesn't accept this arrangement, the Host should then ask for getSpeakerArrangement() and then can (optional)
      recall setSpeakerArrangement().

      \param pluginInput A pointer to the input's #VstSpeakerArrangement structure.
      \param pluginOutput A pointer to the output's #VstSpeakerArrangement structure.
      \return \e true on success

      \note setSpeakerArrangement() and getSpeakerArrangement() are always called in suspended state. 
      (like setSampleRate() or setBlockSize()).

      \sa getSpeakerArrangement()
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getSpeakerArrangement (VstSpeakerArrangement** pluginInput, VstSpeakerArrangement** pluginOutput)
      
      \param pluginInput A pointer to the input's #VstSpeakerArrangement structure.
      \param pluginOutput A pointer to the output's #VstSpeakerArrangement structure.
      \return \e true on success

      \note setSpeakerArrangement() and getSpeakerArrangement() are always called in suspended state. 
      (like setSampleRate() or setBlockSize()).\n
      <pre>Here an example code to show how the host uses getSpeakerArrangement()
      VstSpeakerArrangement *plugInputVstArr = 0;
      VstSpeakerArrangement *plugOutputVstArr = 0;
      if (getFormatVersion () >= 2300 && #getSpeakerArrangement (&plugInputVstArr, &plugOutputVstArr))
            ....
      </pre>      

      \sa setSpeakerArrangement()
*/
//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::setBypass (bool onOff)

      process still called (if Supported) although the plug-in was bypassed. Some plugs need to stay 'alive' even 
      when bypassed. An example is a surround decoder which has more inputs than outputs and must maintain some 
      reasonable signal distribution even when being bypassed. A CanDo 'bypass' allows to ask the plug-in if it 
      supports soft bypass or not. 

      \note This bypass feature could be automated by the Host (this means avoid to much CPU requirement in this call)
      \note If the plug-in supports SoftBypass and it has a latency (initialDelay), in Bypassed state the plug-in has to used
      the same latency value. 
      
      \param onOff
      \return
      - true: supports SoftBypass, process will be called, the plug-in should compensate its latency, and copy inputs to outputs  
      - false: doesn't support SoftBypass, process will not be called, the Host should bypass the process call

      \sa processReplacing()
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getEffectName (char* name)

      \param name A string up to 32 chars
      \return \e true on success
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getVendorString (char* text)

      \param text A string up to 64 chars
      \return \e true on success
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getProductString (char* text)

      \param text A string up to 64 chars
      \return \e true on success
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::getVendorVersion ()

      \return The version of the plug-in

      \note This should be upported
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::canDo (char* text)

      Report what the plug-in is able to do. In general you can but don't have to report whatever you support or not 
      support via canDo. Some application functionality may require some specific reply, but in that case you will 
      probably know. Best is to report whatever you know for sure. A Host application cannot make assumptions about
      the presence of the new 2.x features of a plug-in. Ignoring this inquiry methods and trying to access a 2.x 
      feature from a 1.0 plug, or vice versa, will mean the plug-in or Host application will break. It is not the
      end-users job to pick and choose which plug-ins can be supported by which Host.

      \param text A string from #plugCanDos
      \return
      - 0: don't know (default)
      - 1: yes
      - -1: no

      \note This should be supported.
*/

//----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::canDo (char* text)

      \param text A string from #plugCanDos
      \return
      - 0: don't know (default). 
      - 1: yes.
      - -1: no
*/

//----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getParameterProperties (VstInt32 index, VstParameterProperties* p)

      \param index Index of the parameter
      \param p Pointer to #VstParameterProperties
      \return Return \e true on success
*/

//----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::getVstVersion ()
      \return  
      - 2xxx : the last VST 2.x plug-in version (by default) 
      - 0 : older versions
 
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32  AudioEffectX::getMidiProgramName (VstInt32 channel, MidiProgramName* midiProgramName)
      Ask plug-in if MidiPrograms are used and if so, query for names, numbers 
      (ProgramChange-Number + BankSelect-Number), categories and keynames of each 
      MIDI Program, on each MIDI-channel. If this function is called, your plug-in has to read 
      MidiProgramName::thisProgramIndex, fill out the other fields with the information 
      assigned to a certain MIDI Program and return the number of available MIDI Programs on 
      that MIDI Channel. 
      
      \note plug-in canDo "midiProgramNames". No effect, if 0 is returned. 
      
      \warning don't mix concepts: the MIDI Programs are totally independent from all other 
      programs present in VST. The main difference is, that there are upto 16 simultaneous 
      active MIDI Programs (one per channel), while there can be only one active "VST"-Program. 
      (You should see the "VST"-Program as the one single main global program, which contains 
      the entire current state of the plug-in.) This function can be called in any sequence. 
      
      \param channel MidiChannel: 0-15
      \param midiProgramName Points to \e #MidiProgramName struct
      \return Number of available MIDI Programs on that \e channel
      - number of used programIndexes
      - 0 if no MidiProgramNames supported

      \note Example : plug-in has 3 MidiPrograms on MidiChannel 0.
      <pre>
      Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 0.
      Plug fills out:
      MidiProgramName::name[64] = "Program A"
      MidiProgramName::midiProgram = 0
      MidiProgramName::midiBankMsb = -1
      MidiProgramName::midiBankLsb = -1
      MidiProgramName::parentCategoryIndex = -1
      MidiProgramName::flags = 0 (if plug isn't "Omni").
      Plug returns 3.
      Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 1.
      Plug fills out:
      MidiProgramName::name[64] = "Program B"
      MidiProgramName::midiProgram = 1
      MidiProgramName::midiBankMsb = -1
      MidiProgramName::midiBankLsb = -1
      MidiProgramName::parentCategoryIndex = -1
      MidiProgramName::flags = 0 (if plug isn't "Omni").
      Plug returns 3.
      Host calls #getMidiProgramName with idx = 0 and MidiProgramName::thisProgramIndex = 2.
      Plug fills out:
      MidiProgramName::name[64] = "Program C"
      MidiProgramName::midiProgram = 2
      MidiProgramName::midiBankMsb = -1
      MidiProgramName::midiBankLsb = -1
      MidiProgramName::parentCategoryIndex = -1
      MidiProgramName::flags = 0 (if plug isn't "Omni").
      Plug returns 3.
      </pre>
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::getCurrentMidiProgram (VstInt32 channel, MidiProgramName* currentProgram)
      
      \param channel
      \param currentProgram
      \return
      - programIndex of the current program
      - -1 if not supported
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::getMidiProgramCategory (VstInt32 channel, MidiProgramCategory* category)
      
      \param channel
      \param category
      \return
      - number of used categoryIndexes. 
      - 0 if no #MidiProgramCategory supported/used.
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::hasMidiProgramsChanged (VstInt32 channel)
      
      Ask plug-in for the currently active program on a certain MIDI Channel. Just like 
      getMidiProgramName(), but MidiProgramName::thisProgramIndex has to be filled out with
      the currently active MIDI Program-index, which also has to be returned. 
      
      \param channel
      \return
      - true: if the #MidiProgramNames, #MidiKeyNames or #MidiControllerNames had changed on 
      this channel
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::getMidiKeyName (VstInt32 channel, MidiKeyName* keyName)
      
      \param channel
      \param keyName If keyName is "" the standard name of the key will be displayed
      \return Return \e false if no #MidiKeyNames defined for 'thisProgramIndex'
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::beginSetProgram ()
      
      \return
      - true: the plug-in took the notification into account
      - false: it did not...

      \sa endSetProgram()
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::endSetProgram ()
      
      \return
      - true: the plug-in took the notification into account
      - false: it did not...

      \sa beginSetProgram()
*/

#if VST_2_1_EXTENSIONS
//-----------------------------------------------------------------------------------------------------------------
/*!
      It tells the Host that if it needs to, it has to record automation data for this control.
      
      \param index Index of the parameter
      \return Returns \e true on success

      \sa endEdit()
*/
bool AudioEffectX::beginEdit (VstInt32 index)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterBeginEdit, index, 0, 0, 0)) ? true : false;
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      It notifies the Host that this control is no longer moved by the mouse.
      
      \param index Index of the parameter
      \return Returns \e true on success

      \sa beginEdit()
*/
bool AudioEffectX::endEdit (VstInt32 index)
{
      if (audioMaster)
            return (audioMaster (&cEffect, audioMasterEndEdit, index, 0, 0, 0)) ? true : false;
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \param ptr
      \return Returns \e true on success

      \sa closeFileSelector()
*/
bool AudioEffectX::openFileSelector (VstFileSelect* ptr)
{
      if (audioMaster && ptr)
            return (audioMaster (&cEffect, audioMasterOpenFileSelector, 0, 0, ptr, 0)) ? true : false;
      return 0;
}
#endif // VST_2_1_EXTENSIONS

#if VST_2_2_EXTENSIONS
//-----------------------------------------------------------------------------------------------------------------
/*!
      \param ptr
      \return Returns \e true on success

      \sa openFileSelector()
*/
bool AudioEffectX::closeFileSelector (VstFileSelect* ptr)
{
      if (audioMaster && ptr)
            return (audioMaster (&cEffect, audioMasterCloseFileSelector, 0, 0, ptr, 0)) ? true : false;
      return 0;
}

//-----------------------------------------------------------------------------------------------------------------
/*!   
      It indicates how many samples will be processed.

      \param nativePath
      \return Returns \e true on success 

      \sa getChunk(), setChunk()
*/
bool AudioEffectX::DECLARE_VST_DEPRECATED (getChunkFile) (void* nativePath)
{
      if (audioMaster && nativePath)
            return (audioMaster (&cEffect, DECLARE_VST_DEPRECATED (audioMasterGetChunkFile), 0, 0, nativePath, 0)) ? true : false;
      return 0;
}
#endif // VST_2_2_EXTENSIONS

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::setTotalSampleToProcess (VstInt32 value)
      
      It indicates how many samples will be processed in total.

      \param value Number of samples to process
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::getNextShellPlugin (char* name) { return 0; }
      
      \param name Points to a char buffer of size 64, which is to be filled with the name of the
      plug-in including the terminating zero
      \return Return the next plug-in's uniqueID
      \note Example of Implementation 
<pre>
      //---From the Host side : if found plugin is a Shell category-----------
      if (effect->getCategory () == kPlugCategShell)
      { 
            // scan shell for subplugins
            char tempName[64] = {0}; 
            VstInt32 plugUniqueID = 0;
            while ((plugUniqueID = effect->dispatchEffect (effShellGetNextPlugin, 0, 0, tempName)) != 0)
            { 
                  // subplug needs a name 
                  if (tempName[0] != 0)
                  {
                        ...do what you want with this tempName and plugUniqueID
                  }
            }
      }
      //---From the Host side : Intanciate a subplugin of a shell plugin---
      // retreive the uniqueID of this subplugin the host wants to load
      // set it to the host currentID
      currentID = subplugInfo->uniqueID;
      // call the its shell plugin (main function)
      main ();
      // the shell plugin will ask for the currentUniqueID
      // and should return the chosen subplugin
      ...
      //---From the plugin-Shell Side: for enumeration of subplugins---------
      category = kPlugCategShell;
      ->can ask the host if "shellCategory" is supported
      // at start (instanciation) reset the index for the getNextShellPlugin call.
      myPluginShell::index = 0;
      // implementation of getNextShellPlugin (char* name);
      VstInt32 myPluginShell::getNextShellPlugin (char* name)
      {
            strcpy (name, MyNameTable[index]);
            return MyUniqueIDTable[index++];
      }
      ....
      //---From the plugin-Shell Side: when instanciation-----
      VstInt32 uniqueID = host->getCurrentUniqueID ();
      if (uniqueID == 0) // the host instanciates the shell
      {}
      else // host try to instanciate one of my subplugin...identified by the uniqueID
      {}
</pre>
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::setPanLaw (VstInt32 type, float val) 
      
      \param type
      \param val
      
      \return Returns \e true on success 
      
      \note Gain: for Linear : [1.0 => 0dB PanLaw], [~0.58 => -4.5dB], [0.5 => -6.02dB]
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::beginLoadBank (VstPatchChunkInfo* ptr)
      
      \param ptr
      \return
      - -1: if the Bank cannot be loaded, 
      - 1: if it can be loaded 
      - 0: else (for compatibility)

      \sa beginLoadProgram()

*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::beginLoadProgram (VstPatchChunkInfo* ptr)

      \param ptr
      \return
      - -1: if the Program cannot be loaded, 
      - 1: it can be loaded else,
      - 0: else (for compatibility)

      \sa beginLoadBank()
*/

//-----------------------------------------------------------------------------------------------------------------
// Speaker Arrangement Helpers
//-----------------------------------------------------------------------------------------------------------------

#if VST_2_3_EXTENSIONS
//-----------------------------------------------------------------------------------------------------------------
/*!
      \param arrangement Pointer to a \e #VstSpeakerArrangement structure
      \param nbChannels Number of Channels
      \return Returns \e true on success

      \sa deallocateArrangement(), copySpeaker(), matchArrangement()
*/
bool AudioEffectX::allocateArrangement (VstSpeakerArrangement** arrangement, VstInt32 nbChannels)
{
      if (*arrangement) 
      { 
            char *ptr = (char*)(*arrangement); 
            delete [] ptr;
      }

      VstInt32 size = 2 * sizeof (VstInt32) + nbChannels * sizeof (VstSpeakerProperties);
      char* ptr = new char[size];
      if (!ptr)
            return false;

      memset (ptr, 0, size);
      *arrangement = (VstSpeakerArrangement*)ptr;
      (*arrangement)->numChannels = nbChannels;
      return true;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \param arrangement Pointer to a \e #VstSpeakerArrangement structure
      \return Returns \e true on success

      \sa allocateArrangement(), copySpeaker(), matchArrangement()
*/
bool AudioEffectX::deallocateArrangement (VstSpeakerArrangement** arrangement)
{
      if (*arrangement) 
      { 
            char *ptr = (char*)(*arrangement); 
            delete [] ptr; 
            *arrangement = 0;
      }
      return true;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      Feed the \e to speaker properties with the same values than \e from 's ones.
      It is assumed here that \e to exists yet, ie this function won't
      allocate memory for the speaker (this will prevent from having
      a difference between an Arrangement's number of channels and
       its actual speakers...)
       
       \param to
       \param from
       \return Returns \e true on success

       \sa allocateArrangement(), deallocateArrangement(), matchArrangement()
*/
bool AudioEffectX::copySpeaker (VstSpeakerProperties* to, VstSpeakerProperties* from)
{
      if ((from == NULL) || (to == NULL))
            return false;
      
      vst_strncpy (to->name, from->name, 63);
      to->type      = from->type;
      to->azimuth   = from->azimuth;
      to->elevation = from->elevation;
      to->radius    = from->radius;
      to->reserved  = from->reserved;
      memcpy (to->future, from->future, 28);
      
      return true;
}

//-----------------------------------------------------------------------------------------------------------------
/*!
      \e to is deleted, then created and initialized with the same values as \e from (must exist!).
      It's notably useful when setSpeakerArrangement() is called by the Host. 
      
      \param to
      \param from
      \return Returns \e true on success

      \sa allocateArrangement(), deallocateArrangement(), copySpeaker()
*/

bool AudioEffectX::matchArrangement (VstSpeakerArrangement** to, VstSpeakerArrangement* from)
{
      if (from == NULL)
            return false;

      if ((!deallocateArrangement (to)) || (!allocateArrangement (to, from->numChannels)))
            return false;
      
      (*to)->type = from->type;
      for (VstInt32 i = 0; i < (*to)->numChannels; i++)
      {
            if (!copySpeaker (&((*to)->speakers[i]), &(from->speakers[i])))
                  return false;
      }

      return true;
}
#endif // VST_2_3_EXTENSIONS

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn bool AudioEffectX::setProcessPrecision (VstInt32 precision)

      Is called in suspended state, similar to #setBlockSize. Default (if not called) is single precision float.

      \param precision kVstProcessPrecision32 or kVstProcessPrecision64
      \return Returns \e true on success
      \sa VstProcessPrecision
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::getNumMidiInputChannels ()

      Called by the host application to determine how many MIDI input channels are actually used by a plugin
      e.g. to hide unused channels from the user. 
      For compatibility with VST 2.3 and below, the default return value 0 means 'not implemented' -
      in this case the host assumes 16 MIDI channels to be present (or none at all).

      \return Number of MIDI input channels: 1-15, otherwise: 16 or no MIDI channels at all (0)

      \note The VST 2.x protocol is limited to a maximum of 16 MIDI channels as defined by the MIDI Standard. This might change in future revisions of the API.
      
      \sa
      getNumMidiOutputChannels() @n
      PlugCanDos::canDoReceiveVstMidiEvent
*/

//-----------------------------------------------------------------------------------------------------------------
/*!
      \fn VstInt32 AudioEffectX::getNumMidiOutputChannels ()

      Called by the host application to determine how many MIDI output channels are actually used by a plugin
      e.g. to hide unused channels from the user. 
      For compatibility with VST 2.3 and below, the default return value 0 means 'not implemented' -
      in this case the host assumes 16 MIDI channels to be present (or none at all).

      \return Number of MIDI output channels: 1-15, otherwise: 16 or no MIDI channels at all (0)

      \note The VST 2.x protocol is limited to a maximum of 16 MIDI channels as defined by the MIDI Standard. This might change in future revisions of the API.

      \sa
      getNumMidiInputChannels() @n
      PlugCanDos::canDoSendVstMidiEvent
*/

Generated by  Doxygen 1.6.0   Back to index