pluginbase.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Plugin Kernel File:  pluginbase.h
//
// -----------------------------------------------------------------------------
#ifndef __PluginBase__
#define __PluginBase__
 
#include "pluginparameter.h"
#include <map>
 
class PluginBase
{
public:
    PluginBase();
    virtual ~PluginBase();
 
    // --- PURE VIRTUAL FUNCTIONS ---------------------------------------------------------------------------------------------------- //
    virtual bool processAudioFrame(ProcessFrameInfo& processFrameInfo) = 0;
 
    virtual bool updatePluginParameter(int32_t controlID, double controlValue, ParameterUpdateInfo& paramInfo) = 0;
 
    virtual bool updatePluginParameterNormalized(int32_t controlID, double normalizedValue, ParameterUpdateInfo& paramInfo) = 0;
 
    virtual bool postUpdatePluginParameter(int32_t controlID, double controlValue, ParameterUpdateInfo& paramInfo) = 0;
 
    virtual bool preProcessAudioBuffers(ProcessBufferInfo& processInfo) = 0;
 
    virtual bool postProcessAudioBuffers(ProcessBufferInfo& processInfo) = 0;
    // ----------------------------------------------------------------------------------------------------------------------------- //
 
    virtual bool reset(ResetInfo& resetInfo);
 
    virtual bool initialize(PluginInfo& _pluginInfo);
 
    void syncInBoundVariables();
 
    virtual bool processAudioBuffers(ProcessBufferInfo& processInfo);
 
    virtual bool preProcessAudioBlock(IMidiEventQueue* midiEventQueue = nullptr) { return true; }
 
    virtual bool processAudioBlock(ProcessBlockInfo& processBlockInfo) { return true; }
 
    bool updateOutBoundVariables();
 
    virtual bool guiParameterChanged(int32_t controlID, double actualValue) { return true; }
 
    virtual bool processMessage(MessageInfo& messageInfo) { return true; }
 
    virtual bool processMIDIEvent(midiEvent& event) { return true; }
 
    bool doVST3SAAUpdates();
 
    bool doParameterSmoothing();
 
    virtual bool setVectorJoystickParameters(const VectorJoystickData& vectorJoysickData) { return true; }
 
    int32_t addPluginParameter(PluginParameter* piParam, double sampleRate = 44100);
 
    void setParamAuxAttribute(uint32_t controlID, const AuxParameterAttribute& auxAttribute);
 
    size_t getPluginParameterCount(){ return pluginParameters.size(); }
 
    PluginParameter* getPluginParameterByIndex(int32_t index) { return pluginParameters[index]; }
 
    PluginParameter* getPluginParameterByControlID(int32_t controlID) { return pluginParameterMap[controlID]; }
 
    PluginParameter* getNextParameterOfType(int32_t& startIndex, controlVariableType controlType);
 
    double getPIParamValueDouble(int32_t controlID);
 
    float getPIParamValueFloat(int32_t controlID);
 
    int getPIParamValueInt(int32_t controlID);
 
    uint32_t getPIParamValueUInt(int32_t controlID);
 
    bool hasProToolsGRMeters();
 
    double getProToolsGRValue();
 
    uint32_t addSupportedIOCombination(ChannelIOConfig ioConfig);
 
    uint32_t addSupportedAuxIOCombination(ChannelIOConfig ioConfig);
 
    uint32_t getNumSupportedIOCombinations() {return pluginDescriptor.numSupportedIOCombinations;}
 
    bool hasSupportedInputChannelFormat(uint32_t channelFormat);
 
    bool hasSupportedOutputChannelFormat(uint32_t channelFormat);
 
    int32_t getChannelInputFormat(uint32_t ioConfigIndex) {return pluginDescriptor.supportedIOCombinations[ioConfigIndex].inputChannelFormat;}
 
    int32_t getChannelOutputFormat(uint32_t ioConfigIndex) {return pluginDescriptor.supportedIOCombinations[ioConfigIndex].outputChannelFormat;}
 
    uint32_t getInputChannelCount(uint32_t ioConfigIndex);
 
    uint32_t getOutputChannelCount(uint32_t ioConfigIndex);
 
    uint32_t getDefaultChannelIOConfigForChannelCount(uint32_t channelCount) { return pluginDescriptor.getDefaultChannelIOConfigForChannelCount(channelCount); }
 
    void setPIParamValue(uint32_t _controlID, double _controlValue);
 
    double setPIParamValueNormalized(uint32_t _controlID, double _normalizedValue, bool applyTaper = true);
 
    bool updatePIParamBoundValue(uint32_t _controlID);
 
    void clearUpdateGUIParameters(std::vector<GUIParameter*>& guiParameters);
 
    std::vector<PluginParameter*>* makePluginParameterVectorCopy(bool disableSmoothing = true);
 
    bool initPresetParameters(std::vector<PresetParameter>& presetParameters, bool disableSmoothing = true);
 
