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.
2264 Commits
7 Branches
373MB
Tree: 4e2e3a8a38
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4e2e3a8a38'
${ noResults }
DPF/distrho/src/DistrhoPluginAU.cpp

2505 lines
101KB
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. 

  31. #include <map>

  32. #include <vector>

  33. 

  34. #ifndef DISTRHO_PLUGIN_BRAND_ID

  35. # error DISTRHO_PLUGIN_BRAND_ID undefined!

  36. #endif

  37. 

  38. #ifndef DISTRHO_PLUGIN_UNIQUE_ID

  39. # error DISTRHO_PLUGIN_UNIQUE_ID undefined!

  40. #endif

  41. 

  42. START_NAMESPACE_DISTRHO

  43. 

  44. // --------------------------------------------------------------------------------------------------------------------

  45. 

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

  47. {

  48.     switch (prop)

  49.     {

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

  51.     PROP(kAudioUnitProperty_ClassInfo)

  52.     PROP(kAudioUnitProperty_MakeConnection)

  53.     PROP(kAudioUnitProperty_SampleRate)

  54.     PROP(kAudioUnitProperty_ParameterList)

  55.     PROP(kAudioUnitProperty_ParameterInfo)

  56.    #if !TARGET_OS_IPHONE

  57.     PROP(kAudioUnitProperty_FastDispatch)

  58.    #endif

  59.     PROP(kAudioUnitProperty_CPULoad)

  60.     PROP(kAudioUnitProperty_StreamFormat)

  61.     PROP(kAudioUnitProperty_ElementCount)

  62.     PROP(kAudioUnitProperty_Latency)

  63.     PROP(kAudioUnitProperty_SupportedNumChannels)

  64.     PROP(kAudioUnitProperty_MaximumFramesPerSlice)

  65.     PROP(kAudioUnitProperty_ParameterValueStrings)

  66.     PROP(kAudioUnitProperty_AudioChannelLayout)

  67.     PROP(kAudioUnitProperty_TailTime)

  68.     PROP(kAudioUnitProperty_BypassEffect)

  69.     PROP(kAudioUnitProperty_LastRenderError)

  70.     PROP(kAudioUnitProperty_SetRenderCallback)

  71.     PROP(kAudioUnitProperty_FactoryPresets)

  72.     PROP(kAudioUnitProperty_RenderQuality)

  73.     PROP(kAudioUnitProperty_HostCallbacks)

  74.     PROP(kAudioUnitProperty_InPlaceProcessing)

  75.     PROP(kAudioUnitProperty_ElementName)

  76.     PROP(kAudioUnitProperty_SupportedChannelLayoutTags)

  77.     PROP(kAudioUnitProperty_PresentPreset)

  78.     PROP(kAudioUnitProperty_DependentParameters)

  79.     PROP(kAudioUnitProperty_InputSamplesInOutput)

  80.     PROP(kAudioUnitProperty_ShouldAllocateBuffer)

  81.     PROP(kAudioUnitProperty_FrequencyResponse)

  82.     PROP(kAudioUnitProperty_ParameterHistoryInfo)

  83.     PROP(kAudioUnitProperty_NickName)

  84.     PROP(kAudioUnitProperty_OfflineRender)

  85.     PROP(kAudioUnitProperty_ParameterIDName)

  86.     PROP(kAudioUnitProperty_ParameterStringFromValue)

  87.     PROP(kAudioUnitProperty_ParameterClumpName)

  88.     PROP(kAudioUnitProperty_ParameterValueFromString)

  89.     PROP(kAudioUnitProperty_PresentationLatency)

  90.     PROP(kAudioUnitProperty_ClassInfoFromDocument)

  91.     PROP(kAudioUnitProperty_RequestViewController)

  92.     PROP(kAudioUnitProperty_ParametersForOverview)

  93.     PROP(kAudioUnitProperty_SupportsMPE)

  94.     PROP(kAudioUnitProperty_RenderContextObserver)

  95.     PROP(kAudioUnitProperty_LastRenderSampleTime)

  96.     PROP(kAudioUnitProperty_LoadedOutOfProcess)

  97.    #if !TARGET_OS_IPHONE

  98.     PROP(kAudioUnitProperty_SetExternalBuffer)

  99.     PROP(kAudioUnitProperty_GetUIComponentList)

  100.     PROP(kAudioUnitProperty_CocoaUI)

  101.     PROP(kAudioUnitProperty_IconLocation)

  102.     PROP(kAudioUnitProperty_AUHostIdentifier)

  103.    #endif

  104.     PROP(kAudioUnitProperty_MIDIOutputCallbackInfo)

  105.     PROP(kAudioUnitProperty_MIDIOutputCallback)

  106.     PROP(kAudioUnitProperty_MIDIOutputEventListCallback)

  107.     PROP(kAudioUnitProperty_AudioUnitMIDIProtocol)

  108.     PROP(kAudioUnitProperty_HostMIDIProtocol)

  109.     PROP(kAudioUnitProperty_MIDIOutputBufferSizeHint)

  110.     #undef PROP

  111.     }

  112.     return "[unknown]";

  113. }

  114. 

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

  116. {

  117.     switch (scope)

  118.     {

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

  120.     SCOPE(kAudioUnitScope_Global)

  121.     SCOPE(kAudioUnitScope_Input)

  122.     SCOPE(kAudioUnitScope_Output)

  123.     SCOPE(kAudioUnitScope_Group)

  124.     SCOPE(kAudioUnitScope_Part)

  125.     SCOPE(kAudioUnitScope_Note)

  126.     SCOPE(kAudioUnitScope_Layer)

  127.     SCOPE(kAudioUnitScope_LayerItem)

  128.     #undef SCOPE

  129.     }

  130.     return "[unknown]";

  131. }

  132. 

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

  134. {

  135.     switch (selector)

  136.     {

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

  138.     SEL(kAudioUnitInitializeSelect)

  139.     SEL(kAudioUnitUninitializeSelect)

  140.     SEL(kAudioUnitGetPropertyInfoSelect)

  141.     SEL(kAudioUnitGetPropertySelect)

  142.     SEL(kAudioUnitSetPropertySelect)

  143.     SEL(kAudioUnitAddPropertyListenerSelect)

  144.     SEL(kAudioUnitRemovePropertyListenerSelect)

  145.     SEL(kAudioUnitRemovePropertyListenerWithUserDataSelect)

  146.     SEL(kAudioUnitAddRenderNotifySelect)

  147.     SEL(kAudioUnitRemoveRenderNotifySelect)

  148.     SEL(kAudioUnitGetParameterSelect)

  149.     SEL(kAudioUnitSetParameterSelect)

  150.     SEL(kAudioUnitScheduleParametersSelect)

  151.     SEL(kAudioUnitRenderSelect)

  152.     SEL(kAudioUnitResetSelect)

  153.     SEL(kAudioUnitComplexRenderSelect)

  154.     SEL(kAudioUnitProcessSelect)

  155.     SEL(kAudioUnitProcessMultipleSelect)

  156.     SEL(kMusicDeviceMIDIEventSelect)

  157.     SEL(kMusicDeviceSysExSelect)

  158.     SEL(kMusicDevicePrepareInstrumentSelect)

  159.     SEL(kMusicDeviceReleaseInstrumentSelect)

  160.     SEL(kMusicDeviceStartNoteSelect)

  161.     SEL(kMusicDeviceStopNoteSelect)

  162.     SEL(kMusicDeviceMIDIEventListSelect)

  163.     SEL(kAudioOutputUnitStartSelect)

  164.     SEL(kAudioOutputUnitStopSelect)

  165.     #undef SEL

  166.     }

  167.     return "[unknown]";

  168. }

  169. 

  170. // --------------------------------------------------------------------------------------------------------------------

  171. 

  172. static constexpr const uint32_t kType = d_cconst(STRINGIFY(DISTRHO_PLUGIN_AU_TYPE));

  173. static constexpr const uint32_t kSubType = d_cconst(STRINGIFY(DISTRHO_PLUGIN_UNIQUE_ID));

  174. static constexpr const uint32_t kManufacturer = d_cconst(STRINGIFY(DISTRHO_PLUGIN_BRAND_ID));

  175. 

  176. // --------------------------------------------------------------------------------------------------------------------

  177. 

  178. struct PropertyListener {

  179.     AudioUnitPropertyID	prop;

  180.     AudioUnitPropertyListenerProc proc;

  181.     void* userData;

  182. };

  183. 

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

  185. 

  186. // --------------------------------------------------------------------------------------------------------------------

  187. 

  188. typedef struct {

  189.     UInt32 numPackets;

  190.     MIDIPacket packets[kMaxMidiEvents];

  191. } MIDIPacketList;

  192. 

  193. // --------------------------------------------------------------------------------------------------------------------

  194. 

  195. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  196. static constexpr const writeMidiFunc writeMidiCallback = nullptr;

  197. #endif

  198. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  199. static constexpr const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  200. #endif

  201. #if ! DISTRHO_PLUGIN_WANT_STATE

  202. static constexpr const updateStateValueFunc updateStateValueCallback = nullptr;

  203. #endif

  204. 

  205. typedef std::map<const String, String> StringMap;

  206. 

  207. // --------------------------------------------------------------------------------------------------------------------

  208. 

  209. class PluginAU

  210. {

  211. public:

  212.     PluginAU(const AudioUnit component)

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

  214.           fComponent(component),

  215.           fLastRenderError(noErr),

  216.           fPropertyListeners(),

  217.          #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  218.           fSampleRateForInput(d_nextSampleRate),

  219.          #endif

  220.          #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  221.           fSampleRateForOutput(d_nextSampleRate),

  222.          #endif

  223.           fParameterCount(fPlugin.getParameterCount()),

  224.           fLastParameterValues(nullptr),

  225.           fBypassParameterIndex(UINT32_MAX)

  226.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  227.         , fMidiEventCount(0)

  228.        #endif

  229.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  230.         , fCurrentProgram(0)

  231.        #endif

  232.        #if DISTRHO_PLUGIN_WANT_STATE

  233.         , fStateCount(fPlugin.getStateCount())

  234.        #endif

  235. 

  236.     {

  237.         fCurrentPreset.presetName = CFSTR("Default");

  238.         fCurrentPreset.presetNumber = 0;

  239. 

  240. 	    if (fParameterCount != 0)

  241.         {

  242.             fLastParameterValues = new float[fParameterCount];

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

  244. 

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

  246.             {

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

  248. 

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

  250.                     fBypassParameterIndex = i;

  251.             }

  252.         }

  253. 

  254.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  256.        #endif

  257. 

  258.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

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

  261.        #endif

  262. 

  263.        #if DISTRHO_PLUGIN_WANT_STATE

  264.         for (uint32_t i=0; i<fStateCount; ++i)

  265.         {

  266.             const String& dkey(fPlugin.getStateKey(i));

  267.             fStateMap[dkey] = fPlugin.getStateDefaultValue(i);

  268.         }

  269.        #endif

  270. 

  271.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  272.         std::memset(&fHostCallbackInfo, 0, sizeof(fHostCallbackInfo));

  273. 

  274.         // ticksPerBeat is not possible with AU

  275.         fTimePosition.bbt.ticksPerBeat = 1920.0;

  276.        #endif

  277.     }

  278. 

  279.     ~PluginAU()

  280.     {

  281.         CFRelease(fCurrentPreset.presetName);

  282.         delete[] fLastParameterValues;

  283.     }

  284. 

  285.     OSStatus auInitialize()

  286.     {

  287.         fPlugin.activate();

  288.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  289.         fMidiEventCount = 0;

  290.        #endif

  291.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  292.         fMidiOutputPackets.numPackets = 0;

  293.        #endif

  294.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  295.         fTimePosition.clear();

  296.        #endif

  297.         return noErr;

  298.     }

  299. 

  300.     OSStatus auUninitialize()

  301.     {

  302.         fPlugin.deactivateIfNeeded();

  303.         return noErr;

  304.     }

  305. 

  306.     OSStatus auGetPropertyInfo(const AudioUnitPropertyID inProp,

  307.                                const AudioUnitScope inScope,

  308.                                const AudioUnitElement inElement,

  309.                                UInt32& outDataSize,

  310.                                Boolean& outWritable)

  311.     {

  312.         switch (inProp)

  313.         {

  314.         case kAudioUnitProperty_ClassInfo:

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

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

  317.             outDataSize = sizeof(CFPropertyListRef);

  318.             outWritable = true;

  319.             return noErr;

  320. 

  321.         case kAudioUnitProperty_MakeConnection:

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

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

  324.             outDataSize = sizeof(AudioUnitConnection);

  325.             outWritable = true;

  326.             return noErr;

  327. 

  328.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  329.         case kAudioUnitProperty_SampleRate:

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

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

  332.            #elif DISTRHO_PLUGIN_NUM_INPUTS != 0

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

  334.            #else

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

  336.            #endif

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

  338.             outDataSize = sizeof(Float64);

  339.             outWritable = true;

  340.             return noErr;

  341.        #endif

  342. 

  343.         case kAudioUnitProperty_ParameterList:

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

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

  346.             outWritable = false;

  347.             return noErr;

  348. 

  349.         case kAudioUnitProperty_ParameterInfo:

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

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

  352.             outDataSize = sizeof(AudioUnitParameterInfo);

  353.             outWritable = false;

  354.             return noErr;

  355. 

  356.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  357.         case kAudioUnitProperty_StreamFormat:

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

  359.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  360.             if (inScope == kAudioUnitScope_Input)

  361.             {

  362.                 outDataSize = sizeof(AudioStreamBasicDescription);

  363.                 outWritable = true;

  364.                 return noErr;

  365.             }

  366.            #endif

  367.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  368.             if (inScope == kAudioUnitScope_Output)

  369.             {

  370.                 outDataSize = sizeof(AudioStreamBasicDescription);

  371.                 outWritable = true;

  372.                 return noErr;

  373.             }

  374.            #endif

  375.             return kAudioUnitErr_InvalidScope;

  376.        #endif

  377. 

  378.         case kAudioUnitProperty_ElementCount:

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

  380.             outDataSize = sizeof(UInt32);

  381.             outWritable = false;

  382.             return noErr;

  383. 

  384.         case kAudioUnitProperty_Latency:

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

  386.            #if DISTRHO_PLUGIN_WANT_LATENCY

  387.             if (inScope == kAudioUnitScope_Global)

  388.             {

  389.                 outDataSize = sizeof(Float64);

  390.                 outWritable = false;

  391.                 return noErr;

  392.             }

  393.            #endif

  394.             return kAudioUnitErr_InvalidProperty;

  395. 

  396.         case kAudioUnitProperty_SupportedNumChannels:

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

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

  399.             outDataSize = sizeof(AUChannelInfo);

  400.             outWritable = false;

  401.             return noErr;

  402. 

  403.         case kAudioUnitProperty_MaximumFramesPerSlice:

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

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

  406.             outDataSize = sizeof(UInt32);

  407.             outWritable = true;

  408.             return noErr;

  409. 

  410.         case kAudioUnitProperty_BypassEffect:

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

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

  413.             {

  414.                 outDataSize = sizeof(UInt32);

  415.                 outWritable = true;

  416.                 return noErr;

  417.             }

  418.             return kAudioUnitErr_InvalidProperty;

  419. 

  420.         case kAudioUnitProperty_LastRenderError:

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

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

  423.             outDataSize = sizeof(OSStatus);

  424.             outWritable = false;

  425.             return noErr;

  426. 

  427.         case kAudioUnitProperty_SetRenderCallback:

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

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

  430.             outDataSize = sizeof(AURenderCallbackStruct);

  431.             outWritable = true;

  432.             return noErr;

  433. 

  434.         case kAudioUnitProperty_HostCallbacks:

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

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

  437.            #if DISTRHO_PLUGIN_WANT_TIMEPOS

  438.             outDataSize = sizeof(HostCallbackInfo);

  439.             outWritable = false;

  440.             return noErr;

  441.            #else

  442.             return kAudioUnitErr_InvalidProperty;

  443.            #endif

  444. 

  445.         case kAudioUnitProperty_InPlaceProcessing:

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

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

  448.             outDataSize = sizeof(UInt32);

  449.             outWritable = false;

  450.             return noErr;

  451. 

  452.         case kAudioUnitProperty_PresentPreset:

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

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

  455.             outDataSize = sizeof(AUPreset);

  456.             outWritable = true;

  457.             return noErr;

  458. 

  459.         case kAudioUnitProperty_CocoaUI:

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

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

  462.            #if DISTRHO_PLUGIN_HAS_UI

  463.             outDataSize = sizeof(AudioUnitCocoaViewInfo);

  464.             outWritable = false;

  465.             return noErr;

  466.            #else

  467.             return kAudioUnitErr_InvalidProperty;

  468.            #endif

  469. 

  470.         case kAudioUnitProperty_MIDIOutputCallbackInfo:

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

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

  473.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  474.             outDataSize = sizeof(CFArrayRef);

  475.             outWritable = false;

  476.             return noErr;

  477.            #else

  478.             return kAudioUnitErr_InvalidProperty;

  479.            #endif

  480. 

  481.         case kAudioUnitProperty_MIDIOutputCallback:

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

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

  484.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  485.             outDataSize = sizeof(AUMIDIOutputCallbackStruct);

  486.             outWritable = true;

  487.             return noErr;

  488.            #else

  489.             return kAudioUnitErr_InvalidProperty;

  490.            #endif

  491. 

  492.         case kAudioUnitProperty_AudioUnitMIDIProtocol:

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

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

  495.             // FIXME implement the event list stuff

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

  497.             outDataSize = sizeof(SInt32);

  498.             outWritable = false;

  499.             return noErr;

  500.            #else

  501.             return kAudioUnitErr_InvalidProperty;

  502.            #endif

  503. 

  504.         case 'DPFi':

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

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

  507.             outDataSize = sizeof(uint16_t);

  508.             outWritable = false;

  509.             return noErr;

  510. 

  511.         case 'DPFe':

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

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

  514.             outDataSize = sizeof(uint8_t);

  515.             outWritable = true;

  516.             return noErr;

  517. 

  518.         case 'DPFp':

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

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

  521.             outDataSize = sizeof(float);

  522.             outWritable = true;

  523.             return noErr;

  524. 

  525.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  526.         case 'DPFn':

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

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

  529.             outDataSize = sizeof(uint8_t) * 3;

  530.             outWritable = true;

  531.             return noErr;

  532.        #endif

  533. 

  534.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  535.         case 'DPFo':

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

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

  538.             outDataSize = sizeof(uint32_t);

  539.             outWritable = false;

  540.             return noErr;

  541.        #endif

  542. 

  543.        #if DISTRHO_PLUGIN_WANT_STATE

  544.         case 'DPFl':

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

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

  547.             outDataSize = sizeof(CFArrayRef);

  548.             outWritable = false;

  549.             return noErr;

  550. 

  551.         case 'DPFs':

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

  553.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement < fStateCount, inElement, kAudioUnitErr_InvalidElement);

  554.             outDataSize = sizeof(CFStringRef);

  555.             outWritable = true;

  556.             return noErr;

  557.        #endif

  558. 

  559.        #if DISTRHO_PLUGIN_HAS_UI && DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  560.         case 'DPFa':

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

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

  563.             outDataSize = sizeof(void*);

  564.             outWritable = false;

  565.             return noErr;

  566.        #endif

  567. 

  568.         // unwanted properties

  569.         case kAudioUnitProperty_CPULoad:

  570.         case kAudioUnitProperty_RenderContextObserver:

  571.         case kAudioUnitProperty_TailTime:

  572.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  573.         case kAudioUnitProperty_SampleRate:

  574.         case kAudioUnitProperty_StreamFormat:

  575.        #endif

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

  577.             return kAudioUnitErr_InvalidProperty;

  578.         }

  579. 

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

  581.         return kAudioUnitErr_InvalidProperty;

  582.     }

  583. 

  584.     OSStatus auGetProperty(const AudioUnitPropertyID inProp,

  585.                            const AudioUnitScope inScope,

  586.                            const AudioUnitElement inElement,

  587.                            void* const outData)

  588.     {

  589.         switch (inProp)

  590.         {

  591.         case kAudioUnitProperty_ClassInfo:

  592.             *static_cast<CFPropertyListRef*>(outData) = retrieveClassInfo();

  593.             return noErr;

  594. 

  595.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  596.         case kAudioUnitProperty_SampleRate:

  597.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  598.             if (inScope == kAudioUnitScope_Input)

  599.             {

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

  601.             }

  602.             else

  603.            #endif

  604.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  605.             if (inScope == kAudioUnitScope_Output)

  606.             {

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

  608.             }

  609.             else

  610.            #endif

  611.             {

  612.                 return kAudioUnitErr_InvalidScope;

  613.             }

  614.             return noErr;

  615.        #endif

  616. 

  617.         case kAudioUnitProperty_ParameterList:

  618.             {

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

  620. 

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

  622.                     paramList[i] = i;

  623.             }

  624.             return noErr;

  625. 

  626.         case kAudioUnitProperty_ParameterInfo:

  627.             {

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

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

  630. 

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

  632. 

  633.                 info->flags = kAudioUnitParameterFlag_IsHighResolution

  634.                             | kAudioUnitParameterFlag_IsReadable

  635.                             | kAudioUnitParameterFlag_HasCFNameString;

  636. 

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

  638.                 {

  639.                     info->flags |= kAudioUnitParameterFlag_IsWritable;

  640.                     info->unit = kAudioUnitParameterUnit_Generic;

  641. 

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

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

  644.                 }

  645.                 else

  646.                 {

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

  648. 

  649.                     info->flags |= kAudioUnitParameterFlag_CFNameRelease;

  650. 

  651.                     if (hints & kParameterIsOutput)

  652.                     {

  653.                         info->flags |= kAudioUnitParameterFlag_MeterReadOnly;

  654.                     }

  655.                     else

  656.                     {

  657.                         info->flags |= kAudioUnitParameterFlag_IsWritable;

  658. 

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

  660.                             info->flags |= kAudioUnitParameterFlag_NonRealTime;

  661.                     }

  662. 

  663.                     if (hints & kParameterIsBoolean)

  664.                         info->unit = kAudioUnitParameterUnit_Boolean;

  665.                     else if (hints & kParameterIsInteger)

  666.                         info->unit = kAudioUnitParameterUnit_Indexed;

  667.                     else

  668.                         info->unit = kAudioUnitParameterUnit_Generic;

  669. 

  670.                     // | kAudioUnitParameterFlag_ValuesHaveStrings;

  671. 

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

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

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

  675.                 }

  676. 

  677.                 info->minValue = ranges.min;

  678.                 info->maxValue = ranges.max;

  679.                 info->defaultValue = ranges.def;

  680.             }

  681.             return noErr;

  682. 

  683.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  684.         case kAudioUnitProperty_StreamFormat:

  685.             {

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

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

  688. 

  689.                 if (inElement != 0)

  690.                     return kAudioUnitErr_InvalidElement;

  691. 

  692.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  693.                 if (inScope == kAudioUnitScope_Input)

  694.                 {

  695.                     desc->mChannelsPerFrame = DISTRHO_PLUGIN_NUM_INPUTS;

  696.                 }

  697.                 else

  698.                #endif

  699.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  700.                 if (inScope == kAudioUnitScope_Output)

  701.                 {

  702.                     desc->mChannelsPerFrame = DISTRHO_PLUGIN_NUM_OUTPUTS;

  703.                 }

  704.                 else

  705.                #endif

  706.                 {

  707.                     return kAudioUnitErr_InvalidScope;

  708.                 }

  709. 

  710.                 desc->mFormatID         = kAudioFormatLinearPCM;

  711.                 desc->mFormatFlags      = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;

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

  713.                 desc->mBitsPerChannel   = 32;

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

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

  716.                 desc->mFramesPerPacket  = 1;

  717.             }

  718.             return noErr;

  719.        #endif

  720. 

  721.         case kAudioUnitProperty_ElementCount:

  722.             switch (inScope)

  723.             {

  724.             case kAudioUnitScope_Global:

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

  726.                 break;

  727.             case kAudioUnitScope_Input:

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

  729.                 break;

  730.             case kAudioUnitScope_Output:

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

  732.                 break;

  733.             default:

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

  735.                 break;

  736.             }

  737.             return noErr;

  738. 

  739.        #if DISTRHO_PLUGIN_WANT_LATENCY

  740.         case kAudioUnitProperty_Latency:

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

  742.             return noErr;

  743.        #endif

  744. 

  745.         case kAudioUnitProperty_SupportedNumChannels:

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

  747.             return noErr;

  748. 

  749.         case kAudioUnitProperty_MaximumFramesPerSlice:

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

  751.             return noErr;

  752. 

  753.         case kAudioUnitProperty_LastRenderError:

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

  755.             fLastRenderError = noErr;

  756.             return noErr;

  757. 

  758.         case kAudioUnitProperty_BypassEffect:

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

  760.             return noErr;

  761. 

  762.         case kAudioUnitProperty_SetRenderCallback:

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

  764.             // TODO

  765.             break;

  766. 

  767.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  768.         case kAudioUnitProperty_HostCallbacks:

  769.             std::memcpy(outData, &fHostCallbackInfo, sizeof(HostCallbackInfo));

  770.             return noErr;

  771.        #endif

  772. 

  773.         case kAudioUnitProperty_InPlaceProcessing:

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

  775.             return noErr;

  776. 

  777.         case kAudioUnitProperty_PresentPreset:

  778.             std::memcpy(outData, &fCurrentPreset, sizeof(AUPreset));

  779.             return noErr;

  780. 

  781.        #if DISTRHO_PLUGIN_HAS_UI

  782.         case kAudioUnitProperty_CocoaUI:

  783.             {

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

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

  786. 

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

  788.                     initWithBytes:d_nextBundlePath

  789.                            length:strlen(d_nextBundlePath)

  790.                          encoding:NSUTF8StringEncoding];

  791. 

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

  793. 

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

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

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

  797. 

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

  799.                                                                             DISTRHO_PLUGIN_UNIQUE_ID,

  800.                                                                             DISTRHO_PLUGIN_BRAND_ID));

  801. 

  802.                 #undef MACRO_STR

  803.                 #undef MACRO_STR2

  804.                 #undef MACRO_STR3

  805. 

  806.                 [bundlePathString release];

  807.             }

  808.             return noErr;

  809.        #endif

  810. 

  811.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  812.         case kAudioUnitProperty_MIDIOutputCallbackInfo:

  813.             {

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

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

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

  817.                                                                    1,

  818.                                                                    &kCFTypeArrayCallBacks);

  819.             }

  820.             return noErr;

  821.        #endif

  822. 

  823.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT || DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  824.         /* FIXME implement the event list stuff

  825.         case kAudioUnitProperty_AudioUnitMIDIProtocol:

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

  827.             return noErr;

  828.         */

  829.        #endif

  830. 

  831.         case 'DPFp':

  832.             *static_cast<float*>(outData) = fPlugin.getParameterValue(inElement);

  833.             return noErr;

  834. 

  835.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  836.         case 'DPFo':

  837.             *static_cast<uint32_t*>(outData) = fCurrentProgram;

  838.             return noErr;

  839.        #endif

  840. 

  841.        #if DISTRHO_PLUGIN_WANT_STATE

  842.         case 'DPFl':

  843.             if (const CFMutableArrayRef keysRef = CFArrayCreateMutable(nullptr,

  844.                                                                        fStateCount,

  845.                                                                        &kCFTypeArrayCallBacks))

  846.             {

  847.                 for (uint32_t i=0; i<fStateCount; ++i)

  848.                 {

  849.                     const CFStringRef keyRef = CFStringCreateWithCString(nullptr,

  850.                                                                          fPlugin.getStateKey(i),

  851.                                                                          kCFStringEncodingASCII);

  852.                     CFArrayAppendValue(keysRef, keyRef);

  853.                     CFRelease(keyRef);

  854.                 }

  855. 

  856.                 *static_cast<CFArrayRef*>(outData) = keysRef;

  857.                 return noErr;

  858.             }

  859.             return kAudio_ParamError;

  860. 

  861.         case 'DPFs':

  862.             {

  863.                 const String& key(fPlugin.getStateKey(inElement));

  864.                #if DISTRHO_PLUGIN_WANT_FULL_STATE

  865.                 fStateMap[key] = fPlugin.getStateValue(key);

  866.                #endif

  867. 

  868.                 *static_cast<CFStringRef*>(outData) = CFStringCreateWithCString(nullptr,

  869.                                                                                 fStateMap[key],

  870.                                                                                 kCFStringEncodingUTF8);

  871.             }

  872.             return noErr;

  873.        #endif

  874. 

  875.        #if DISTRHO_PLUGIN_HAS_UI && DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  876.         case 'DPFa':

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

  878.             return noErr;

  879.        #endif

  880.         }

  881. 

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

  883.         return kAudioUnitErr_InvalidProperty;

  884.     }

  885. 

  886.     OSStatus auSetProperty(const AudioUnitPropertyID inProp,

  887.                            const AudioUnitScope inScope,

  888.                            const AudioUnitElement inElement,

  889.                            const void* const inData,

  890.                            const UInt32 inDataSize)

  891.     {

  892.         switch (inProp)

  893.         {

  894.         case kAudioUnitProperty_ClassInfo:

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

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

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

  898.             {

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

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

  901. 

  902.                 restoreClassInfo(static_cast<CFDictionaryRef>(propList));

  903.             }

  904.             return noErr;

  905. 

  906.         case kAudioUnitProperty_MakeConnection:

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

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

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

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

  911.             // TODO

  912.             return noErr;

  913. 

  914.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  915.         case kAudioUnitProperty_SampleRate:

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

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

  918.            #elif DISTRHO_PLUGIN_NUM_INPUTS != 0

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

  920.            #else

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

  922.            #endif

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

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

  925.             {

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

  927. 

  928.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  929.                 if (inScope == kAudioUnitScope_Input)

  930.                 {

  931.                     if (d_isNotEqual(fSampleRateForInput, sampleRate))

  932.                     {

  933.                         fSampleRateForInput = sampleRate;

  934.                         d_nextSampleRate = sampleRate;

  935. 

  936.                        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  937.                         if (d_isEqual(fSampleRateForOutput, sampleRate))

  938.                        #endif

  939.                         {

  940.                             fPlugin.setSampleRate(sampleRate, true);

  941.                         }

  942. 

  943.                         notifyListeners(inProp, inScope, inElement);

  944.                     }

  945.                     return noErr;

  946.                 }

  947.                #endif

  948. 

  949.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  950.                 if (inScope == kAudioUnitScope_Output)

  951.                 {

  952.                     if (d_isNotEqual(fSampleRateForOutput, sampleRate))

  953.                     {

  954.                         fSampleRateForOutput = sampleRate;

  955.                         d_nextSampleRate = sampleRate;

  956. 

  957.                        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  958.                         if (d_isEqual(fSampleRateForInput, sampleRate))

  959.                        #endif

  960.                         {

  961.                             fPlugin.setSampleRate(sampleRate, true);

  962.                         }

  963. 

  964.                         notifyListeners(inProp, inScope, inElement);

  965.                     }

  966.                     return noErr;

  967.                 }

  968.                #endif

  969.             }

  970.             return kAudioUnitErr_InvalidScope;

  971.        #endif

  972. 

  973.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  974.         case kAudioUnitProperty_StreamFormat:

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

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

  977.            #elif DISTRHO_PLUGIN_NUM_INPUTS != 0

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

  979.            #else

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

  981.            #endif

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

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

  984.             {

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

  986. 

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

  988.                     return kAudioUnitErr_FormatNotSupported;

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

  990.                     return kAudioUnitErr_FormatNotSupported;

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

  992.                     return kAudioUnitErr_FormatNotSupported;

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

  994.                     return kAudioUnitErr_FormatNotSupported;

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

  996.                     return kAudioUnitErr_FormatNotSupported;

  997. 

  998.                #if 1

  999.                 // dont allow interleaved data

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

  1001.                #else

  1002.                 // allow interleaved data

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

  1004.                #endif

  1005.                     return kAudioUnitErr_FormatNotSupported;

  1006. 

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

  1008.                                                                                  : DISTRHO_PLUGIN_NUM_OUTPUTS))

  1009.                     return kAudioUnitErr_FormatNotSupported;

  1010. 

  1011.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1012.                 if (inScope == kAudioUnitScope_Input)

  1013.                 {

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

  1015.                     {

  1016.                         fSampleRateForInput = desc->mSampleRate;

  1017. 

  1018.                        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

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

  1020.                        #endif

  1021.                         {

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

  1023.                         }

  1024. 

  1025.                         notifyListeners(inProp, inScope, inElement);

  1026.                         notifyListeners(kAudioUnitProperty_SampleRate, inScope, inElement);

  1027.                     }

  1028.                     return noErr;

  1029.                 }

  1030.                #endif

  1031. 

  1032.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1033.                 if (inScope == kAudioUnitScope_Output)

  1034.                 {

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

  1036.                     {

  1037.                         fSampleRateForOutput = desc->mSampleRate;

  1038. 

  1039.                        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

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

  1041.                        #endif

  1042.                         {

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

  1044.                         }

  1045. 

  1046.                         notifyListeners(inProp, inScope, inElement);

  1047.                         notifyListeners(kAudioUnitProperty_SampleRate, inScope, inElement);

  1048.                     }

  1049.                     return noErr;

  1050.                 }

  1051.                #endif

  1052.             }

  1053.             return kAudioUnitErr_InvalidScope;

  1054.        #endif

  1055. 

  1056.         case kAudioUnitProperty_MaximumFramesPerSlice:

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

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

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

  1060. 

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

  1062. 	            notifyListeners(inProp, inScope, inElement);

  1063. 

  1064.             return noErr;

  1065. 

  1066.         case kAudioUnitProperty_BypassEffect:

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

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

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

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

  1071.             {

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

  1073. 

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

  1075.                 {

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

  1077.                     fLastParameterValues[fBypassParameterIndex] = value;

  1078.                     fPlugin.setParameterValue(fBypassParameterIndex, value);

  1079. 	                notifyListeners(inProp, inScope, inElement);

  1080.                 }

  1081.             }

  1082.             return noErr;

  1083. 

  1084.         case kAudioUnitProperty_SetRenderCallback:

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

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

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

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

  1089.             // TODO

  1090.             return noErr;

  1091. 

  1092.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1093.         case kAudioUnitProperty_HostCallbacks:

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

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

  1096.             {

  1097.                 const UInt32 usableDataSize = std::min(inDataSize, static_cast<UInt32>(sizeof(HostCallbackInfo)));

  1098. 		        const bool changed = std::memcmp(&fHostCallbackInfo, inData, usableDataSize) != 0;

  1099. 

  1100. 		        std::memcpy(&fHostCallbackInfo, inData, usableDataSize);

  1101. 

  1102.                 if (sizeof(HostCallbackInfo) > usableDataSize)

  1103. 		            std::memset(&fHostCallbackInfo + usableDataSize, 0, sizeof(HostCallbackInfo) - usableDataSize);

  1104. 

  1105.                 if (changed)

  1106.                     notifyListeners(inProp, inScope, inElement);

  1107.             }

  1108.             return noErr;

  1109.        #endif

  1110. 

  1111.         case kAudioUnitProperty_PresentPreset:

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

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

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

  1115.             {

  1116.                 CFRelease(fCurrentPreset.presetName);

  1117.                 std::memcpy(&fCurrentPreset, inData, sizeof(AUPreset));

  1118.             }

  1119.             return noErr;

  1120. 

  1121.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1122.         case kAudioUnitProperty_MIDIOutputCallback:

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

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

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

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

  1127.             return noErr;

  1128.        #endif

  1129. 

  1130.         case 'DPFi':

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

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

  1133.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(uint16_t), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1134.             {

  1135.                 const uint16_t magic = *static_cast<const uint16_t*>(inData);

  1136. 

  1137.                 if (magic != 1337)

  1138.                     return noErr;

  1139. 

  1140.                #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1141.                 notifyListeners('DPFo', kAudioUnitScope_Global, 0);

  1142.                #endif

  1143. 

  1144.                #if DISTRHO_PLUGIN_WANT_STATE

  1145.                 for (uint32_t i=0; i<fStateCount; ++i)

  1146.                     notifyListeners('DPFs', kAudioUnitScope_Global, i);

  1147.                #endif

  1148. 

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

  1150.                     notifyListeners('DPFp', kAudioUnitScope_Global, i);

  1151.             }

  1152.             return noErr;

  1153. 

  1154.         case 'DPFe':

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

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

  1157.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(uint8_t), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1158.             {

  1159.                 const uint8_t flag = *static_cast<const uint8_t*>(inData);

  1160. 

  1161.                 if (flag != 1 && flag != 2)

  1162.                     return noErr;

  1163. 

  1164.                 AudioUnitEvent event;

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

  1166. 

  1167.                 event.mEventType                        = flag == 1 ? kAudioUnitEvent_BeginParameterChangeGesture

  1168.                                                                     : kAudioUnitEvent_EndParameterChangeGesture;

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

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

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

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

  1173.             }

  1174.             return noErr;

  1175. 

  1176.         case 'DPFp':

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

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

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

  1180.             {

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

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

  1183. 

  1184.                 if (d_isEqual(fLastParameterValues[inElement], value))

  1185.                     return noErr;

  1186. 

  1187.                 fLastParameterValues[inElement] = value;

  1188.                 fPlugin.setParameterValue(inElement, value);

  1189. 

  1190.                 AudioUnitEvent event;

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

  1192. 

  1193.                 event.mEventType                        = kAudioUnitEvent_ParameterValueChange;

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

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

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

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

  1198. 

  1199.                 if (fBypassParameterIndex == inElement)

  1200. 	                notifyListeners(kAudioUnitProperty_BypassEffect, kAudioUnitScope_Global, 0);

  1201.             }

  1202.             return noErr;

  1203. 

  1204.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1205.         case 'DPFn':

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

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

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

  1209.            #if DISTRHO_PLUGIN_HAS_UI

  1210.             {

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

  1212. 

  1213.                 if (midiData[0] == 0)

  1214.                     return noErr;

  1215. 

  1216.                 fNotesRingBuffer.writeCustomData(midiData, 3);

  1217.                 fNotesRingBuffer.commitWrite();

  1218.             }

  1219.            #endif

  1220.             return noErr;

  1221.        #endif

  1222. 

  1223.        #if DISTRHO_PLUGIN_WANT_STATE

  1224.         case 'DPFs':

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

  1226.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inElement < fStateCount, inElement, kAudioUnitErr_InvalidElement);

  1227.             DISTRHO_SAFE_ASSERT_UINT_RETURN(inDataSize == sizeof(CFStringRef), inDataSize, kAudioUnitErr_InvalidPropertyValue);

  1228.             {

  1229.                 const CFStringRef valueRef = *static_cast<const CFStringRef*>(inData);

  1230.                 DISTRHO_SAFE_ASSERT_RETURN(valueRef != nullptr && CFGetTypeID(valueRef) == CFStringGetTypeID(),

  1231.                                            kAudioUnitErr_InvalidPropertyValue);

  1232. 

  1233.                 const CFIndex valueLen = CFStringGetLength(valueRef);

  1234.                 char* const value = static_cast<char*>(std::malloc(valueLen + 1));

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

  1236.                 DISTRHO_SAFE_ASSERT_RETURN(CFStringGetCString(valueRef, value, valueLen + 1, kCFStringEncodingUTF8),

  1237.                                            kAudioUnitErr_InvalidPropertyValue);

  1238. 

  1239.                 const String& key(fPlugin.getStateKey(inElement));

  1240. 

  1241.                 // save this key as needed

  1242.                 if (fPlugin.wantStateKey(key))

  1243.                     fStateMap[key] = value;

  1244. 

  1245.                 fPlugin.setState(key, value);

  1246. 

  1247.                 CFRelease(valueRef);

  1248.                 std::free(value);

  1249.             }

  1250.             return noErr;

  1251.        #endif

  1252.         }

  1253. 

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

  1255.         return kAudioUnitErr_InvalidProperty;

  1256.     }

  1257. 

  1258.     OSStatus auAddPropertyListener(const AudioUnitPropertyID prop,

  1259.                                    const AudioUnitPropertyListenerProc proc,

  1260.                                    void* const userData)

  1261.     {

  1262.         const PropertyListener pl = {

  1263.             prop, proc, userData

  1264.         };

  1265. 

  1266.         if (fPropertyListeners.empty())

  1267.             fPropertyListeners.reserve(32);

  1268. 

  1269.         fPropertyListeners.push_back(pl);

  1270.         return noErr;

  1271.     }

  1272. 

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

  1274.     {

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

  1276.         {

  1277.             const PropertyListener& pl(*it);

  1278. 

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

  1280.             {

  1281.                 fPropertyListeners.erase(it);

  1282.                 return auRemovePropertyListener(prop, proc);

  1283.             }

  1284.         }

  1285. 

  1286.         return noErr;

  1287.     }

  1288. 

  1289.     OSStatus auRemovePropertyListenerWithUserData(const AudioUnitPropertyID prop,

  1290.                                                   const AudioUnitPropertyListenerProc proc,

  1291.                                                   void* const userData)

  1292.     {

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

  1294.         {

  1295.             const PropertyListener& pl(*it);

  1296. 

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

  1298.             {

  1299.                 fPropertyListeners.erase(it);

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

  1301.             }

  1302.         }

  1303. 

  1304.         return noErr;

  1305.     }

  1306. 

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

  1308.     {

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

  1310.         // TODO

  1311.         return noErr;

  1312.     }

  1313. 

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

  1315.     {

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

  1317.         // TODO

  1318.         return noErr;

  1319.     }

  1320. 

  1321.     OSStatus auGetParameter(const AudioUnitParameterID param,

  1322.                             const AudioUnitScope scope,

  1323.                             const AudioUnitElement elem,

  1324.                             AudioUnitParameterValue* const value)

  1325.     {

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

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

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

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

  1330. 

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

  1332.         return noErr;

  1333.     }

  1334. 

  1335.     OSStatus auSetParameter(const AudioUnitParameterID param,

  1336.                             const AudioUnitScope scope,

  1337.                             const AudioUnitElement elem,

  1338.                             const AudioUnitParameterValue value,

  1339.                             UInt32 /* bufferOffset */)

  1340.     {

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

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

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

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

  1345. 

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

  1347.         {

  1348.             fLastParameterValues[param] = value;

  1349.             fPlugin.setParameterValue(param, value);

  1350. 

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

  1352.             notifyListeners('DPFp', kAudioUnitScope_Global, param);

  1353. 

  1354.             if (fBypassParameterIndex == elem)

  1355.                 notifyListeners(kAudioUnitProperty_BypassEffect, kAudioUnitScope_Global, 0);

  1356.         }

  1357. 

  1358.         return noErr;

  1359.     }

  1360. 

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

  1362.     {

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

  1364.         {

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

  1366. 

  1367.             if (event.eventType == kParameterEvent_Immediate)

  1368.             {

  1369.                 auSetParameter(event.parameter,

  1370.                                event.scope,

  1371.                                event.element,

  1372.                                event.eventValues.immediate.value,

  1373.                                event.eventValues.immediate.bufferOffset);

  1374.             }

  1375.             else

  1376.             {

  1377.                 // TODO?

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

  1379.             }

  1380.         }

  1381.         return noErr;

  1382.     }

  1383. 

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

  1385.     {

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

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

  1388. 

  1389.         if (fPlugin.isActive())

  1390.         {

  1391.             fPlugin.deactivate();

  1392.             fPlugin.activate();

  1393.         }

  1394. 

  1395.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1396.         fMidiEventCount = 0;

  1397.        #endif

  1398.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1399.         fMidiOutputPackets.numPackets = 0;

  1400.        #endif

  1401.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1402.         fTimePosition.clear();

  1403.        #endif

  1404.         return noErr;

  1405.     }

  1406. 

  1407.     OSStatus auRender(AudioUnitRenderActionFlags* const ioActionFlags,

  1408.                       const AudioTimeStamp* const inTimeStamp,

  1409.                       const UInt32 inBusNumber,

  1410.                       const UInt32 inFramesToProcess,

  1411.                       AudioBufferList& ioData)

  1412.     {

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

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

  1415. 

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

  1417.         {

  1418.             setLastRenderError(kAudioUnitErr_TooManyFramesToProcess);

  1419.             return kAudioUnitErr_TooManyFramesToProcess;

  1420.         }

  1421. 

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

  1423.         {

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

  1425. 

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

  1427.             if (buffer.mData == nullptr)

  1428.             {

  1429.                 return noErr;

  1430.             }

  1431. 

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

  1433.         }

  1434. 

  1435.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1436.         const float* inputs[DISTRHO_PLUGIN_NUM_INPUTS];

  1437. 

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

  1439.         {

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

  1441.         }

  1442.        #else

  1443.         constexpr const float** inputs = nullptr;

  1444.        #endif

  1445. 

  1446.        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1447.         float* outputs[DISTRHO_PLUGIN_NUM_OUTPUTS];

  1448. 

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

  1450.         {

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

  1452.         }

  1453.        #else

  1454.         constexpr float** outputs = nullptr;

  1455.        #endif

  1456. 

  1457.         run(inputs, outputs, inFramesToProcess, inTimeStamp);

  1458. 

  1459.         if (ioActionFlags != nullptr)

  1460.         {

  1461.             // TODO what now?

  1462.         }

  1463. 

  1464.         return noErr;

  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.         // TODO

  1483.         switch (inStatus)

  1484.         {

  1485.         case 0x80:

  1486.         case 0x90:

  1487.         case 0xA0:

  1488.         case 0xB0:

  1489.         case 0xD0:

  1490.         case 0xE0:

  1491.             midiEvent.size = 3;

  1492.             break;

  1493.         case 0xC0:

  1494.             midiEvent.size = 2;

  1495.             break;

  1496.         default:

  1497.             midiEvent.size = 1;

  1498.             break;

  1499.         }

  1500. 

  1501.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS == 0

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

  1503.         run(nullptr, nullptr, std::max(1u, inOffsetSampleFrame), nullptr);

  1504.        #endif

  1505. 

  1506.         return noErr;

  1507.     }

  1508. 

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

  1510.     {

  1511.         if (fMidiEventCount >= kMaxMidiEvents)

  1512.             return noErr;

  1513. 

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

  1515.         midiEvent.frame = fMidiEventCount != 1 ? fMidiEvents[fMidiEventCount - 1].frame : 0;

  1516.         midiEvent.size  = inLength;

  1517. 

  1518.         // FIXME who owns inData ??

  1519.         if (inLength > MidiEvent::kDataSize)

  1520.         {

  1521.             std::memset(midiEvent.data, 0, MidiEvent::kDataSize);

  1522.             midiEvent.dataExt = inData;

  1523.         }

  1524.         else

  1525.         {

  1526.             std::memcpy(midiEvent.data, inData, inLength);

  1527.         }

  1528. 

  1529.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS == 0

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

  1531.         run(nullptr, nullptr, 1, nullptr);

  1532.        #endif

  1533. 

  1534.         return noErr;

  1535.     }

  1536.    #endif

  1537. 

  1538.     // ----------------------------------------------------------------------------------------------------------------

  1539. 

  1540. private:

  1541.     PluginExporter fPlugin;

  1542. 

  1543.     // AU component

  1544.     const AudioUnit fComponent;

  1545. 

  1546.     // AUv2 related fields

  1547.     AUPreset fCurrentPreset;

  1548.     OSStatus fLastRenderError;

  1549.     PropertyListeners fPropertyListeners;

  1550.    #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1551.     Float64 fSampleRateForInput;

  1552.    #endif

  1553.    #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1554.     Float64 fSampleRateForOutput;

  1555.    #endif

  1556. 

  1557.     // Caching

  1558.     const uint32_t fParameterCount;

  1559.     float* fLastParameterValues;

  1560.     uint32_t fBypassParameterIndex;

  1561. 

  1562.   #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1563.     uint32_t fMidiEventCount;

  1564.     MidiEvent fMidiEvents[kMaxMidiEvents];

  1565.    #if DISTRHO_PLUGIN_HAS_UI

  1566.     SmallStackRingBuffer fNotesRingBuffer;

  1567.    #endif

  1568.   #endif

  1569. 

  1570.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1571.     AUMIDIOutputCallbackStruct fMidiOutput;

  1572.     MIDIPacketList fMidiOutputPackets;

  1573.    #endif

  1574. 

  1575.    #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1576.     uint32_t fCurrentProgram;

  1577.    #endif

  1578. 

  1579.    #if DISTRHO_PLUGIN_WANT_STATE

  1580.     const uint32_t fStateCount;

  1581.     StringMap fStateMap;

  1582.    #endif

  1583. 

  1584.    #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1585.     HostCallbackInfo fHostCallbackInfo;

  1586.     TimePosition fTimePosition;

  1587.    #endif

  1588. 

  1589.     // ----------------------------------------------------------------------------------------------------------------

  1590. 

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

  1592.     {

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

  1594.         {

  1595.             const PropertyListener& pl(*it);

  1596. 

  1597.             if (pl.prop == prop)

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

  1599.         }

  1600.     }

  1601. 

  1602.     void run(const float** inputs, float** outputs, const uint32_t frames, const AudioTimeStamp* const inTimeStamp)

  1603.     {

  1604.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT && DISTRHO_PLUGIN_HAS_UI

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

  1606.         {

  1607.             uint8_t midiData[3];

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

  1609. 

  1610.             while (fNotesRingBuffer.isDataAvailableForReading())

  1611.             {

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

  1613.                     break;

  1614. 

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

  1616.                 midiEvent.frame = frame;

  1617.                 midiEvent.size  = 3;

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

  1619. 

  1620.                 if (fMidiEventCount == kMaxMidiEvents)

  1621.                     break;

  1622.             }

  1623.         }

  1624.        #endif

  1625. 

  1626.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1627.         fMidiOutputPackets.numPackets = 0;

  1628.        #endif

  1629. 

  1630.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1631.         if (fHostCallbackInfo.beatAndTempoProc != nullptr ||

  1632.             fHostCallbackInfo.musicalTimeLocationProc != nullptr ||

  1633.             fHostCallbackInfo.transportStateProc != nullptr)

  1634.         {

  1635.             // reused values so we can check null and return value together

  1636.             Boolean b1 = false;

  1637.             Float32 f1 = 4.f; // initial value for beats per bar

  1638.             Float64 g1 = 0.0;

  1639.             Float64 g2 = 0.0;

  1640.             UInt32 u1 = 0.0;

  1641. 

  1642.             if (fHostCallbackInfo.musicalTimeLocationProc != nullptr

  1643.                 && fHostCallbackInfo.musicalTimeLocationProc(fHostCallbackInfo.hostUserData,

  1644.                                                              nullptr, &f1, &u1, nullptr) == noErr)

  1645.             {

  1646.                 fTimePosition.bbt.beatsPerBar = f1;

  1647.                 fTimePosition.bbt.beatType    = u1;

  1648.             }

  1649.             else

  1650.             {

  1651.                 fTimePosition.bbt.beatsPerBar = 4.f;

  1652.                 fTimePosition.bbt.beatType    = 4.f;

  1653.             }

  1654. 

  1655.             if (fHostCallbackInfo.beatAndTempoProc != nullptr

  1656.                 && fHostCallbackInfo.beatAndTempoProc(fHostCallbackInfo.hostUserData, &g1, &g2) == noErr)

  1657.             {

  1658.                 const double beat = static_cast<int32_t>(g1);

  1659. 

  1660.                 fTimePosition.bbt.valid = true;

  1661.                 fTimePosition.bbt.bar   = static_cast<int32_t>(beat / f1) + 1;

  1662.                 fTimePosition.bbt.beat  = static_cast<int32_t>(std::fmod(beat, f1)) + 1;

  1663.                 fTimePosition.bbt.tick  = std::fmod(g1, 1.0) * 1920.0;

  1664.                 fTimePosition.bbt.beatsPerMinute = g2;

  1665.             }

  1666.             else

  1667.             {

  1668.                 fTimePosition.bbt.valid = false;

  1669.                 fTimePosition.bbt.bar   = 1;

  1670.                 fTimePosition.bbt.beat  = 1;

  1671.                 fTimePosition.bbt.tick  = 0.0;

  1672.                 fTimePosition.bbt.beatsPerMinute = 120.0;

  1673.             }

  1674. 

  1675.             if (fHostCallbackInfo.transportStateProc != nullptr

  1676.                 && fHostCallbackInfo.transportStateProc(fHostCallbackInfo.hostUserData,

  1677.                                                         &b1, nullptr, &g1, nullptr, nullptr, nullptr) == noErr)

  1678.             {

  1679.                 fTimePosition.playing = b1;

  1680.                 fTimePosition.frame = static_cast<int64_t>(g1);

  1681.             }

  1682.             else

  1683.             {

  1684.                 fTimePosition.playing = false;

  1685.                 fTimePosition.frame = 0;

  1686.             }

  1687. 

  1688.             fTimePosition.bbt.barStartTick = fTimePosition.bbt.ticksPerBeat *

  1689.                                              fTimePosition.bbt.beatsPerBar *

  1690.                                              (fTimePosition.bbt.bar - 1);

  1691. 

  1692.             fPlugin.setTimePosition(fTimePosition);

  1693.         }

  1694.         else

  1695.         {

  1696.             d_stdout("no time");

  1697.         }

  1698.        #endif

  1699. 

  1700.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1701.         fPlugin.run(inputs, outputs, frames, fMidiEvents, fMidiEventCount);

  1702.         fMidiEventCount = 0;

  1703.        #else

  1704.         fPlugin.run(inputs, outputs, frames);

  1705.        #endif

  1706. 

  1707.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  1709.         {

  1710.             fMidiOutput.midiOutputCallback(fMidiOutput.userData,

  1711.                                            inTimeStamp,

  1712.                                            0,

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

  1714.         }

  1715.        #else

  1716.         // unused

  1717.         (void)inTimeStamp;

  1718.        #endif

  1719. 

  1720.         float value;

  1721.         AudioUnitEvent event;

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

  1723.         event.mEventType                      = kAudioUnitEvent_ParameterValueChange;

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

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

  1726. 

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

  1728.         {

  1729.             if (fPlugin.isParameterOutputOrTrigger(i))

  1730.             {

  1731.                 value = fPlugin.getParameterValue(i);

  1732. 

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

  1734.                     continue;

  1735. 

  1736.                 fLastParameterValues[i] = value;

  1737. 

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

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

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

  1741.                 notifyListeners('DPFp', kAudioUnitScope_Global, i);

  1742.             }

  1743.         }

  1744.     }

  1745. 

  1746.     void setLastRenderError(const OSStatus err)

  1747.     {

  1748.         if (fLastRenderError != noErr)

  1749.             return;

  1750. 

  1751.         fLastRenderError = err;

  1752.         notifyListeners(kAudioUnitProperty_LastRenderError, kAudioUnitScope_Global, 0);

  1753.     }

  1754. 

  1755.     // ----------------------------------------------------------------------------------------------------------------

  1756. 

  1757.     CFMutableDictionaryRef retrieveClassInfo()

  1758.     {

  1759.         CFMutableDictionaryRef clsInfo = CFDictionaryCreateMutable(nullptr,

  1760.                                                                    0,

  1761.                                                                    &kCFTypeDictionaryKeyCallBacks,

  1762.                                                                    &kCFTypeDictionaryValueCallBacks);

  1763.         SInt32 value;

  1764. 

  1765.         value = 0;

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

  1767.         {

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

  1769.             CFRelease(num);

  1770.         }

  1771. 

  1772.         value = kType;

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

  1774.         {

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

  1776.             CFRelease(num);

  1777.         }

  1778. 

  1779.         value = kSubType;

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

  1781.         {

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

  1783.             CFRelease(num);

  1784.         }

  1785. 

  1786.         value = kManufacturer;

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

  1788.         {

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

  1790.             CFRelease(num);

  1791.         }

  1792. 

  1793.         CFDictionarySetValue(clsInfo, CFSTR(kAUPresetNameKey), fCurrentPreset.presetName);

  1794. 

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

  1796.                                                                           0,

  1797.                                                                           &kCFTypeDictionaryKeyCallBacks,

  1798.                                                                           &kCFTypeDictionaryValueCallBacks))

  1799.         {

  1800.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1801.             const SInt32 program = fCurrentProgram;

  1802.             if (const CFNumberRef programRef = CFNumberCreate(nullptr, kCFNumberSInt32Type, &program))

  1803.             {

  1804.                CFDictionarySetValue(data, CFSTR("program"), programRef);

  1805.                CFRelease(programRef);

  1806.             }

  1807.            #endif

  1808. 

  1809.            #if DISTRHO_PLUGIN_WANT_FULL_STATE

  1810.             // Update current state

  1811.             for (StringMap::const_iterator cit=fStateMap.begin(), cite=fStateMap.end(); cit != cite; ++cit)

  1812.             {

  1813.                 const String& key(cit->first);

  1814.                 fStateMap[key] = fPlugin.getStateValue(key);

  1815.             }

  1816.            #endif

  1817. 

  1818.            #if DISTRHO_PLUGIN_WANT_STATE

  1819.             if (const CFMutableArrayRef statesRef = CFArrayCreateMutable(nullptr,

  1820.                                                                          fStateCount,

  1821.                                                                          &kCFTypeArrayCallBacks))

  1822.             {

  1823.                 for (StringMap::const_iterator cit=fStateMap.begin(), cite=fStateMap.end(); cit != cite; ++cit)

  1824.                 {

  1825.                     const String& key(cit->first);

  1826.                     const String& value(cit->second);

  1827. 

  1828.                    #if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS && ! DISTRHO_PLUGIN_HAS_UI

  1829.                     bool wantStateKey = true;

  1830. 

  1831.                     for (uint32_t i=0; i<fStateCount; ++i)

  1832.                     {

  1833.                         if (fPlugin.getStateKey(i) == key)

  1834.                         {

  1835.                             if (fPlugin.getStateHints(i) & kStateIsOnlyForUI)

  1836.                                 wantStateKey = false;

  1837. 

  1838.                             break;

  1839.                         }

  1840.                     }

  1841. 

  1842.                     if (! wantStateKey)

  1843.                         continue;

  1844.                    #endif

  1845. 

  1846.                     CFStringRef keyRef = CFStringCreateWithCString(nullptr, key, kCFStringEncodingASCII);

  1847.                     CFStringRef valueRef = CFStringCreateWithCString(nullptr, value, kCFStringEncodingUTF8);

  1848. 

  1849.                     if (CFDictionaryRef dictRef = CFDictionaryCreate(nullptr,

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

  1851.                                                                      reinterpret_cast<const void**>(&valueRef),

  1852.                                                                      1,

  1853.                                                                      &kCFTypeDictionaryKeyCallBacks,

  1854.                                                                      &kCFTypeDictionaryValueCallBacks))

  1855.                     {

  1856.                         CFArrayAppendValue(statesRef, dictRef);

  1857.                         CFRelease(dictRef);

  1858.                     }

  1859. 

  1860.                     CFRelease(keyRef);

  1861.                     CFRelease(valueRef);

  1862.                 }

  1863. 

  1864.                 CFDictionarySetValue(data, CFSTR("states"), statesRef);

  1865.                 CFRelease(statesRef);

  1866.             }

  1867.            #endif

  1868. 

  1869.             if (const CFMutableArrayRef paramsRef = CFArrayCreateMutable(nullptr,

  1870.                                                                          fParameterCount,

  1871.                                                                          &kCFTypeArrayCallBacks))

  1872.             {

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

  1874.                 {

  1875.                     if (fPlugin.isParameterOutputOrTrigger(i))

  1876.                         continue;

  1877. 

  1878.                     const float value = fPlugin.getParameterValue(i);

  1879. 

  1880.                     CFStringRef keyRef = CFStringCreateWithCString(nullptr,

  1881.                                                                    fPlugin.getParameterSymbol(i),

  1882.                                                                    kCFStringEncodingASCII);

  1883.                     CFNumberRef valueRef = CFNumberCreate(nullptr, kCFNumberFloat32Type, &value);

  1884. 

  1885.                     if (CFDictionaryRef dictRef = CFDictionaryCreate(nullptr,

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

  1887.                                                                      reinterpret_cast<const void**>(&valueRef),

  1888.                                                                      1,

  1889.                                                                      &kCFTypeDictionaryKeyCallBacks,

  1890.                                                                      &kCFTypeDictionaryValueCallBacks))

  1891.                     {

  1892.                         CFArrayAppendValue(paramsRef, dictRef);

  1893.                         CFRelease(dictRef);

  1894.                     }

  1895. 

  1896.                     CFRelease(keyRef);

  1897.                     CFRelease(valueRef);

  1898.                 }

  1899. 

  1900.                 CFDictionarySetValue(data, CFSTR("params"), paramsRef);

  1901.                 CFRelease(paramsRef);

  1902.             }

  1903. 

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

  1905.             CFRelease(data);

  1906.         }

  1907. 

  1908.         return clsInfo;

  1909.     }

  1910. 

  1911.     void restoreClassInfo(const CFDictionaryRef clsInfo)

  1912.     {

  1913.         CFDictionaryRef data = nullptr;

  1914.         DISTRHO_SAFE_ASSERT_RETURN(CFDictionaryGetValueIfPresent(clsInfo,

  1915.                                                                  CFSTR(kAUPresetDataKey),

  1916.                                                                  reinterpret_cast<const void**>(&data)),);

  1917.         DISTRHO_SAFE_ASSERT_RETURN(CFGetTypeID(data) == CFDictionaryGetTypeID(),);

  1918. 

  1919.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1920.         CFNumberRef programRef = nullptr;

  1921.         if (CFDictionaryGetValueIfPresent(data, CFSTR("program"), reinterpret_cast<const void**>(&programRef))

  1922.             && CFGetTypeID(programRef) == CFNumberGetTypeID())

  1923.         {

  1924.             SInt32 program = 0;

  1925.             if (CFNumberGetValue(programRef, kCFNumberSInt32Type, &program) && program >= 0)

  1926.             {

  1927.                 fCurrentProgram = program;

  1928.                 fPlugin.loadProgram(fCurrentProgram);

  1929.                 notifyListeners('DPFo', kAudioUnitScope_Global, 0);

  1930.             }

  1931.         }

  1932.        #endif

  1933. 

  1934.        #if DISTRHO_PLUGIN_WANT_STATE

  1935.         CFArrayRef statesRef = nullptr;

  1936.         if (CFDictionaryGetValueIfPresent(data, CFSTR("states"), reinterpret_cast<const void**>(&statesRef))

  1937.             && CFGetTypeID(statesRef) == CFArrayGetTypeID())

  1938.         {

  1939.             const CFIndex numStates = CFArrayGetCount(statesRef);

  1940.             char* key = nullptr;

  1941.             char* value = nullptr;

  1942.             CFIndex keyLen = -1;

  1943.             CFIndex valueLen = -1;

  1944. 

  1945.             for (CFIndex i=0; i<numStates; ++i)

  1946.             {

  1947.                 const CFDictionaryRef state = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(statesRef, i));

  1948.                 DISTRHO_SAFE_ASSERT_BREAK(CFGetTypeID(state) == CFDictionaryGetTypeID());

  1949.                 DISTRHO_SAFE_ASSERT_BREAK(CFDictionaryGetCount(state) == 1);

  1950. 

  1951.                 CFStringRef keyRef = nullptr;

  1952.                 CFStringRef valueRef = nullptr;

  1953.                 CFDictionaryGetKeysAndValues(state,

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

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

  1956.                 DISTRHO_SAFE_ASSERT_BREAK(keyRef != nullptr && CFGetTypeID(keyRef) == CFStringGetTypeID());

  1957.                 DISTRHO_SAFE_ASSERT_BREAK(valueRef != nullptr && CFGetTypeID(valueRef) == CFStringGetTypeID());

  1958. 

  1959.                 const CFIndex keyRefLen = CFStringGetLength(keyRef);

  1960.                 if (keyLen < keyRefLen)

  1961.                 {

  1962.                     keyLen = keyRefLen;

  1963.                     key = static_cast<char*>(std::realloc(key, keyLen + 1));

  1964.                 }

  1965.                 DISTRHO_SAFE_ASSERT_BREAK(CFStringGetCString(keyRef, key, keyLen + 1, kCFStringEncodingASCII));

  1966. 

  1967.                 if (! fPlugin.wantStateKey(key))

  1968.                     continue;

  1969. 

  1970.                 const CFIndex valueRefLen = CFStringGetLength(valueRef);

  1971.                 if (valueLen < valueRefLen)

  1972.                 {

  1973.                     valueLen = valueRefLen;

  1974.                     value = static_cast<char*>(std::realloc(value, valueLen + 1));

  1975.                 }

  1976.                 DISTRHO_SAFE_ASSERT_BREAK(CFStringGetCString(valueRef, value, valueLen + 1, kCFStringEncodingUTF8));

  1977. 

  1978.                 const String dkey(key);

  1979.                 fStateMap[dkey] = value;

  1980.                 fPlugin.setState(key, value);

  1981. 

  1982.                 for (uint32_t j=0; j<fStateCount; ++j)

  1983.                 {

  1984.                     if (fPlugin.getStateKey(j) == key)

  1985.                     {

  1986.                         if ((fPlugin.getStateHints(i) & kStateIsOnlyForDSP) == 0x0)

  1987.                             notifyListeners('DPFs', kAudioUnitScope_Global, j);

  1988. 

  1989.                         break;

  1990.                     }

  1991.                 }

  1992.             }

  1993. 

  1994.             std::free(key);

  1995.             std::free(value);

  1996.         }

  1997.        #endif

  1998. 

  1999.         CFArrayRef paramsRef = nullptr;

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

  2001.             && CFGetTypeID(paramsRef) == CFArrayGetTypeID())

  2002.         {

  2003.             const CFIndex numParams = CFArrayGetCount(paramsRef);

  2004.             char* symbol = nullptr;

  2005.             CFIndex symbolLen = -1;

  2006. 

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

  2008.             {

  2009.                 const CFDictionaryRef param = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(paramsRef, i));

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

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

  2012. 

  2013.                 CFStringRef keyRef = nullptr;

  2014.                 CFNumberRef valueRef = nullptr;

  2015.                 CFDictionaryGetKeysAndValues(param,

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

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

  2018.                 DISTRHO_SAFE_ASSERT_BREAK(keyRef != nullptr && CFGetTypeID(keyRef) == CFStringGetTypeID());

  2019.                 DISTRHO_SAFE_ASSERT_BREAK(valueRef != nullptr && CFGetTypeID(valueRef) == CFNumberGetTypeID());

  2020. 

  2021.                 float value = 0.f;

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

  2023. 

  2024.                 const CFIndex keyRefLen = CFStringGetLength(keyRef);

  2025.                 if (symbolLen < keyRefLen)

  2026.                 {

  2027.                     symbolLen = keyRefLen;

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

  2029.                 }

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

  2031. 

  2032.                 for (uint32_t j=0; j<fParameterCount; ++j)

  2033.                 {

  2034.                     if (fPlugin.isParameterOutputOrTrigger(j))

  2035.                         continue;

  2036.                     if (fPlugin.getParameterSymbol(j) != symbol)

  2037.                         continue;

  2038. 

  2039.                     fLastParameterValues[j] = value;

  2040.                     fPlugin.setParameterValue(j, value);

  2041.                     notifyListeners('DPFp', kAudioUnitScope_Global, j);

  2042. 

  2043.                     if (fBypassParameterIndex == j)

  2044.                         notifyListeners(kAudioUnitProperty_BypassEffect, kAudioUnitScope_Global, 0);

  2045. 

  2046.                     break;

  2047.                 }

  2048.             }

  2049. 

  2050.             std::free(symbol);

  2051.         }

  2052.     }

  2053. 

  2054.     // ----------------------------------------------------------------------------------------------------------------

  2055.     // DPF callbacks

  2056. 

  2057.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2058.     bool writeMidi(const MidiEvent& midiEvent)

  2059.     {

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

  2061. 

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

  2063.             return true;

  2064.         if (fMidiOutputPackets.numPackets == kMaxMidiEvents)

  2065.             return false;

  2066. 

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

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

  2069.         packet.timeStamp = midiEvent.frame;

  2070.         packet.length = midiEvent.size;

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

  2072.         return true;

  2073.     }

  2074. 

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

  2076.     {

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

  2078.     }

  2079.    #endif

  2080. 

  2081.    #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

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

  2083.     {

  2084.         AudioUnitEvent event;

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

  2086.         event.mEventType                        = kAudioUnitEvent_ParameterValueChange;

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

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

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

  2090. 

  2091.         fLastParameterValues[index] = value;

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

  2093.         notifyListeners('DPFp', kAudioUnitScope_Global, index);

  2094.         return true;

  2095.     }

  2096. 

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

  2098.     {

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

  2100.     }

  2101.    #endif

  2102. 

  2103.    #if DISTRHO_PLUGIN_WANT_STATE

  2104.     bool updateState(const char* const key, const char* const newValue)

  2105.     {

  2106.         fPlugin.setState(key, newValue);

  2107. 

  2108.         for (uint32_t i=0; i<fStateCount; ++i)

  2109.         {

  2110.             if (fPlugin.getStateKey(i) == key)

  2111.             {

  2112.                 const String dkey(key);

  2113.                 fStateMap[dkey] = newValue;

  2114. 

  2115.                 if ((fPlugin.getStateHints(i) & kStateIsOnlyForDSP) == 0x0)

  2116.                     notifyListeners('DPFs', kAudioUnitScope_Global, i);

  2117. 

  2118.                 return true;

  2119.             }

  2120.         }

  2121. 

  2122.         d_stderr("Failed to find plugin state with key \"%s\"", key);

  2123.         return false;

  2124.     }

  2125. 

  2126.     static bool updateStateValueCallback(void* const ptr, const char* const key, const char* const newValue)

  2127.     {

  2128.         return static_cast<PluginAU*>(ptr)->updateState(key, newValue);

  2129.     }

  2130.    #endif

  2131. 

  2132.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginAU)

  2133. };

  2134. 

  2135. // --------------------------------------------------------------------------------------------------------------------

  2136. 

  2137. struct AudioComponentPlugInInstance {

  2138. 	AudioComponentPlugInInterface acpi;

  2139.     PluginAU* plugin;

  2140. 

  2141.     AudioComponentPlugInInstance() noexcept

  2142.         : acpi(),

  2143.           plugin(nullptr)

  2144.     {

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

  2146.         acpi.Open = Open;

  2147. 		acpi.Close = Close;

  2148. 		acpi.Lookup = Lookup;

  2149. 		acpi.reserved = nullptr;

  2150.     }

  2151. 

  2152.     ~AudioComponentPlugInInstance()

  2153.     {

  2154.         delete plugin;

  2155.     }

  2156. 

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

  2158.     {

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

  2160.         return noErr;

  2161.     }

  2162. 

  2163. 	static OSStatus Close(void* const self)

  2164.     {

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

  2166.         return noErr;

  2167.     }

  2168. 

  2169.     static AudioComponentMethod Lookup(const SInt16 selector)

  2170.     {

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

  2172. 

  2173.         switch (selector)

  2174.         {

  2175.         case kAudioUnitInitializeSelect:

  2176.             return reinterpret_cast<AudioComponentMethod>(Initialize);

  2177.         case kAudioUnitUninitializeSelect:

  2178.             return reinterpret_cast<AudioComponentMethod>(Uninitialize);

  2179.         case kAudioUnitGetPropertyInfoSelect:

  2180.             return reinterpret_cast<AudioComponentMethod>(GetPropertyInfo);

  2181.         case kAudioUnitGetPropertySelect:

  2182.             return reinterpret_cast<AudioComponentMethod>(GetProperty);

  2183.         case kAudioUnitSetPropertySelect:

  2184.             return reinterpret_cast<AudioComponentMethod>(SetProperty);

  2185.         case kAudioUnitAddPropertyListenerSelect:

  2186.             return reinterpret_cast<AudioComponentMethod>(AddPropertyListener);

  2187.         case kAudioUnitRemovePropertyListenerSelect:

  2188.             return reinterpret_cast<AudioComponentMethod>(RemovePropertyListener);

  2189.         case kAudioUnitRemovePropertyListenerWithUserDataSelect:

  2190.             return reinterpret_cast<AudioComponentMethod>(RemovePropertyListenerWithUserData);

  2191.         case kAudioUnitAddRenderNotifySelect:

  2192.             return reinterpret_cast<AudioComponentMethod>(AddRenderNotify);

  2193.         case kAudioUnitRemoveRenderNotifySelect:

  2194.             return reinterpret_cast<AudioComponentMethod>(RemoveRenderNotify);

  2195.         case kAudioUnitGetParameterSelect:

  2196.             return reinterpret_cast<AudioComponentMethod>(GetParameter);

  2197.         case kAudioUnitSetParameterSelect:

  2198.             return reinterpret_cast<AudioComponentMethod>(SetParameter);

  2199.         case kAudioUnitScheduleParametersSelect:

  2200.             return reinterpret_cast<AudioComponentMethod>(ScheduleParameters);

  2201.         case kAudioUnitRenderSelect:

  2202.             return reinterpret_cast<AudioComponentMethod>(Render);

  2203.         /*

  2204.         case kAudioUnitComplexRenderSelect:

  2205.             return reinterpret_cast<AudioComponentMethod>(ComplexRender);

  2206.         */

  2207.         case kAudioUnitResetSelect:

  2208.             return reinterpret_cast<AudioComponentMethod>(Reset);

  2209.         /*

  2210.         case kAudioUnitProcessSelect:

  2211.             return reinterpret_cast<AudioComponentMethod>(Process);

  2212.         case kAudioUnitProcessMultipleSelect:

  2213.             return reinterpret_cast<AudioComponentMethod>(ProcessMultiple);

  2214.         */

  2215.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2216.         case kMusicDeviceMIDIEventSelect:

  2217.             return reinterpret_cast<AudioComponentMethod>(MIDIEvent);

  2218.         case kMusicDeviceSysExSelect:

  2219.             return reinterpret_cast<AudioComponentMethod>(SysEx);

  2220.        #else

  2221.         case kMusicDeviceMIDIEventSelect:

  2222.         case kMusicDeviceSysExSelect:

  2223.             return nullptr;

  2224.        #endif

  2225.         }

  2226. 

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

  2228.         return nullptr;

  2229.     }

  2230. 

  2231.     static OSStatus Initialize(AudioComponentPlugInInstance* const self)

  2232.     {

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

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

  2235.     }

  2236. 

  2237.     static OSStatus Uninitialize(AudioComponentPlugInInstance* const self)

  2238.     {

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

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

  2241.     }

  2242. 

  2243.     static OSStatus GetPropertyInfo(AudioComponentPlugInInstance* const self,

  2244.                                     const AudioUnitPropertyID inProp,

  2245.                                     const AudioUnitScope inScope,

  2246.                                     const AudioUnitElement inElement,

  2247.                                     UInt32* const outDataSize,

  2248.                                     Boolean* const outWritable)

  2249.     {

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

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

  2252. 

  2253. 		UInt32 dataSize = 0;

  2254. 		Boolean writable = false;

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

  2256. 

  2257. 		if (outDataSize != nullptr)

  2258. 			*outDataSize = dataSize;

  2259. 

  2260. 		if (outWritable != nullptr)

  2261. 			*outWritable = writable;

  2262. 

  2263.         return res;

  2264.     }

  2265. 

  2266.     static OSStatus GetProperty(AudioComponentPlugInInstance* const self,

  2267.                                 const AudioUnitPropertyID inProp,

  2268.                                 const AudioUnitScope inScope,

  2269.                                 const AudioUnitElement inElement,

  2270.                                 void* const outData,

  2271.                                 UInt32* const ioDataSize)

  2272.     {

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

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

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

  2276. 

  2277.         Boolean writable;

  2278.         UInt32 outDataSize = 0;

  2279.         OSStatus res;

  2280. 

  2281.         if (outData == nullptr)

  2282.         {

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

  2284.             *ioDataSize = outDataSize;

  2285.             return res;

  2286.         }

  2287. 

  2288.         const UInt32 inDataSize = *ioDataSize;

  2289.         if (inDataSize == 0)

  2290.             return kAudio_ParamError;

  2291. 

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

  2293. 

  2294.         if (res != noErr)

  2295.             return res;

  2296. 

  2297. 		void* outBuffer;

  2298.         uint8_t* tmpBuffer;

  2299.         if (inDataSize < outDataSize)

  2300. 		{

  2301. 			tmpBuffer = new uint8_t[outDataSize];

  2302. 			outBuffer = tmpBuffer;

  2303. 		}

  2304.         else

  2305.         {

  2306. 			tmpBuffer = nullptr;

  2307. 			outBuffer = outData;

  2308. 		}

  2309. 

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

  2311. 

  2312. 		if (res != noErr)

  2313.         {

  2314. 			*ioDataSize = 0;

  2315.             return res;

  2316.         }

  2317. 

  2318.         if (tmpBuffer != nullptr)

  2319.         {

  2320.             memcpy(outData, tmpBuffer, inDataSize);

  2321.             delete[] tmpBuffer;

  2322.         }

  2323.         else

  2324.         {

  2325.             *ioDataSize = outDataSize;

  2326.         }

  2327. 

  2328.         return noErr;

  2329.     }

  2330. 

  2331.     static OSStatus SetProperty(AudioComponentPlugInInstance* const self,

  2332.                                 const AudioUnitPropertyID inProp,

  2333.                                 const AudioUnitScope inScope,

  2334.                                 const AudioUnitElement inElement,

  2335.                                 const void* const inData,

  2336.                                 const UInt32 inDataSize)

  2337.     {

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

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

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

  2341.     }

  2342. 

  2343.     static OSStatus AddPropertyListener(AudioComponentPlugInInstance* const self,

  2344.                                         const AudioUnitPropertyID prop,

  2345.                                         const AudioUnitPropertyListenerProc proc,

  2346.                                         void* const userData)

  2347.     {

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

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

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

  2351.     }

  2352. 

  2353.     static OSStatus RemovePropertyListener(AudioComponentPlugInInstance* const self,

  2354.                                            const AudioUnitPropertyID prop,

  2355.                                            const AudioUnitPropertyListenerProc proc)

  2356.     {

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

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

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

  2360.     }

  2361. 

  2362.     static OSStatus RemovePropertyListenerWithUserData(AudioComponentPlugInInstance* const self,

  2363.                                                        const AudioUnitPropertyID prop,

  2364.                                                        const AudioUnitPropertyListenerProc proc,

  2365.                                                        void* const userData)

  2366.     {

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

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

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

  2370.     }

  2371. 

  2372.     static OSStatus AddRenderNotify(AudioComponentPlugInInstance* const self,

  2373.                                     const AURenderCallback proc,

  2374.                                     void* const userData)

  2375.     {

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

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

  2378.     }

  2379. 

  2380.     static OSStatus RemoveRenderNotify(AudioComponentPlugInInstance* const self,

  2381.                                        const AURenderCallback proc,

  2382.                                        void* const userData)

  2383.     {

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

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

  2386.     }

  2387. 

  2388.     static OSStatus GetParameter(AudioComponentPlugInInstance* const self,

  2389.                                  const AudioUnitParameterID param,

  2390.                                  const AudioUnitScope scope,

  2391.                                  const AudioUnitElement elem,

  2392.                                  AudioUnitParameterValue* const value)

  2393.     {

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

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

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

  2397.     }

  2398. 

  2399.     static OSStatus SetParameter(AudioComponentPlugInInstance* const self,

  2400.                                  const AudioUnitParameterID param,

  2401.                                  const AudioUnitScope scope,

  2402.                                  const AudioUnitElement elem,

  2403.                                  const AudioUnitParameterValue value,

  2404.                                  const UInt32 bufferOffset)

  2405.     {

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

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

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

  2409.     }

  2410. 

  2411.     static OSStatus ScheduleParameters(AudioComponentPlugInInstance* const self,

  2412.                                        const AudioUnitParameterEvent* const events,

  2413.                                        const UInt32 numEvents)

  2414.     {

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

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

  2417.     }

  2418. 

  2419.     static OSStatus Reset(AudioComponentPlugInInstance* const self,

  2420.                           const AudioUnitScope scope,

  2421.                           const AudioUnitElement elem)

  2422.     {

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

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

  2425.     }

  2426. 

  2427.     static OSStatus Render(AudioComponentPlugInInstance* const self,

  2428.                            AudioUnitRenderActionFlags* ioActionFlags,

  2429.                            const AudioTimeStamp* const inTimeStamp,

  2430.                            const UInt32 inOutputBusNumber,

  2431.                            const UInt32 inNumberFrames,

  2432.                            AudioBufferList* const ioData)

  2433.     {

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

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

  2436. 

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

  2438.     }

  2439. 

  2440.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2441.     static OSStatus MIDIEvent(AudioComponentPlugInInstance* const self,

  2442.                               const UInt32 inStatus,

  2443.                               const UInt32 inData1,

  2444.                               const UInt32 inData2,

  2445.                               const UInt32 inOffsetSampleFrame)

  2446.     {

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

  2448.     }

  2449. 

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

  2451.     {

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

  2453.     }

  2454.    #endif

  2455. 

  2456.     DISTRHO_DECLARE_NON_COPYABLE(AudioComponentPlugInInstance)

  2457. };

  2458. 

  2459. // --------------------------------------------------------------------------------------------------------------------

  2460. 

  2461. END_NAMESPACE_DISTRHO

  2462. 

  2463. DISTRHO_PLUGIN_EXPORT

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

  2465. {

  2466.     USE_NAMESPACE_DISTRHO

  2467. 

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

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

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

  2471. 

  2472.     if (d_nextBufferSize == 0)

  2473.         d_nextBufferSize = 1156;

  2474. 

  2475.     if (d_isZero(d_nextSampleRate))

  2476.         d_nextSampleRate = 44100.0;

  2477. 

  2478.     if (d_nextBundlePath == nullptr)

  2479.     {

  2480.         static String bundlePath;

  2481. 

  2482.         String tmpPath(getBinaryFilename());

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

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

  2485. 

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

  2487.         {

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

  2489.             bundlePath = tmpPath;

  2490.         }

  2491.         else

  2492.         {

  2493.             bundlePath = "error";

  2494.         }

  2495. 

  2496.         d_nextBundlePath = bundlePath.buffer();

  2497.     }

  2498. 

  2499.     d_nextCanRequestParameterValueChanges = true;

  2500. 

  2501.     return new AudioComponentPlugInInstance();

  2502. }

  2503. 

  2504. // --------------------------------------------------------------------------------------------------------------------