AAXPluginParameters.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK AAX Shell File:  aaxpluginparameters.h
//
// -----------------------------------------------------------------------------
#pragma once
#ifndef RACKAFX_PARAMETERS_H
#define RACKAFX_PARAMETERS_H

#include "AAX_CEffectParameters.h"
#pragma warning(disable : 4985) // --- 'ceil': attributes not present on previous declaration NOTE: for VS2008 only, see the google for more info

#include "AAX_CAtomicQueue.h"
#include "AAX_IParameter.h"
#include "AAX_IMIDINode.h"
#include "AAX_IString.h"
#include "AAX_IEffectDescriptor.h"
#include "AAX_IComponentDescriptor.h"
#include "AAX_IPropertyMap.h"

#include <set>
#include <list>
#include <utility>
#include <vector>

// --- our plugin core object
#include "plugincore.h"

// --- see AAX_ITransport.h before enabling this: performance hits!
// #define ENABLE_EXTRA_HOST_INFO

// --- constants
const AAX_CTypeID PLUGIN_CUSTOMDATA_ID = 0; 

// --- special ProTools meter
const AAX_CTypeID GR_MeterID = 'grMT';  
const unsigned int meterTapCount = 1;   

// --- setup context struct
class AAXPluginParameters;
class GUIPluginConnector;
class PluginHostConnector;
class AAXMIDIEventQueue;

struct pluginCustomData
{
    GUIPluginConnector* guiPlugin_Connector = nullptr; // added nullptr 5.9.18
    PluginCore* plugin_Core = nullptr;
};

struct pluginPrivateData
{
    AAXPluginParameters* aaxPluginParameters;
};

struct AAXAlgorithm
{
    // --- audio
    pluginPrivateData*  privateData;            // --- the RAFX Monolithic Parameters
    float**             inputBufferPtrs;        // --- inputs buffer
    float**             outputBufferPtrs;       // --- outputs buffer
    int32_t*            bufferLength;           // --- buffer size (per channel)
    float**             grMeterPtrs;            // --- Meter taps; currrently support one GR meter (have never seen more than 1)

#ifdef WANT_SIDECHAIN
    int32_t*            sidechainChannel;       // --- sidechain channel pointer
#endif

    // --- MIDI
    AAX_IMIDINode*      midiInputNode;             // --- MIDI input node -> plugin
    AAX_IMIDINode*      midiTransportNode;         // --- for getting info about the host BPM, etc...

    // --- params
    int64_t*            currentStateNum;        // --- state value
};

#define kMaxAdditionalMIDINodes 15
#define kMaxAuxOutputStems 32

// --- NOTE: default here is 64 parameters; you should tweak this value to your final parameter count
//           for the smallest size plugin; undetermined if this is more efficient or not.
#define kSynchronizedParameterQueueSize 64

typedef std::pair<AAX_CParamID const, const AAX_IParameterValue*> TParamValPair;

class AAXPluginParameters : public AAX_CEffectParameters
{
public:
    AAXPluginParameters ();
    virtual ~AAXPluginParameters();

    static AAX_CEffectParameters* AAX_CALLBACK Create();

    virtual AAX_Result UpdateParameterNormalizedValue (AAX_CParamID iParameterID, double iValue, AAX_EUpdateSource iSource );

    void AddSynchronizedParameter(const AAX_IParameter& inParameter);

public:
    // --- Overrides from AAX_CEffectParameters
    virtual AAX_Result EffectInit();                
    virtual AAX_Result ResetFieldData (AAX_CFieldIndex inFieldIndex, void * oData, uint32_t iDataSize) const;
    virtual AAX_Result GenerateCoefficients();      
    virtual AAX_Result TimerWakeup();               

    static void AAX_CALLBACK StaticRenderAudio(AAXAlgorithm* const inInstancesBegin[], const void* inInstancesEnd);

    static AAX_Result StaticDescribe(AAX_IComponentDescriptor& outDesc);

    virtual AAX_Result GetCustomData(AAX_CTypeID iDataBlockID, uint32_t iDataSize, void* oData, uint32_t* oDataWritten) const;

