aufxplugin.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK AU Shell File:  aufxplugin.h
//
// -----------------------------------------------------------------------------
#include <AudioToolbox/AudioUnitUtilities.h>
#include "AUMIDIEffectBase.h"   // For FX + MIDI
#include "plugingui.h"
#include "plugincore.h"
#include <math.h>
#include <queue>
#include <string>

// custom properties id's must be 64000 or greater
// see <AudioUnit/AudioUnitProperties.h> for a list of Apple-defined standard properties
//
// --- These are for VSTGUI4 messaging - WP
enum guiMessage
{
    kOpenGUI = 64000,
    kCloseGUI
};

class GUIPluginConnector;
class PluginHostConnector;
class AUMIDIEventQueue;

class AUFXPlugin : public AUMIDIEffectBase
{
public:
    AUFXPlugin(AudioUnit component);
    ~AUFXPlugin();

    virtual ComponentResult Version() {return 1000;}

    virtual ComponentResult Initialize();

    virtual OSStatus GetPropertyInfo(AudioUnitPropertyID    inID,
                                     AudioUnitScope         nScope,
                                     AudioUnitElement       inElement,
                                     UInt32&                outDataSize,
                                     Boolean&               outWritable );

    virtual OSStatus GetProperty(AudioUnitPropertyID    inID,
                                 AudioUnitScope         inScope,
                                 AudioUnitElement       inElement,
                                 void*                  outData );

    virtual OSStatus SetProperty(AudioUnitPropertyID inID,
                                 AudioUnitScope      inScope,
                                 AudioUnitElement    inElement,
                                 const void*         inData,
                                 UInt32              inDataSize);

    virtual ComponentResult GetParameterInfo(AudioUnitScope         inScope,
                                             AudioUnitParameterID   inParameterID,
                                             AudioUnitParameterInfo &outParameterInfo );

    virtual ComponentResult GetPresets(CFArrayRef* outData) const;

    virtual OSStatus NewFactoryPresetSet (const AUPreset& inNewFactoryPreset);

    virtual bool SupportsTail()
    {
        if(pluginCore)
            return pluginCore->getTailTimeInMSec() > 0 ? true : false;

        return false;
    }

    virtual Float64 GetTailTime()
    {
        if(pluginCore)
            return pluginCore->getTailTimeInMSec() / 1000.0;

        return 0.0;
    }

    virtual Float64 GetLatency() {return latencyInSeconds;}


    virtual ComponentResult SetParameter(AudioUnitParameterID    inID,
                                         AudioUnitScope          inScope,
                                         AudioUnitElement        inElement,
                                         AudioUnitParameterValue inValue,
                                         UInt32                  inBufferOffsetInFrames);

    virtual OSStatus Render(AudioUnitRenderActionFlags &        ioActionFlags,
                            const AudioTimeStamp &              inTimeStamp,
                            UInt32                              inNumberFrames);


    virtual OSStatus ProcessBufferLists(AudioUnitRenderActionFlags& ioActionFlags,
                                        const AudioBufferList&      inBuffer,
                                        AudioBufferList&            outBuffer,
                                        UInt32                      inFramesToProcess );

    virtual ComponentResult Reset(AudioUnitScope   inScope,
                                  AudioUnitElement inElement);

    virtual ComponentResult GetParameterValueStrings(AudioUnitScope       inScope,
                                                     AudioUnitParameterID inParameterID,
                                                     CFArrayRef*          outStrings);

    // --- need this for when user selects a NON factory-preset (ie they created the preset in the Client)
    virtual ComponentResult RestoreState(CFPropertyListRef inData);
    virtual UInt32 SupportedNumChannels(const AUChannelInfo** outInfo);

    // --- MIDI Functions
    virtual OSStatus HandleNoteOn(UInt8     inChannel,
                                  UInt8     inNoteNumber,
                                  UInt8     inVelocity,
                                  UInt32    inStartFrame);

