pluginstructures.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Plugin Kernel File:  pluginstructures.h
//
// -----------------------------------------------------------------------------
#ifndef _pluginstructures_h
#define _pluginstructures_h
 
// --- support multichannel operation up to 128 channels
#define MAX_CHANNEL_COUNT 128
 
#include <string>
#include <sstream>
#include <vector>
#include <stdint.h>
 
#include "readerwriterqueue.h"
#include "atomicops.h"
 
class IGUIPluginConnector;
class IGUIWindowFrame;
class IGUIView;
 
#ifdef AUPLUGIN
#import <CoreFoundation/CoreFoundation.h>
#import <AudioUnit/AudioUnit.h>
#import <AudioToolbox/AudioToolbox.h>
 
typedef struct
{
    void* pWindow;
    float width;
    float height;
    AudioUnit au;
    IGUIWindowFrame* pGUIFrame;
    IGUIView* pGUIView;
} VIEW_STRUCT;
#endif
 
 
enum pluginType
{
    kFXPlugin,
    kSynthPlugin
};
 
enum aaxPlugInCategory
{
    aaxPlugInCategory_None              = 0x00000000,
    aaxPlugInCategory_EQ                = 0x00000001,   
    aaxPlugInCategory_Dynamics          = 0x00000002,   
    aaxPlugInCategory_PitchShift        = 0x00000004,   
    aaxPlugInCategory_Reverb            = 0x00000008,   
    aaxPlugInCategory_Delay             = 0x00000010,   
    aaxPlugInCategory_Modulation        = 0x00000020,   
    aaxPlugInCategory_Harmonic          = 0x00000040,   
    aaxPlugInCategory_NoiseReduction    = 0x00000080,   
    aaxPlugInCategory_Dither            = 0x00000100,   
    aaxPlugInCategory_SoundField        = 0x00000200,   
    aaxPlugInCategory_HWGenerators      = 0x00000400,   
    aaxPlugInCategory_SWGenerators      = 0x00000800,   
    aaxPlugInCategory_WrappedPlugin     = 0x00001000,   
    aaxPlugInCategory_Effect            = 0x00002000,   
};
 
enum channelFormat
{
    kCFNone,
    kCFMono,
    kCFStereo,
    kCFLCR,
    kCFLCRS,
    kCFQuad,
    kCF5p0,
    kCF5p1,
    kCF6p0,
    kCF6p1,
    kCF7p0Sony,
    kCF7p0DTS,
    kCF7p1Sony,
    kCF7p1DTS,
    kCF7p1Proximity,
 
    /* the following are NOT directly suppported by AAX/AU */
    kCF8p1,
    kCF9p0,
    kCF9p1,
    kCF10p0,
    kCF10p1,
    kCF10p2,
    kCF11p0,
    kCF11p1,
    kCF12p2,
    kCF13p0,
    kCF13p1,
    kCF22p2,
};
 
enum auxGUIIdentifier
{
    GUIKnobGraphic,
    GUI2SSButtonStyle,
    EnableMIDIControl,
    MIDIControlChannel,
    MIDIControlIndex,
    midiControlData,
    guiControlData
};
 
struct ResetInfo
{
    ResetInfo()
        : sampleRate(44100)
        , bitDepth(16) {}
 
    ResetInfo(double _sampleRate,
        uint32_t _bitDepth)
        : sampleRate(_sampleRate)
        , bitDepth(_bitDepth) {}
 
    double sampleRate = 0.0;    
    uint32_t bitDepth = 0;      
};
 
struct APISpecificInfo
{
    APISpecificInfo ()
    : aaxManufacturerID(0) /* change this in the plugin core constructor */
    , aaxProductID(0)      /* change this in the plugin core constructor */
    , aaxEffectID("")
    , aaxPluginCategoryCode(aaxPlugInCategory::aaxPlugInCategory_Effect)
    , fourCharCode(0)
    , vst3FUID("")
    , enableVST3SampleAccurateAutomation(0)
    , vst3SampleAccurateGranularity(1)
    , vst3BundleID("")
    , auBundleID("")
    {}
 
    APISpecificInfo& operator=(const APISpecificInfo& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        aaxManufacturerID = data.aaxManufacturerID;
        aaxProductID = data.aaxProductID;
        aaxEffectID = data.aaxEffectID;
        aaxBundleID = data.aaxBundleID;
        aaxPluginCategoryCode = data.aaxPluginCategoryCode;
 
        fourCharCode = data.fourCharCode;
        vst3FUID = data.vst3FUID;
 
        enableVST3SampleAccurateAutomation = data.enableVST3SampleAccurateAutomation;
        vst3SampleAccurateGranularity = data.vst3SampleAccurateGranularity;
        vst3BundleID = data.vst3BundleID;
        auBundleID = data.auBundleID;
        auBundleName = data.auBundleName;
 
        return *this;
    }
 
