ivstaudioprocessor.h

Go to the documentation of this file.

//------------------------------------------------------------------------
// 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"
//------------------------------------------------------------------------
 
//------------------------------------------------------------------------
//------------------------------------------------------------------------
#ifndef kVstAudioEffectClass
#define kVstAudioEffectClass "Audio Module Class"
#endif
 
//------------------------------------------------------------------------
namespace Steinberg {
namespace Vst {
 
class IEventList;
class IParameterChanges;
struct ProcessContext;
 
//------------------------------------------------------------------------
namespace PlugType
{
//------------------------------------------------------------------------
const CString kFxAnalyzer                       = "Fx|Analyzer";        
const CString kFxDelay                          = "Fx|Delay";           
const CString kFxDistortion                     = "Fx|Distortion";      
const CString kFxDynamics                       = "Fx|Dynamics";        
const CString kFxEQ                                     = "Fx|EQ";                      
const CString kFxFilter                         = "Fx|Filter";          
const CString kFx                                       = "Fx";                         
const CString kFxInstrument                     = "Fx|Instrument";      
const CString kFxInstrumentExternal     = "Fx|Instrument|External";     
const CString kFxSpatial                        = "Fx|Spatial";         
const CString kFxGenerator                      = "Fx|Generator";       
const CString kFxMastering                      = "Fx|Mastering";       
const CString kFxModulation                     = "Fx|Modulation";      
const CString kFxPitchShift                     = "Fx|Pitch Shift";     
const CString kFxRestoration            = "Fx|Restoration";     
const CString kFxReverb                         = "Fx|Reverb";          
const CString kFxSurround                       = "Fx|Surround";        
const CString kFxTools                          = "Fx|Tools";           
const CString kFxNetwork                        = "Fx|Network";         
 
const CString kInstrument                       = "Instrument";                 
const CString kInstrumentDrum           = "Instrument|Drum";    
const CString kInstrumentExternal       = "Instrument|External";
const CString kInstrumentPiano          = "Instrument|Piano";   
const CString kInstrumentSampler        = "Instrument|Sampler"; 
const CString kInstrumentSynth          = "Instrument|Synth";   
const CString kInstrumentSynthSampler = "Instrument|Synth|Sampler";     
 
const CString kSpatial                          = "Spatial";            
const CString kSpatialFx                        = "Spatial|Fx";         
const CString kOnlyRealTime                     = "OnlyRT";                     
const CString kOnlyOfflineProcess       = "OnlyOfflineProcess"; 
const CString kOnlyARA                          = "OnlyARA";            
 
const CString kNoOfflineProcess         = "NoOfflineProcess";   
const CString kUpDownMix                        = "Up-Downmix";         
const CString kAnalyzer                     = "Analyzer";           
const CString kAmbisonics                       = "Ambisonics";         
 
const CString kMono                                     = "Mono";                       
const CString kStereo                           = "Stereo";                     
const CString kSurround                         = "Surround";           
 
//------------------------------------------------------------------------
}
 
//------------------------------------------------------------------------
enum ComponentFlags
{
//------------------------------------------------------------------------
        kDistributable                  = 1 << 0,       
        kSimpleModeSupported    = 1 << 1        
//------------------------------------------------------------------------
};
 
//------------------------------------------------------------------------
enum SymbolicSampleSizes
{
        kSample32,              
        kSample64               
};
 
//------------------------------------------------------------------------
enum ProcessModes
{
        kRealtime,              
        kPrefetch,              
        kOffline                
};
 
//------------------------------------------------------------------------
static const uint32 kNoTail = 0;
 
//------------------------------------------------------------------------
static const uint32 kInfiniteTail = kMaxInt32u;
 
//------------------------------------------------------------------------
struct ProcessSetup
{
//------------------------------------------------------------------------
        int32 processMode;                      
        int32 symbolicSampleSize;       
        int32 maxSamplesPerBlock;       
        SampleRate sampleRate;          
//------------------------------------------------------------------------
};
 
//------------------------------------------------------------------------
struct AudioBusBuffers
{
        AudioBusBuffers () : numChannels (0), silenceFlags (0), channelBuffers64 (nullptr) {}
 
//------------------------------------------------------------------------
        int32 numChannels;              
        uint64 silenceFlags;    
        union
        {
                Sample32** channelBuffers32;    
                Sample64** channelBuffers64;    
        };
//------------------------------------------------------------------------
};
 
//------------------------------------------------------------------------
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;                      
        int32 symbolicSampleSize;   
        int32 numSamples;                       
        int32 numInputs;                        
        int32 numOutputs;                       
        AudioBusBuffers* inputs;        
        AudioBusBuffers* outputs;       
 
        IParameterChanges* inputParameterChanges;       
        IParameterChanges* outputParameterChanges;      
        IEventList* inputEvents;                                
        IEventList* outputEvents;                               
        ProcessContext* processContext;                 
//------------------------------------------------------------------------
};
 
//------------------------------------------------------------------------
class IAudioProcessor : public FUnknown
{
public:
//------------------------------------------------------------------------
        virtual tresult PLUGIN_API setBusArrangements (SpeakerArrangement* inputs, int32 numIns,
                                                                                                   SpeakerArrangement* outputs, int32 numOuts) = 0;

        virtual tresult PLUGIN_API getBusArrangement (BusDirection dir, int32 index, SpeakerArrangement& arr) = 0;

        virtual tresult PLUGIN_API canProcessSampleSize (int32 symbolicSampleSize) = 0;

        virtual uint32 PLUGIN_API getLatencySamples () = 0;

        virtual tresult PLUGIN_API setupProcessing (ProcessSetup& setup) = 0;

        virtual tresult PLUGIN_API setProcessing (TBool state) = 0;

        virtual tresult PLUGIN_API process (ProcessData& data) = 0;

        virtual uint32 PLUGIN_API getTailSamples () = 0;
 
//------------------------------------------------------------------------
        static const FUID iid;
};
 
DECLARE_CLASS_IID (IAudioProcessor, 0x42043F99, 0xB7DA453C, 0xA569E79D, 0x9AAEC33D)
 
//------------------------------------------------------------------------
class IAudioPresentationLatency : public FUnknown
{
public:
        //------------------------------------------------------------------------
        virtual tresult PLUGIN_API setAudioPresentationLatencySamples (BusDirection dir, int32 busIndex, uint32 latencyInSamples) = 0;
 
        //------------------------------------------------------------------------
        static const FUID iid;
};
 
DECLARE_CLASS_IID (IAudioPresentationLatency, 0x309ECE78, 0xEB7D4fae, 0x8B2225D9, 0x09FD08B6)
 
//------------------------------------------------------------------------
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
        };
        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"
//------------------------------------------------------------------------