    void updateHostInfo(AAXAlgorithm* ioRenderInfo, HostInfo* hostInfo);

    void ProcessAudio(AAXAlgorithm* ioRenderInfo, const TParamValPair* inSynchronizedParamValues[], int32_t inNumSynchronizedParamValues);

    void UpdatePluginParameters(const TParamValPair* inSynchronizedParamValues[], int32_t inNumSynchronizedParamValues);

    void updateOutboundAAXParameters();

    struct SParamValList
    {
        // Using 4x the preset queue size: the buffer must be large enough to accommodate the maximum
        // number of updates that we expect to be queued between/before executions of the render callback.
        // The maximum queuing that will likely ever occur is during a preset change (i.e. a call to
        // SetChunk()), in which updates to all parameters may be queued in the same state frame. It is
        // possible that the host would call SetChunk() on the plug-in more than once before the render
        // callback executes, but probably not more than 2-3x. Therefore 4x seems like a safe upper limit
        // for the capacity of this buffer.
        static const int32_t sCap = 4*kSynchronizedParameterQueueSize;

        TParamValPair* mElem[sCap];
        int32_t mSize;

        SParamValList()
        {
            Clear();
        }

        void Add(TParamValPair* inElem)
        {
            AAX_ASSERT(sCap > mSize);
            if (sCap > mSize)
            {
                mElem[mSize++] = inElem;
            }
        }

        void Append(const SParamValList& inOther)
        {
            AAX_ASSERT(sCap >= mSize + inOther.mSize);
            for (int32_t i = 0; i < inOther.mSize; ++i)
            {
                Add(inOther.mElem[i]);
            }
        }

        void Append(const std::list<TParamValPair*>& inOther)
        {
            AAX_ASSERT(sCap >= mSize + (int64_t)inOther.size());
            for (std::list<TParamValPair*>::const_iterator iter = inOther.begin(); iter != inOther.end(); ++iter)
            {
                Add(*iter);
            }
        }

        void Merge(AAX_IPointerQueue<TParamValPair>& inOther)
        {
            do
            {
                TParamValPair* const val = inOther.Pop();
                if (NULL == val) { break; }
                Add(val);
            } while (1);
        }

        void Clear() 
        {
            std::memset(mElem, 0x0, sizeof(mElem));
            mSize = 0;
        }
    };

private:
    // --- see AAX_CMonolithicParameters in SDK
    //     these are identically declared and used with the AAX_CMonolithicParameters sample code
    //     this is the AVID method of synchronizing the playback-head to the controls
    typedef std::set<const AAX_IParameter*> TParamSet;                              
    typedef std::pair<int64_t, std::list<TParamValPair*> > TNumberedParamStateList; 
    typedef AAX_CAtomicQueue<TNumberedParamStateList, 256> TNumberedStateListQueue; 

    typedef AAX_CAtomicQueue<const TParamValPair, 16*kSynchronizedParameterQueueSize> TParamValPairQueue; 

    SParamValList GetUpdatesForState(int64_t inTargetStateNum);     
    void DeleteUsedParameterChanges();                              
    std::set<std::string> mSynchronizedParameters;                  
    int64_t mStateCounter;                                          
    TParamSet mDirtyParameters;                                     
    TNumberedStateListQueue mQueuedParameterChanges;                
    TNumberedStateListQueue mFinishedParameterChanges;              
    TParamValPairQueue mFinishedParameterValues;                    
    int64_t mCurrentStateNum;                                       

    // --- soft bypass flag
    bool softBypass = false; 

    // --- plugin core and interfaces
    PluginCore* pluginCore = nullptr;                   
    GUIPluginConnector* guiPluginConnector = nullptr;   
    PluginHostConnector* pluginHostConnector = nullptr; 
    AAXMIDIEventQueue* midiEventQueue = nullptr;        