    uint32_t aaxManufacturerID = 0;         
    uint32_t aaxProductID = 0;              
    std::string aaxEffectID;                
    std::string aaxBundleID;                
    uint32_t aaxPluginCategoryCode = 0;     
 
    // --- common to AU and AAX
    int fourCharCode = 0;                   
 
    // --- VST3
    std::string vst3FUID;                               
    bool enableVST3SampleAccurateAutomation = false;    
    uint32_t vst3SampleAccurateGranularity = 1;         
    std::string vst3BundleID;                           
 
    // --- AU
    std::string auBundleID;         
    std::string auBundleName;       
 
 };
 
struct VectorJoystickData
{
    VectorJoystickData()
        : vectorA(0.0)
        , vectorB(0.0)
        , vectorC(0.0)
        , vectorD(0.0)
        , vectorACMix(0.0)
        , vectorBDMix(0.0) {}
 
    VectorJoystickData(double _vectorA, double _vectorB, double _vectorC, double _vectorD, double _vectorACMix, double _vectorBDMix)
        : vectorA(_vectorA)
        , vectorB(_vectorB)
        , vectorC(_vectorC)
        , vectorD(_vectorD)
        , vectorACMix(_vectorACMix)
        , vectorBDMix(_vectorBDMix) {}
 
    VectorJoystickData& operator=(const VectorJoystickData& vsData) // need this override for collections to work
    {
        if (this == &vsData)
            return *this;
 
        vectorA = vsData.vectorA;
        vectorB = vsData.vectorB;
        vectorC = vsData.vectorC;
        vectorD = vsData.vectorD;
 
        vectorACMix = vsData.vectorACMix;
        vectorBDMix = vsData.vectorBDMix;
 
        return *this;
    }
 
    double vectorA = 0.0;
    double vectorB = 0.0;
    double vectorC = 0.0;
    double vectorD = 0.0;
 
    double vectorACMix = 0.0;
    double vectorBDMix = 0.0;
};
 
 
struct GUIParameter
{
    GUIParameter()
        : controlID(0)
        , actualValue(0.0)
        , useCustomData(0)
        , customData(0) {}
 
    GUIParameter& operator=(const GUIParameter& data)   // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        controlID = data.controlID;
        actualValue = data.actualValue;
        useCustomData = data.useCustomData;
        customData = data.customData;
 
        return *this;
    }
 
    uint32_t controlID = 0;     
    double actualValue = 0.0;   
    bool useCustomData = false; 
 
    // --- for custom drawing, or other custom data
    void* customData = nullptr; 
};
 
struct PresetParameter
{
    PresetParameter ()
    : controlID(0)
    , actualValue(0.0){}
 
    PresetParameter (uint32_t _controlID, double _actualValue)
    : controlID(_controlID)
    , actualValue(_actualValue){}
 
    PresetParameter& operator=(const PresetParameter& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        controlID = data.controlID;
        actualValue = data.actualValue;
        return *this;
    }
 
    uint32_t controlID = 0;     
    double actualValue = 0.0;   
};
 
struct PresetInfo
{
    PresetInfo(uint32_t _presetIndex, const char* _name)
    : presetIndex(_presetIndex)
    , presetName(_name) {}
 
    PresetInfo& operator=(const PresetInfo& data)   // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        presetIndex = data.presetIndex;
        presetName = data.presetName;
        presetParameters = data.presetParameters;
 
        return *this;
    }
 
    uint32_t presetIndex = 0;       
    std::string presetName;         
 
    std::vector<PresetParameter> presetParameters;  
};
 
struct GUIUpdateData
{
    GUIUpdateData& operator=(const GUIUpdateData& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        guiUpdateCode = data.guiUpdateCode;
        guiParameters = data.guiParameters;
        customData = data.customData;
        useCustomData = data.useCustomData;
 
        return *this;
    }
 
    uint32_t guiUpdateCode = -1; 
 
    // --- for control updates
    std::vector<GUIParameter> guiParameters; 
 
    // --- for custom draw updates (graphs, etc...)
    void* customData = nullptr; 
 
    // --- flag
    bool useCustomData = false; 
};
 
enum hostMessage { sendGUIUpdate, sendRAFXStatusWndText };
 
struct HostMessageInfo
{
    HostMessageInfo()
        : hostMessage(0){}
 
    HostMessageInfo& operator=(const HostMessageInfo& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        hostMessage = data.hostMessage;
        guiParameter = data.guiParameter;
        guiUpdateData = data.guiUpdateData;
        rafxStatusWndText = data.rafxStatusWndText;
 
        return *this;
    }
 
    uint32_t hostMessage = 0;
    GUIParameter guiParameter;      /* for single param updates */
 
