ausynthplugin.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK AU Shell File:  ausynthplugin.h
//
// -----------------------------------------------------------------------------
#include <AudioToolbox/AudioUnitUtilities.h>
#include "AudioUnitSDK/MusicDeviceBase.h"   // for Synths
#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 AUSynthPlugin : public ausdk::MusicDeviceBase
{
public:
    AUSynthPlugin(AudioUnit component);
    ~AUSynthPlugin();
 
    virtual OSStatus    Version() {return 1000;}
 
    virtual OSStatus    Initialize() override;
 
    virtual OSStatus GetPropertyInfo(AudioUnitPropertyID    inID,
                                     AudioUnitScope         nScope,
                                     AudioUnitElement       inElement,
                                     UInt32&                outDataSize,
                                     bool&               outWritable ) override;
 
    virtual OSStatus GetProperty(AudioUnitPropertyID    inID,
                                 AudioUnitScope         inScope,
                                 AudioUnitElement       inElement,
                                 void*                  outData ) override;
 
    virtual OSStatus SetProperty(AudioUnitPropertyID inID,
                                 AudioUnitScope      inScope,
                                 AudioUnitElement    inElement,
                                 const void*         inData,
                                 UInt32              inDataSize) override;
 
    virtual OSStatus    GetParameterInfo(AudioUnitScope         inScope,
                                             AudioUnitParameterID   inParameterID,
                                         AudioUnitParameterInfo &outParameterInfo ) override;
 
    virtual OSStatus    GetPresets(CFArrayRef* outData) const override;
 
    virtual OSStatus NewFactoryPresetSet (const AUPreset& inNewFactoryPreset) override;
 
    virtual bool SupportsTail() override
    {
        if(pluginCore)
            return pluginCore->getTailTimeInMSec() > 0 ? true : false;
 
        return false;
    }
 
    virtual Float64 GetTailTime() override
    {
        if(pluginCore)
            return pluginCore->getTailTimeInMSec() / 1000.0;
 
        return 0.0;
    }
 
    virtual Float64 GetLatency() override {return latencyInSeconds;}
 
 
    virtual OSStatus SetParameter(AudioUnitParameterID   inID,
                                         AudioUnitScope          inScope,
                                         AudioUnitElement        inElement,
                                         AudioUnitParameterValue inValue,
                                         UInt32                  inBufferOffsetInFrames) override;
 
    virtual OSStatus Render(AudioUnitRenderActionFlags &        ioActionFlags,
                            const AudioTimeStamp &              inTimeStamp,
                            UInt32                              inNumberFrames) override;
 
 
    virtual OSStatus    Reset(AudioUnitScope   inScope,
                                  AudioUnitElement inElement) override;
 
    virtual OSStatus    GetParameterValueStrings(AudioUnitScope       inScope,
                                                     AudioUnitParameterID inParameterID,
                                                     CFArrayRef*          outStrings) override;
 
    // --- need this for when user selects a NON factory-preset (ie they created the preset in the Client)
    virtual OSStatus    RestoreState(CFPropertyListRef inData) override;
    virtual UInt32 SupportedNumChannels(const AUChannelInfo** outInfo) override;
 
    // --- MIDI Functions
    virtual OSStatus HandleNoteOn(UInt8     inChannel,
                                  UInt8     inNoteNumber,
                                  UInt8     inVelocity,
                                  UInt32    inStartFrame) override;
 
    virtual OSStatus HandleNoteOff(UInt8    inChannel,
                                   UInt8    inNoteNumber,
                                   UInt8    inVelocity,
                                   UInt32   inStartFrame) override;
 
    // --- MIDI Pitchbend (slightly different from all other CCs)
    virtual OSStatus HandlePitchWheel(UInt8  inChannel,
                                      UInt8  inPitch1,
                                      UInt8  inPitch2,
                                      UInt32 inStartFrame) override;
 
    // --- all other MIDI CC messages
    virtual OSStatus HandleControlChange(UInt8  inChannel,
                                         UInt8  inController,
                                         UInt8  inValue,
                                         UInt32 inStartFrame) override;
 
    // --- for ALL other MIDI messages you can get them here
    OSStatus MIDIEvent(UInt32 inStatus, UInt32 inData1, UInt32 inData2, UInt32 inOffsetSampleFrame) override;
 
    // --- virtual base class overrides required to be non-abstract
    bool StreamFormatWritable(AudioUnitScope, AudioUnitElement) override { return true; }
    bool CanScheduleParameters() const override { return false; }
 
    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
    VSTGUI::PluginGUI* pluginGUI = nullptr;
};
 
class PluginHostConnector : public IPluginHostConnector
{
public:
    PluginHostConnector(AUSynthPlugin* _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:
    AUSynthPlugin* 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(AUSynthPlugin* _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; 
    AUSynthPlugin* 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;                    
};