    uint32_t getChannelFormatForAAXStemFormat(AAX_EStemFormat format)
    {
        switch(format)
        {
            case AAX_eStemFormat_None: {
                return kCFNone; }

            case AAX_eStemFormat_Mono: {
                return kCFMono; }

            case AAX_eStemFormat_Stereo: {
                return kCFStereo; }

            case AAX_eStemFormat_LCR: {
                return kCFLCR; }

            case AAX_eStemFormat_LCRS: {
                return kCFLCRS; }

            case AAX_eStemFormat_Quad: {
                return kCFQuad; }

            case AAX_eStemFormat_5_0: {
                return kCF5p0; }

            case AAX_eStemFormat_5_1: {
                return kCF5p1; }

            case AAX_eStemFormat_6_0: {
                return kCF6p0; }

            case AAX_eStemFormat_6_1: {
                return kCF6p1; }

            case AAX_eStemFormat_7_0_SDDS: {
                return kCF7p0Sony; }

            case AAX_eStemFormat_7_0_DTS: {
                return kCF7p0DTS; }

            case AAX_eStemFormat_7_1_SDDS: {
                return kCF7p1Sony; }

            case AAX_eStemFormat_7_1_DTS: {
                return kCF7p1DTS; }

            case AAX_eStemFormat_7_1_2: {
                return kCF7p1Proximity; }

            default: {
                return kCFNone; }
        }
        return kCFNone;
    }

};

class PluginHostConnector : public IPluginHostConnector
{
public:
    PluginHostConnector(AAX_IEffectParameters* _aaxParameters) {aaxParameters = _aaxParameters;}
    virtual ~PluginHostConnector(){}

    virtual void sendHostMessage(const HostMessageInfo& hostMessageInfo)
    {
        switch(hostMessageInfo.hostMessage)
        {
            case sendGUIUpdate:
            {
                GUIUpdateData guiUpdateData = hostMessageInfo.guiUpdateData;

                for (uint32_t i = 0; i < guiUpdateData.guiParameters.size(); i++)
                {
                    GUIParameter guiParam = guiUpdateData.guiParameters[i];

                    std::stringstream str;
                    str << guiParam.controlID + 1;
                    AAX_IParameter* oParameter;
                    AAX_Result result = aaxParameters->GetParameter(str.str().c_str(), &oParameter);
                    if(AAX_SUCCESS == result)
                    {
                        oParameter->SetValueWithDouble(guiParam.actualValue);
                    }
                }

                // --- clean up
                for (uint32_t i = 0; i < guiUpdateData.guiParameters.size(); i++)
                    guiUpdateData.guiParameters.pop_back();

                break;
            }
            default:
                break;
        }
    }

protected:
    AAX_IEffectParameters* aaxParameters; 
};


class CustomViewController : public ICustomView
{
public:
    CustomViewController(ICustomView* _customViewIF) { customViewIF = _customViewIF; }
    virtual ~CustomViewController() {}

    virtual void updateView()
    {
        if (customViewIF)
            customViewIF->updateView();
    }

    virtual void pushDataValue(double data)
    {
        if (customViewIF)
            customViewIF->pushDataValue(data);
    }

    virtual void sendMessage(void* data)
    {
        if (customViewIF)
            customViewIF->sendMessage(data);
    }

    void setCustomViewPtr(ICustomView* _customViewIF) { customViewIF = _customViewIF; }

    const ICustomView* getCustomViewPtr() { return customViewIF; }

    void clearCustomViewPtr() { customViewIF = nullptr; }


private:
    ICustomView* customViewIF = nullptr; 
};

class GUIPluginConnector : public IGUIPluginConnector
{
public:
    GUIPluginConnector(AAX_IEffectParameters* _aaxParameters, PluginCore* _pluginCore){pluginCore = _pluginCore; aaxParameters = _aaxParameters;}

    virtual ~GUIPluginConnector()
    {
        for (customViewControllerMap::const_iterator it = customSubControllerMap.begin(), end = customSubControllerMap.end(); it != end; ++it)
        {
            delete it->second;
        }
        for (customViewControllerMap::const_iterator it = customViewMap.begin(), end = customViewMap.end(); it != end; ++it)
        {
            delete it->second;
        }
    }