    // --- for GUI messages
    GUIUpdateData guiUpdateData;    /* for multiple param updates */
    std::string rafxStatusWndText;
};
 
 
struct ChannelIOConfig
{
    ChannelIOConfig ()
    : inputChannelFormat(kCFStereo)
    , outputChannelFormat(kCFStereo) {}
 
    ChannelIOConfig (uint32_t _inputChannelFormat,
                     uint32_t _outputChannelFormat)
    : inputChannelFormat(_inputChannelFormat)
    , outputChannelFormat(_outputChannelFormat){}
 
    ChannelIOConfig& operator=(const ChannelIOConfig& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        inputChannelFormat = data.inputChannelFormat;
        outputChannelFormat = data.outputChannelFormat;
 
        return *this;
    }
 
    uint32_t inputChannelFormat = kCFStereo;    
    uint32_t outputChannelFormat = kCFStereo;   
 
};
 
struct midiEvent
{
    midiEvent(uint32_t _midiMessage, uint32_t _midiChannel, uint32_t _midiData1, uint32_t _midiData2, uint32_t _midiSampleOffset)
        : midiMessage(_midiMessage)
        , midiChannel(_midiChannel)
        , midiData1(_midiData1)
        , midiData2(_midiData2)
        , midiSampleOffset(_midiSampleOffset)
    {
        midiPitchBendValue = 0;
        midiNormalizedPitchBendValue = 0.f;
        midiIsDirty = false;
        auxUintData1 = 0;
        auxUintData2 = 0;
        auxIntData1 = -1;
        auxIntData2 = -1;
        auxDoubleData1 = 0.0;
        auxDoubleData2 = 0.0;
    }
 
    midiEvent(uint32_t _midiMessage, uint32_t _midiChannel, uint32_t _midiData1, uint32_t _midiData2, uint32_t _midiSampleOffset, double _audioTimeStamp)
        : midiMessage(_midiMessage)
        , midiChannel(_midiChannel)
        , midiData1(_midiData1)
        , midiData2(_midiData2)
        , midiSampleOffset(_midiSampleOffset)
        , audioTimeStamp(_audioTimeStamp)
    {
        midiPitchBendValue = 0;
        midiNormalizedPitchBendValue = 0.f;
        midiIsDirty = false;
        auxUintData1 = 0;
        auxUintData2 = 0;
        auxIntData1 = -1;
        auxIntData2 = -1;
        auxDoubleData1 = 0.0;
        auxDoubleData2 = 0.0;
    }
 
    midiEvent ()
    : midiMessage(0)
    , midiChannel(0)
    , midiData1(0)
    , midiData2(0)
    , midiSampleOffset(0)
    , auxUintData1(0)
    , auxUintData2(0)
    , auxIntData1(-1)
    , auxIntData2(-1)
    , auxDoubleData1(0.0)
    , auxDoubleData2(0.0)
    , midiPitchBendValue(0)
    , midiNormalizedPitchBendValue(0)
    , midiIsDirty(0)
    , audioTimeStamp(0.0){}
 
    midiEvent& operator=(const midiEvent& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        midiMessage = data.midiMessage;
        midiChannel = data.midiChannel;
        midiData1 = data.midiData1;
        midiData2 = data.midiData2;
        midiSampleOffset = data.midiSampleOffset;
        auxUintData1 = data.auxUintData1;
        auxUintData2 = data.auxUintData2;
        auxIntData1 = data.auxIntData1;
        auxIntData2 = data.auxIntData2;
        auxDoubleData1 = data.auxDoubleData1;
        auxDoubleData2 = data.auxDoubleData2;
        midiPitchBendValue = data.midiPitchBendValue;
        midiNormalizedPitchBendValue = data.midiNormalizedPitchBendValue;
        midiIsDirty = data.midiIsDirty;
        audioTimeStamp = data.audioTimeStamp;
 
        return *this;
    }
 
