AAXPluginParameters.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK AAX Shell File:  aaxpluginparameters.h
//
// -----------------------------------------------------------------------------
#pragma once
#ifndef AAX_PARAMETERS_H
#define AAX_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"
#include "customcontrols.h"
 
#if MAC
#include <CoreFoundation/CoreFoundation.h>
#else
#include <windows.h>
#endif
 
// --- 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;
};
 
// --- processing struct
struct AAXAlgorithm
{
    // --- audio
    pluginPrivateData*  privateData;            // --- the Monolithic Parameters
    float**             inputBufferPtrs;        // --- inputs buffer
    float**             outputBufferPtrs;       // --- outputs buffer
    int32_t*            bufferLength;           // --- buffer size (per channel)
#ifdef PT_GR_METER
    float**             grMeterPtrs;            // --- Meter taps; currrently support one GR meter (have never seen more than 1)
#endif
    
#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() AAX_OVERRIDE;                
    virtual AAX_Result ResetFieldData (AAX_CFieldIndex inFieldIndex, void * oData, uint32_t iDataSize) const AAX_OVERRIDE;
    virtual AAX_Result GenerateCoefficients() AAX_OVERRIDE;      
    virtual AAX_Result TimerWakeup() AAX_OVERRIDE;               
    AAX_Result GetParameterNormalizedValue (AAX_CParamID iParameterID, double * oValuePtr )  const AAX_OVERRIDE;
    
    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 AAX_OVERRIDE;
 
    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;        
    AAX_CParameterManager mMeterParameterManager;
    
    AAX_Result SetMeterParameterNormalizedValue (AAX_CParamID iParameterID, double aValue)
    {
        AAX_IParameter* parameter = mMeterParameterManager.GetParameterByID(iParameterID);
        if (parameter == 0)
            return AAX_ERROR_INVALID_PARAMETER_ID;
        
        parameter->SetNormalizedValue ( aValue );
        return AAX_SUCCESS;
    }
    
    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;
    }
 
#if defined _WINDOWS || defined _WINDLL
    wchar_t* convertCharArrayToLPCWSTR(const char* charArray)
    {
        wchar_t* wString = new wchar_t[4096];
        MultiByteToWideChar(CP_ACP, 0, charArray, -1, wString, 4096);
        return wString;
    }
    // --- getMyDLLDirectory()
    //     returns the directory where the .component resides
    char* getMyDLLDirectory(const char* dllName)
    {
        wchar_t* cPluginName = convertCharArrayToLPCWSTR(dllName);
        HMODULE hmodule = GetModuleHandle(cPluginName);
        
        TCHAR dir[MAX_PATH];
        memset(&dir[0], 0, MAX_PATH*sizeof(TCHAR));
        dir[MAX_PATH-1] = '\0';
        
        if(hmodule)
            GetModuleFileName(hmodule, &dir[0], MAX_PATH);
        else
            return nullptr;
        
        // --- use string tools
        std::wstring backslash(L"\\");
        std::wstring strPlugin(cPluginName);
        std::wstring strDir(&dir[0]);
        int pathLen = strDir.size() - strPlugin.size() - backslash.size();
        if (pathLen > 0)
        {
            std::wstring strPath = strDir.substr(0, pathLen);
            char* str = new char[MAX_PATH];
            sprintf(str, "%ls", strPath.c_str());
            delete[] cPluginName;
            
            return str; // dllPath.c_str();
        }
        return "";
    }
    
#else
    char* getMyComponentDirectory(CFStringRef bundleID)
    {
        if (bundleID != nullptr)
        {
            CFBundleRef helixBundle = CFBundleGetBundleWithIdentifier( bundleID );
            if(helixBundle != nullptr)
            {
                CFURLRef bundleURL = CFBundleCopyBundleURL ( helixBundle );
                if(bundleURL != nullptr)
                {
                    CFURLRef componentFolderPathURL = CFURLCreateCopyDeletingLastPathComponent(nullptr, bundleURL);
                    
                    CFStringRef myComponentPath = CFURLCopyFileSystemPath(componentFolderPathURL, kCFURLPOSIXPathStyle);
                    CFRelease(componentFolderPathURL);
                    
                    if(myComponentPath != nullptr)
                    {
                        int nSize = CFStringGetLength(myComponentPath);
                        char* path = new char[nSize+1];
                        memset(path, 0, (nSize+1)*sizeof(char));
                        
                        bool success = CFStringGetCString(myComponentPath, path, nSize+1, kCFStringEncodingASCII);
                        CFRelease(myComponentPath);
                        
                        if(success) return path;
                        else return nullptr;
                    }
                    CFRelease(bundleURL);
                }
            }
            CFRelease(bundleID);
        }
        return nullptr;
    }
#endif
};
 
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(AAXPluginParameters* _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)
    {
        //if(aaxParameters->)
        // --- 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;     ///< the parent object
    AAXPluginParameters* 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