    bool setPresetParameter(std::vector<PresetParameter>& presetParameters, uint32_t _controlID, double _controlValue);
 
    void setPluginHostConnector(IPluginHostConnector* _pluginHostConnector){pluginHostConnector = _pluginHostConnector;}
 
    size_t getPresetCount(){return presets.size();}
 
    const char* getPresetName(uint32_t index);
 
    size_t addPreset(PresetInfo* preset);
 
    void removePreset(uint32_t index);
 
    void removeAllPresets();
 
    PresetInfo* getPreset(uint32_t index);
 
    void initPluginParameterArray();
 
    bool compareSelectedString(int32_t controlID, const char* compareString);
 
    bool hasSidechain() { return pluginDescriptor.hasSidechain; }
 
    bool wantsMIDI() { return pluginDescriptor.wantsMIDI; }
 
    bool hasCustomGUI() { return pluginDescriptor.hasCustomGUI; }
 
    double getLatencyInSamples() { return pluginDescriptor.latencyInSamples; }
 
    double getTailTimeInMSec() { return pluginDescriptor.tailTimeInMSec; }
 
    bool wantsInfiniteTailVST3() { return pluginDescriptor.infiniteTailVST3; }
 
    const char* getPluginName() { return pluginDescriptor.pluginName.c_str(); }
 
    const char* getShortPluginName() { return pluginDescriptor.shortPluginName.c_str(); }
 
    const char* getVendorName() { return pluginDescriptor.vendorName.c_str(); }
 
    uint32_t getPluginType() { return pluginDescriptor.pluginTypeCode; }
 
    double getSampleRate() { return audioProcDescriptor.sampleRate; }
 
    int getFourCharCode() { return apiSpecificInfo.fourCharCode; }
 
    const uint32_t getAAXManufacturerID() { return apiSpecificInfo.aaxManufacturerID; }
 
    const uint32_t getAAXProductID() { return apiSpecificInfo.aaxProductID; }
 
    const char* getAAXBundleID() { return apiSpecificInfo.aaxBundleID.c_str(); }
 
    const char* getAAXEffectID() { return apiSpecificInfo.aaxEffectID.c_str(); }
 
    uint32_t getAAXPluginCategory() { return apiSpecificInfo.aaxPluginCategoryCode; }
 
    const char* getVST3_FUID() { return apiSpecificInfo.vst3FUID.c_str(); }
 
    bool wantsVST3SampleAccurateAutomation() { return apiSpecificInfo.enableVST3SampleAccurateAutomation; }
 
    uint32_t getVST3SampleAccuracyGranularity() { return apiSpecificInfo.vst3SampleAccurateGranularity; }
 
    const char* getVST3BundleID() { return apiSpecificInfo.vst3BundleID.c_str(); }
 
    const char* getAUBundleID() { return apiSpecificInfo.auBundleID.c_str(); }
 
    const char* getAUBundleName() { return apiSpecificInfo.auBundleName.c_str(); }
 
protected:
    PluginDescriptor pluginDescriptor;          
    APISpecificInfo apiSpecificInfo;            
    AudioProcDescriptor audioProcDescriptor;    
    PluginInfo pluginInfo;                      
 
    // --- arrays for frame processing
    float inputFrame[MAX_CHANNEL_COUNT];        
    float outputFrame[MAX_CHANNEL_COUNT];       
    float auxInputFrame[MAX_CHANNEL_COUNT];     
    float auxOutputFrame[MAX_CHANNEL_COUNT];    
 
    // --- block info struct (optional for block processing, if enabled)
    ProcessBlockInfo processBlockInfo;
 
    // --- ultra-fast access ***for real-time audio processing***
    PluginParameter** pluginParameterArray = nullptr;           
    uint32_t numPluginParameters = 0;                           
 
    PluginParameter** VSTSAAPluginParameters = nullptr;     
    uint32_t numVSTSAAPluginParameters = 0;                 
 
    PluginParameter** smoothingPluginParameters = nullptr;      
    uint32_t numSmoothingPluginParameters = 0;                  
 
    PluginParameter** outboundPluginParameters = nullptr;       
    uint32_t numOutboundPluginParameters = 0;                   
 
    // --- vectorized version of pluginParameterMap for faster iteration that the map version below
    std::vector<PluginParameter*> pluginParameters;             
 
    // --- map<controlID , PluginParameter*> NOTE: VERY SLOW ITERATIONS -- only used for non-audio proc thread stuff
    typedef std::map<uint32_t, PluginParameter*> pluginParameterControlIDMap;   
    pluginParameterControlIDMap pluginParameterMap;                             
 
    // --- plugin core -> host (wrap) connector
    IPluginHostConnector* pluginHostConnector = nullptr;                        
 
    // --- PRESETS
    std::vector<PresetInfo*> presets;   
};
 
#endif /* defined(__PluginBase__) */