    uint32_t    midiMessage = 0;            
    uint32_t    midiChannel = 0;            
    uint32_t    midiData1 = 0;              
    uint32_t    midiData2 = 0;              
    uint32_t    midiSampleOffset = 0;       
    uint32_t    auxUintData1 = 0;           
    uint32_t    auxUintData2 = 0;           
    int32_t     auxIntData1 = 0;            
    int32_t     auxIntData2 = 0;            
    double      auxDoubleData1 = 0.0;       
    double      auxDoubleData2 = 0.0;       
    int         midiPitchBendValue = 0;     
    float       midiNormalizedPitchBendValue = 0.0;
    bool        midiIsDirty = false;        
    double      audioTimeStamp = 0.0;       
};
 
 
enum messageType {
    PLUGINGUI_DIDOPEN,                       /* called after successful population of GUI frame, NOT called with GUI_USER_CUSTOMOPEN*/
    PLUGINGUI_WILLCLOSE,                     /* called before window is destroyed, NOT called with GUI_USER_CUSTOM_CLOSE */
    PLUGINGUI_TIMERPING,                    /* timer ping for custom views */
    PLUGINGUI_REGISTER_CUSTOMVIEW,          /* register a custom view */
    PLUGINGUI_DE_REGISTER_CUSTOMVIEW,       /* un-register a custom view */
    PLUGINGUI_REGISTER_SUBCONTROLLER,       /* register a subcontroller */
    PLUGINGUI_DE_REGISTER_SUBCONTROLLER,    /* un-register a subcontroller */
    PLUGINGUI_QUERY_HASUSERCUSTOM,          /* CUSTOM GUI - reply in bHasUserCustomView */
    PLUGINGUI_USER_CUSTOMOPEN,              /* CUSTOM GUI - create your custom GUI, you must supply the code */
    PLUGINGUI_USER_CUSTOMCLOSE,             /* CUSTOM GUI - destroy your custom GUI, you must supply the code */
    PLUGINGUI_USER_CUSTOMSYNC,              /* CUSTOM GUI - re-sync the GUI */
    PLUGINGUI_EXTERNAL_SET_NORMVALUE,       // for VST3??
    PLUGINGUI_EXTERNAL_SET_ACTUALVALUE,
    PLUGINGUI_EXTERNAL_GET_NORMVALUE,       /* currently not used */
    PLUGINGUI_EXTERNAL_GET_ACTUALVALUE,
    PLUGINGUI_PARAMETER_CHANGED,            /* for pluginCore->guiParameterChanged(nControlIndex, fValue); */
    PLUGIN_QUERY_DESCRIPTION,               /* fill in a Rafx2PluginDescriptor for host */
    PLUGIN_QUERY_PARAMETER,                 /* fill in a Rafx2PluginParameter for host inMessageData = index of parameter*/
    PLUGIN_QUERY_TRACKPAD_X,
    PLUGIN_QUERY_TRACKPAD_Y,
};
 
 
struct MessageInfo
{
    MessageInfo ()
    : message(0)
    , inMessageData(0)
    , outMessageData(0){}
 
    MessageInfo (uint32_t _message)
    : message(_message)
     , inMessageData(0)
    , outMessageData(0)
    {}
 
    MessageInfo& operator=(const MessageInfo& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        message = data.message;
        inMessageData = data.inMessageData;
        outMessageData = data.outMessageData;
        inMessageString = data.inMessageString;
        outMessageString = data.outMessageString;
 
        return *this;
    }
 
    uint32_t message = 0;           
    void* inMessageData = nullptr;  
    void* outMessageData = nullptr; 
 
    std::string inMessageString;    
    std::string outMessageString;   
};
 
struct PluginInfo
{
    PluginInfo() {}
 
    PluginInfo& operator=(const PluginInfo& data)   // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        pathToDLL = data.pathToDLL; 
 
        return *this;
    }
 
    const char* pathToDLL;  
};
 
 
struct CreateGUIInfo
{
    CreateGUIInfo()
        : window(0)
        , guiPluginConnector(0)
        , guiWindowFrame(0)
        , width(0.0)
        , height(0.0)
    { }
 
    CreateGUIInfo(void* _window, IGUIPluginConnector* _guiPluginConnector, IGUIWindowFrame* _guiWindowFrame)
        : window(_window)
        , guiPluginConnector(_guiPluginConnector)
        , guiWindowFrame(_guiWindowFrame)
        , width(0.0)
        , height(0.0)
    { }
 
    CreateGUIInfo& operator=(const CreateGUIInfo& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        window = data.window;
        guiPluginConnector = data.guiPluginConnector;
        guiWindowFrame = data.guiWindowFrame;
        width = data.width;
        height = data.height;
 
        return *this;
    }
 
    void* window = nullptr;                             
    IGUIPluginConnector* guiPluginConnector = nullptr;  
    IGUIWindowFrame* guiWindowFrame;                    
 
    // --- returned
    double width = 0.0;     
    double height = 0.0;    
};
 
struct ParameterUpdateInfo
{
    ParameterUpdateInfo()
        : isSmoothing(0)
        , isVSTSampleAccurateUpdate(0)
        , loadingPreset(0)
        , boundVariableUpdate(0)
        , bufferProcUpdate(0)
        , applyTaper(1){}
 
    ParameterUpdateInfo(bool _isSmoothing, bool _isVSTSampleAccurateUpdate)
        : isSmoothing(_isSmoothing)
        , isVSTSampleAccurateUpdate(_isVSTSampleAccurateUpdate) {
        loadingPreset = false;
        boundVariableUpdate = false;
        bufferProcUpdate = false;
        applyTaper = true;
    }
 
