472 lines
24 KiB
C++
472 lines
24 KiB
C++
//------------------------------------------------------------------------
|
|
// Project : VST SDK
|
|
//
|
|
// Category : Interfaces
|
|
// Filename : pluginterfaces/vst/ivstaudioprocessor.h
|
|
// Created by : Steinberg, 10/2005
|
|
// Description : VST Audio Processing Interfaces
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// This file is part of a Steinberg SDK. It is subject to the license terms
|
|
// in the LICENSE file found in the top-level directory of this distribution
|
|
// and at www.steinberg.net/sdklicenses.
|
|
// No part of the SDK, including this file, may be copied, modified, propagated,
|
|
// or distributed except according to the terms contained in the LICENSE file.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include "ivstcomponent.h"
|
|
#include "vstspeaker.h"
|
|
|
|
//------------------------------------------------------------------------
|
|
#include "pluginterfaces/base/falignpush.h"
|
|
//------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Class Category Name for Audio Processor Component */
|
|
//------------------------------------------------------------------------
|
|
#ifndef kVstAudioEffectClass
|
|
#define kVstAudioEffectClass "Audio Module Class"
|
|
#endif
|
|
|
|
//------------------------------------------------------------------------
|
|
namespace Steinberg {
|
|
namespace Vst {
|
|
|
|
class IEventList;
|
|
class IParameterChanges;
|
|
struct ProcessContext;
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Component Types used as subCategories in PClassInfo2 */
|
|
namespace PlugType
|
|
{
|
|
/**
|
|
* \defgroup plugType Plug-in Type used for subCategories
|
|
* @{ */
|
|
SMTG_CONSTEXPR const CString kFx = "Fx"; ///< others type (not categorized)
|
|
SMTG_CONSTEXPR const CString kFxAnalyzer = "Fx|Analyzer"; ///< Scope, FFT-Display, Loudness Processing...
|
|
SMTG_CONSTEXPR const CString kFxBass = "Fx|Bass"; ///< Tools dedicated to Bass Guitar
|
|
SMTG_CONSTEXPR const CString kFxChannelStrip = "Fx|Channel Strip"; ///< Tools dedicated to Channel Strip
|
|
SMTG_CONSTEXPR const CString kFxDelay = "Fx|Delay"; ///< Delay, Multi-tap Delay, Ping-Pong Delay...
|
|
SMTG_CONSTEXPR const CString kFxDistortion = "Fx|Distortion"; ///< Amp Simulator, Sub-Harmonic, SoftClipper...
|
|
SMTG_CONSTEXPR const CString kFxDrums = "Fx|Drums"; ///< Tools dedicated to Drums...
|
|
SMTG_CONSTEXPR const CString kFxDynamics = "Fx|Dynamics"; ///< Compressor, Expander, Gate, Limiter, Maximizer, Tape Simulator, EnvelopeShaper...
|
|
SMTG_CONSTEXPR const CString kFxEQ = "Fx|EQ"; ///< Equalization, Graphical EQ...
|
|
SMTG_CONSTEXPR const CString kFxFilter = "Fx|Filter"; ///< WahWah, ToneBooster, Specific Filter,...
|
|
SMTG_CONSTEXPR const CString kFxGenerator = "Fx|Generator"; ///< Tone Generator, Noise Generator...
|
|
SMTG_CONSTEXPR const CString kFxGuitar = "Fx|Guitar"; ///< Tools dedicated to Guitar
|
|
SMTG_CONSTEXPR const CString kFxInstrument = "Fx|Instrument"; ///< Fx which could be loaded as Instrument too
|
|
SMTG_CONSTEXPR const CString kFxInstrumentExternal = "Fx|Instrument|External"; ///< Fx which could be loaded as Instrument too and is external (wrapped Hardware)
|
|
SMTG_CONSTEXPR const CString kFxMastering = "Fx|Mastering"; ///< Dither, Noise Shaping,...
|
|
SMTG_CONSTEXPR const CString kFxMicrophone = "Fx|Microphone"; ///< Tools dedicated to Microphone
|
|
SMTG_CONSTEXPR const CString kFxModulation = "Fx|Modulation"; ///< Phaser, Flanger, Chorus, Tremolo, Vibrato, AutoPan, Rotary, Cloner...
|
|
SMTG_CONSTEXPR const CString kFxNetwork = "Fx|Network"; ///< using Network
|
|
SMTG_CONSTEXPR const CString kFxPitchShift = "Fx|Pitch Shift"; ///< Pitch Processing, Pitch Correction, Vocal Tuning...
|
|
SMTG_CONSTEXPR const CString kFxRestoration = "Fx|Restoration"; ///< Denoiser, Declicker,...
|
|
SMTG_CONSTEXPR const CString kFxReverb = "Fx|Reverb"; ///< Reverberation, Room Simulation, Convolution Reverb...
|
|
SMTG_CONSTEXPR const CString kFxSpatial = "Fx|Spatial"; ///< MonoToStereo, StereoEnhancer,...
|
|
SMTG_CONSTEXPR const CString kFxSurround = "Fx|Surround"; ///< dedicated to surround processing: LFE Splitter, Bass Manager...
|
|
SMTG_CONSTEXPR const CString kFxTools = "Fx|Tools"; ///< Volume, Mixer, Tuner...
|
|
SMTG_CONSTEXPR const CString kFxVocals = "Fx|Vocals"; ///< Tools dedicated to Vocals
|
|
|
|
SMTG_CONSTEXPR const CString kInstrument = "Instrument"; ///< Effect used as instrument (sound generator), not as insert
|
|
SMTG_CONSTEXPR const CString kInstrumentDrum = "Instrument|Drum"; ///< Instrument for Drum sounds
|
|
SMTG_CONSTEXPR const CString kInstrumentExternal = "Instrument|External";///< External Instrument (wrapped Hardware)
|
|
SMTG_CONSTEXPR const CString kInstrumentPiano = "Instrument|Piano"; ///< Instrument for Piano sounds
|
|
SMTG_CONSTEXPR const CString kInstrumentSampler = "Instrument|Sampler"; ///< Instrument based on Samples
|
|
SMTG_CONSTEXPR const CString kInstrumentSynth = "Instrument|Synth"; ///< Instrument based on Synthesis
|
|
SMTG_CONSTEXPR const CString kInstrumentSynthSampler = "Instrument|Synth|Sampler"; ///< Instrument based on Synthesis and Samples
|
|
|
|
SMTG_CONSTEXPR const CString kAmbisonics = "Ambisonics"; ///< used for Ambisonics channel (FX or Panner/Mixconverter/Up-Mixer/Down-Mixer when combined with other category)
|
|
SMTG_CONSTEXPR const CString kAnalyzer = "Analyzer"; ///< Meter, Scope, FFT-Display, not selectable as insert plug-in
|
|
SMTG_CONSTEXPR const CString kNoOfflineProcess = "NoOfflineProcess"; ///< will be NOT used for plug-in offline processing (will work as normal insert plug-in)
|
|
SMTG_CONSTEXPR const CString kOnlyARA = "OnlyARA"; ///< used for plug-ins that require ARA to operate (will not work as normal insert plug-in)
|
|
SMTG_CONSTEXPR const CString kOnlyOfflineProcess = "OnlyOfflineProcess"; ///< used for plug-in offline processing (will not work as normal insert plug-in)
|
|
SMTG_CONSTEXPR const CString kOnlyRealTime = "OnlyRT"; ///< indicates that it supports only realtime process call, no processing faster than realtime
|
|
SMTG_CONSTEXPR const CString kSpatial = "Spatial"; ///< used for SurroundPanner
|
|
SMTG_CONSTEXPR const CString kSpatialFx = "Spatial|Fx"; ///< used for SurroundPanner and as insert effect
|
|
SMTG_CONSTEXPR const CString kUpDownMix = "Up-Downmix"; ///< used for Mixconverter/Up-Mixer/Down-Mixer
|
|
|
|
SMTG_CONSTEXPR const CString kMono = "Mono"; ///< used for Mono only plug-in [optional]
|
|
SMTG_CONSTEXPR const CString kStereo = "Stereo"; ///< used for Stereo only plug-in [optional]
|
|
SMTG_CONSTEXPR const CString kSurround = "Surround"; ///< used for Surround only plug-in [optional]
|
|
|
|
/**@}*/
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Component Flags used as classFlags in PClassInfo2 */
|
|
enum ComponentFlags
|
|
{
|
|
//------------------------------------------------------------------------
|
|
kDistributable = 1 << 0, ///< Component can be run on remote computer
|
|
kSimpleModeSupported = 1 << 1 ///< Component supports simple IO mode (or works in simple mode anyway) see \ref vst3IoMode
|
|
//------------------------------------------------------------------------
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Symbolic sample size.
|
|
* \see ProcessSetup, ProcessData
|
|
*/
|
|
enum SymbolicSampleSizes
|
|
{
|
|
kSample32, ///< 32-bit precision
|
|
kSample64 ///< 64-bit precision
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Processing mode informs the plug-in about the context and at which frequency the process call is
|
|
* called.
|
|
* .
|
|
* VST3 defines 3 modes:
|
|
*
|
|
* - kRealtime: each process call is called at a realtime frequency (defined by [numSamples of
|
|
* ProcessData] / samplerate). The plug-in should always try to process as fast as possible in order
|
|
* to let enough time slice to other plug-ins.
|
|
*
|
|
* - kPrefetch: each process call could be called at a variable frequency (jitter, slower /
|
|
* faster than realtime), the plug-in should process at the same quality level than realtime,
|
|
* plug-in must not slow down to realtime (e.g. disk streaming)! The host should avoid to process in
|
|
* kPrefetch mode such sampler based plug-in.
|
|
*
|
|
* - kOffline: each process call could be faster than realtime or slower, higher quality than
|
|
* realtime could be used. plug-ins using disk streaming should be sure that they have enough time
|
|
* in the process call for streaming, if needed by slowing down to realtime or slower.
|
|
* .
|
|
* Note about Process Modes switching:
|
|
* - Switching between kRealtime and kPrefetch process modes are done in realtime thread without
|
|
* need of calling IAudioProcessor::setupProcessing, the plug-in should check in process call the
|
|
* member processMode of ProcessData in order to know in which mode it is processed.
|
|
* - Switching between kRealtime (or kPrefetch) and kOffline requires that the host calls
|
|
* IAudioProcessor::setupProcessing in order to inform the plug-in about this mode change.
|
|
* .
|
|
* \see ProcessSetup, ProcessData
|
|
*/
|
|
enum ProcessModes
|
|
{
|
|
kRealtime, ///< realtime processing
|
|
kPrefetch, ///< prefetch processing
|
|
kOffline ///< offline processing
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
/** kNoTail
|
|
*
|
|
* to be returned by getTailSamples when no tail is wanted
|
|
* \see IAudioProcessor::getTailSamples
|
|
*/
|
|
static const uint32 kNoTail = 0;
|
|
|
|
//------------------------------------------------------------------------
|
|
/** kInfiniteTail
|
|
*
|
|
* to be returned by getTailSamples when infinite tail is wanted
|
|
* \see IAudioProcessor::getTailSamples
|
|
*/
|
|
static const uint32 kInfiniteTail = kMaxInt32u;
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Audio processing setup.
|
|
* \see IAudioProcessor::setupProcessing
|
|
*/
|
|
struct ProcessSetup
|
|
{
|
|
//------------------------------------------------------------------------
|
|
int32 processMode; ///< \ref ProcessModes
|
|
int32 symbolicSampleSize; ///< \ref SymbolicSampleSizes
|
|
int32 maxSamplesPerBlock; ///< maximum number of samples per audio block
|
|
SampleRate sampleRate; ///< sample rate
|
|
//------------------------------------------------------------------------
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Processing buffers of an audio bus.
|
|
This structure contains the processing buffer for each channel of an audio bus.
|
|
|
|
- The number of channels (numChannels) must always match the current bus arrangement. It could be
|
|
set to value '0' when the host wants to flush the parameters (when the plug-in is not processed).
|
|
|
|
- The size of the channel buffer array must always match the number of channels. So the host must
|
|
always supply an array for the channel buffers, regardless if the bus is active or not. However, if
|
|
an audio bus is currently inactive, the actual sample buffer addresses are safe to be null.
|
|
|
|
- The silence flag is set when every sample of the according buffer has the value '0'. It is
|
|
intended to be used as help for optimizations allowing a plug-in to reduce processing activities.
|
|
But even if this flag is set for a channel, the channel buffers must still point to valid memory!
|
|
This flag is optional. A host is free to support it or not.
|
|
.
|
|
\see ProcessData
|
|
*/
|
|
struct AudioBusBuffers
|
|
{
|
|
AudioBusBuffers () : numChannels (0), silenceFlags (0), channelBuffers64 (nullptr) {}
|
|
|
|
//------------------------------------------------------------------------
|
|
int32 numChannels; ///< number of audio channels in bus
|
|
uint64 silenceFlags; ///< Bitset of silence state per channel
|
|
union
|
|
{
|
|
Sample32** channelBuffers32; ///< sample buffers to process with 32-bit precision
|
|
Sample64** channelBuffers64; ///< sample buffers to process with 64-bit precision
|
|
};
|
|
//------------------------------------------------------------------------
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Any data needed in audio processing.
|
|
* The host prepares AudioBusBuffers for each input/output bus,
|
|
* regardless of the bus activation state. Bus buffer indices always match
|
|
* with bus indices used in IComponent::getBusInfo of media type kAudio.
|
|
* \see AudioBusBuffers, IParameterChanges, IEventList, ProcessContext, IProcessContextRequirements
|
|
*/
|
|
struct ProcessData
|
|
{
|
|
ProcessData ()
|
|
: processMode (0)
|
|
, symbolicSampleSize (kSample32)
|
|
, numSamples (0)
|
|
, numInputs (0)
|
|
, numOutputs (0)
|
|
, inputs (nullptr)
|
|
, outputs (nullptr)
|
|
, inputParameterChanges (nullptr)
|
|
, outputParameterChanges (nullptr)
|
|
, inputEvents (nullptr)
|
|
, outputEvents (nullptr)
|
|
, processContext (nullptr)
|
|
{
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
int32 processMode; ///< processing mode - value of \ref ProcessModes
|
|
int32 symbolicSampleSize; ///< sample size - value of \ref SymbolicSampleSizes
|
|
int32 numSamples; ///< number of samples to process
|
|
int32 numInputs; ///< number of audio input busses
|
|
int32 numOutputs; ///< number of audio output busses
|
|
AudioBusBuffers* inputs; ///< buffers of input busses
|
|
AudioBusBuffers* outputs; ///< buffers of output busses
|
|
|
|
IParameterChanges* inputParameterChanges; ///< incoming parameter changes for this block
|
|
IParameterChanges* outputParameterChanges; ///< outgoing parameter changes for this block (optional)
|
|
IEventList* inputEvents; ///< incoming events for this block (optional)
|
|
IEventList* outputEvents; ///< outgoing events for this block (optional)
|
|
ProcessContext* processContext; ///< processing context (optional, but most welcome)
|
|
//------------------------------------------------------------------------
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Audio processing interface: Vst::IAudioProcessor
|
|
\ingroup vstIPlug vst300
|
|
- [plug imp]
|
|
- [extends IComponent]
|
|
- [released: 3.0.0]
|
|
- [mandatory]
|
|
|
|
This interface must always be supported by audio processing plug-ins.
|
|
*/
|
|
class IAudioProcessor : public FUnknown
|
|
{
|
|
public:
|
|
//------------------------------------------------------------------------
|
|
/** Try to set (host => plug-in) a wanted arrangement for inputs and outputs.
|
|
* The host should always deliver the same number of input and output busses than the plug-in
|
|
* needs (see \ref IComponent::getBusCount). The plug-in has 3 possibilities to react on this
|
|
* setBusArrangements call:\n
|
|
*
|
|
* 1. The plug-in accepts these arrangements, then it should modify, if needed, its busses to
|
|
* match these new arrangements (later on asked by the host with IComponent::getBusInfo () or
|
|
* IAudioProcessor::getBusArrangement ()) and then should return kResultTrue.\n
|
|
*
|
|
* 2. The plug-in does not accept or support these requested arrangements for all
|
|
* inputs/outputs or just for some or only one bus, but the plug-in can try to adapt its
|
|
* current arrangements according to the requested ones (requested arrangements for kMain busses
|
|
* should be handled with more priority than the ones for kAux busses), then it should modify
|
|
* its busses arrangements and should return kResultFalse.\n
|
|
*
|
|
* 3. Same than the point 2 above the plug-in does not support these requested arrangements but
|
|
* the plug-in cannot find corresponding arrangements, the plug-in could keep its current
|
|
* arrangement or fall back to a default arrangement by modifying its busses arrangements and
|
|
* should return kResultFalse.\n
|
|
*
|
|
* \param inputs pointer to an array of \ref SpeakerArrangement
|
|
* \param numIns number of \ref SpeakerArrangement in inputs array
|
|
* \param outputs pointer to an array of \ref SpeakerArrangement
|
|
* \param numOuts number of \ref SpeakerArrangement in outputs array
|
|
* Returns kResultTrue when Arrangements is supported and is the current one, else returns
|
|
* kResultFalse.
|
|
*
|
|
* \note [UI-thread & (Initialized | Connected | Setup Done)] */
|
|
virtual tresult PLUGIN_API setBusArrangements (SpeakerArrangement* inputs /*in*/,
|
|
int32 numIns /*in*/,
|
|
SpeakerArrangement* outputs /*in*/,
|
|
int32 numOuts /*in*/) = 0;
|
|
|
|
/** Gets the bus arrangement for a given direction (input/output) and index.
|
|
* Note: IComponent::getBusInfo () and IAudioProcessor::getBusArrangement () should be always
|
|
* return the same information about the busses arrangements.
|
|
* \note [UI-thread & (Initialized | Connected | Setup Done | Activated | Processing] */
|
|
virtual tresult PLUGIN_API getBusArrangement (BusDirection dir /*in*/, int32 index /*in*/,
|
|
SpeakerArrangement& arr /*inout*/) = 0;
|
|
|
|
/** Asks if a given sample size is supported see \ref SymbolicSampleSizes.
|
|
* \note [UI-thread & (Initialized | Connected)] */
|
|
virtual tresult PLUGIN_API canProcessSampleSize (int32 symbolicSampleSize /*in*/) = 0;
|
|
|
|
/** Gets the current Latency in samples.
|
|
* The returned value defines the group delay or the latency of the plug-in. For example, if
|
|
* the plug-in internally needs to look in advance (like compressors) 512 samples then this
|
|
* plug-in should report 512 as latency. If during the use of the plug-in this latency change,
|
|
* the plug-in has to inform the host by using IComponentHandler::restartComponent
|
|
* (kLatencyChanged), this could lead to audio playback interruption because the host has to
|
|
* recompute its internal mixer delay compensation. Note that for player live recording this
|
|
* latency should be zero or small.
|
|
* \note [UI-thread & Setup Done] */
|
|
virtual uint32 PLUGIN_API getLatencySamples () = 0;
|
|
|
|
/** Called in disable state (setActive not called with true) before setProcessing is called and
|
|
* processing will begin.
|
|
* \note [UI-thread & (Initialized | Connected)]] */
|
|
virtual tresult PLUGIN_API setupProcessing (ProcessSetup& setup /*in*/) = 0;
|
|
|
|
/** Informs the plug-in about the processing state. This will be called before any process calls
|
|
* start with true and after with false.
|
|
* Note that setProcessing (false) may be called after setProcessing (true) without any process
|
|
* calls.
|
|
* Note this function could be called in the UI or in Processing Thread, thats why the plug-in
|
|
* should only light operation (no memory allocation or big setup reconfiguration),
|
|
* this could be used to reset some buffers (like Delay line or Reverb).
|
|
* The host has to be sure that it is called only when the plug-in is enable (setActive (true)
|
|
* was called).
|
|
* \note [(UI-thread or processing-thread) & Activated] */
|
|
virtual tresult PLUGIN_API setProcessing (TBool state /*in*/) = 0;
|
|
|
|
/** The Process call, where all information (parameter changes, event, audio buffer) are passed.
|
|
* \note [processing-thread & Processing] */
|
|
virtual tresult PLUGIN_API process (ProcessData& data /*in*/) = 0;
|
|
|
|
/** Gets tail size in samples. For example, if the plug-in is a Reverb plug-in and it knows that
|
|
* the maximum length of the Reverb is 2sec, then it has to return in getTailSamples ()
|
|
* (in VST2 it was getGetTailSize ()): 2*sampleRate.
|
|
* This information could be used by host for offline processing, process optimization and
|
|
* downmix (avoiding signal cut (clicks)).
|
|
* It should return:
|
|
* - kNoTail when no tail
|
|
* - x * sampleRate when x Sec tail.
|
|
* - kInfiniteTail when infinite tail.
|
|
*
|
|
* \note [UI-thread & Setup Done] */
|
|
virtual uint32 PLUGIN_API getTailSamples () = 0;
|
|
|
|
//------------------------------------------------------------------------
|
|
static const FUID iid;
|
|
};
|
|
|
|
DECLARE_CLASS_IID (IAudioProcessor, 0x42043F99, 0xB7DA453C, 0xA569E79D, 0x9AAEC33D)
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Extended IAudioProcessor interface for a component: Vst::IAudioPresentationLatency
|
|
\ingroup vstIPlug vst310
|
|
- [plug imp]
|
|
- [extends IAudioProcessor]
|
|
- [released: 3.1.0]
|
|
- [optional]
|
|
|
|
Inform the plug-in about how long from the moment of generation/acquiring (from file or from Input)
|
|
it will take for its input to arrive, and how long it will take for its output to be presented (to
|
|
output or to speaker).
|
|
|
|
Note for Input Presentation Latency: when reading from file, the first plug-in will have an input
|
|
presentation latency set to zero. When monitoring audio input from an audio device, the initial
|
|
input latency is the input latency of the audio device itself.
|
|
|
|
Note for Output Presentation Latency: when writing to a file, the last plug-in will have an output
|
|
presentation latency set to zero. When the output of this plug-in is connected to an audio device,
|
|
the initial output latency is the output latency of the audio device itself.
|
|
|
|
A value of zero either means no latency or an unknown latency.
|
|
|
|
Each plug-in adding a latency (returning a none zero value for IAudioProcessor::getLatencySamples)
|
|
will modify the input presentation latency of the next plug-ins in the mixer routing graph and will
|
|
modify the output presentation latency of the previous plug-ins.
|
|
|
|
\n
|
|
\image html "iaudiopresentationlatency_usage.png"
|
|
\n
|
|
\see IAudioProcessor
|
|
\see IComponent
|
|
*/
|
|
class IAudioPresentationLatency : public FUnknown
|
|
{
|
|
public:
|
|
//------------------------------------------------------------------------
|
|
/** Informs the plug-in about the Audio Presentation Latency in samples for a given direction
|
|
* (kInput/kOutput) and bus index.
|
|
* \note [UI-thread & Activated] */
|
|
virtual tresult PLUGIN_API setAudioPresentationLatencySamples (
|
|
BusDirection dir /*in*/, int32 busIndex /*in*/, uint32 latencyInSamples /*in*/) = 0;
|
|
|
|
//------------------------------------------------------------------------
|
|
static const FUID iid;
|
|
};
|
|
|
|
DECLARE_CLASS_IID (IAudioPresentationLatency, 0x309ECE78, 0xEB7D4fae, 0x8B2225D9, 0x09FD08B6)
|
|
|
|
//------------------------------------------------------------------------
|
|
/** Extended IAudioProcessor interface for a component: Vst::IProcessContextRequirements
|
|
\ingroup vstIPlug vst370
|
|
- [plug imp]
|
|
- [extends IAudioProcessor]
|
|
- [released: 3.7.0]
|
|
- [mandatory]
|
|
|
|
To get accurate process context information (Vst::ProcessContext), it is now required to implement
|
|
this interface and return the desired bit mask of flags which your audio effect needs. If you do not
|
|
implement this interface, you may not get any information at all of the process function!
|
|
|
|
The host asks for this information once between initialize and setActive (in Setup Done). It cannot
|
|
be changed afterwards.
|
|
|
|
This gives the host the opportunity to better optimize the audio process graph when it knows which
|
|
plug-ins need which information.
|
|
|
|
Plug-ins built with an earlier SDK version (< 3.7) will still get the old information, but the
|
|
information may not be as accurate as when using this interface.
|
|
*/
|
|
class IProcessContextRequirements : public FUnknown
|
|
{
|
|
public:
|
|
enum Flags
|
|
{
|
|
kNeedSystemTime = 1 << 0, // kSystemTimeValid
|
|
kNeedContinousTimeSamples = 1 << 1, // kContTimeValid
|
|
kNeedProjectTimeMusic = 1 << 2, // kProjectTimeMusicValid
|
|
kNeedBarPositionMusic = 1 << 3, // kBarPositionValid
|
|
kNeedCycleMusic = 1 << 4, // kCycleValid
|
|
kNeedSamplesToNextClock = 1 << 5, // kClockValid
|
|
kNeedTempo = 1 << 6, // kTempoValid
|
|
kNeedTimeSignature = 1 << 7, // kTimeSigValid
|
|
kNeedChord = 1 << 8, // kChordValid
|
|
kNeedFrameRate = 1 << 9, // kSmpteValid
|
|
kNeedTransportState = 1 << 10, // kPlaying, kCycleActive, kRecording
|
|
};
|
|
/** Allows the host to ask the plug-in what is really needed for the process context information
|
|
* (Vst::ProcessContext).
|
|
* \note [UI-thread & Setup Done] */
|
|
virtual uint32 PLUGIN_API getProcessContextRequirements () = 0;
|
|
|
|
//------------------------------------------------------------------------
|
|
static const FUID iid;
|
|
};
|
|
|
|
DECLARE_CLASS_IID (IProcessContextRequirements, 0x2A654303, 0xEF764E3D, 0x95B5FE83, 0x730EF6D0)
|
|
|
|
//------------------------------------------------------------------------
|
|
} // namespace Vst
|
|
} // namespace Steinberg
|
|
|
|
//------------------------------------------------------------------------
|
|
#include "pluginterfaces/base/falignpop.h"
|
|
//------------------------------------------------------------------------
|