    virtual void parameterChanged(int32_t controlID, double actualValue, double /*normalizedValue*/)
    {
        if(pluginCore)
            pluginCore->guiParameterChanged(controlID, actualValue);
    }

    virtual double getNormalizedPluginParameter(int32_t controlID)
    {
        // --- NOTE: this is the proper way for the GUI to get parameter values
        std::stringstream str;
        str << controlID + 1;
        double param = 0.0;
        AAX_Result result = aaxParameters->GetParameterNormalizedValue(str.str().c_str(), &param);
        if(AAX_SUCCESS == result)
            return param;

        return 0.0;
    }

    virtual void setNormalizedPluginParameter(int32_t controlID, double value)
    {
        // --- NOTE: this is the proper way for the GUI to set parameter values
        std::stringstream str;
        str << controlID + 1;
        aaxParameters->SetParameterNormalizedValue(str.str().c_str(), value);
    }

    virtual void beginParameterChangeGesture(int controlTag)
    {
        if(aaxParameters)
        {
            std::stringstream str;
            str << controlTag+1;
            aaxParameters->TouchParameter(str.str().c_str());
        }
    }

    virtual void endParameterChangeGesture(int controlTag)
    {
        if(aaxParameters )
        {
            std::stringstream str;
            str << controlTag+1;
            aaxParameters->ReleaseParameter(str.str().c_str());
        }
    }

    virtual bool registerSubcontroller(std::string subcontrollerName, ICustomView* customViewConnector)
    {
        // --- do we have this in our map already?
        CustomViewController* pCVC = nullptr;

        customViewControllerMap::const_iterator it = customSubControllerMap.find(subcontrollerName);
        if (it != customSubControllerMap.end())
        {
            pCVC = it->second;
            pCVC->setCustomViewPtr(customViewConnector);
        }
        else
        {
            pCVC = new CustomViewController(customViewConnector);
            customSubControllerMap.insert(std::make_pair(subcontrollerName, pCVC));
        }

        MessageInfo info(PLUGINGUI_REGISTER_SUBCONTROLLER);
        info.inMessageString = subcontrollerName;
        info.inMessageData = pCVC;

        if (pluginCore && pluginCore->processMessage(info))
            return true;

        return false;
    }

    virtual bool deRregisterSubcontroller(ICustomView* customViewConnector)
    {
        CustomViewController* pCVC = getCustomSubController(customViewConnector);
        if (pCVC)
        {
            pCVC->clearCustomViewPtr();

            MessageInfo info(PLUGINGUI_DE_REGISTER_SUBCONTROLLER);
            info.inMessageString = "";
            info.inMessageData = pCVC;

            if (pluginCore && pluginCore->processMessage(info))
                return true;
        }

        return false;
    }

    virtual bool registerCustomView(std::string customViewName, ICustomView* customViewConnector)
    {
        // --- do we have this in our map already?
        CustomViewController* pCVC = nullptr;

        customViewControllerMap::const_iterator it = customViewMap.find(customViewName);
        if (it != customViewMap.end())
        {
            pCVC = it->second;
            pCVC->setCustomViewPtr(customViewConnector);
        }
        else
        {
            pCVC = new CustomViewController(customViewConnector);
            customViewMap.insert(std::make_pair(customViewName, pCVC));
        }

        MessageInfo info(PLUGINGUI_REGISTER_CUSTOMVIEW);
        info.inMessageString = customViewName;
        info.inMessageData = pCVC;

        if(pluginCore && pluginCore->processMessage(info))
            return true;

        return false;
    }

    virtual bool deRegisterCustomView(ICustomView* customViewConnector)
    {
        CustomViewController* pCVC = getCustomViewController(customViewConnector);
        if (pCVC)
        {
            // --- clear it
            pCVC->clearCustomViewPtr();

            MessageInfo info(PLUGINGUI_DE_REGISTER_CUSTOMVIEW);
            info.inMessageString = "";
            info.inMessageData = pCVC;

            if (pluginCore && pluginCore->processMessage(info))
                return true;
        }

        return false;
    }