    ParameterUpdateInfo& operator=(const ParameterUpdateInfo& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        isSmoothing = data.isSmoothing;
        isVSTSampleAccurateUpdate = data.isVSTSampleAccurateUpdate;
        loadingPreset = data.loadingPreset;
        boundVariableUpdate = data.boundVariableUpdate;
        bufferProcUpdate = data.bufferProcUpdate;
        applyTaper = data.applyTaper;
 
        return *this;
    }
 
    bool isSmoothing = false;               
    bool isVSTSampleAccurateUpdate = false; 
    bool loadingPreset = false;             
    bool boundVariableUpdate = false;       
    bool bufferProcUpdate = false;          
    bool applyTaper = true;                 
};
 
enum attributeType { isFloatAttribute, isDoubleAttribute, isIntAttribute, isUintAttribute, isBoolAttribute, isVoidPtrAttribute, isStringAttribute };
 
union attributeValue
{
    float f;
    double d;
    int n;
    unsigned int u;
    bool b;
    void* vp;
};
 
struct AuxParameterAttribute
{
    AuxParameterAttribute()
    : attributeID(0)
    { memset(&value, 0, sizeof(attributeValue)); }
 
    AuxParameterAttribute(uint32_t _attributeID)
        : attributeID(_attributeID) { }
 
    AuxParameterAttribute& operator=(const AuxParameterAttribute& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        value = data.value;
        attributeID = data.attributeID;
        return *this;
    }
 
    void reset(uint32_t _attributeID) { memset(&value, 0, sizeof(attributeValue));  attributeID = _attributeID; }
 
    void setFloatAttribute(float f) { value.f = f; }
    void setDoubleAttribute(double d) { value.d = d; }
    void setIntAttribute(int n) { value.n = n; }
    void setUintAttribute(unsigned int u) { value.u = u; }
    void setBoolAttribute(bool b) { value.b = b; }
    void setVoidPtrAttribute(void* vp) { value.vp = vp; }
 
    float getFloatAttribute( ) { return value.f; }
    double getDoubleAttribute( ) { return value.d; }
    int getIntAttribute( ) { return value.n; }
    unsigned int getUintAttribute( ) { return  value.u; }
    bool getBoolAttribute( ) { return value.b; }
    void* getVoidPtrAttribute( ) { return value.vp; }
 
    attributeValue value;   
    uint32_t attributeID = 0;   
};
 
struct HostInfo
{
    // --- common to all APIs
    unsigned long long uAbsoluteFrameBufferIndex = 0;   
    double dAbsoluteFrameBufferTime = 0.0;              
    double dBPM = 0.0;                                  
    float fTimeSigNumerator = 0.f;                      
    uint32_t uTimeSigDenomintor = 0;                    
 
    // --- VST3 Specific: note these use same variable names as VST3::struct ProcessContext
    //     see ..\VST3 SDK\pluginterfaces\vst\ivstprocesscontext.h for information on decoding these
    //
    uint32_t state = 0;                 
    long long systemTime = 0;           
    double continousTimeSamples = 0.0;  
    double projectTimeMusic = 0.0;      
    double barPositionMusic = 0.0;      
    double cycleStartMusic = 0.0;       
    double cycleEndMusic = 0.0;         
    uint32_t samplesToNextClock = 0;    
    bool enableVSTSampleAccurateAutomation = false;
    /*
     IF you need SMPTE information, you need to get the information yourself at the start of the process( ) function
     where the above values are filled out. See the variables here in VST3 SDK\pluginterfaces\vst\ivstprocesscontext.h:
 
     int32 smpteOffsetSubframes = 0;    // --- SMPTE (sync) offset in subframes (1/80 of frame)
     FrameRate frameRate;               // --- frame rate
     */
 
    // --- AU Specific
    //     see AUBase.h for definitions and information on decoding these
    //
    double dCurrentBeat = 0.0;                  
    bool bIsPlayingAU = false;                  
    bool bTransportStateChanged = false;        
    uint32_t nDeltaSampleOffsetToNextBeat = 0;  
    double dCurrentMeasureDownBeat = 0.0;       
    bool bIsCycling = false;                    
    double dCycleStartBeat = 0.0;               
    double dCycleEndBeat = 0.0;                 
 