    virtual OSStatus HandleNoteOff(UInt8    inChannel,
                                   UInt8    inNoteNumber,
                                   UInt8    inVelocity,
                                   UInt32   inStartFrame);

    // --- MIDI Pitchbend (slightly different from all other CCs)
    virtual OSStatus HandlePitchWheel(UInt8  inChannel,
                                      UInt8  inPitch1,
                                      UInt8  inPitch2,
                                      UInt32 inStartFrame);

    // --- all other MIDI CC messages
    virtual OSStatus HandleControlChange(UInt8  inChannel,
                                         UInt8  inController,
                                         UInt8  inValue,
                                         UInt32 inStartFrame);

    // --- for ALL other MIDI messages you can get them here
    virtual OSStatus HandleMidiEvent(UInt8  status,
                             UInt8  channel,
                             UInt8  data1,
                             UInt8  data2,
                             UInt32 inStartFrame);

    char* getMyComponentDirectory(CFStringRef bundleID)
    {
        if (bundleID != NULL)
        {
            CFBundleRef helixBundle = CFBundleGetBundleWithIdentifier( bundleID );
            if(helixBundle != NULL)
            {
                CFURLRef bundleURL = CFBundleCopyBundleURL ( helixBundle );
                if(bundleURL != NULL)
                {
                    CFURLRef componentFolderPathURL = CFURLCreateCopyDeletingLastPathComponent(NULL, bundleURL);

                    CFStringRef myComponentPath = CFURLCopyFileSystemPath(componentFolderPathURL, kCFURLPOSIXPathStyle);
                    CFRelease(componentFolderPathURL);

                    if(myComponentPath != NULL)
                    {
                        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 NULL;
                    }
                    CFRelease(bundleURL);
                }
            }
            CFRelease(bundleID);
        }
        return NULL;
    }

    void setAUParameterChangeEvent(unsigned int controlID, double actualValue);

    double getAUParameter(unsigned int controlID);

    GUIPluginConnector* guiPluginConnector = nullptr;       
    PluginHostConnector* pluginHostConnector = nullptr;     
    AUMIDIEventQueue* midiEventQueue = nullptr;             

protected:
    // --- Plugin Core
    PluginCore* pluginCore = nullptr;           
    void initAUParametersWithPluginCore();      
    void updateAUParametersWithPluginCore();    
    void updatePluginCoreParameters();          
    void updateHostInfo(HostInfo* hostInfo);    

    // --- sidechaining
    bool hasSidechain = false;                          
    AudioBufferList* sidechainBufferList = nullptr;     
    int sidechainChannelCount = 0;                      
    AUChannelInfo* auChannelInfo = nullptr;             
    float** inputBuffers = nullptr;                     
    float** outputBuffers = nullptr;                    
    float** sidechainInputBuffers = nullptr;            

    // --- raw bytes for "static" preset data
    void* presetsArrayData = nullptr;                   
    int currentPreset = 0;                              

    // --- NOTE: AU takes latency in seconds, not samples; this is recalculated
    //           during init() and reset() operations
    Float64 latencyInSeconds = 0 ;                      


    //                          It should NEVER be used to try to communicate
    //                          directly with the GUI - not thread safe
    PluginGUI* pluginGUI = nullptr;
};

class PluginHostConnector : public IPluginHostConnector
{
public:
    PluginHostConnector(AUFXPlugin* _auInstance){auInstance = _auInstance;}
    virtual ~PluginHostConnector(){}

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

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

                    // --- threadsafe atomic write to global param & GUI update dispatch
                    auInstance->setAUParameterChangeEvent(guiParam.controlID, guiParam.actualValue);
                }

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

                break;
            }
            default:
                break;
        }
    }

protected:
    AUFXPlugin* auInstance = nullptr; 
};

// --- GUI -> Plugin interface
//
// --- container for a custom view pointer
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; 
};