    virtual bool guiDidOpen()
    {
        if(!pluginCore) return false;
        MessageInfo info(PLUGINGUI_DIDOPEN);
        return pluginCore->processMessage(info);
    }

    virtual bool guiWillClose()
    {
        if(!pluginCore) return false;

        for (customViewControllerMap::const_iterator it = customViewMap.begin(), end = customViewMap.end(); it != end; ++it)
        {
            it->second->clearCustomViewPtr();
        }
        for (customViewControllerMap::const_iterator it = customSubControllerMap.begin(), end = customSubControllerMap.end(); it != end; ++it)
        {
            it->second->clearCustomViewPtr();
        }

        MessageInfo info(PLUGINGUI_WILLCLOSE);
        return pluginCore->processMessage(info);
    }

    virtual bool guiTimerPing()
    {
        if(!pluginCore) return false;
        MessageInfo info(PLUGINGUI_TIMERPING);
        return pluginCore->processMessage(info);
    }

    virtual bool checkNonBoundValueChange(int tag, float normalizedValue)
    {
        if(!pluginCore) return false;

        // --- do any additional stuff here
        // --- dispatch non-bound value changes directly to receiver

        return false;
    }

protected:
    PluginCore* pluginCore = nullptr;                   
    AAX_IEffectParameters* aaxParameters = nullptr;     

    // --- this is for supporting the persistent interface pointer for the core object
    //     and is required by ASPiK Specifications
    typedef std::map<std::string, CustomViewController*> customViewControllerMap;   
    customViewControllerMap customViewMap;

    CustomViewController* getCustomViewController(ICustomView* customViewConnector)
    {
        for (customViewControllerMap::const_iterator it = customViewMap.begin(), end = customViewMap.end(); it != end; ++it)
        {
            if (it->second->getCustomViewPtr() == customViewConnector)
                return it->second;
        }

        return nullptr;
    }

    customViewControllerMap customSubControllerMap;                                 

    CustomViewController* getCustomSubController(ICustomView* customViewConnector)
    {
        for (customViewControllerMap::const_iterator it = customSubControllerMap.begin(), end = customSubControllerMap.end(); it != end; ++it)
        {
            if (it->second->getCustomViewPtr() == customViewConnector)
                return it->second;
        }

        return nullptr;
    }
};

class AAXMIDIEventQueue : public IMidiEventQueue
{
public:
    AAXMIDIEventQueue(PluginCore* _pluginCore)
    : ioPacketPtr(0),
    midiBuffersize(0)
    {
        pluginCore = _pluginCore;
    };

    virtual ~AAXMIDIEventQueue(){}

    void setMIDIpackets(const AAX_CMidiPacket*& _ioPacketPtr, uint32_t& _midiBuffersize)
    {
        ioPacketPtr = _ioPacketPtr;
        midiBuffersize = _midiBuffersize;

    }

    virtual unsigned int getEventCount()
    {
        return midiBuffersize;
    }

    virtual bool fireMidiEvents(unsigned int sampleOffset)
    {
        while( (midiBuffersize > 0) && (NULL != ioPacketPtr) && ((ioPacketPtr->mTimestamp <= sampleOffset)))
        {
            const uint8_t uMessage = (ioPacketPtr->mData[0] & 0xF0);    // message
            const uint8_t uChannel = (ioPacketPtr->mData[0] & 0x0F);    // channel

            midiEvent event;
            event.midiMessage = (unsigned int)uMessage;
            event.midiChannel = (unsigned int)uChannel;
            event.midiData1 = (unsigned int)ioPacketPtr->mData[1];
            event.midiData2 = (unsigned int)ioPacketPtr->mData[2];
            event.midiSampleOffset = sampleOffset;

            // --- send to core for processing
            if(pluginCore)
                pluginCore->processMIDIEvent(event);

            ++ioPacketPtr;
            --midiBuffersize;
        }
        return true;
    }

protected:
    PluginCore* pluginCore = nullptr;       
    const AAX_CMidiPacket* ioPacketPtr;     
    uint32_t midiBuffersize = 0;            
};

#endif