    // --- AAX Specific
    //     see AAX_ITransport.h for definitions and information on decoding these
    bool bIsPlayingAAX = false;                 
    long long nTickPosition = 0;                
    bool bLooping = false;                      
    long long nLoopStartTick = 0;               
    long long nLoopEndTick = 0;                 
    /*
     NOTE: there are two optional functions that cause a performance hit in AAX; these are commented outs;
     if you decide to use them, you should re-locate them to a non-realtime thread. Use at your own risk!
 
     int32_t nBars = 0;
     int32_t nBeats = 0;
     int64_t nDisplayTicks = 0;
     int64_t nCustomTickPosition = 0;
 
     // --- There is a minor performance cost associated with using this API in Pro Tools. It should NOT be used excessively without need
     midiTransport->GetBarBeatPosition(&nBars, &nBeats, &nDisplayTicks, nAbsoluteSampleLocation);
 
     // --- There is a minor performance cost associated with using this API in Pro Tools. It should NOT be used excessively without need
     midiTransport->GetCustomTickPosition(&nCustomTickPosition, nAbsoluteSampleLocation);
 
     NOTE: if you need SMPTE or metronome information, you need to get the information yourself at the start of the ProcessAudio( ) function
              see AAX_ITransport.h for definitions and information on decoding these
     virtual    AAX_Result GetTimeCodeInfo(AAX_EFrameRate* oFrameRate, int32_t* oOffset) const = 0;
     virtual    AAX_Result GetFeetFramesInfo(AAX_EFeetFramesRate* oFeetFramesRate, int64_t* oOffset) const = 0;
     virtual AAX_Result IsMetronomeEnabled(int32_t* isEnabled) const = 0;
     */
};
 
// --- block size constants
const uint32_t DEFAULT_AUDIO_BLOCK_SIZE = 64;
const uint32_t WANT_WHOLE_BUFFER = 0; // --- reserved for full buffer
 
struct ProcessBlockInfo
{
    ProcessBlockInfo() { }
 
    float** inputs = nullptr;           
    float** outputs = nullptr;          
    float** auxInputs = nullptr;            
    float** auxOutputs = nullptr;           
 
    uint32_t numAudioInChannels = 0;        
    uint32_t numAudioOutChannels = 0;       
    uint32_t numAuxAudioInChannels = 0;     
    uint32_t numAuxAudioOutChannels = 0;        
 
    uint32_t currentBlock = 0;          
    uint32_t blockSize = 64;            
    uint32_t blockStartIndex = 0;       
    uint32_t blockEndIndex = 0;         
 
    void pushMidiEvent(midiEvent event) {
        midiEventList.push_back(event);
    }
    void clearMidiEvents() {
        midiEventList.clear();
    }
    uint32_t getMidiEventCount() {
        return midiEventList.size();
    }
    midiEvent* getMidiEvent(uint32_t index) {
        if (index >= getMidiEventCount())
            return nullptr;
 
        return &midiEventList[index];
    }
 
    double absoluteBufferTime_Sec = 0.0;            
    double BPM = 0.0;                               
    double timeSigNumerator = 0.0;                  
    uint32_t timeSigDenomintor = 0;                 
 
protected:
    std::vector<midiEvent> midiEventList;          
};
 
class IMidiEventQueue;
 
struct ProcessBufferInfo
{
    ProcessBufferInfo(){}
 
    /*
    AAX -- MUST be float
    AU --- Float32
    RAFX2 --- float
    VST3 --- float OR double
     *  \brief Subscribes an audio input context field
     *
     *  Defines an audio in port for host-provided information in the algorithm's
     *  context structure.
     *
     *  - Data type: float**
     *  - Data kind: An array of float arrays, one for each input channel
     *
     */
    // --- audio inputs and outputs (arrays of channel-array pointers)
    float** inputs = nullptr;       
    float** outputs = nullptr;      
    float** auxInputs = nullptr;    
    float** auxOutputs = nullptr;   
    uint32_t numAudioInChannels = 0;        
    uint32_t numAudioOutChannels = 0;       
    uint32_t numAuxAudioInChannels = 0;     
    uint32_t numAuxAudioOutChannels = 0;    
 
    uint32_t numFramesToProcess = 0;        
    ChannelIOConfig channelIOConfig;        
    ChannelIOConfig auxChannelIOConfig;     
 
    // --- for future use, VCVRack
    float* controlSignalInputs = nullptr;   
    float* controlSignalOutputs = nullptr;  
    uint32_t numControlSignalInputs = 0;    
    uint32_t numControlSignalOutputs = 0;   
 
    // --- should make these const?
    HostInfo* hostInfo = nullptr;           
    IMidiEventQueue* midiEventQueue = nullptr;  
};
 
struct ProcessFrameInfo
{
    ProcessFrameInfo(){ }
 
    float* audioInputFrame = nullptr;       
    float* audioOutputFrame = nullptr;      
    float* auxAudioInputFrame = nullptr;    
    float* auxAudioOutputFrame = nullptr;   
 
    uint32_t numAudioInChannels = 0;        
    uint32_t numAudioOutChannels = 0;       
    uint32_t numAuxAudioInChannels = 0;     
    uint32_t numAuxAudioOutChannels = 0;    
 
    ChannelIOConfig channelIOConfig;    
    ChannelIOConfig auxChannelIOConfig; 
    uint32_t currentFrame = 0;          
 
    // --- for future use, VCVRack
    float* controlSignalInputs = nullptr;   
    float* controlSignalOutputs = nullptr;  
    uint32_t numControlSignalInputs = 0;    
    uint32_t numControlSignalOutputs = 0;   
 