// --- GUI -> Plugin interface
class GUIPluginConnector : public IGUIPluginConnector
{
public:
    GUIPluginConnector(AUFXPlugin* _auInstance, PluginCore* _pluginCore){auInstance = _auInstance; pluginCore = _pluginCore;}

    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 getActualPluginParameter(int32_t controlID)
    {
        PluginParameter* piParam = pluginCore->getPluginParameterByControlID(controlID);
        if(piParam)
        {
            return auInstance->getAUParameter(controlID);
        }
        else
            return 0.0;
    }

    virtual double getNormalizedPluginParameter(int32_t controlID)
    {
        if(pluginCore && auInstance)
        {
            PluginParameter* piParam = pluginCore->getPluginParameterByControlID(controlID);
            if(piParam)
            {
                double actualValue = getActualPluginParameter(controlID);
                return piParam->getNormalizedControlValueWithActualValue(actualValue);
            }
        }
        return 0.0;
    }

    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; 
    AUFXPlugin* auInstance = 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;
    }
};

// --- GUI -> Plugin interface
class AUMIDIEventQueue : public IMidiEventQueue
{
public:

    AUMIDIEventQueue(PluginCore* _pluginCore)
    {
        pluginCore = _pluginCore;
        writingQueueA.store(true);
    };

    virtual ~AUMIDIEventQueue()
    {
        clearEvents();
    }

    void clearEvents()
    {
        clearQueueAEvents();
        clearQueueBEvents();
    }

    void clearQueueAEvents()
    {
        if(midiEventQueueA.size() > 0)
            fprintf(stderr, "midiEventQueueA.size() > 0: %u", midiEventQueueA.size() > 0);

        while(midiEventQueueA.size() > 0)
            midiEventQueueA.pop();
    }

    void clearQueueBEvents()
    {
        if(midiEventQueueB.size() > 0)
            fprintf(stderr, "midiEventQueueB.size() > 0: %u", midiEventQueueB.size() > 0);

        while(midiEventQueueB.size() > 0)
            midiEventQueueB.pop();
    }

    void toggleQueue()
    {
        // --- toggle the atomic bool
        writingQueueA = !writingQueueA;

        // --- clear out write-queue (should never be non-empty)
        if(writingQueueA)
            clearQueueAEvents();
        else
            clearQueueBEvents();
    }

    inline void addEvent(midiEvent event)
    {
        if(writingQueueA)
        {
            midiEventQueueA.push(event);
           // fprintf(stderr, "QA addEvent: %u", event.midiData1);
           // fprintf(stderr, "  with offset: %u\n", event.midiSampleOffset);

        }
        else
        {
            midiEventQueueB.push(event);
            //fprintf(stderr, "QB addEvent: %u", event.midiData1);
           // fprintf(stderr, "  with offset: %u\n", event.midiSampleOffset);

        }
    }

    virtual unsigned int getEventCount()
    {
        if(writingQueueA)
            return midiEventQueueB.size();
        else
            return midiEventQueueA.size();
    }

    virtual bool fireMidiEvents(unsigned int sampleOffset)
    {
        std::queue<midiEvent>* readingQueue = writingQueueA ? &midiEventQueueB : &midiEventQueueA;

        if(readingQueue->size() <= 0 || !pluginCore) return false;

        while(readingQueue->size() > 0)
        {
            // --- check the current top
            midiEvent event = readingQueue->front();
            if(event.midiSampleOffset != sampleOffset) return false;

           // fprintf(stderr, "fired MIDI Event: %u", event.midiData1);
          //  fprintf(stderr, "  with offset: %u\n", event.midiSampleOffset);

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

            // --- pop to remove
            readingQueue->pop();
        }
        return true;
    }


protected:
    PluginCore* pluginCore = nullptr;                   
    std::queue<midiEvent> midiEventQueueA;              
    std::queue<midiEvent> midiEventQueueB;              
    std::atomic<bool> writingQueueA;                    
};