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);

    void syncInBoundVariables();

    virtual bool processAudioBuffers(ProcessBufferInfo& processInfo);

    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; }

    void doSampleAccurateParameterUpdates();

    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;    

    // --- arrays for frame processing
    float inputFrame[MAX_CHANNEL_COUNT];        
    float outputFrame[MAX_CHANNEL_COUNT];       
    float auxInputFrame[MAX_CHANNEL_COUNT];     
    float auxOutputFrame[MAX_CHANNEL_COUNT];    

    // --- ultra-fast access for real-time audio processing
    PluginParameter** pluginParameterArray = nullptr;           
    uint32_t numPluginParameters = 0;                           
    PluginParameter** smoothablePluginParameters = nullptr;     
    uint32_t numSmoothablePluginParameters = 0;                 
    PluginParameter** outboundPluginParameters = nullptr;       
    uint32_t numOutboundPluginParameters = 0;                   

    // --- vectorized version of pluginParameterMap for fast iteration when key not needed
    std::vector<PluginParameter*> pluginParameters;             

    // --- map<controlID , PluginParameter*>
    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__) */