    // --- should make these const?
    HostInfo* hostInfo = nullptr;           
    IMidiEventQueue* midiEventQueue = nullptr;  
};
 
struct AudioProcDescriptor
{
    AudioProcDescriptor ()
    : sampleRate(44100)
    , bitDepth(16){}
 
    AudioProcDescriptor (double _sampleRate,
                         uint32_t _bitDepth)
    : sampleRate(_sampleRate)
    , bitDepth(_bitDepth){}
 
    AudioProcDescriptor& operator=(const AudioProcDescriptor& data) // need this override for collections to work
    {
        if (this == &data)
            return *this;
 
        sampleRate = data.sampleRate;
        bitDepth = data.bitDepth;
        return *this;
    }
 
    double sampleRate = 44100.0;    
    uint32_t bitDepth = 16;         
};
 
 
struct PluginDescriptor
{
    PluginDescriptor ()
    : pluginName("Long Plugin Name") // max 31 chars
    , shortPluginName("ShortPIName") // max 15 chars
    , vendorName("Plugin Developer")
    , pluginTypeCode(pluginType::kFXPlugin) // FX or synth
    , hasSidechain(0)
    , processFrames(1)                  /* default operation */
    , wantsMIDI(1)                      /* default operation */
    , hasCustomGUI(1)
    , latencyInSamples(0)
    , tailTimeInMSec(0)
    , infiniteTailVST3(0)
    , numSupportedIOCombinations(0)
    , supportedIOCombinations(0)
    , numSupportedAuxIOCombinations(0)
    , supportedAuxIOCombinations(0)
    {}
 
    // --- string descriptors
    std::string pluginName;         
    std::string shortPluginName;    
    std::string vendorName;         
    uint32_t pluginTypeCode = 0;    
 
    bool hasSidechain = false;      
    bool processFrames = true;      
    bool wantsMIDI = true;          
    bool hasCustomGUI = true;       
    uint32_t latencyInSamples = 0;  
    double tailTimeInMSec = 0.0;    
    bool infiniteTailVST3 = false;  
 
    uint32_t numSupportedIOCombinations = 0;    
    ChannelIOConfig* supportedIOCombinations;
 
    uint32_t numSupportedAuxIOCombinations = 0;
    ChannelIOConfig* supportedAuxIOCombinations;
 
    uint32_t getDefaultChannelIOConfigForChannelCount(uint32_t channelCount)
    {
        switch(channelCount)
        {
            case 0:
                return kCFNone;
            case 1:
                return kCFMono;
            case 2:
                return kCFStereo;
            case 3:
                return kCFLCR;
            case 4:
                return kCFQuad; // or kCFLCR
            case 5:
                return kCF5p0;
            case 6:
                return kCF5p1; // or kCF6p0
            case 7:
                return kCF6p1; // or kCF7p0Sony kCF7p0DTS
            case 8:
                return kCF7p1DTS; // or kCF7p1Sony or kCF7p1Proximity
            case 9:
                return kCF8p1; // or kCF9p0
            case 10:
                return kCF9p1; // or kCF10p0
            case 11:
                return kCF10p1;
            case 12:
                return kCF11p1; // or kCF10p2
            case 13:
                return kCF13p0; // or kCF12p2
            case 14:
                return kCF13p1;
            case 24:
                return kCF22p2;
 
            default:
                return 0;
        }
    }
    uint32_t getChannelCountForChannelIOConfig(uint32_t format)
    {
        switch(format)
        {
            case kCFNone:
                return 0;
 
            case kCFMono:
                return 1;
            case kCFStereo:
                return 2;
            case kCFLCR:
                return 3;
 
            case kCFQuad:
            case kCFLCRS:
                return 4;
 
            case kCF5p0:
                return 5;
 
            case kCF5p1:
            case kCF6p0:
                return 6;
 
            case kCF6p1:
            case kCF7p0Sony:
            case kCF7p0DTS:
                return 7;
 
            case kCF7p1Sony:
            case kCF7p1DTS:
            case kCF7p1Proximity:
                return 8;
 
            case kCF8p1:
            case kCF9p0:
                return 9;
 
            case kCF9p1:
            case kCF10p0:
                return 10;
 
            case kCF10p1:
                return 11;
 
            case kCF10p2:
            case kCF11p1:
                return 12;
 
            case kCF13p0:
            case kCF12p2:
                return 13;
 
            case kCF13p1:
                return 14;
 
            case kCF22p2:
                return 24;
 
            default:
                return 0;
        }
        return 0;
    }
};
 
