DISTRHO
/
DPF
mirror of https://github.com/DISTRHO/DPF
1
0
Fork 0
Code Releases 0 Activity
DISTRHO Plugin Framework
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2259 Commits
7 Branches
53MB
Tree: 496f832a0b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '496f832a0b'
${ noResults }
DPF/distrho/src/DistrhoPluginAU.cpp

2053 lines
84KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Plugin Framework (DPF)

  3.  * Copyright (C) 2012-2024 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * Permission to use, copy, modify, and/or distribute this software for any purpose with

  6.  * or without fee is hereby granted, provided that the above copyright notice and this

  7.  * permission notice appear in all copies.

  8.  *

  9.  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

  10.  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN

  11.  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

  12.  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

  13.  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  14.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  15.  */

  16. 

  17. // TODO

  18. // - g_nextBundlePath vs d_nextBundlePath cleanup

  19. // - scale points to kAudioUnitParameterFlag_ValuesHaveStrings

  20. 

  21. #include "DistrhoPluginInternal.hpp"

  22. #include "../DistrhoPluginUtils.hpp"

  23. 

  24. #if DISTRHO_PLUGIN_HAS_UI

  25. # include "../extra/RingBuffer.hpp"

  26. #endif

  27. 

  28. #include <AudioUnit/AudioUnit.h>

  29. #include <AudioToolbox/AudioUnitUtilities.h>

  30. #include <vector>

  31. 

  32. #ifndef DISTRHO_PLUGIN_AU_SUBTYPE

  33. # error DISTRHO_PLUGIN_AU_SUBTYPE undefined!

  34. #endif

  35. 

  36. #ifndef DISTRHO_PLUGIN_AU_MANUFACTURER

  37. # error DISTRHO_PLUGIN_AU_MANUFACTURER undefined!

  38. #endif

  39. 

  40. START_NAMESPACE_DISTRHO

  41. 

  42. // --------------------------------------------------------------------------------------------------------------------

  43. 

  44. static const char* AudioUnitPropertyID2Str(const AudioUnitPropertyID prop) noexcept

  45. {

  46.     switch (prop)

  47.     {

  48.     #define PROP(s) case s: return #s;

  49.     PROP(kAudioUnitProperty_ClassInfo)

  50.     PROP(kAudioUnitProperty_MakeConnection)

  51.     PROP(kAudioUnitProperty_SampleRate)

  52.     PROP(kAudioUnitProperty_ParameterList)

  53.     PROP(kAudioUnitProperty_ParameterInfo)

  54.    #if !TARGET_OS_IPHONE

  55.     PROP(kAudioUnitProperty_FastDispatch)

  56.    #endif

  57.     PROP(kAudioUnitProperty_CPULoad)

  58.     PROP(kAudioUnitProperty_StreamFormat)

  59.     PROP(kAudioUnitProperty_ElementCount)

  60.     PROP(kAudioUnitProperty_Latency)

  61.     PROP(kAudioUnitProperty_SupportedNumChannels)

  62.     PROP(kAudioUnitProperty_MaximumFramesPerSlice)

  63.     PROP(kAudioUnitProperty_ParameterValueStrings)

  64.     PROP(kAudioUnitProperty_AudioChannelLayout)

  65.     PROP(kAudioUnitProperty_TailTime)

  66.     PROP(kAudioUnitProperty_BypassEffect)

  67.     PROP(kAudioUnitProperty_LastRenderError)

  68.     PROP(kAudioUnitProperty_SetRenderCallback)

  69.     PROP(kAudioUnitProperty_FactoryPresets)

  70.     PROP(kAudioUnitProperty_RenderQuality)

  71.     PROP(kAudioUnitProperty_HostCallbacks)

  72.     PROP(kAudioUnitProperty_InPlaceProcessing)

  73.     PROP(kAudioUnitProperty_ElementName)

  74.     PROP(kAudioUnitProperty_SupportedChannelLayoutTags)

  75.     PROP(kAudioUnitProperty_PresentPreset)

  76.     PROP(kAudioUnitProperty_DependentParameters)

  77.     PROP(kAudioUnitProperty_InputSamplesInOutput)

  78.     PROP(kAudioUnitProperty_ShouldAllocateBuffer)

  79.     PROP(kAudioUnitProperty_FrequencyResponse)

  80.     PROP(kAudioUnitProperty_ParameterHistoryInfo)

  81.     PROP(kAudioUnitProperty_NickName)

  82.     PROP(kAudioUnitProperty_OfflineRender)

  83.     PROP(kAudioUnitProperty_ParameterIDName)

  84.     PROP(kAudioUnitProperty_ParameterStringFromValue)

  85.     PROP(kAudioUnitProperty_ParameterClumpName)

  86.     PROP(kAudioUnitProperty_ParameterValueFromString)

  87.     PROP(kAudioUnitProperty_PresentationLatency)

  88.     PROP(kAudioUnitProperty_ClassInfoFromDocument)

  89.     PROP(kAudioUnitProperty_RequestViewController)

  90.     PROP(kAudioUnitProperty_ParametersForOverview)

  91.     PROP(kAudioUnitProperty_SupportsMPE)

  92.     PROP(kAudioUnitProperty_RenderContextObserver)

  93.     PROP(kAudioUnitProperty_LastRenderSampleTime)

  94.     PROP(kAudioUnitProperty_LoadedOutOfProcess)

  95.    #if !TARGET_OS_IPHONE

  96.     PROP(kAudioUnitProperty_SetExternalBuffer)

  97.     PROP(kAudioUnitProperty_GetUIComponentList)

  98.     PROP(kAudioUnitProperty_CocoaUI)

  99.     PROP(kAudioUnitProperty_IconLocation)

  100.     PROP(kAudioUnitProperty_AUHostIdentifier)

  101.    #endif

  102.     PROP(kAudioUnitProperty_MIDIOutputCallbackInfo)

  103.     PROP(kAudioUnitProperty_MIDIOutputCallback)

  104.     PROP(kAudioUnitProperty_MIDIOutputEventListCallback)

  105.     PROP(kAudioUnitProperty_AudioUnitMIDIProtocol)

  106.     PROP(kAudioUnitProperty_HostMIDIProtocol)

  107.     PROP(kAudioUnitProperty_MIDIOutputBufferSizeHint)

  108.     #undef PROP

  109.     }

  110.     return "[unknown]";

  111. }

  112. 

  113. static const char* AudioUnitScope2Str(const AudioUnitScope scope) noexcept

  114. {

  115.     switch (scope)

  116.     {

  117.     #define SCOPE(s) case s: return #s;

  118.     SCOPE(kAudioUnitScope_Global)

  119.     SCOPE(kAudioUnitScope_Input)

  120.     SCOPE(kAudioUnitScope_Output)

  121.     SCOPE(kAudioUnitScope_Group)

  122.     SCOPE(kAudioUnitScope_Part)

  123.     SCOPE(kAudioUnitScope_Note)

  124.     SCOPE(kAudioUnitScope_Layer)

  125.     SCOPE(kAudioUnitScope_LayerItem)

  126.     #undef SCOPE

  127.     }

  128.     return "[unknown]";

  129. }

  130. 

  131. static const char* AudioUnitSelector2Str(const SInt16 selector) noexcept

  132. {

  133.     switch (selector)

  134.     {

  135.     #define SEL(s) case s: return #s;

  136.     SEL(kAudioUnitInitializeSelect)

  137.     SEL(kAudioUnitUninitializeSelect)

  138.     SEL(kAudioUnitGetPropertyInfoSelect)

  139.     SEL(kAudioUnitGetPropertySelect)

  140.     SEL(kAudioUnitSetPropertySelect)

  141.     SEL(kAudioUnitAddPropertyListenerSelect)

  142.     SEL(kAudioUnitRemovePropertyListenerSelect)

  143.     SEL(kAudioUnitRemovePropertyListenerWithUserDataSelect)

  144.     SEL(kAudioUnitAddRenderNotifySelect)

  145.     SEL(kAudioUnitRemoveRenderNotifySelect)

  146.     SEL(kAudioUnitGetParameterSelect)

  147.     SEL(kAudioUnitSetParameterSelect)

  148.     SEL(kAudioUnitScheduleParametersSelect)

  149.     SEL(kAudioUnitRenderSelect)

  150.     SEL(kAudioUnitResetSelect)

  151.     SEL(kAudioUnitComplexRenderSelect)

  152.     SEL(kAudioUnitProcessSelect)

  153.     SEL(kAudioUnitProcessMultipleSelect)

  154.     SEL(kMusicDeviceMIDIEventSelect)

  155.     SEL(kMusicDeviceSysExSelect)

  156.     SEL(kMusicDevicePrepareInstrumentSelect)

  157.     SEL(kMusicDeviceReleaseInstrumentSelect)

  158.     SEL(kMusicDeviceStartNoteSelect)

  159.     SEL(kMusicDeviceStopNoteSelect)

  160.     SEL(kMusicDeviceMIDIEventListSelect)

  161.     SEL(kAudioOutputUnitStartSelect)

  162.     SEL(kAudioOutputUnitStopSelect)

  163.     #undef SEL

  164.     }

  165.     return "[unknown]";

  166. }

  167. 

  168. static constexpr FourCharCode getFourCharCodeFromString(const char str[4])

  169. {

  170.     return (str[0] << 24) + (str[1] << 16) + (str[2] << 8) + str[3];

  171. }

  172. 

  173. // --------------------------------------------------------------------------------------------------------------------

  174. 

  175. #define MACRO_STR2(s) #s

  176. #define MACRO_STR(s) MACRO_STR2(s)

  177. 

  178. static constexpr const char kTypeStr[] = MACRO_STR(DISTRHO_PLUGIN_AU_TYPE);

  179. static constexpr const char kSubTypeStr[] = MACRO_STR(DISTRHO_PLUGIN_AU_SUBTYPE);

  180. static constexpr const char kManufacturerStr[] = MACRO_STR(DISTRHO_PLUGIN_AU_MANUFACTURER);

  181. 

  182. #undef MACRO_STR

  183. #undef MACRO_STR2

  184. 

  185. static constexpr const FourCharCode kType = getFourCharCodeFromString(kTypeStr);

  186. static constexpr const FourCharCode kSubType = getFourCharCodeFromString(kSubTypeStr);

  187. static constexpr const FourCharCode kManufacturer = getFourCharCodeFromString(kManufacturerStr);

  188. 

  189. // --------------------------------------------------------------------------------------------------------------------

  190. 

  191. struct PropertyListener {

  192.     AudioUnitPropertyID	prop;

  193.     AudioUnitPropertyListenerProc proc;

  194.     void* userData;

  195. };

  196. 

  197. typedef std::vector<PropertyListener> PropertyListeners;

  198. 

  199. // --------------------------------------------------------------------------------------------------------------------

  200. 

  201. typedef struct {

  202.     UInt32 numPackets;

  203.     MIDIPacket packets[kMaxMidiEvents];

  204. } MIDIPacketList;

  205. 

  206. // --------------------------------------------------------------------------------------------------------------------

  207. 

  208. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  209. static constexpr const writeMidiFunc writeMidiCallback = nullptr;

  210. #endif

  211. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  212. static constexpr const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  213. #endif

  214. #if ! DISTRHO_PLUGIN_WANT_STATE

  215. static constexpr const updateStateValueFunc updateStateValueCallback = nullptr;

  216. #endif

  217. 

  218. class PluginAU

  219. {

  220. public:

  221.     PluginAU(const AudioUnit component)

  222.         : fPlugin(this, writeMidiCallback, requestParameterValueChangeCallback, updateStateValueCallback),

  223.           fComponent(component),

  224.           fLastRenderError(noErr),

  225.           fPropertyListeners(),

  226.          #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  227.           fSampleRateForInput(d_nextSampleRate),

  228.          #endif

  229.          #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  230.           fSampleRateForOutput(d_nextSampleRate),

  231.          #endif

  232.           fParameterCount(fPlugin.getParameterCount()),

  233.           fLastParameterValues(nullptr),

  234.           fBypassParameterIndex(UINT32_MAX)

  235.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  236.         , fMidiEventCount(0)

  237.        #endif

  238.     {

  239. 	    if (fParameterCount != 0)

  240.         {

  241.             fLastParameterValues = new float[fParameterCount];

  242.             std::memset(fLastParameterValues, 0, sizeof(float) * fParameterCount);

  243. 

  244.             for (uint32_t i=0; i<fParameterCount; ++i)

  245.             {

  246.                 fLastParameterValues[i] = fPlugin.getParameterValue(i);

  247. 

  248.                 if (fPlugin.getParameterDesignation(i) == kParameterDesignationBypass)

  249.                     fBypassParameterIndex = i;

  250.             }

  251.         }

  252. 

  253.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  254.         std::memset(&fMidiEvents, 0, sizeof(fMidiEvents));

  255.        #endif

  256. 

  257.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  258.         std::memset(&fMidiOutput, 0, sizeof(fMidiOutput));

  259.         std::memset(&fMidiOutputPackets, 0, sizeof(fMidiOutputPackets));

  260.        #endif

  261.     }

  262. 

  263.     ~PluginAU()

  264.     {

  265.         delete[] fLastParameterValues;

  266.     }

  267. 

  268.     OSStatus auInitialize()

  269.     {

  270.         fPlugin.activate();

  271.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  272.         fMidiEventCount = 0;

  273.        #endif

  274.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  275.         fMidiOutputPackets.numPackets = 0;

  276.        #endif

  277.         return noErr;

  278.     }

  279. 

  280.     OSStatus auUninitialize()

  281.     {

  282.         fPlugin.deactivateIfNeeded();

  283.         return noErr;

  284.     }

  285. 

  286.     OSStatus auGetPropertyInfo(const AudioUnitPropertyID inProp,

  287.                                const AudioUnitScope inScope,

  288.                                const AudioUnitElement inElement,

  289.                                UInt32& outDataSize,

  290.                                Boolean& outWritable)

  291.     {

  292.         switch (inProp)

  293.         {

  294.         case kAudioUnitProperty_ClassInfo:

  295.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  296.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  297.             outDataSize = sizeof(CFPropertyListRef);

  298.             outWritable = true;

  299.             return noErr;

  300. 

  301.         case kAudioUnitProperty_MakeConnection:

  302.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global || inScope == kAudioUnitScope_Input, inScope, kAudioUnitErr_InvalidScope);

  303.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  304.             outDataSize = sizeof(AudioUnitConnection);

  305.             outWritable = true;

  306.             return noErr;

  307. 

  308.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  309.         case kAudioUnitProperty_SampleRate:

  310.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0 && DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  311.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Input || inScope == kAudioUnitScope_Output, inScope, kAudioUnitErr_InvalidScope);

  312.            #elif DISTRHO_PLUGIN_NUM_INPUTS != 0

  313.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Input, inScope, kAudioUnitErr_InvalidScope);

  314.            #else

  315.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Output, inScope, kAudioUnitErr_InvalidScope);

  316.            #endif

  317.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  318.             outDataSize = sizeof(Float64);

  319.             outWritable = true;

  320.             return noErr;

  321.        #endif

  322. 

  323.         case kAudioUnitProperty_ParameterList:

  324.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  325.             outDataSize = inScope == kAudioUnitScope_Global ? sizeof(AudioUnitParameterID) * fParameterCount : 0;

  326.             outWritable = false;

  327.             return noErr;

  328. 

  329.         case kAudioUnitProperty_ParameterInfo:

  330.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  331.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement < fParameterCount, inElement, kAudioUnitErr_InvalidElement);

  332.             outDataSize = sizeof(AudioUnitParameterInfo);

  333.             outWritable = false;

  334.             return noErr;

  335. 

  336.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  337.         case kAudioUnitProperty_StreamFormat:

  338.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  339.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  340.             if (inScope == kAudioUnitScope_Input)

  341.             {

  342.                 outDataSize = sizeof(AudioStreamBasicDescription);

  343.                 outWritable = true;

  344.                 return noErr;

  345.             }

  346.            #endif

  347.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  348.             if (inScope == kAudioUnitScope_Output)

  349.             {

  350.                 outDataSize = sizeof(AudioStreamBasicDescription);

  351.                 outWritable = true;

  352.                 return noErr;

  353.             }

  354.            #endif

  355.             return kAudioUnitErr_InvalidScope;

  356.        #endif

  357. 

  358.         case kAudioUnitProperty_ElementCount:

  359.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  360.             outDataSize = sizeof(UInt32);

  361.             outWritable = false;

  362.             return noErr;

  363. 

  364.         case kAudioUnitProperty_Latency:

  365.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  366.            #if DISTRHO_PLUGIN_WANT_LATENCY

  367.             if (inScope == kAudioUnitScope_Global)

  368.             {

  369.                 outDataSize = sizeof(Float64);

  370.                 outWritable = false;

  371.                 return noErr;

  372.             }

  373.            #endif

  374.             return kAudioUnitErr_InvalidProperty;

  375. 

  376.         case kAudioUnitProperty_SupportedNumChannels:

  377.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  378.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  379.             outDataSize = sizeof(AUChannelInfo);

  380.             outWritable = false;

  381.             return noErr;

  382. 

  383.         case kAudioUnitProperty_MaximumFramesPerSlice:

  384.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  385.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  386.             outDataSize = sizeof(UInt32);

  387.             outWritable = true;

  388.             return noErr;

  389. 

  390.         case kAudioUnitProperty_BypassEffect:

  391.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  392.             if (inScope == kAudioUnitScope_Global && fBypassParameterIndex != UINT32_MAX)

  393.             {

  394.                 outDataSize = sizeof(UInt32);

  395.                 outWritable = false;

  396.                 return noErr;

  397.             }

  398.             return kAudioUnitErr_InvalidProperty;

  399. 

  400.         case kAudioUnitProperty_LastRenderError:

  401.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  402.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  403.             outDataSize = sizeof(OSStatus);

  404.             outWritable = false;

  405.             return noErr;

  406. 

  407.         case kAudioUnitProperty_SetRenderCallback:

  408.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Input, inScope, kAudioUnitErr_InvalidScope);

  409.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  410.             outDataSize = sizeof(AURenderCallbackStruct);

  411.             outWritable = true;

  412.             return noErr;

  413. 

  414.         case kAudioUnitProperty_InPlaceProcessing:

  415.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  416.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  417.             outDataSize = sizeof(UInt32);

  418.             outWritable = false;

  419.             return noErr;

  420. 

  421.         case kAudioUnitProperty_PresentPreset:

  422.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  423.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  424.             outDataSize = sizeof(AUPreset);

  425.             outWritable = true;

  426.             return noErr;

  427. 

  428.         case kAudioUnitProperty_CocoaUI:

  429.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  430.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  431.            #if DISTRHO_PLUGIN_HAS_UI

  432.             outDataSize = sizeof(AudioUnitCocoaViewInfo);

  433.             outWritable = false;

  434.             return noErr;

  435.            #else

  436.             return kAudioUnitErr_InvalidProperty;

  437.            #endif

  438. 

  439.         case kAudioUnitProperty_MIDIOutputCallbackInfo:

  440.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  441.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  442.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  443.             outDataSize = sizeof(CFArrayRef);

  444.             outWritable = false;

  445.             return noErr;

  446.            #else

  447.             return kAudioUnitErr_InvalidProperty;

  448.            #endif

  449. 

  450.         case kAudioUnitProperty_MIDIOutputCallback:

  451.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  452.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  453.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  454.             outDataSize = sizeof(AUMIDIOutputCallbackStruct);

  455.             outWritable = true;

  456.             return noErr;

  457.            #else

  458.             return kAudioUnitErr_InvalidProperty;

  459.            #endif

  460. 

  461.         case kAudioUnitProperty_AudioUnitMIDIProtocol:

  462.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  463.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  464.             // FIXME implement the event list stuff

  465.            #if 0 && (DISTRHO_PLUGIN_WANT_MIDI_INPUT || DISTRHO_PLUGIN_WANT_MIDI_OUTPUT)

  466.             outDataSize = sizeof(SInt32);

  467.             outWritable = false;

  468.             return noErr;

  469.            #else

  470.             return kAudioUnitErr_InvalidProperty;

  471.            #endif

  472. 

  473.        #if DISTRHO_PLUGIN_HAS_UI && DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  474.         case 'DPFa':

  475.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  476.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  477.             outDataSize = sizeof(void*);

  478.             outWritable = false;

  479.             return noErr;

  480.        #endif

  481. 

  482.         case 'DPFe':

  483.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  484.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement < fParameterCount, inElement, kAudioUnitErr_InvalidElement);

  485.             outDataSize = sizeof(bool);

  486.             outWritable = true;

  487.             return noErr;

  488. 

  489.         case 'DPFp':

  490.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  491.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement < fParameterCount, inElement, kAudioUnitErr_InvalidElement);

  492.             outDataSize = sizeof(float);

  493.             outWritable = true;

  494.             return noErr;

  495. 

  496.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT && DISTRHO_PLUGIN_HAS_UI

  497.         case 'DPFn':

  498.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  499.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  500.             outDataSize = sizeof(uint8_t) * 3;

  501.             outWritable = true;

  502.             return noErr;

  503.        #endif

  504. 

  505.        #if DISTRHO_PLUGIN_WANT_STATE

  506.         case 'DPFs':

  507.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  508.             DISTRHO_SAFE_ASSERT_RETURN(inElement != 0, kAudioUnitErr_InvalidElement);

  509.             outDataSize = inElement;

  510.             outWritable = true;

  511.             return noErr;

  512.        #endif

  513. 

  514.         // unwanted properties

  515.         case kAudioUnitProperty_CPULoad:

  516.         case kAudioUnitProperty_RenderContextObserver:

  517.         case kAudioUnitProperty_TailTime:

  518.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  519.         case kAudioUnitProperty_SampleRate:

  520.         case kAudioUnitProperty_StreamFormat:

  521.        #endif

  522.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  523.             return kAudioUnitErr_InvalidProperty;

  524.         }

  525. 

  526.         d_stdout("TODO GetPropertyInfo(%2d:%s, %d:%s, %d, ...)", inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement);

  527.         return kAudioUnitErr_InvalidProperty;

  528.     }

  529. 

  530.     OSStatus auGetProperty(const AudioUnitPropertyID inProp,

  531.                            const AudioUnitScope inScope,

  532.                            const AudioUnitElement inElement,

  533.                            void* const outData)

  534.     {

  535.         switch (inProp)

  536.         {

  537.         case kAudioUnitProperty_ClassInfo:

  538.             {

  539.                 CFPropertyListRef* const propList = static_cast<CFPropertyListRef*>(outData);

  540. 

  541.                 CFMutableDictionaryRef clsInfo = CFDictionaryCreateMutable(nullptr,

  542.                                                                            0,

  543.                                                                            &kCFTypeDictionaryKeyCallBacks,

  544.                                                                            &kCFTypeDictionaryValueCallBacks);

  545.                 SInt32 value;

  546. 

  547.                 value = 0;

  548.                 if (const CFNumberRef num = CFNumberCreate(nullptr, kCFNumberSInt32Type, &value))

  549.                 {

  550.                     CFDictionarySetValue(clsInfo, CFSTR(kAUPresetVersionKey), num);

  551.                     CFRelease(num);

  552.                 }

  553. 

  554.                 value = kType;

  555.                 if (const CFNumberRef num = CFNumberCreate(nullptr, kCFNumberSInt32Type, &value))

  556.                 {

  557.                     CFDictionarySetValue(clsInfo, CFSTR(kAUPresetTypeKey), num);

  558.                     CFRelease(num);

  559.                 }

  560. 

  561.                 value = kSubType;

  562.                 if (const CFNumberRef num = CFNumberCreate(nullptr, kCFNumberSInt32Type, &value))

  563.                 {

  564.                     CFDictionarySetValue(clsInfo, CFSTR(kAUPresetSubtypeKey), num);

  565.                     CFRelease(num);

  566.                 }

  567. 

  568.                 value = kManufacturer;

  569.                 if (const CFNumberRef num = CFNumberCreate(nullptr, kCFNumberSInt32Type, &value))

  570.                 {

  571.                     CFDictionarySetValue(clsInfo, CFSTR(kAUPresetManufacturerKey), num);

  572.                     CFRelease(num);

  573.                 }

  574. 

  575. 	            if (const CFMutableDictionaryRef data = CFDictionaryCreateMutable(nullptr,

  576.                                                                                   0,

  577.                                                                                   &kCFTypeDictionaryKeyCallBacks,

  578.                                                                                   &kCFTypeDictionaryValueCallBacks))

  579.                 {

  580.                     // TODO save plugin state here

  581.                     d_stdout("WIP GetProperty(%d:%s, %d:%s, %d, ...)",

  582.                              inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement);

  583. 

  584.                     if (fParameterCount != 0)

  585.                     {

  586.                         CFMutableArrayRef params = CFArrayCreateMutable(nullptr, fParameterCount, &kCFTypeArrayCallBacks);

  587. 

  588.                         for (uint32_t i=0; i<fParameterCount; ++i)

  589.                         {

  590.                             if (fPlugin.isParameterOutputOrTrigger(i))

  591.                                 continue;

  592. 

  593.                             const float valuef = fPlugin.getParameterValue(i);

  594.                             CFStringRef key = CFStringCreateWithCString(nullptr,

  595.                                                                         fPlugin.getParameterSymbol(i),

  596.                                                                         kCFStringEncodingASCII);

  597.                             CFNumberRef value = CFNumberCreate(nullptr, kCFNumberFloat32Type, &valuef);

  598.                             CFDictionaryRef dict = CFDictionaryCreate(nullptr,

  599.                                                                       reinterpret_cast<const void**>(&key),

  600.                                                                       reinterpret_cast<const void**>(&value),

  601.                                                                       1,

  602.                                                                       &kCFTypeDictionaryKeyCallBacks,

  603.                                                                       &kCFTypeDictionaryValueCallBacks);

  604. 

  605.                             CFArrayAppendValue(params, dict);

  606.                             CFRelease(key);

  607.                             CFRelease(value);

  608.                             CFRelease(dict);

  609.                         }

  610. 

  611.                         CFDictionarySetValue(data, CFSTR("params"), params);

  612.                         CFRelease(params);

  613.                     }

  614. 

  615.                     CFDictionarySetValue(clsInfo, CFSTR(kAUPresetDataKey), data);

  616.                     CFRelease(data);

  617.                 }

  618. 

  619. 	            CFDictionarySetValue(clsInfo, CFSTR(kAUPresetNameKey), CFSTR("Default"));

  620. 

  621.                 *propList = clsInfo;

  622.             }

  623.             return noErr;

  624. 

  625.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  626.         case kAudioUnitProperty_SampleRate:

  627.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  628.             if (inScope == kAudioUnitScope_Input)

  629.             {

  630.                 *static_cast<Float64*>(outData) = fSampleRateForInput;

  631.             }

  632.             else

  633.            #endif

  634.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  635.             if (inScope == kAudioUnitScope_Output)

  636.             {

  637.                 *static_cast<Float64*>(outData) = fSampleRateForOutput;

  638.             }

  639.             else

  640.            #endif

  641.             {

  642.                 return kAudioUnitErr_InvalidScope;

  643.             }

  644.             return noErr;

  645.        #endif

  646. 

  647.         case kAudioUnitProperty_ParameterList:

  648.             {

  649.                 AudioUnitParameterID* const paramList = static_cast<AudioUnitParameterID*>(outData);

  650. 

  651.                 for (uint32_t i=0; i<fParameterCount; ++i)

  652.                     paramList[i] = i;

  653.             }

  654.             return noErr;

  655. 

  656.         case kAudioUnitProperty_ParameterInfo:

  657.             {

  658.                 AudioUnitParameterInfo* const info = static_cast<AudioUnitParameterInfo*>(outData);

  659.                 std::memset(info, 0, sizeof(*info));

  660. 

  661.                 const ParameterRanges& ranges(fPlugin.getParameterRanges(inElement));

  662. 

  663.                 info->flags = kAudioUnitParameterFlag_IsHighResolution

  664.                             | kAudioUnitParameterFlag_IsReadable

  665.                             | kAudioUnitParameterFlag_HasCFNameString;

  666. 

  667.                 if (fPlugin.getParameterDesignation(inElement) == kParameterDesignationBypass)

  668.                 {

  669.                     info->flags |= kAudioUnitParameterFlag_IsWritable;

  670.                     info->unit = kAudioUnitParameterUnit_Generic;

  671. 

  672.                     d_strncpy(info->name, "Bypass", sizeof(info->name));

  673.                     info->cfNameString = CFSTR("Bypass");

  674.                 }

  675.                 else

  676.                 {

  677.                     const uint32_t hints = fPlugin.getParameterHints(inElement);

  678. 

  679.                     info->flags |= kAudioUnitParameterFlag_CFNameRelease;

  680. 

  681.                     if (hints & kParameterIsOutput)

  682.                     {

  683.                         info->flags |= kAudioUnitParameterFlag_MeterReadOnly;

  684.                     }

  685.                     else

  686.                     {

  687.                         info->flags |= kAudioUnitParameterFlag_IsWritable;

  688. 

  689.                         if ((hints & kParameterIsAutomatable) == 0x0)

  690.                             info->flags |= kAudioUnitParameterFlag_NonRealTime;

  691.                     }

  692. 

  693.                     if (hints & kParameterIsBoolean)

  694.                         info->unit = kAudioUnitParameterUnit_Boolean;

  695.                     else if (hints & kParameterIsInteger)

  696.                         info->unit = kAudioUnitParameterUnit_Indexed;

  697.                     else

  698.                         info->unit = kAudioUnitParameterUnit_Generic;

  699. 

  700.                     // | kAudioUnitParameterFlag_ValuesHaveStrings;

  701. 

  702.                     const String& name(fPlugin.getParameterName(inElement));

  703.                     d_strncpy(info->name, name, sizeof(info->name));

  704.                     info->cfNameString = CFStringCreateWithCString(nullptr, name, kCFStringEncodingUTF8);

  705.                 }

  706. 

  707.                 info->minValue = ranges.min;

  708.                 info->maxValue = ranges.max;

  709.                 info->defaultValue = ranges.def;

  710.             }

  711.             return noErr;

  712. 

  713.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  714.         case kAudioUnitProperty_StreamFormat:

  715.             {

  716.                 AudioStreamBasicDescription* const desc = static_cast<AudioStreamBasicDescription*>(outData);

  717.                 std::memset(desc, 0, sizeof(*desc));

  718. 

  719.                 if (inElement != 0)

  720.                     return kAudioUnitErr_InvalidElement;

  721. 

  722.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  723.                 if (inScope == kAudioUnitScope_Input)

  724.                 {

  725.                     desc->mChannelsPerFrame = DISTRHO_PLUGIN_NUM_INPUTS;

  726.                 }

  727.                 else

  728.                #endif

  729.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  730.                 if (inScope == kAudioUnitScope_Output)

  731.                 {

  732.                     desc->mChannelsPerFrame = DISTRHO_PLUGIN_NUM_OUTPUTS;

  733.                 }

  734.                 else

  735.                #endif

  736.                 {

  737.                     return kAudioUnitErr_InvalidScope;

  738.                 }

  739. 

  740.                 desc->mFormatID         = kAudioFormatLinearPCM;

  741.                 desc->mFormatFlags      = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;

  742.                 desc->mSampleRate       = fPlugin.getSampleRate();

  743.                 desc->mBitsPerChannel   = 32;

  744.                 desc->mBytesPerFrame    = sizeof(float);

  745.                 desc->mBytesPerPacket   = sizeof(float);

  746.                 desc->mFramesPerPacket  = 1;

  747.             }

  748.             return noErr;

  749.        #endif

  750. 

  751.         case kAudioUnitProperty_ElementCount:

  752.             switch (inScope)

  753.             {

  754.             case kAudioUnitScope_Global:

  755.                 *static_cast<UInt32*>(outData) = 1;

  756.                 break;

  757.             case kAudioUnitScope_Input:

  758.                 *static_cast<UInt32*>(outData) = DISTRHO_PLUGIN_NUM_INPUTS != 0 ? 1 : 0;

  759.                 break;

  760.             case kAudioUnitScope_Output:

  761.                 *static_cast<UInt32*>(outData) = DISTRHO_PLUGIN_NUM_OUTPUTS != 0 ? 1 : 0;

  762.                 break;

  763.             default:

  764.                 *static_cast<UInt32*>(outData) = 0;

  765.                 break;

  766.             }

  767.             return noErr;

  768. 

  769.        #if DISTRHO_PLUGIN_WANT_LATENCY

  770.         case kAudioUnitProperty_Latency:

  771.             *static_cast<Float64*>(outData) = static_cast<double>(fPlugin.getLatency()) / fPlugin.getSampleRate();

  772.             return noErr;

  773.        #endif

  774. 

  775.         case kAudioUnitProperty_SupportedNumChannels:

  776.             *static_cast<AUChannelInfo*>(outData) = { DISTRHO_PLUGIN_NUM_INPUTS, DISTRHO_PLUGIN_NUM_OUTPUTS };

  777.             return noErr;

  778. 

  779.         case kAudioUnitProperty_MaximumFramesPerSlice:

  780.             *static_cast<UInt32*>(outData) = fPlugin.getBufferSize();

  781.             return noErr;

  782. 

  783.         case kAudioUnitProperty_LastRenderError:

  784.             *static_cast<OSStatus*>(outData) = fLastRenderError;

  785.             fLastRenderError = noErr;

  786.             return noErr;

  787. 

  788.         case kAudioUnitProperty_BypassEffect:

  789.             *static_cast<OSStatus*>(outData) = fPlugin.getParameterValue(fBypassParameterIndex) > 0.5f ? 1 : 0;

  790.             return noErr;

  791. 

  792.         case kAudioUnitProperty_SetRenderCallback:

  793.             d_stdout("WIP GetProperty(%d:%s, %d:%s, %d, ...)", inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement);

  794.             // TODO

  795.             break;

  796. 

  797.         case kAudioUnitProperty_InPlaceProcessing:

  798.             *static_cast<UInt32*>(outData) = 1;

  799.             return noErr;

  800. 

  801.         case kAudioUnitProperty_PresentPreset:

  802.             {

  803.                 AUPreset* const preset = static_cast<AUPreset*>(outData);

  804.                 std::memset(preset, 0, sizeof(*preset));

  805. 

  806.                 preset->presetName = CFStringCreateWithCString(nullptr, "Default", kCFStringEncodingUTF8);

  807.             }

  808.             return noErr;

  809. 

  810.        #if DISTRHO_PLUGIN_HAS_UI

  811.         case kAudioUnitProperty_CocoaUI:

  812.             {

  813.                 AudioUnitCocoaViewInfo* const info = static_cast<AudioUnitCocoaViewInfo*>(outData);

  814.                 std::memset(info, 0, sizeof(*info));

  815. 

  816.                 NSString* const bundlePathString = [[NSString alloc]

  817.                     initWithBytes:d_nextBundlePath

  818.                            length:strlen(d_nextBundlePath)

  819.                          encoding:NSUTF8StringEncoding];

  820. 

  821.                 info->mCocoaAUViewBundleLocation = static_cast<CFURLRef>([[NSURL fileURLWithPath: bundlePathString] retain]);

  822. 

  823.                 #define MACRO_STR3(a, b, c) a "_" b "_" c

  824.                 #define MACRO_STR2(a, b, c) MACRO_STR3(#a, #b, #c)

  825.                 #define MACRO_STR(a, b, c) MACRO_STR2(a, b, c)

  826. 

  827.                 info->mCocoaAUViewClass[0] = CFSTR("CocoaAUView_" MACRO_STR(DISTRHO_PLUGIN_AU_TYPE,

  828.                                                                             DISTRHO_PLUGIN_AU_SUBTYPE,

  829.                                                                             DISTRHO_PLUGIN_AU_MANUFACTURER));

  830. 

  831.                 #undef MACRO_STR

  832.                 #undef MACRO_STR2

  833.                 #undef MACRO_STR3

  834. 

  835.                 [bundlePathString release];

  836.             }

  837.             return noErr;

  838.        #endif

  839. 

  840.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  841.         case kAudioUnitProperty_MIDIOutputCallbackInfo:

  842.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  843.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  844.             {

  845.                 CFStringRef refs[1] = { CFSTR("MIDI Output") };

  846.                 *static_cast<CFArrayRef*>(outData) = CFArrayCreate(nullptr,

  847.                                                                    reinterpret_cast<const void**>(refs),

  848.                                                                    1,

  849.                                                                    &kCFTypeArrayCallBacks);

  850.             }

  851.             return noErr;

  852.        #endif

  853. 

  854.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT || DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  855.         /* FIXME implement the event list stuff

  856.         case kAudioUnitProperty_AudioUnitMIDIProtocol:

  857.             *static_cast<SInt32*>(outData) = kMIDIProtocol_1_0;

  858.             return noErr;

  859.         */

  860.        #endif

  861. 

  862.        #if DISTRHO_PLUGIN_HAS_UI && DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  863.         case 'DPFa':

  864.             *static_cast<void**>(outData) = fPlugin.getInstancePointer();

  865.             return noErr;

  866.        #endif

  867.         }

  868. 

  869.         d_stdout("TODO GetProperty(%d:%s, %d:%s, %d, ...)", inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement);

  870.         return kAudioUnitErr_InvalidProperty;

  871.     }

  872. 

  873.     OSStatus auSetProperty(const AudioUnitPropertyID inProp,

  874.                            const AudioUnitScope inScope,

  875.                            const AudioUnitElement inElement,

  876.                            const void* const inData,

  877.                            const UInt32 inDataSize)

  878.     {

  879.         switch (inProp)

  880.         {

  881.         case kAudioUnitProperty_ClassInfo:

  882.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  883.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  884.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(CFPropertyListRef), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  885.             {

  886.                 const CFPropertyListRef propList = *static_cast<const CFPropertyListRef*>(inData);

  887.                 DISTRHO_SAFE_ASSERT_RETURN(CFGetTypeID(propList) == CFDictionaryGetTypeID(), kAudioUnitErr_InvalidPropertyValue);

  888. 

  889.                 const CFDictionaryRef clsInfo = static_cast<CFDictionaryRef>(propList);

  890. 

  891. 	            CFDictionaryRef data = nullptr;

  892.                 if (CFDictionaryGetValueIfPresent(clsInfo, CFSTR(kAUPresetDataKey), reinterpret_cast<const void**>(&data)))

  893.                 {

  894.                     DISTRHO_SAFE_ASSERT_RETURN(CFGetTypeID(data) == CFDictionaryGetTypeID(), kAudioUnitErr_InvalidPropertyValue);

  895. 

  896. 	                CFArrayRef params = nullptr;

  897.                     if (CFDictionaryGetValueIfPresent(data, CFSTR("params"), reinterpret_cast<const void**>(&params))

  898.                         && CFGetTypeID(params) == CFArrayGetTypeID())

  899.                     {

  900.                         const CFIndex numParams = CFArrayGetCount(params);

  901.                         CFStringRef keyRef;

  902.                         CFNumberRef valueRef;

  903.                         uint32_t index;

  904.                         float value;

  905.                         char* symbol = nullptr;

  906.                         CFIndex symbolLen = -1;

  907. 

  908.                         for (CFIndex i=0; i<numParams; ++i)

  909.                         {

  910.                             const CFDictionaryRef param = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(params, i));

  911.                             DISTRHO_SAFE_ASSERT_BREAK(CFGetTypeID(param) == CFDictionaryGetTypeID());

  912.                             DISTRHO_SAFE_ASSERT_BREAK(CFDictionaryGetCount(param) == 1);

  913. 

  914.                             keyRef = nullptr;

  915.                             valueRef = nullptr;

  916.                             CFDictionaryGetKeysAndValues(param,

  917.                                                          reinterpret_cast<const void**>(&keyRef),

  918.                                                          reinterpret_cast<const void**>(&valueRef));

  919.                             DISTRHO_SAFE_ASSERT_BREAK(keyRef != nullptr);

  920.                             DISTRHO_SAFE_ASSERT_BREAK(valueRef != nullptr);

  921.                             DISTRHO_SAFE_ASSERT_BREAK(CFGetTypeID(keyRef) == CFStringGetTypeID());

  922.                             DISTRHO_SAFE_ASSERT_BREAK(CFGetTypeID(valueRef) == CFNumberGetTypeID());

  923.                             DISTRHO_SAFE_ASSERT_BREAK(CFNumberGetValue(valueRef, kCFNumberFloat32Type, &value));

  924. 

  925.                             const CFIndex keyLen = CFStringGetLength(keyRef);

  926.                             if (symbolLen < keyLen)

  927.                             {

  928.                                 symbolLen = keyLen;

  929.                                 symbol = static_cast<char*>(std::realloc(symbol, symbolLen + 1));

  930.                             }

  931.                             DISTRHO_SAFE_ASSERT_BREAK(CFStringGetCString(keyRef, symbol, symbolLen + 1, kCFStringEncodingASCII));

  932.                             DISTRHO_SAFE_ASSERT_BREAK(fPlugin.getParameterIndexForSymbol(symbol, index));

  933. 

  934.                             fLastParameterValues[index] = value;

  935.                             fPlugin.setParameterValue(index, value);

  936.                             notifyListeners('DPFP', kAudioUnitScope_Global, index);

  937.                         }

  938.                     }

  939.                 }

  940.             }

  941.             // TODO

  942.             d_stdout("WIP SetProperty(%d:%s, %d:%s, %d, %p, %u)",

  943.                      inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement, inData, inDataSize);

  944.             return noErr;

  945. 

  946.         case kAudioUnitProperty_MakeConnection:

  947.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global || inScope == kAudioUnitScope_Input, inScope, kAudioUnitErr_InvalidScope);

  948.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  949.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(AudioUnitConnection), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  950.             d_stdout("WIP SetProperty(%d:%s, %d:%s, %d, %p, %u)", inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement, inData, inDataSize);

  951.             // TODO

  952.             return noErr;

  953. 

  954.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  955.         case kAudioUnitProperty_SampleRate:

  956.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0 && DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  957.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Input || inScope == kAudioUnitScope_Output, inScope, kAudioUnitErr_InvalidScope);

  958.            #elif DISTRHO_PLUGIN_NUM_INPUTS != 0

  959.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Input, inScope, kAudioUnitErr_InvalidScope);

  960.            #else

  961.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Output, inScope, kAudioUnitErr_InvalidScope);

  962.            #endif

  963.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  964.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(Float64), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  965.             {

  966.                 const Float64 sampleRate = *static_cast<const Float64*>(inData);

  967. 

  968.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  969.                 if (inScope == kAudioUnitScope_Input)

  970.                 {

  971.                     if (d_isNotEqual(fSampleRateForInput, sampleRate))

  972.                     {

  973.                         fSampleRateForInput = sampleRate;

  974. 

  975.                        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  976.                         if (d_isEqual(fSampleRateForOutput, sampleRate))

  977.                        #endif

  978.                         {

  979.                             fPlugin.setSampleRate(sampleRate, true);

  980.                         }

  981. 

  982.                         notifyListeners(inProp, inScope, inElement);

  983.                     }

  984.                     return noErr;

  985.                 }

  986.                #endif

  987. 

  988.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  989.                 if (inScope == kAudioUnitScope_Output)

  990.                 {

  991.                     if (d_isNotEqual(fSampleRateForOutput, sampleRate))

  992.                     {

  993.                         fSampleRateForOutput = sampleRate;

  994. 

  995.                        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  996.                         if (d_isEqual(fSampleRateForInput, sampleRate))

  997.                        #endif

  998.                         {

  999.                             fPlugin.setSampleRate(sampleRate, true);

  1000.                         }

  1001. 

  1002.                         notifyListeners(inProp, inScope, inElement);

  1003.                     }

  1004.                     return noErr;

  1005.                 }

  1006.                #endif

  1007.             }

  1008.             return kAudioUnitErr_InvalidScope;

  1009.        #endif

  1010. 

  1011.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1012.         case kAudioUnitProperty_StreamFormat:

  1013.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0 && DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1014.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Input || inScope == kAudioUnitScope_Output, inScope, kAudioUnitErr_InvalidScope);

  1015.            #elif DISTRHO_PLUGIN_NUM_INPUTS != 0

  1016.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Input, inScope, kAudioUnitErr_InvalidScope);

  1017.            #else

  1018.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Output, inScope, kAudioUnitErr_InvalidScope);

  1019.            #endif

  1020.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  1021.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(AudioStreamBasicDescription), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1022.             {

  1023.                 const AudioStreamBasicDescription* const desc = static_cast<const AudioStreamBasicDescription*>(inData);

  1024. 

  1025.                 if (desc->mFormatID != kAudioFormatLinearPCM)

  1026.                     return kAudioUnitErr_FormatNotSupported;

  1027.                 if (desc->mBitsPerChannel != 32)

  1028.                     return kAudioUnitErr_FormatNotSupported;

  1029.                 if (desc->mBytesPerFrame != sizeof(float))

  1030.                     return kAudioUnitErr_FormatNotSupported;

  1031.                 if (desc->mBytesPerPacket != sizeof(float))

  1032.                     return kAudioUnitErr_FormatNotSupported;

  1033.                 if (desc->mFramesPerPacket != 1)

  1034.                     return kAudioUnitErr_FormatNotSupported;

  1035. 

  1036.                #if 1

  1037.                 // dont allow interleaved data

  1038.                 if (desc->mFormatFlags != (kAudioFormatFlagsNativeFloatPacked|kAudioFormatFlagIsNonInterleaved))

  1039.                #else

  1040.                 // allow interleaved data

  1041.                 if ((desc->mFormatFlags & ~kAudioFormatFlagIsNonInterleaved) != kAudioFormatFlagsNativeFloatPacked)

  1042.                #endif

  1043.                     return kAudioUnitErr_FormatNotSupported;

  1044. 

  1045.                 if (desc->mChannelsPerFrame != (inScope == kAudioUnitScope_Input ? DISTRHO_PLUGIN_NUM_INPUTS

  1046.                                                                                  : DISTRHO_PLUGIN_NUM_OUTPUTS))

  1047.                     return kAudioUnitErr_FormatNotSupported;

  1048. 

  1049.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1050.                 if (inScope == kAudioUnitScope_Input)

  1051.                 {

  1052.                     if (d_isNotEqual(fSampleRateForInput, desc->mSampleRate))

  1053.                     {

  1054.                         fSampleRateForInput = desc->mSampleRate;

  1055. 

  1056.                        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1057.                         if (d_isEqual(fSampleRateForOutput, desc->mSampleRate))

  1058.                        #endif

  1059.                         {

  1060.                             fPlugin.setSampleRate(desc->mSampleRate, true);

  1061.                         }

  1062. 

  1063.                         notifyListeners(inProp, inScope, inElement);

  1064.                     }

  1065.                     return noErr;

  1066.                 }

  1067.                #endif

  1068. 

  1069.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1070.                 if (inScope == kAudioUnitScope_Output)

  1071.                 {

  1072.                     if (d_isNotEqual(fSampleRateForOutput, desc->mSampleRate))

  1073.                     {

  1074.                         fSampleRateForOutput = desc->mSampleRate;

  1075. 

  1076.                        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1077.                         if (d_isEqual(fSampleRateForInput, desc->mSampleRate))

  1078.                        #endif

  1079.                         {

  1080.                             fPlugin.setSampleRate(desc->mSampleRate, true);

  1081.                         }

  1082. 

  1083.                         notifyListeners(inProp, inScope, inElement);

  1084.                     }

  1085.                     return noErr;

  1086.                 }

  1087.                #endif

  1088.             }

  1089.             return kAudioUnitErr_InvalidScope;

  1090.        #endif

  1091. 

  1092.         case kAudioUnitProperty_MaximumFramesPerSlice:

  1093.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  1094.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  1095.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(UInt32), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1096. 

  1097.             if (fPlugin.setBufferSize(*static_cast<const UInt32*>(inData), true))

  1098. 	            notifyListeners(inProp, inScope, inElement);

  1099. 

  1100.             return noErr;

  1101. 

  1102.         case kAudioUnitProperty_BypassEffect:

  1103.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  1104.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  1105.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(UInt32), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1106.             DISTRHO_SAFE_ASSERT_RETURN(fBypassParameterIndex != UINT32_MAX, kAudioUnitErr_InvalidPropertyValue);

  1107.             {

  1108.                 const bool bypass = *static_cast<const UInt32*>(inData) != 0;

  1109. 

  1110.                 if ((fLastParameterValues[fBypassParameterIndex] > 0.5f) != bypass)

  1111.                 {

  1112.                     const float value = bypass ? 1.f : 0.f;

  1113.                     fLastParameterValues[fBypassParameterIndex] = value;

  1114.                     fPlugin.setParameterValue(fBypassParameterIndex, value);

  1115. 	                notifyListeners(inProp, inScope, inElement);

  1116.                 }

  1117.             }

  1118.             return noErr;

  1119. 

  1120.         case kAudioUnitProperty_SetRenderCallback:

  1121.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Input, inScope, kAudioUnitErr_InvalidScope);

  1122.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  1123.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(AURenderCallbackStruct), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1124.             d_stdout("WIP SetProperty(%d:%s, %d:%s, %d, %p, %u)", inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement, inData, inDataSize);

  1125.             // TODO

  1126.             return noErr;

  1127. 

  1128.         case kAudioUnitProperty_PresentPreset:

  1129.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  1130.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  1131.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(AUPreset), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1132.             d_stdout("WIP SetProperty(%d:%s, %d:%s, %d, %p, %u)", inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement, inData, inDataSize);

  1133.             // TODO

  1134.             return noErr;

  1135. 

  1136.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1137.         case kAudioUnitProperty_MIDIOutputCallback:

  1138.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  1139.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  1140.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(AUMIDIOutputCallbackStruct), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1141.             std::memcpy(&fMidiOutput, inData, sizeof(AUMIDIOutputCallbackStruct));

  1142.             return noErr;

  1143.        #endif

  1144. 

  1145.         case 'DPFe':

  1146.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  1147.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement < fParameterCount, inElement, kAudioUnitErr_InvalidElement);

  1148.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(bool), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1149.             {

  1150.                 const bool started = *static_cast<const bool*>(inData);

  1151. 

  1152.                 AudioUnitEvent event;

  1153.                 std::memset(&event, 0, sizeof(event));

  1154. 

  1155.                 event.mEventType                        = started ? kAudioUnitEvent_BeginParameterChangeGesture

  1156.                                                                   : kAudioUnitEvent_EndParameterChangeGesture;

  1157.                 event.mArgument.mParameter.mAudioUnit   = fComponent;

  1158.                 event.mArgument.mParameter.mParameterID = inElement;

  1159.                 event.mArgument.mParameter.mScope       = kAudioUnitScope_Global;

  1160.                 AUEventListenerNotify(NULL, NULL, &event);

  1161.             }

  1162.             return noErr;

  1163. 

  1164.         case 'DPFp':

  1165.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  1166.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement < fParameterCount, inElement, kAudioUnitErr_InvalidElement);

  1167.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(float), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1168.             {

  1169.                 const float value = *static_cast<const float*>(inData);

  1170.                 DISTRHO_SAFE_ASSERT_RETURN(std::isfinite(value), kAudioUnitErr_InvalidParameterValue);

  1171. 

  1172.                 fLastParameterValues[inElement] = value;

  1173.                 fPlugin.setParameterValue(inElement, value);

  1174. 

  1175.                 AudioUnitEvent event;

  1176.                 std::memset(&event, 0, sizeof(event));

  1177. 

  1178.                 event.mEventType                        = kAudioUnitEvent_ParameterValueChange;

  1179.                 event.mArgument.mParameter.mAudioUnit   = fComponent;

  1180.                 event.mArgument.mParameter.mParameterID = inElement;

  1181.                 event.mArgument.mParameter.mScope       = kAudioUnitScope_Global;

  1182.                 AUEventListenerNotify(NULL, NULL, &event);

  1183.             }

  1184.             return noErr;

  1185. 

  1186.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT && DISTRHO_PLUGIN_HAS_UI

  1187.         case 'DPFn':

  1188.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  1189.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement == 0, inElement, kAudioUnitErr_InvalidElement);

  1190.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(uint8_t) * 3, inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1191.             {

  1192.                 const uint8_t* const midiData = static_cast<const uint8_t*>(inData);

  1193. 

  1194.                 fNotesRingBuffer.writeCustomData(midiData, 3);

  1195.                 fNotesRingBuffer.commitWrite();

  1196.             }

  1197.             return noErr;

  1198.        #endif

  1199. 

  1200.        #if DISTRHO_PLUGIN_WANT_STATE

  1201.         case 'DPFs':

  1202.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inScope == kAudioUnitScope_Global, inScope, kAudioUnitErr_InvalidScope);

  1203.             DISTRHO_SAFE_ASSERT_RETURN(inElement != 0, kAudioUnitErr_InvalidElement);

  1204.             DISTRHO_SAFE_ASSERT_UINT2_RETURN(inDataSize == inElement, inDataSize, inElement, kAudioUnitErr_InvalidPropertyValue);

  1205.             {

  1206.                 const char* const key = static_cast<const char*>(inData);

  1207.                 const char* const value = key + std::strlen(key) + 1;

  1208. 

  1209.                 fPlugin.setState(key, value);

  1210.             }

  1211.             return noErr;

  1212.        #endif

  1213.         }

  1214. 

  1215.         d_stdout("TODO SetProperty(%d:%s, %d:%s, %d, %p, %u)", inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement, inData, inDataSize);

  1216.         return kAudioUnitErr_InvalidProperty;

  1217.     }

  1218. 

  1219.     OSStatus auAddPropertyListener(const AudioUnitPropertyID prop,

  1220.                                    const AudioUnitPropertyListenerProc proc,

  1221.                                    void* const userData)

  1222.     {

  1223.         const PropertyListener pl = {

  1224.             prop, proc, userData

  1225.         };

  1226. 

  1227.         if (fPropertyListeners.empty())

  1228.             fPropertyListeners.reserve(32);

  1229. 

  1230.         fPropertyListeners.push_back(pl);

  1231.         return noErr;

  1232.     }

  1233. 

  1234.     OSStatus auRemovePropertyListener(const AudioUnitPropertyID prop, const AudioUnitPropertyListenerProc proc)

  1235.     {

  1236.         for (PropertyListeners::iterator it = fPropertyListeners.begin(); it != fPropertyListeners.end(); ++it)

  1237.         {

  1238.             const PropertyListener& pl(*it);

  1239. 

  1240.             if (pl.prop == prop && pl.proc == proc)

  1241.             {

  1242.                 fPropertyListeners.erase(it);

  1243.                 return auRemovePropertyListener(prop, proc);

  1244.             }

  1245.         }

  1246. 

  1247.         return noErr;

  1248.     }

  1249. 

  1250.     OSStatus auRemovePropertyListenerWithUserData(const AudioUnitPropertyID prop,

  1251.                                                   const AudioUnitPropertyListenerProc proc,

  1252.                                                   void* const userData)

  1253.     {

  1254.         for (PropertyListeners::iterator it = fPropertyListeners.begin(); it != fPropertyListeners.end(); ++it)

  1255.         {

  1256.             const PropertyListener& pl(*it);

  1257. 

  1258.             if (pl.prop == prop && pl.proc == proc && pl.userData == userData)

  1259.             {

  1260.                 fPropertyListeners.erase(it);

  1261.                 return auRemovePropertyListenerWithUserData(prop, proc, userData);

  1262.             }

  1263.         }

  1264. 

  1265.         return noErr;

  1266.     }

  1267. 

  1268.     OSStatus auAddRenderNotify(const AURenderCallback proc, void* const userData)

  1269.     {

  1270.         d_stdout("WIP AddRenderNotify(%p, %p)", proc, userData);

  1271.         // TODO

  1272.         return noErr;

  1273.     }

  1274. 

  1275.     OSStatus auRemoveRenderNotify(const AURenderCallback proc, void* const userData)

  1276.     {

  1277.         d_stdout("WIP RemoveRenderNotify(%p, %p)", proc, userData);

  1278.         // TODO

  1279.         return noErr;

  1280.     }

  1281. 

  1282.     OSStatus auGetParameter(const AudioUnitParameterID param,

  1283.                             const AudioUnitScope scope,

  1284.                             const AudioUnitElement elem,

  1285.                             AudioUnitParameterValue* const value)

  1286.     {

  1287.         DISTRHO_SAFE_ASSERT_UINT_RETURN(scope == kAudioUnitScope_Global, scope, kAudioUnitErr_InvalidScope);

  1288.         DISTRHO_SAFE_ASSERT_UINT_RETURN(param < fParameterCount, param, kAudioUnitErr_InvalidElement);

  1289.         DISTRHO_SAFE_ASSERT_UINT_RETURN(elem == 0, elem, kAudioUnitErr_InvalidElement);

  1290.         DISTRHO_SAFE_ASSERT_RETURN(value != nullptr, kAudio_ParamError);

  1291. 

  1292.         *value = fPlugin.getParameterValue(param);

  1293.         return noErr;

  1294.     }

  1295. 

  1296.     OSStatus auSetParameter(const AudioUnitParameterID param,

  1297.                             const AudioUnitScope scope,

  1298.                             const AudioUnitElement elem,

  1299.                             const AudioUnitParameterValue value,

  1300.                             const UInt32 bufferOffset)

  1301.     {

  1302.         DISTRHO_SAFE_ASSERT_UINT_RETURN(scope == kAudioUnitScope_Global, scope, kAudioUnitErr_InvalidScope);

  1303.         DISTRHO_SAFE_ASSERT_UINT_RETURN(param < fParameterCount, param, kAudioUnitErr_InvalidElement);

  1304.         DISTRHO_SAFE_ASSERT_UINT_RETURN(elem == 0, elem, kAudioUnitErr_InvalidElement);

  1305.         DISTRHO_SAFE_ASSERT_RETURN(std::isfinite(value), kAudioUnitErr_InvalidParameterValue);

  1306. 

  1307.         if (d_isNotEqual(fLastParameterValues[param], value))

  1308.         {

  1309.             fLastParameterValues[param] = value;

  1310.             fPlugin.setParameterValue(param, value);

  1311.             // TODO flag param only, notify listeners later on bg thread (sem_post etc)

  1312.             notifyListeners('DPFP', kAudioUnitScope_Global, param);

  1313.         }

  1314. 

  1315.         return noErr;

  1316.     }

  1317. 

  1318.     OSStatus auScheduleParameters(const AudioUnitParameterEvent* const events, const UInt32 numEvents)

  1319.     {

  1320.         for (UInt32 i=0; i<numEvents; ++i)

  1321.         {

  1322.             const AudioUnitParameterEvent& event(events[i]);

  1323. 

  1324.             if (event.eventType == kParameterEvent_Immediate)

  1325.             {

  1326.                 auSetParameter(event.parameter,

  1327.                                event.scope,

  1328.                                event.element,

  1329.                                event.eventValues.immediate.value,

  1330.                                event.eventValues.immediate.bufferOffset);

  1331.             }

  1332.             else

  1333.             {

  1334.                 // TODO?

  1335.                 d_stdout("WIP ScheduleParameters(%p, %u)", events, numEvents);

  1336.             }

  1337.         }

  1338.         return noErr;

  1339.     }

  1340. 

  1341.     OSStatus auReset(const AudioUnitScope scope, const AudioUnitElement elem)

  1342.     {

  1343.         DISTRHO_SAFE_ASSERT_UINT_RETURN(scope == kAudioUnitScope_Global || scope == kAudioUnitScope_Input || scope == kAudioUnitScope_Output, scope, kAudioUnitErr_InvalidScope);

  1344.         DISTRHO_SAFE_ASSERT_UINT_RETURN(elem == 0, elem, kAudioUnitErr_InvalidElement);

  1345. 

  1346.         if (fPlugin.isActive())

  1347.         {

  1348.             fPlugin.deactivate();

  1349.             fPlugin.activate();

  1350.         }

  1351. 

  1352.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1353.         fMidiEventCount = 0;

  1354.        #endif

  1355.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1356.         fMidiOutputPackets.numPackets = 0;

  1357.        #endif

  1358.         return noErr;

  1359.     }

  1360. 

  1361.     OSStatus auRender(AudioUnitRenderActionFlags& ioActionFlags,

  1362.                       const AudioTimeStamp& inTimeStamp,

  1363.                       const UInt32 inBusNumber,

  1364.                       const UInt32 inFramesToProcess,

  1365.                       AudioBufferList& ioData)

  1366.     {

  1367.         DISTRHO_SAFE_ASSERT_UINT_RETURN(inBusNumber == 0, inBusNumber, kAudioUnitErr_InvalidElement);

  1368.         DISTRHO_SAFE_ASSERT_UINT_RETURN(ioData.mNumberBuffers == std::max<uint>(DISTRHO_PLUGIN_NUM_INPUTS, DISTRHO_PLUGIN_NUM_OUTPUTS), ioData.mNumberBuffers, kAudio_ParamError);

  1369. 

  1370.         if (inFramesToProcess > fPlugin.getBufferSize())

  1371.         {

  1372.             setLastRenderError(kAudioUnitErr_TooManyFramesToProcess);

  1373.             return kAudioUnitErr_TooManyFramesToProcess;

  1374.         }

  1375. 

  1376.         for (uint i=0; i<ioData.mNumberBuffers; ++i)

  1377.         {

  1378.             AudioBuffer& buffer(ioData.mBuffers[i]);

  1379. 

  1380.             // TODO there must be something more to this...

  1381.             if (buffer.mData == nullptr)

  1382.                 return noErr;

  1383. 

  1384.             DISTRHO_SAFE_ASSERT_UINT_RETURN(buffer.mDataByteSize == inFramesToProcess * sizeof(float), buffer.mDataByteSize, kAudio_ParamError);

  1385.         }

  1386. 

  1387.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1388.         const float* inputs[DISTRHO_PLUGIN_NUM_INPUTS];

  1389. 

  1390.         for (uint16_t i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)

  1391.         {

  1392.             inputs[i] = static_cast<const float*>(ioData.mBuffers[i].mData);

  1393.         }

  1394.        #else

  1395.         constexpr const float** inputs = nullptr;

  1396.        #endif

  1397. 

  1398.        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1399.         float* outputs[DISTRHO_PLUGIN_NUM_OUTPUTS];

  1400. 

  1401.         for (uint16_t i=0; i<DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)

  1402.         {

  1403.             outputs[i] = static_cast<float*>(ioData.mBuffers[i].mData);

  1404.         }

  1405.        #else

  1406.         constexpr float** outputs = nullptr;

  1407.        #endif

  1408. 

  1409.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1410.         fMidiOutputPackets.numPackets = 0;

  1411.        #endif

  1412. 

  1413.       #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1414.        #if DISTRHO_PLUGIN_HAS_UI

  1415.         importRingBufferNotes();

  1416.        #endif

  1417. 

  1418.         fPlugin.run(inputs, outputs, inFramesToProcess, fMidiEvents, fMidiEventCount);

  1419.         fMidiEventCount = 0;

  1420.       #else

  1421.         fPlugin.run(inputs, outputs, inFramesToProcess);

  1422.       #endif

  1423. 

  1424.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1425.         if (fMidiOutputPackets.numPackets != 0 && fMidiOutput.midiOutputCallback != nullptr)

  1426.         {

  1427.             fMidiOutput.midiOutputCallback(fMidiOutput.userData,

  1428.                                            &inTimeStamp,

  1429.                                            0,

  1430.                                            reinterpret_cast<const ::MIDIPacketList*>(&fMidiOutputPackets));

  1431.         }

  1432.        #endif

  1433. 

  1434.         float value;

  1435.         AudioUnitEvent event;

  1436.         std::memset(&event, 0, sizeof(event));

  1437.         event.mEventType                      = kAudioUnitEvent_ParameterValueChange;

  1438.         event.mArgument.mParameter.mAudioUnit = fComponent;

  1439.         event.mArgument.mParameter.mScope     = kAudioUnitScope_Global;

  1440. 

  1441.         for (uint32_t i=0; i<fParameterCount; ++i)

  1442.         {

  1443.             if (fPlugin.isParameterOutputOrTrigger(i))

  1444.             {

  1445.                 value = fPlugin.getParameterValue(i);

  1446. 

  1447.                 if (d_isEqual(fLastParameterValues[i], value))

  1448.                     continue;

  1449. 

  1450.                 fLastParameterValues[i] = value;

  1451. 

  1452.                 // TODO flag param only, notify listeners later on bg thread (sem_post etc)

  1453.                 event.mArgument.mParameter.mParameterID = i;

  1454.                 AUEventListenerNotify(NULL, NULL, &event);

  1455.                 notifyListeners('DPFP', kAudioUnitScope_Global, i);

  1456.             }

  1457.         }

  1458. 

  1459.         return noErr;

  1460. 

  1461.        #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1462.         // unused

  1463.         (void)inTimeStamp;

  1464.        #endif

  1465.     }

  1466. 

  1467.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1468.     OSStatus auMIDIEvent(const UInt32 inStatus,

  1469.                          const UInt32 inData1,

  1470.                          const UInt32 inData2,

  1471.                          const UInt32 inOffsetSampleFrame)

  1472.     {

  1473.         if (fMidiEventCount >= kMaxMidiEvents)

  1474.             return noErr;

  1475. 

  1476.         MidiEvent& midiEvent(fMidiEvents[fMidiEventCount++]);

  1477.         midiEvent.frame   = inOffsetSampleFrame;

  1478.         midiEvent.data[0] = inStatus;

  1479.         midiEvent.data[1] = inData1;

  1480.         midiEvent.data[2] = inData2;

  1481. 

  1482.         switch (inStatus)

  1483.         {

  1484.         case 0x80:

  1485.         case 0x90:

  1486.         case 0xA0:

  1487.         case 0xB0:

  1488.         case 0xD0:

  1489.         case 0xE0:

  1490.             midiEvent.size = 3;

  1491.             break;

  1492.         case 0xC0:

  1493.             midiEvent.size = 2;

  1494.             break;

  1495.         default:

  1496.             midiEvent.size = 1;

  1497.             break;

  1498.         }

  1499. 

  1500.         // if plugin has no audio, assume render function is not going to be called

  1501.       #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  1502.        #if DISTRHO_PLUGIN_HAS_UI

  1503.         importRingBufferNotes();

  1504.        #endif

  1505.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1506.         fMidiOutputPackets.numPackets = 0;

  1507.        #endif

  1508. 

  1509.         fPlugin.run(nullptr, nullptr, std::max(1u, inOffsetSampleFrame), fMidiEvents, fMidiEventCount);

  1510.         fMidiEventCount = 0;

  1511. 

  1512.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1513.         if (fMidiOutputPackets.numPackets != 0 && fMidiOutput.midiOutputCallback != nullptr)

  1514.         {

  1515.             fMidiOutput.midiOutputCallback(fMidiOutput.userData,

  1516.                                            nullptr, 0, // FIXME do we need a valid timestamp?

  1517.                                            reinterpret_cast<const ::MIDIPacketList*>(&fMidiOutputPackets));

  1518.         }

  1519.        #endif

  1520.       #endif

  1521. 

  1522.         return noErr;

  1523.     }

  1524. 

  1525.     OSStatus auSysEx(const UInt8* const inData, const UInt32 inLength)

  1526.     {

  1527.         // TODO

  1528.         return kAudioUnitErr_PropertyNotInUse;

  1529.     }

  1530.    #endif

  1531. 

  1532.     // ----------------------------------------------------------------------------------------------------------------

  1533. 

  1534. private:

  1535.     PluginExporter fPlugin;

  1536. 

  1537.     // AU component

  1538.     const AudioUnit fComponent;

  1539. 

  1540.     // AUv2 related fields

  1541.     OSStatus fLastRenderError;

  1542.     PropertyListeners fPropertyListeners;

  1543.    #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1544.     Float64 fSampleRateForInput;

  1545.    #endif

  1546.    #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1547.     Float64 fSampleRateForOutput;

  1548.    #endif

  1549. 

  1550.     // Caching

  1551.     const uint32_t fParameterCount;

  1552.     float* fLastParameterValues;

  1553.     uint32_t fBypassParameterIndex;

  1554. 

  1555.   #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1556.     uint32_t fMidiEventCount;

  1557.     MidiEvent fMidiEvents[kMaxMidiEvents];

  1558.    #if DISTRHO_PLUGIN_HAS_UI

  1559.     SmallStackRingBuffer fNotesRingBuffer;

  1560.    #endif

  1561.   #endif

  1562. 

  1563.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1564.     AUMIDIOutputCallbackStruct fMidiOutput;

  1565.     MIDIPacketList fMidiOutputPackets;

  1566.    #endif

  1567. 

  1568.     // ----------------------------------------------------------------------------------------------------------------

  1569. 

  1570.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT && DISTRHO_PLUGIN_HAS_UI

  1571.     void importRingBufferNotes()

  1572.     {

  1573.         if (fMidiEventCount != kMaxMidiEvents && fNotesRingBuffer.isDataAvailableForReading())

  1574.         {

  1575.             uint8_t midiData[3];

  1576.             const uint32_t frame = fMidiEventCount != 0 ? fMidiEvents[fMidiEventCount - 1].frame : 0;

  1577. 

  1578.             while (fNotesRingBuffer.isDataAvailableForReading())

  1579.             {

  1580.                 if (! fNotesRingBuffer.readCustomData(midiData, 3))

  1581.                     break;

  1582. 

  1583.                 MidiEvent& midiEvent(fMidiEvents[fMidiEventCount++]);

  1584.                 midiEvent.frame = frame;

  1585.                 midiEvent.size  = 3;

  1586.                 std::memcpy(midiEvent.data, midiData, 3);

  1587. 

  1588.                 if (fMidiEventCount == kMaxMidiEvents)

  1589.                     break;

  1590.             }

  1591.         }

  1592.     }

  1593.    #endif

  1594. 

  1595.     void notifyListeners(const AudioUnitPropertyID prop, const AudioUnitScope scope, const AudioUnitElement elem)

  1596.     {

  1597.         for (PropertyListeners::iterator it = fPropertyListeners.begin(); it != fPropertyListeners.end(); ++it)

  1598.         {

  1599.             const PropertyListener& pl(*it);

  1600. 

  1601.             if (pl.prop == prop)

  1602. 			    pl.proc(pl.userData, fComponent, prop, scope, elem);

  1603.         }

  1604.     }

  1605. 

  1606.     void setLastRenderError(const OSStatus err)

  1607.     {

  1608.         if (fLastRenderError != noErr)

  1609.             return;

  1610. 

  1611.         fLastRenderError = err;

  1612.         notifyListeners(kAudioUnitProperty_LastRenderError, kAudioUnitScope_Global, 0);

  1613.     }

  1614. 

  1615.     // ----------------------------------------------------------------------------------------------------------------

  1616.     // DPF callbacks

  1617. 

  1618.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1619.     bool writeMidi(const MidiEvent& midiEvent)

  1620.     {

  1621.         DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_RETURN("MIDI output unsupported", fMidiOutput.midiOutputCallback != nullptr, false);

  1622. 

  1623.         if (midiEvent.size > sizeof(MIDIPacket::data))

  1624.             return true;

  1625.         if (fMidiOutputPackets.numPackets == kMaxMidiEvents)

  1626.             return false;

  1627. 

  1628.         const uint8_t* const midiData = midiEvent.size > MidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data;

  1629.         MIDIPacket& packet(fMidiOutputPackets.packets[fMidiOutputPackets.numPackets++]);

  1630.         packet.timeStamp = midiEvent.frame;

  1631.         packet.length = midiEvent.size;

  1632.         std::memcpy(packet.data, midiData, midiEvent.size);

  1633.         return true;

  1634.     }

  1635. 

  1636.     static bool writeMidiCallback(void* const ptr, const MidiEvent& midiEvent)

  1637.     {

  1638.         return static_cast<PluginAU*>(ptr)->writeMidi(midiEvent);

  1639.     }

  1640.    #endif

  1641. 

  1642.    #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  1643.     bool requestParameterValueChange(const uint32_t index, const float value)

  1644.     {

  1645.         AudioUnitEvent event;

  1646.         std::memset(&event, 0, sizeof(event));

  1647.         event.mEventType                        = kAudioUnitEvent_ParameterValueChange;

  1648.         event.mArgument.mParameter.mAudioUnit   = fComponent;

  1649.         event.mArgument.mParameter.mParameterID = index;

  1650.         event.mArgument.mParameter.mScope       = kAudioUnitScope_Global;

  1651. 

  1652.         fLastParameterValues[index] = value;

  1653.         AUEventListenerNotify(NULL, NULL, &event);

  1654.         notifyListeners('DPFP', kAudioUnitScope_Global, index);

  1655.         return true;

  1656.     }

  1657. 

  1658.     static bool requestParameterValueChangeCallback(void* const ptr, const uint32_t index, const float value)

  1659.     {

  1660.         return static_cast<PluginAU*>(ptr)->requestParameterValueChange(index, value);

  1661.     }

  1662.    #endif

  1663. 

  1664.    #if DISTRHO_PLUGIN_WANT_STATE

  1665.     bool updateState(const char*, const char*)

  1666.     {

  1667.         return true;

  1668.     }

  1669. 

  1670.     static bool updateStateValueCallback(void* const ptr, const char* const key, const char* const value)

  1671.     {

  1672.         return static_cast<PluginAU*>(ptr)->updateState(key, value);

  1673.     }

  1674.    #endif

  1675. 

  1676.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginAU)

  1677. };

  1678. 

  1679. // --------------------------------------------------------------------------------------------------------------------

  1680. 

  1681. struct AudioComponentPlugInInstance {

  1682. 	AudioComponentPlugInInterface acpi;

  1683.     PluginAU* plugin;

  1684. 

  1685.     AudioComponentPlugInInstance() noexcept

  1686.         : acpi(),

  1687.           plugin(nullptr)

  1688.     {

  1689.         std::memset(&acpi, 0, sizeof(acpi));

  1690.         acpi.Open = Open;

  1691. 		acpi.Close = Close;

  1692. 		acpi.Lookup = Lookup;

  1693. 		acpi.reserved = nullptr;

  1694.     }

  1695. 

  1696.     ~AudioComponentPlugInInstance()

  1697.     {

  1698.         delete plugin;

  1699.     }

  1700. 

  1701. 	static OSStatus Open(void* const self, const AudioUnit component)

  1702.     {

  1703.         static_cast<AudioComponentPlugInInstance*>(self)->plugin = new PluginAU(component);

  1704.         return noErr;

  1705.     }

  1706. 

  1707. 	static OSStatus Close(void* const self)

  1708.     {

  1709.         delete static_cast<AudioComponentPlugInInstance*>(self);

  1710.         return noErr;

  1711.     }

  1712. 

  1713.     static AudioComponentMethod Lookup(const SInt16 selector)

  1714.     {

  1715.         d_debug("AudioComponentPlugInInstance::Lookup(%3d:%s)", selector, AudioUnitSelector2Str(selector));

  1716. 

  1717.         switch (selector)

  1718.         {

  1719.         case kAudioUnitInitializeSelect:

  1720.             return reinterpret_cast<AudioComponentMethod>(Initialize);

  1721.         case kAudioUnitUninitializeSelect:

  1722.             return reinterpret_cast<AudioComponentMethod>(Uninitialize);

  1723.         case kAudioUnitGetPropertyInfoSelect:

  1724.             return reinterpret_cast<AudioComponentMethod>(GetPropertyInfo);

  1725.         case kAudioUnitGetPropertySelect:

  1726.             return reinterpret_cast<AudioComponentMethod>(GetProperty);

  1727.         case kAudioUnitSetPropertySelect:

  1728.             return reinterpret_cast<AudioComponentMethod>(SetProperty);

  1729.         case kAudioUnitAddPropertyListenerSelect:

  1730.             return reinterpret_cast<AudioComponentMethod>(AddPropertyListener);

  1731.         case kAudioUnitRemovePropertyListenerSelect:

  1732.             return reinterpret_cast<AudioComponentMethod>(RemovePropertyListener);

  1733.         case kAudioUnitRemovePropertyListenerWithUserDataSelect:

  1734.             return reinterpret_cast<AudioComponentMethod>(RemovePropertyListenerWithUserData);

  1735.         case kAudioUnitAddRenderNotifySelect:

  1736.             return reinterpret_cast<AudioComponentMethod>(AddRenderNotify);

  1737.         case kAudioUnitRemoveRenderNotifySelect:

  1738.             return reinterpret_cast<AudioComponentMethod>(RemoveRenderNotify);

  1739.         case kAudioUnitGetParameterSelect:

  1740.             return reinterpret_cast<AudioComponentMethod>(GetParameter);

  1741.         case kAudioUnitSetParameterSelect:

  1742.             return reinterpret_cast<AudioComponentMethod>(SetParameter);

  1743.         case kAudioUnitScheduleParametersSelect:

  1744.             return reinterpret_cast<AudioComponentMethod>(ScheduleParameters);

  1745.         case kAudioUnitRenderSelect:

  1746.             return reinterpret_cast<AudioComponentMethod>(Render);

  1747.         /*

  1748.         case kAudioUnitComplexRenderSelect:

  1749.             return reinterpret_cast<AudioComponentMethod>(ComplexRender);

  1750.         */

  1751.         case kAudioUnitResetSelect:

  1752.             return reinterpret_cast<AudioComponentMethod>(Reset);

  1753.         /*

  1754.         case kAudioUnitProcessSelect:

  1755.             return reinterpret_cast<AudioComponentMethod>(Process);

  1756.         case kAudioUnitProcessMultipleSelect:

  1757.             return reinterpret_cast<AudioComponentMethod>(ProcessMultiple);

  1758.         */

  1759.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1760.         case kMusicDeviceMIDIEventSelect:

  1761.             return reinterpret_cast<AudioComponentMethod>(MIDIEvent);

  1762.         case kMusicDeviceSysExSelect:

  1763.             return reinterpret_cast<AudioComponentMethod>(SysEx);

  1764.        #endif

  1765.         }

  1766. 

  1767.         d_stdout("TODO Lookup(%3d:%s)", selector, AudioUnitSelector2Str(selector));

  1768.         return nullptr;

  1769.     }

  1770. 

  1771.     static OSStatus Initialize(AudioComponentPlugInInstance* const self)

  1772.     {

  1773.         d_debug("AudioComponentPlugInInstance::Initialize(%p)", self);

  1774.         return self->plugin->auInitialize();

  1775.     }

  1776. 

  1777.     static OSStatus Uninitialize(AudioComponentPlugInInstance* const self)

  1778.     {

  1779.         d_debug("AudioComponentPlugInInstance::Uninitialize(%p)", self);

  1780.         return self->plugin->auUninitialize();

  1781.     }

  1782. 

  1783.     static OSStatus GetPropertyInfo(AudioComponentPlugInInstance* const self,

  1784.                                     const AudioUnitPropertyID inProp,

  1785.                                     const AudioUnitScope inScope,

  1786.                                     const AudioUnitElement inElement,

  1787.                                     UInt32* const outDataSize,

  1788.                                     Boolean* const outWritable)

  1789.     {

  1790.         d_debug("AudioComponentPlugInInstance::GetPropertyInfo(%p, %2d:%s, %d:%s, %d, ...)",

  1791.                 self, inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement);

  1792. 

  1793. 		UInt32 dataSize = 0;

  1794. 		Boolean writable = false;

  1795.         const OSStatus res = self->plugin->auGetPropertyInfo(inProp, inScope, inElement, dataSize, writable);

  1796. 

  1797. 		if (outDataSize != nullptr)

  1798. 			*outDataSize = dataSize;

  1799. 

  1800. 		if (outWritable != nullptr)

  1801. 			*outWritable = writable;

  1802. 

  1803.         return res;

  1804.     }

  1805. 

  1806.     static OSStatus GetProperty(AudioComponentPlugInInstance* const self,

  1807.                                 const AudioUnitPropertyID inProp,

  1808.                                 const AudioUnitScope inScope,

  1809.                                 const AudioUnitElement inElement,

  1810.                                 void* const outData,

  1811.                                 UInt32* const ioDataSize)

  1812.     {

  1813.         d_debug("AudioComponentPlugInInstance::GetProperty    (%p, %2d:%s, %d:%s, %d, ...)",

  1814.                 self, inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement);

  1815.         DISTRHO_SAFE_ASSERT_RETURN(ioDataSize != nullptr, kAudio_ParamError);

  1816. 

  1817.         Boolean writable;

  1818.         UInt32 outDataSize = 0;

  1819.         OSStatus res;

  1820. 

  1821.         if (outData == nullptr)

  1822.         {

  1823.             res = self->plugin->auGetPropertyInfo(inProp, inScope, inElement, outDataSize, writable);

  1824.             *ioDataSize = outDataSize;

  1825.             return res;

  1826.         }

  1827. 

  1828.         const UInt32 inDataSize = *ioDataSize;

  1829.         if (inDataSize == 0)

  1830.             return kAudio_ParamError;

  1831. 

  1832.         res = self->plugin->auGetPropertyInfo(inProp, inScope, inElement, outDataSize, writable);

  1833. 

  1834.         if (res != noErr)

  1835.             return res;

  1836. 

  1837. 		void* outBuffer;

  1838.         uint8_t* tmpBuffer;

  1839.         if (inDataSize < outDataSize)

  1840. 		{

  1841. 			tmpBuffer = new uint8_t[outDataSize];

  1842. 			outBuffer = tmpBuffer;

  1843. 		}

  1844.         else

  1845.         {

  1846. 			tmpBuffer = nullptr;

  1847. 			outBuffer = outData;

  1848. 		}

  1849. 

  1850.         res = self->plugin->auGetProperty(inProp, inScope, inElement, outBuffer);

  1851. 

  1852. 		if (res != noErr)

  1853.         {

  1854. 			*ioDataSize = 0;

  1855.             return res;

  1856.         }

  1857. 

  1858.         if (tmpBuffer != nullptr)

  1859.         {

  1860.             memcpy(outData, tmpBuffer, inDataSize);

  1861.             delete[] tmpBuffer;

  1862.         }

  1863.         else

  1864.         {

  1865.             *ioDataSize = outDataSize;

  1866.         }

  1867. 

  1868.         return noErr;

  1869.     }

  1870. 

  1871.     static OSStatus SetProperty(AudioComponentPlugInInstance* const self,

  1872.                                 const AudioUnitPropertyID inProp,

  1873.                                 const AudioUnitScope inScope,

  1874.                                 const AudioUnitElement inElement,

  1875.                                 const void* const inData,

  1876.                                 const UInt32 inDataSize)

  1877.     {

  1878.         d_debug("AudioComponentPlugInInstance::SetProperty(%p, %d:%s, %d:%s, %d, %p, %u)",

  1879.                 self, inProp, AudioUnitPropertyID2Str(inProp), inScope, AudioUnitScope2Str(inScope), inElement, inData, inDataSize);

  1880.         return self->plugin->auSetProperty(inProp, inScope, inElement, inData, inDataSize);

  1881.     }

  1882. 

  1883.     static OSStatus AddPropertyListener(AudioComponentPlugInInstance* const self,

  1884.                                         const AudioUnitPropertyID prop,

  1885.                                         const AudioUnitPropertyListenerProc proc,

  1886.                                         void* const userData)

  1887.     {

  1888.         d_debug("AudioComponentPlugInInstance::AddPropertyListener(%p, %d:%s, %p, %p)",

  1889.                 self, prop, AudioUnitPropertyID2Str(prop), proc, userData);

  1890.         return self->plugin->auAddPropertyListener(prop, proc, userData);

  1891.     }

  1892. 

  1893.     static OSStatus RemovePropertyListener(AudioComponentPlugInInstance* const self,

  1894.                                            const AudioUnitPropertyID prop,

  1895.                                            const AudioUnitPropertyListenerProc proc)

  1896.     {

  1897.         d_debug("AudioComponentPlugInInstance::RemovePropertyListener(%p, %d:%s, %p)",

  1898.                 self, prop, AudioUnitPropertyID2Str(prop), proc);

  1899.         return self->plugin->auRemovePropertyListener(prop, proc);

  1900.     }

  1901. 

  1902.     static OSStatus RemovePropertyListenerWithUserData(AudioComponentPlugInInstance* const self,

  1903.                                                        const AudioUnitPropertyID prop,

  1904.                                                        const AudioUnitPropertyListenerProc proc,

  1905.                                                        void* const userData)

  1906.     {

  1907.         d_debug("AudioComponentPlugInInstance::RemovePropertyListenerWithUserData(%p, %d:%s, %p, %p)",

  1908.                 self, prop, AudioUnitPropertyID2Str(prop), proc, userData);

  1909.         return self->plugin->auRemovePropertyListenerWithUserData(prop, proc, userData);

  1910.     }

  1911. 

  1912.     static OSStatus AddRenderNotify(AudioComponentPlugInInstance* const self,

  1913.                                     const AURenderCallback proc,

  1914.                                     void* const userData)

  1915.     {

  1916.         d_debug("AudioComponentPlugInInstance::AddRenderNotify(%p, %p, %p)", self, proc, userData);

  1917.         return self->plugin->auAddRenderNotify(proc, userData);

  1918.     }

  1919. 

  1920.     static OSStatus RemoveRenderNotify(AudioComponentPlugInInstance* const self,

  1921.                                        const AURenderCallback proc,

  1922.                                        void* const userData)

  1923.     {

  1924.         d_debug("AudioComponentPlugInInstance::RemoveRenderNotify(%p, %p, %p)", self, proc, userData);

  1925.         return self->plugin->auRemoveRenderNotify(proc, userData);

  1926.     }

  1927. 

  1928.     static OSStatus GetParameter(AudioComponentPlugInInstance* const self,

  1929.                                  const AudioUnitParameterID param,

  1930.                                  const AudioUnitScope scope,

  1931.                                  const AudioUnitElement elem,

  1932.                                  AudioUnitParameterValue* const value)

  1933.     {

  1934.         d_debug("AudioComponentPlugInInstance::GetParameter(%p, %d, %d:%s, %d, %p)",

  1935.                 self, param, scope, AudioUnitScope2Str(scope), elem, value);

  1936.         return self->plugin->auGetParameter(param, scope, elem, value);

  1937.     }

  1938. 

  1939.     static OSStatus SetParameter(AudioComponentPlugInInstance* const self,

  1940.                                  const AudioUnitParameterID param,

  1941.                                  const AudioUnitScope scope,

  1942.                                  const AudioUnitElement elem,

  1943.                                  const AudioUnitParameterValue value,

  1944.                                  const UInt32 bufferOffset)

  1945.     {

  1946.         d_debug("AudioComponentPlugInInstance::SetParameter(%p, %d %d:%s, %d, %f, %u)",

  1947.                 self, param, scope, AudioUnitScope2Str(scope), elem, value, bufferOffset);

  1948.         return self->plugin->auSetParameter(param, scope, elem, value, bufferOffset);

  1949.     }

  1950. 

  1951.     static OSStatus ScheduleParameters(AudioComponentPlugInInstance* const self,

  1952.                                        const AudioUnitParameterEvent* const events,

  1953.                                        const UInt32 numEvents)

  1954.     {

  1955.         d_debug("AudioComponentPlugInInstance::ScheduleParameters(%p, %p, %u)", self, events, numEvents);

  1956.         return self->plugin->auScheduleParameters(events, numEvents);

  1957.     }

  1958. 

  1959.     static OSStatus Reset(AudioComponentPlugInInstance* const self,

  1960.                           const AudioUnitScope scope,

  1961.                           const AudioUnitElement elem)

  1962.     {

  1963.         d_debug("AudioComponentPlugInInstance::Reset(%p, %d:%s, %d)", self, scope, AudioUnitScope2Str(scope), elem);

  1964.         return self->plugin->auReset(scope, elem);

  1965.     }

  1966. 

  1967.     static OSStatus Render(AudioComponentPlugInInstance* const self,

  1968.                            AudioUnitRenderActionFlags* ioActionFlags,

  1969.                            const AudioTimeStamp* const inTimeStamp,

  1970.                            const UInt32 inOutputBusNumber,

  1971.                            const UInt32 inNumberFrames,

  1972.                            AudioBufferList* const ioData)

  1973.     {

  1974.         DISTRHO_SAFE_ASSERT_RETURN(inTimeStamp != nullptr, kAudio_ParamError);

  1975.         DISTRHO_SAFE_ASSERT_RETURN(ioData != nullptr, kAudio_ParamError);

  1976. 

  1977.         AudioUnitRenderActionFlags tmpFlags;

  1978. 

  1979.         if (ioActionFlags == nullptr)

  1980.         {

  1981.             tmpFlags = 0;

  1982.             ioActionFlags = &tmpFlags;

  1983.         }

  1984. 

  1985.         return self->plugin->auRender(*ioActionFlags, *inTimeStamp, inOutputBusNumber, inNumberFrames, *ioData);

  1986.     }

  1987. 

  1988.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1989.     static OSStatus MIDIEvent(AudioComponentPlugInInstance* const self,

  1990.                               const UInt32 inStatus,

  1991.                               const UInt32 inData1,

  1992.                               const UInt32 inData2,

  1993.                               const UInt32 inOffsetSampleFrame)

  1994.     {

  1995.         return self->plugin->auMIDIEvent(inStatus, inData1, inData2, inOffsetSampleFrame);

  1996.     }

  1997. 

  1998.     static OSStatus SysEx(AudioComponentPlugInInstance* const self, const UInt8* const inData, const UInt32 inLength)

  1999.     {

  2000.         return self->plugin->auSysEx(inData, inLength);

  2001.     }

  2002.    #endif

  2003. 

  2004.     DISTRHO_DECLARE_NON_COPYABLE(AudioComponentPlugInInstance)

  2005. };

  2006. 

  2007. // --------------------------------------------------------------------------------------------------------------------

  2008. 

  2009. END_NAMESPACE_DISTRHO

  2010. 

  2011. DISTRHO_PLUGIN_EXPORT

  2012. void* PluginAUFactory(const AudioComponentDescription* const desc)

  2013. {

  2014.     USE_NAMESPACE_DISTRHO

  2015. 

  2016.     DISTRHO_SAFE_ASSERT_UINT2_RETURN(desc->componentType == kType, desc->componentType, kType, nullptr);

  2017.     DISTRHO_SAFE_ASSERT_UINT2_RETURN(desc->componentSubType == kSubType, desc->componentSubType, kSubType, nullptr);

  2018.     DISTRHO_SAFE_ASSERT_UINT2_RETURN(desc->componentManufacturer == kManufacturer, desc->componentManufacturer, kManufacturer, nullptr);

  2019. 

  2020.     if (d_nextBufferSize == 0)

  2021.         d_nextBufferSize = 1156;

  2022. 

  2023.     if (d_isZero(d_nextSampleRate))

  2024.         d_nextSampleRate = 44100.0;

  2025. 

  2026.     if (d_nextBundlePath == nullptr)

  2027.     {

  2028.         static String bundlePath;

  2029. 

  2030.         String tmpPath(getBinaryFilename());

  2031.         tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  2032.         tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  2033. 

  2034.         if (tmpPath.endsWith(DISTRHO_OS_SEP_STR "Contents"))

  2035.         {

  2036.             tmpPath.truncate(tmpPath.rfind(DISTRHO_OS_SEP));

  2037.             bundlePath = tmpPath;

  2038.         }

  2039.         else

  2040.         {

  2041.             bundlePath = "error";

  2042.         }

  2043. 

  2044.         d_nextBundlePath = bundlePath.buffer();

  2045.     }

  2046. 

  2047.     d_nextCanRequestParameterValueChanges = true;

  2048. 

  2049.     return new AudioComponentPlugInInstance();

  2050. }

  2051. 

  2052. // --------------------------------------------------------------------------------------------------------------------