struct JSControl
{
    JSControl() {}
    JSControl& operator=(const JSControl& aControl)
    {
        if (this == &aControl)
            return *this;
 
        trackpadIndex = aControl.trackpadIndex;
        midiControl = aControl.midiControl;
        midiControlCommand = aControl.midiControlCommand;
        midiControlName = aControl.midiControlName;
        midiControlChannel = aControl.midiControlChannel;
        joystickValue = aControl.joystickValue;
        korgVectorJoystickOrientation = aControl.korgVectorJoystickOrientation;
        enableParamSmoothing = aControl.enableParamSmoothing;
        smoothingTimeInMs = aControl.smoothingTimeInMs;
        return *this;
    }
 
    int32_t trackpadIndex = -1;         
    bool midiControl = false;           
    uint32_t midiControlCommand = 0;    
    uint32_t midiControlName = 0;       
    uint32_t midiControlChannel = 0;    
    double joystickValue = 0.0;         
    bool korgVectorJoystickOrientation = false; 
    bool enableParamSmoothing = false;  
    double smoothingTimeInMs = 0.0;     
};
 
 
// --------------------------------------------------------------------------------------------------------------------------- //
// --- INTERFACES
// --------------------------------------------------------------------------------------------------------------------------- //
 
class ICustomView
{
public:
    virtual void updateView() = 0;
 
    virtual void pushDataValue(double data) { }
 
    virtual void sendMessage(void* data) { }
};
 
class IGUIWindowFrame
{
public:
    virtual bool setWindowFrameSize(double left = 0, double top = 0, double right = 0, double bottom = 0) = 0;
 
    virtual bool getWindowFrameSize(double& left, double&  top, double&  right, double&  bottom) = 0;
 
    virtual void enableGUIDesigner(bool enable) { }
};
 
class IGUIView
{
public:
    virtual void setGUIWindowFrame(IGUIWindowFrame* frame) = 0;
};
 
 
class IGUIPluginConnector
{
public:
    virtual bool registerCustomView(std::string customViewName, ICustomView* customViewConnector) = 0;
 
    virtual bool deRegisterCustomView(ICustomView* customViewConnector) = 0;
 
    virtual bool guiDidOpen() = 0;
 
    virtual bool guiWillClose() = 0;
 
    virtual bool guiTimerPing() = 0;
 
    virtual bool registerSubcontroller(std::string subcontrollerName, ICustomView* customViewConnector) { return false; }
 
    virtual bool deRregisterSubcontroller(ICustomView* customViewConnector) { return false; }
 
    virtual uint32_t getNonBoundVariableCount() { return 0; }
 
    virtual uint32_t getNextNonBoundVariableTag(int startTag) { return -1; }
 
    virtual bool checkNonBoundValueChange(int tag, float normalizedValue) { return false; }
 
    virtual void checkSendUpdateGUI(int tag, float actualValue, bool loadingPreset, void* data1 = 0, void* data2 = 0) {}
 
    virtual void parameterChanged(int32_t controlID, double actualValue, double normalizedValue) {}
 
    virtual double getNormalizedPluginParameter(int32_t controlID) { return 0.0; }
 
    virtual void setNormalizedPluginParameter(int32_t controlID, double value) { }
 
    virtual double getActualPluginParameter(int32_t controlID) { return 0.0; }
 
    virtual void setActualPluginParameter(int32_t controlID, double value) { }
 
    virtual void beginParameterChangeGesture(int controlTag){ }
 
    virtual void endParameterChangeGesture(int controlTag){ }
};
 
 
class IPluginHostConnector
{
public:
    virtual void sendHostMessage(const HostMessageInfo& hostMessageInfo) = 0;
};
 
class IMidiEventQueue
{
public:
    virtual uint32_t getEventCount() = 0;
 
    virtual bool fireMidiEvents(uint32_t uSampleOffset) = 0;
};
 
 
class IParameterUpdateQueue
{
public:
    virtual uint32_t getParameterIndex() = 0;
 
    virtual bool getValueAtOffset(long int _sampleOffset, double _previousValue, double& _nextValue) = 0;
 
    virtual bool getNextValue(double& _nextValue) = 0;
};
 
// --------------------------------------------------------------------------------------------------------------------------- //
// --- HELPER FUNCTIONS
// --------------------------------------------------------------------------------------------------------------------------- //
inline std::string numberToString(unsigned int number)
{
    std::ostringstream strm;
    strm << number;
    std::string str = strm.str();
    return str;
}
 
inline std::string numberToString(int number)
{
    std::ostringstream strm;
    strm << number;
    std::string str = strm.str();
    return str;
}
 
inline std::string numberToString(float number)
{
    std::ostringstream strm;
    strm << number;
    std::string str = strm.str();
    return str;
}
 
inline std::string numberToString(double number)
{
    std::ostringstream strm;
    strm << number;
    std::string str = strm.str();
    return str;
}
 
inline std::string boolToStdString(bool value)
{
    std::string returnString;
    if (value) returnString.assign("true");
    else returnString.assign("false");
    return returnString;
}
 
 
#endif //_pluginstructures_h