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

3242 lines
129KB
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. // - report latency changes

  21. 

  22. #include "DistrhoPluginInternal.hpp"

  23. #include "../DistrhoPluginUtils.hpp"

  24. 

  25. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  27. #endif

  28. 

  29. #include <AudioUnit/AudioUnit.h>

  30. #include <AudioToolbox/AudioUnitUtilities.h>

  31. 

  32. #include <map>

  33. #include <vector>

  34. 

  35. #ifndef DISTRHO_PLUGIN_BRAND_ID

  36. # error DISTRHO_PLUGIN_BRAND_ID undefined!

  37. #endif

  38. 

  39. #ifndef DISTRHO_PLUGIN_UNIQUE_ID

  40. # error DISTRHO_PLUGIN_UNIQUE_ID undefined!

  41. #endif

  42. 

  43. START_NAMESPACE_DISTRHO

  44. 

  45. // --------------------------------------------------------------------------------------------------------------------

  46. 

  47. #ifndef __MAC_12_3

  48. enum {

  49.     kAudioUnitProperty_MIDIOutputBufferSizeHint = 66,

  50. };

  51. #endif

  52. 

  53. // --------------------------------------------------------------------------------------------------------------------

  54. 

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

  56. {

  57.     switch (prop)

  58.     {

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

  60.     PROP(kAudioUnitProperty_ClassInfo)

  61.     PROP(kAudioUnitProperty_MakeConnection)

  62.     PROP(kAudioUnitProperty_SampleRate)

  63.     PROP(kAudioUnitProperty_ParameterList)

  64.     PROP(kAudioUnitProperty_ParameterInfo)

  65.    #if !TARGET_OS_IPHONE

  66.     PROP(kAudioUnitProperty_FastDispatch)

  67.    #endif

  68.     PROP(kAudioUnitProperty_CPULoad)

  69.     PROP(kAudioUnitProperty_StreamFormat)

  70.     PROP(kAudioUnitProperty_ElementCount)

  71.     PROP(kAudioUnitProperty_Latency)

  72.     PROP(kAudioUnitProperty_SupportedNumChannels)

  73.     PROP(kAudioUnitProperty_MaximumFramesPerSlice)

  74.     PROP(kAudioUnitProperty_ParameterValueStrings)

  75.     PROP(kAudioUnitProperty_AudioChannelLayout)

  76.     PROP(kAudioUnitProperty_TailTime)

  77.     PROP(kAudioUnitProperty_BypassEffect)

  78.     PROP(kAudioUnitProperty_LastRenderError)

  79.     PROP(kAudioUnitProperty_SetRenderCallback)

  80.     PROP(kAudioUnitProperty_FactoryPresets)

  81.     PROP(kAudioUnitProperty_RenderQuality)

  82.     PROP(kAudioUnitProperty_HostCallbacks)

  83.     PROP(kAudioUnitProperty_InPlaceProcessing)

  84.     PROP(kAudioUnitProperty_ElementName)

  85.     PROP(kAudioUnitProperty_SupportedChannelLayoutTags)

  86.     PROP(kAudioUnitProperty_PresentPreset)

  87.     PROP(kAudioUnitProperty_DependentParameters)

  88.     PROP(kAudioUnitProperty_InputSamplesInOutput)

  89.     PROP(kAudioUnitProperty_ShouldAllocateBuffer)

  90.     PROP(kAudioUnitProperty_FrequencyResponse)

  91.     PROP(kAudioUnitProperty_ParameterHistoryInfo)

  92.     PROP(kAudioUnitProperty_NickName)

  93.     PROP(kAudioUnitProperty_OfflineRender)

  94.     PROP(kAudioUnitProperty_ParameterIDName)

  95.     PROP(kAudioUnitProperty_ParameterStringFromValue)

  96.     PROP(kAudioUnitProperty_ParameterClumpName)

  97.     PROP(kAudioUnitProperty_ParameterValueFromString)

  98.     PROP(kAudioUnitProperty_PresentationLatency)

  99.     PROP(kAudioUnitProperty_ClassInfoFromDocument)

  100.     PROP(kAudioUnitProperty_RequestViewController)

  101.     PROP(kAudioUnitProperty_ParametersForOverview)

  102.     PROP(kAudioUnitProperty_SupportsMPE)

  103.     PROP(kAudioUnitProperty_RenderContextObserver)

  104.     PROP(kAudioUnitProperty_LastRenderSampleTime)

  105.     PROP(kAudioUnitProperty_LoadedOutOfProcess)

  106.    #if !TARGET_OS_IPHONE

  107.     PROP(kAudioUnitProperty_SetExternalBuffer)

  108.     PROP(kAudioUnitProperty_GetUIComponentList)

  109.     PROP(kAudioUnitProperty_CocoaUI)

  110.     PROP(kAudioUnitProperty_IconLocation)

  111.     PROP(kAudioUnitProperty_AUHostIdentifier)

  112.    #endif

  113.     PROP(kAudioUnitProperty_MIDIOutputCallbackInfo)

  114.     PROP(kAudioUnitProperty_MIDIOutputCallback)

  115.     PROP(kAudioUnitProperty_MIDIOutputEventListCallback)

  116.     PROP(kAudioUnitProperty_AudioUnitMIDIProtocol)

  117.     PROP(kAudioUnitProperty_HostMIDIProtocol)

  118.     PROP(kAudioUnitProperty_MIDIOutputBufferSizeHint)

  119.     PROP(kMusicDeviceProperty_DualSchedulingMode)

  120.     #undef PROP

  121.     // DPF specific properties

  122.     #define PROPX(s) (s[0] << 24) | (s[1] << 16) | (s[2] << 8) | (s[3] << 0)

  123.     #define PROP(s) case PROPX(#s): return #s;

  124.     PROP(DPFi)

  125.     PROP(DPFe)

  126.     PROP(DPFp)

  127.     PROP(DPFn)

  128.     PROP(DPFo)

  129.     PROP(DPFl)

  130.     PROP(DPFs)

  131.     PROP(DPFa)

  132.     #undef PROP

  133.     #undef PROPX

  134.     }

  135.     return "[unknown]";

  136. }

  137. 

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

  139. {

  140.     switch (scope)

  141.     {

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

  143.     SCOPE(kAudioUnitScope_Global)

  144.     SCOPE(kAudioUnitScope_Input)

  145.     SCOPE(kAudioUnitScope_Output)

  146.     SCOPE(kAudioUnitScope_Group)

  147.     SCOPE(kAudioUnitScope_Part)

  148.     SCOPE(kAudioUnitScope_Note)

  149.     SCOPE(kAudioUnitScope_Layer)

  150.     SCOPE(kAudioUnitScope_LayerItem)

  151.     #undef SCOPE

  152.     }

  153.     return "[unknown]";

  154. }

  155. 

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

  157. {

  158.     switch (selector)

  159.     {

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

  161.     SEL(kAudioUnitInitializeSelect)

  162.     SEL(kAudioUnitUninitializeSelect)

  163.     SEL(kAudioUnitGetPropertyInfoSelect)

  164.     SEL(kAudioUnitGetPropertySelect)

  165.     SEL(kAudioUnitSetPropertySelect)

  166.     SEL(kAudioUnitAddPropertyListenerSelect)

  167.     SEL(kAudioUnitRemovePropertyListenerSelect)

  168.     SEL(kAudioUnitRemovePropertyListenerWithUserDataSelect)

  169.     SEL(kAudioUnitAddRenderNotifySelect)

  170.     SEL(kAudioUnitRemoveRenderNotifySelect)

  171.     SEL(kAudioUnitGetParameterSelect)

  172.     SEL(kAudioUnitSetParameterSelect)

  173.     SEL(kAudioUnitScheduleParametersSelect)

  174.     SEL(kAudioUnitRenderSelect)

  175.     SEL(kAudioUnitResetSelect)

  176.     SEL(kAudioUnitComplexRenderSelect)

  177.     SEL(kAudioUnitProcessSelect)

  178.     SEL(kAudioUnitProcessMultipleSelect)

  179.     SEL(kMusicDeviceMIDIEventSelect)

  180.     SEL(kMusicDeviceSysExSelect)

  181.     SEL(kMusicDevicePrepareInstrumentSelect)

  182.     SEL(kMusicDeviceReleaseInstrumentSelect)

  183.     SEL(kMusicDeviceStartNoteSelect)

  184.     SEL(kMusicDeviceStopNoteSelect)

  185.     SEL(kMusicDeviceMIDIEventListSelect)

  186.     SEL(kAudioOutputUnitStartSelect)

  187.     SEL(kAudioOutputUnitStopSelect)

  188.     #undef SEL

  189.     }

  190.     return "[unknown]";

  191. }

  192. 

  193. #if 0

  194. static OSStatus FastDispatchGetParameter(void*, AudioUnitParameterID, AudioUnitScope, AudioUnitElement, Float32*);

  195. static OSStatus FastDispatchSetParameter(void*, AudioUnitParameterID, AudioUnitScope, AudioUnitElement, Float32, UInt32);

  196. static OSStatus FastDispatchRender(void*, AudioUnitRenderActionFlags*, const AudioTimeStamp*, UInt32, UInt32, AudioBufferList*);

  197. #endif

  198. 

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

  200. 

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

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

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

  204. 

  205. static constexpr const uint32_t kWantedAudioFormat = kAudioFormatFlagsNativeFloatPacked

  206.                                                    | kAudioFormatFlagIsNonInterleaved;

  207. 

  208. 

  209. // --------------------------------------------------------------------------------------------------------------------

  210. // clang `std::max` is not constexpr compatible, we need to define our own

  211. 

  212. template<typename T>

  213. static inline constexpr T d_max(const T a, const T b) { return a > b ? a : b; }

  214. 

  215. // --------------------------------------------------------------------------------------------------------------------

  216. 

  217. static constexpr const AUChannelInfo kChannelInfo[] = {

  218.     { DISTRHO_PLUGIN_NUM_INPUTS, DISTRHO_PLUGIN_NUM_OUTPUTS },

  219.    #ifdef DISTRHO_PLUGIN_EXTRA_IO

  220.     DISTRHO_PLUGIN_EXTRA_IO

  221.    #endif

  222. };

  223. 

  224. #ifdef DISTRHO_PLUGIN_EXTRA_IO

  225. #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  226. #error DISTRHO_PLUGIN_EXTRA_IO defined but no IO available

  227. #endif

  228. 

  229. static inline

  230. bool isInputNumChannelsValid(const uint16_t numChannels)

  231. {

  232.     for (uint16_t i = 0; i < ARRAY_SIZE(kChannelInfo); ++i)

  233.     {

  234.         if (kChannelInfo[i].inChannels == numChannels)

  235.             return true;

  236.     }

  237.     return false;

  238. }

  239. 

  240. static inline

  241. bool isOutputNumChannelsValid(const uint16_t numChannels)

  242. {

  243.     for (uint16_t i = 0; i < ARRAY_SIZE(kChannelInfo); ++i)

  244.     {

  245.         if (kChannelInfo[i].outChannels == numChannels)

  246.             return true;

  247.     }

  248.     return false;

  249. }

  250. 

  251. static inline

  252. bool isNumChannelsComboValid(const uint16_t numInputs, const uint16_t numOutputs)

  253. {

  254.     for (uint16_t i = 0; i < ARRAY_SIZE(kChannelInfo); ++i)

  255.     {

  256.         if (kChannelInfo[i].inChannels == numInputs && kChannelInfo[i].outChannels == numOutputs)

  257.             return true;

  258.     }

  259.     return false;

  260. }

  261. #endif

  262. 

  263. // --------------------------------------------------------------------------------------------------------------------

  264. 

  265. struct PropertyListener {

  266.     AudioUnitPropertyID	prop;

  267.     AudioUnitPropertyListenerProc proc;

  268.     void* userData;

  269. };

  270. 

  271. struct RenderListener {

  272.     AURenderCallback proc;

  273.     void* userData;

  274. };

  275. 

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

  277. typedef std::vector<RenderListener> RenderListeners;

  278. 

  279. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  280. // useful definitions

  281. static constexpr const uint32_t kMIDIPacketNonDataSize = sizeof(MIDIPacket) - sizeof(MIDIPacket::data);

  282. static constexpr const uint32_t kMIDIPacketListNonDataSize = sizeof(MIDIPacketList) - sizeof(MIDIPacketList::packet);

  283. 

  284. // size of data used for midi events

  285. static constexpr const uint32_t kMIDIPacketListMaxDataSize = kMIDIPacketNonDataSize * kMaxMidiEvents

  286.                                                            + sizeof(Byte) * MidiEvent::kDataSize * kMaxMidiEvents;

  287. 

  288. // size of midi list + data

  289. static constexpr const uint32_t kMIDIPacketListSize = kMIDIPacketListNonDataSize + kMIDIPacketListMaxDataSize;

  290. #endif

  291. 

  292. // --------------------------------------------------------------------------------------------------------------------

  293. 

  294. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  295. static constexpr const writeMidiFunc writeMidiCallback = nullptr;

  296. #endif

  297. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  298. static constexpr const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  299. #endif

  300. #if ! DISTRHO_PLUGIN_WANT_STATE

  301. static constexpr const updateStateValueFunc updateStateValueCallback = nullptr;

  302. #endif

  303. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  304. static constexpr const double kDefaultTicksPerBeat = 1920.0;

  305. #endif

  306. 

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

  308. 

  309. // --------------------------------------------------------------------------------------------------------------------

  310. 

  311. class PluginAU

  312. {

  313. public:

  314.     PluginAU(const AudioUnit component)

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

  316.           fComponent(component),

  317.           fLastRenderError(noErr),

  318.           fPropertyListeners(),

  319.           fRenderListeners(),

  320.         #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  321.           fInputConnectionBus(0),

  322.           fInputConnectionUnit(nullptr),

  323.           fSampleRateForInput(d_nextSampleRate),

  324.          #ifdef DISTRHO_PLUGIN_EXTRA_IO

  325.           fNumInputs(DISTRHO_PLUGIN_NUM_INPUTS),

  326.          #endif

  327.         #endif

  328.         #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  329.           fSampleRateForOutput(d_nextSampleRate),

  330.          #ifdef DISTRHO_PLUGIN_EXTRA_IO

  331.           fNumOutputs(DISTRHO_PLUGIN_NUM_OUTPUTS),

  332.          #endif

  333.         #endif

  334.          #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  335.           fAudioBufferList(nullptr),

  336.          #endif

  337.           fUsingRenderListeners(false),

  338.           fParameterCount(fPlugin.getParameterCount()),

  339.           fLastParameterValues(nullptr),

  340.           fBypassParameterIndex(UINT32_MAX)

  341.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  342.         , fMidiEventCount(0)

  343.        #endif

  344.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  345.         , fMidiOutputDataOffset(0)

  346.        #endif

  347.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  348.         , fCurrentProgram(-1)

  349.         , fLastFactoryProgram(0)

  350.         , fProgramCount(fPlugin.getProgramCount())

  351.         , fFactoryPresetsData(nullptr)

  352.        #endif

  353.        #if DISTRHO_PLUGIN_WANT_STATE

  354.         , fStateCount(fPlugin.getStateCount())

  355.        #endif

  356.     {

  357. 	    if (fParameterCount != 0)

  358.         {

  359.             fLastParameterValues = new float[fParameterCount];

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

  361. 

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

  363.             {

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

  365. 

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

  367.                     fBypassParameterIndex = i;

  368.             }

  369.         }

  370. 

  371.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  372.         std::memset(&fInputRenderCallback, 0, sizeof(fInputRenderCallback));

  373.         fInputRenderCallback.inputProc = nullptr;

  374.         fInputRenderCallback.inputProcRefCon = nullptr;

  375.        #endif

  376. 

  377.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  379.        #endif

  380. 

  381.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  382.         if ((fMidiOutputPackets = static_cast<MIDIPacketList*>(std::malloc(kMIDIPacketListSize))) != nullptr)

  383.             std::memset(fMidiOutputPackets, 0, kMIDIPacketListSize);

  384. 

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

  386.        #endif

  387. 

  388.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  389.         if (fProgramCount != 0)

  390.         {

  391.             fFactoryPresetsData = new AUPreset[fProgramCount];

  392.             std::memset(fFactoryPresetsData, 0, sizeof(AUPreset) * fProgramCount);

  393. 

  394.             for (uint32_t i=0; i<fProgramCount; ++i)

  395.             {

  396.                 fFactoryPresetsData[i].presetNumber = i;

  397. 

  398.                 if (const CFStringRef nameRef = CFStringCreateWithCString(nullptr,

  399.                                                                           fPlugin.getProgramName(i),

  400.                                                                           kCFStringEncodingUTF8))

  401.                     fFactoryPresetsData[i].presetName = nameRef;

  402.                 else

  403.                     fFactoryPresetsData[i].presetName = CFSTR("");

  404.             }

  405.         }

  406.         else

  407.         {

  408.             fFactoryPresetsData = new AUPreset;

  409.             std::memset(fFactoryPresetsData, 0, sizeof(AUPreset));

  410. 

  411.             fFactoryPresetsData->presetNumber = 0;

  412.             fFactoryPresetsData->presetName = CFSTR("Default");

  413.         }

  414.        #endif

  415. 

  416.         fUserPresetData.presetNumber = -1;

  417.         fUserPresetData.presetName = CFSTR("");

  418. 

  419.        #if DISTRHO_PLUGIN_WANT_STATE

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

  421.         {

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

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

  424.         }

  425.        #endif

  426. 

  427.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

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

  429.         fTimePosition.bbt.ticksPerBeat = kDefaultTicksPerBeat;

  430.        #endif

  431.     }

  432. 

  433.     ~PluginAU()

  434.     {

  435.         delete[] fLastParameterValues;

  436.         CFRelease(fUserPresetData.presetName);

  437. 

  438.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  439.         reallocAudioBufferList(false);

  440.        #endif

  441. 

  442.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  443.         std::free(fMidiOutputPackets);

  444.        #endif

  445. 

  446.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  447.         for (uint32_t i=0; i<fProgramCount; ++i)

  448.             CFRelease(fFactoryPresetsData[i].presetName);

  449.         delete[] fFactoryPresetsData;

  450.        #endif

  451.     }

  452. 

  453.     OSStatus auInitialize()

  454.     {

  455.        #if defined(DISTRHO_PLUGIN_EXTRA_IO) && DISTRHO_PLUGIN_NUM_INPUTS != 0 && DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  456.         if (! isNumChannelsComboValid(fNumInputs, fNumOutputs))

  457.             return kAudioUnitErr_FormatNotSupported;

  458.        #endif

  459. 

  460.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  461.         if (! reallocAudioBufferList(true))

  462.             return kAudio_ParamError;

  463.        #endif

  464. 

  465.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  466.         fMidiEventCount = 0;

  467.        #endif

  468.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  469.         fMidiOutputDataOffset = 0;

  470.         fMidiOutputPackets->numPackets = 0;

  471.        #endif

  472.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  473.         fTimePosition.clear();

  474.         fTimePosition.bbt.ticksPerBeat = kDefaultTicksPerBeat;

  475.        #endif

  476. 

  477.         fPlugin.activate();

  478.         return noErr;

  479.     }

  480. 

  481.     OSStatus auUninitialize()

  482.     {

  483.         fPlugin.deactivateIfNeeded();

  484. 

  485.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  486.         reallocAudioBufferList(false);

  487.        #endif

  488.         return noErr;

  489.     }

  490. 

  491.     OSStatus auGetPropertyInfo(const AudioUnitPropertyID inProp,

  492.                                const AudioUnitScope inScope,

  493.                                const AudioUnitElement inElement,

  494.                                UInt32& outDataSize,

  495.                                Boolean& outWritable)

  496.     {

  497.         switch (inProp)

  498.         {

  499.         case kAudioUnitProperty_ClassInfo:

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

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

  502.             outDataSize = sizeof(CFPropertyListRef);

  503.             outWritable = true;

  504.             return noErr;

  505. 

  506.         case kAudioUnitProperty_MakeConnection:

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

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

  509.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  510.             outDataSize = sizeof(AudioUnitConnection);

  511.             outWritable = true;

  512.             return noErr;

  513.            #else

  514.             return kAudioUnitErr_InvalidProperty;

  515.            #endif

  516. 

  517.         case kAudioUnitProperty_SampleRate:

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

  519.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  520.             if (inScope == kAudioUnitScope_Input)

  521.             {

  522.                 outDataSize = sizeof(Float64);

  523.                 outWritable = true;

  524.                 return noErr;

  525.             }

  526.            #endif

  527.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  528.             if (inScope == kAudioUnitScope_Output)

  529.             {

  530.                 outDataSize = sizeof(Float64);

  531.                 outWritable = true;

  532.                 return noErr;

  533.             }

  534.            #endif

  535.             return kAudioUnitErr_InvalidScope;

  536. 

  537.         case kAudioUnitProperty_ParameterList:

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

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

  540.             outWritable = false;

  541.             return noErr;

  542. 

  543.         case kAudioUnitProperty_ParameterInfo:

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

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

  546.             outDataSize = sizeof(AudioUnitParameterInfo);

  547.             outWritable = false;

  548.             return noErr;

  549. 

  550.        #if 0

  551.         case kAudioUnitProperty_FastDispatch:

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

  553.             outDataSize = sizeof(void*);

  554.             outWritable = false;

  555.             return noErr;

  556.        #endif

  557. 

  558.         case kAudioUnitProperty_StreamFormat:

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

  560.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  561.             if (inScope == kAudioUnitScope_Input)

  562.             {

  563.                 outDataSize = sizeof(AudioStreamBasicDescription);

  564.                 outWritable = true;

  565.                 return noErr;

  566.             }

  567.            #endif

  568.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  569.             if (inScope == kAudioUnitScope_Output)

  570.             {

  571.                 outDataSize = sizeof(AudioStreamBasicDescription);

  572.                 outWritable = true;

  573.                 return noErr;

  574.             }

  575.            #endif

  576.             return kAudioUnitErr_InvalidScope;

  577. 

  578.         case kAudioUnitProperty_ElementCount:

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

  580.             outDataSize = sizeof(UInt32);

  581.             outWritable = false;

  582.             return noErr;

  583. 

  584.         case kAudioUnitProperty_Latency:

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

  586.            #if DISTRHO_PLUGIN_WANT_LATENCY

  587.             if (inScope == kAudioUnitScope_Global)

  588.             {

  589.                 outDataSize = sizeof(Float64);

  590.                 outWritable = false;

  591.                 return noErr;

  592.             }

  593.            #endif

  594.             return kAudioUnitErr_InvalidProperty;

  595. 

  596.         case kAudioUnitProperty_SupportedNumChannels:

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

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

  599.             outDataSize = sizeof(kChannelInfo);

  600.             outWritable = false;

  601.             return noErr;

  602. 

  603.         case kAudioUnitProperty_MaximumFramesPerSlice:

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

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

  606.             outDataSize = sizeof(UInt32);

  607.             outWritable = true;

  608.             return noErr;

  609. 

  610.         case kAudioUnitProperty_BypassEffect:

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

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

  613.             {

  614.                 outDataSize = sizeof(UInt32);

  615.                 outWritable = true;

  616.                 return noErr;

  617.             }

  618.             return kAudioUnitErr_InvalidProperty;

  619. 

  620.         case kAudioUnitProperty_LastRenderError:

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

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

  623.             outDataSize = sizeof(OSStatus);

  624.             outWritable = false;

  625.             return noErr;

  626. 

  627.         case kAudioUnitProperty_SetRenderCallback:

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

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

  630.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  631.             outDataSize = sizeof(AURenderCallbackStruct);

  632.             outWritable = true;

  633.             return noErr;

  634.            #else

  635.             return kAudioUnitErr_InvalidProperty;

  636.            #endif

  637. 

  638.         case kAudioUnitProperty_FactoryPresets:

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

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

  641.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  642.             outDataSize = sizeof(CFArrayRef);

  643.             outWritable = false;

  644.             return noErr;

  645.            #else

  646.             return kAudioUnitErr_InvalidProperty;

  647.            #endif

  648. 

  649.         case kAudioUnitProperty_HostCallbacks:

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

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

  652.            #if DISTRHO_PLUGIN_WANT_TIMEPOS

  653.             outDataSize = sizeof(HostCallbackInfo);

  654.             outWritable = false;

  655.             return noErr;

  656.            #else

  657.             return kAudioUnitErr_InvalidProperty;

  658.            #endif

  659. 

  660.         case kAudioUnitProperty_InPlaceProcessing:

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

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

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

  664.             outDataSize = sizeof(UInt32);

  665.             outWritable = false;

  666.             return noErr;

  667.            #else

  668.             return kAudioUnitErr_InvalidProperty;

  669.            #endif

  670. 

  671.         case kAudioUnitProperty_PresentPreset:

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

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

  674.             outDataSize = sizeof(AUPreset);

  675.             outWritable = true;

  676.             return noErr;

  677. 

  678.         case kAudioUnitProperty_CocoaUI:

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

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

  681.            #if DISTRHO_PLUGIN_HAS_UI

  682.             outDataSize = sizeof(AudioUnitCocoaViewInfo);

  683.             outWritable = false;

  684.             return noErr;

  685.            #else

  686.             return kAudioUnitErr_InvalidProperty;

  687.            #endif

  688. 

  689.         case kAudioUnitProperty_MIDIOutputCallbackInfo:

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

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

  692.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  693.             outDataSize = sizeof(CFArrayRef);

  694.             outWritable = false;

  695.             return noErr;

  696.            #else

  697.             return kAudioUnitErr_InvalidProperty;

  698.            #endif

  699. 

  700.         case kAudioUnitProperty_MIDIOutputCallback:

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

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

  703.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  704.             outDataSize = sizeof(AUMIDIOutputCallbackStruct);

  705.             outWritable = true;

  706.             return noErr;

  707.            #else

  708.             return kAudioUnitErr_InvalidProperty;

  709.            #endif

  710. 

  711.         case kAudioUnitProperty_AudioUnitMIDIProtocol:

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

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

  714.             // FIXME implement the event list stuff

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

  716.             outDataSize = sizeof(SInt32);

  717.             outWritable = false;

  718.             return noErr;

  719.            #else

  720.             return kAudioUnitErr_InvalidProperty;

  721.            #endif

  722. 

  723.         case 'DPFi':

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

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

  726.             outDataSize = sizeof(uint16_t);

  727.             outWritable = false;

  728.             return noErr;

  729. 

  730.         case 'DPFe':

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

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

  733.             outDataSize = sizeof(uint8_t);

  734.             outWritable = true;

  735.             return noErr;

  736. 

  737.         case 'DPFp':

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

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

  740.             outDataSize = sizeof(float);

  741.             outWritable = true;

  742.             return noErr;

  743. 

  744.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  745.         case 'DPFn':

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

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

  748.             outDataSize = sizeof(uint8_t) * 3;

  749.             outWritable = true;

  750.             return noErr;

  751.        #endif

  752. 

  753.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  754.         case 'DPFo':

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

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

  757.             outDataSize = sizeof(uint32_t);

  758.             outWritable = false;

  759.             return noErr;

  760.        #endif

  761. 

  762.        #if DISTRHO_PLUGIN_WANT_STATE

  763.         case 'DPFl':

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

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

  766.             outDataSize = sizeof(CFArrayRef);

  767.             outWritable = false;

  768.             return noErr;

  769. 

  770.         case 'DPFs':

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

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

  773.             outDataSize = sizeof(CFStringRef);

  774.             outWritable = true;

  775.             return noErr;

  776.        #endif

  777. 

  778.        #if DISTRHO_PLUGIN_HAS_UI && DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  779.         case 'DPFa':

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

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

  782.             outDataSize = sizeof(void*);

  783.             outWritable = false;

  784.             return noErr;

  785.        #endif

  786. 

  787.         // unwanted properties

  788.         case kAudioUnitProperty_CPULoad:

  789.         case kAudioUnitProperty_RenderContextObserver:

  790.         case kAudioUnitProperty_AudioChannelLayout:

  791.         case kAudioUnitProperty_TailTime:

  792.         case kAudioUnitProperty_SupportedChannelLayoutTags:

  793.         case kMusicDeviceProperty_DualSchedulingMode:

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

  795.             return kAudioUnitErr_InvalidProperty;

  796.         }

  797. 

  798.         d_stdout("TODO GetPropertyInfo(%d:%x:%s, %d:%s, %d, ...)",

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

  800.         return kAudioUnitErr_InvalidProperty;

  801.     }

  802. 

  803.     OSStatus auGetProperty(const AudioUnitPropertyID inProp,

  804.                            const AudioUnitScope inScope,

  805.                            const AudioUnitElement inElement,

  806.                            void* const outData)

  807.     {

  808.         switch (inProp)

  809.         {

  810.         case kAudioUnitProperty_ClassInfo:

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

  812.             return noErr;

  813. 

  814.         case kAudioUnitProperty_SampleRate:

  815.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  816.             if (inScope == kAudioUnitScope_Input)

  817.             {

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

  819.             }

  820.             else

  821.            #endif

  822.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  823.             if (inScope == kAudioUnitScope_Output)

  824.             {

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

  826.             }

  827.             else

  828.            #endif

  829.             {

  830.                 return kAudioUnitErr_InvalidScope;

  831.             }

  832.             return noErr;

  833. 

  834.         case kAudioUnitProperty_ParameterList:

  835.             {

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

  837. 

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

  839.                     paramList[i] = i;

  840.             }

  841.             return noErr;

  842. 

  843.         case kAudioUnitProperty_ParameterInfo:

  844.             {

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

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

  847. 

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

  849. 

  850.                 info->flags = kAudioUnitParameterFlag_IsHighResolution

  851.                             | kAudioUnitParameterFlag_IsReadable

  852.                             | kAudioUnitParameterFlag_HasCFNameString;

  853. 

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

  855.                 {

  856.                     info->flags |= kAudioUnitParameterFlag_IsWritable;

  857.                     info->unit = kAudioUnitParameterUnit_Boolean;

  858. 

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

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

  861.                 }

  862.                 else

  863.                 {

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

  865. 

  866.                     info->flags |= kAudioUnitParameterFlag_CFNameRelease;

  867. 

  868.                     if (hints & kParameterIsOutput)

  869.                     {

  870.                         info->flags |= kAudioUnitParameterFlag_MeterReadOnly;

  871.                     }

  872.                     else

  873.                     {

  874.                         info->flags |= kAudioUnitParameterFlag_IsWritable;

  875. 

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

  877.                             info->flags |= kAudioUnitParameterFlag_NonRealTime;

  878.                     }

  879. 

  880.                     if (hints & kParameterIsBoolean)

  881.                         info->unit = kAudioUnitParameterUnit_Boolean;

  882.                     else if (hints & kParameterIsInteger)

  883.                         info->unit = kAudioUnitParameterUnit_Indexed;

  884.                     else

  885.                         info->unit = kAudioUnitParameterUnit_Generic;

  886. 

  887.                     // | kAudioUnitParameterFlag_ValuesHaveStrings;

  888. 

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

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

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

  892.                 }

  893. 

  894.                 info->minValue = ranges.min;

  895.                 info->maxValue = ranges.max;

  896.                 info->defaultValue = ranges.def;

  897.             }

  898.             return noErr;

  899. 

  900.        #if 0

  901.         case kAudioUnitProperty_FastDispatch:

  902.             switch (inElement)

  903.             {

  904. 			case kAudioUnitGetParameterSelect:

  905.                 *static_cast<AudioUnitGetParameterProc*>(outData) = FastDispatchGetParameter;

  906.                 return noErr;

  907. 			case kAudioUnitSetParameterSelect:

  908.                 *static_cast<AudioUnitSetParameterProc*>(outData) = FastDispatchSetParameter;

  909.                 return noErr;

  910. 			case kAudioUnitRenderSelect:

  911.                 *static_cast<AudioUnitRenderProc*>(outData) = FastDispatchRender;

  912.                 return noErr;

  913.             }

  914.             d_stdout("WIP FastDispatch(%d:%x:%s)", inElement, inElement, AudioUnitPropertyID2Str(inElement));

  915.             return kAudioUnitErr_InvalidElement;

  916.        #endif

  917. 

  918.         case kAudioUnitProperty_StreamFormat:

  919.             {

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

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

  922. 

  923.                 if (inElement != 0)

  924.                     return kAudioUnitErr_InvalidElement;

  925. 

  926.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  927.                 if (inScope == kAudioUnitScope_Input)

  928.                 {

  929.                    #ifdef DISTRHO_PLUGIN_EXTRA_IO

  930.                     desc->mChannelsPerFrame = fNumInputs;

  931.                    #else

  932.                     desc->mChannelsPerFrame = DISTRHO_PLUGIN_NUM_INPUTS;

  933.                    #endif

  934.                 }

  935.                 else

  936.                #endif

  937.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  938.                 if (inScope == kAudioUnitScope_Output)

  939.                 {

  940.                    #ifdef DISTRHO_PLUGIN_EXTRA_IO

  941.                     desc->mChannelsPerFrame = fNumOutputs;

  942.                    #else

  943.                     desc->mChannelsPerFrame = DISTRHO_PLUGIN_NUM_OUTPUTS;

  944.                    #endif

  945.                 }

  946.                 else

  947.                #endif

  948.                 {

  949.                     return kAudioUnitErr_InvalidScope;

  950.                 }

  951. 

  952.                 desc->mFormatID         = kAudioFormatLinearPCM;

  953.                 desc->mFormatFlags      = kWantedAudioFormat;

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

  955.                 desc->mBitsPerChannel   = 32;

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

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

  958.                 desc->mFramesPerPacket  = 1;

  959.             }

  960.             return noErr;

  961. 

  962.         case kAudioUnitProperty_ElementCount:

  963.             switch (inScope)

  964.             {

  965.             case kAudioUnitScope_Global:

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

  967.                 break;

  968.             case kAudioUnitScope_Input:

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

  970.                 break;

  971.             case kAudioUnitScope_Output:

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

  973.                 break;

  974.             default:

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

  976.                 break;

  977.             }

  978.             return noErr;

  979. 

  980.        #if DISTRHO_PLUGIN_WANT_LATENCY

  981.         case kAudioUnitProperty_Latency:

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

  983.             return noErr;

  984.        #endif

  985. 

  986.         case kAudioUnitProperty_SupportedNumChannels:

  987.             std::memcpy(outData, kChannelInfo, sizeof(kChannelInfo));

  988.             return noErr;

  989. 

  990.         case kAudioUnitProperty_MaximumFramesPerSlice:

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

  992.             return noErr;

  993. 

  994.         case kAudioUnitProperty_LastRenderError:

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

  996.             fLastRenderError = noErr;

  997.             return noErr;

  998. 

  999.         case kAudioUnitProperty_BypassEffect:

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

  1001.             return noErr;

  1002. 

  1003.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1004.         case kAudioUnitProperty_SetRenderCallback:

  1005.             std::memcpy(outData, &fInputRenderCallback, sizeof(AURenderCallbackStruct));

  1006.             return noErr;

  1007.        #endif

  1008. 

  1009.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1010.         case kAudioUnitProperty_FactoryPresets:

  1011.             if (const CFMutableArrayRef presetsRef = CFArrayCreateMutable(nullptr, fProgramCount, nullptr))

  1012.             {

  1013.                 for (uint32_t i=0; i<fProgramCount; ++i)

  1014.                     CFArrayAppendValue(presetsRef, &fFactoryPresetsData[i]);

  1015. 

  1016.                 *static_cast<CFArrayRef*>(outData) = presetsRef;

  1017.                 return noErr;

  1018.             }

  1019.             return kAudio_ParamError;

  1020.        #endif

  1021. 

  1022.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1023.         case kAudioUnitProperty_HostCallbacks:

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

  1025.             return noErr;

  1026.        #endif

  1027. 

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

  1029.         case kAudioUnitProperty_InPlaceProcessing:

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

  1031.             return noErr;

  1032.        #endif

  1033. 

  1034.         case kAudioUnitProperty_PresentPreset:

  1035.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1036.             if (fCurrentProgram >= 0)

  1037.             {

  1038.                 std::memcpy(outData, &fFactoryPresetsData[fCurrentProgram], sizeof(AUPreset));

  1039.             }

  1040.             else

  1041.            #endif

  1042.             {

  1043.                 std::memcpy(outData, &fUserPresetData, sizeof(AUPreset));

  1044.             }

  1045.             return noErr;

  1046. 

  1047.        #if DISTRHO_PLUGIN_HAS_UI

  1048.         case kAudioUnitProperty_CocoaUI:

  1049.             {

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

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

  1052. 

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

  1054.                     initWithBytes:d_nextBundlePath

  1055.                            length:strlen(d_nextBundlePath)

  1056.                          encoding:NSUTF8StringEncoding];

  1057. 

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

  1059. 

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

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

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

  1063. 

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

  1065.                                                                             DISTRHO_PLUGIN_UNIQUE_ID,

  1066.                                                                             DISTRHO_PLUGIN_BRAND_ID));

  1067. 

  1068.                 #undef MACRO_STR

  1069.                 #undef MACRO_STR2

  1070.                 #undef MACRO_STR3

  1071. 

  1072.                 [bundlePathString release];

  1073.             }

  1074.             return noErr;

  1075.        #endif

  1076. 

  1077.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1078.         case kAudioUnitProperty_MIDIOutputCallbackInfo:

  1079.             {

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

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

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

  1083.                                                                    1,

  1084.                                                                    &kCFTypeArrayCallBacks);

  1085.             }

  1086.             return noErr;

  1087.        #endif

  1088. 

  1089.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT || DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1090.         /* FIXME implement the event list stuff

  1091.         case kAudioUnitProperty_AudioUnitMIDIProtocol:

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

  1093.             return noErr;

  1094.         */

  1095.        #endif

  1096. 

  1097.         case 'DPFp':

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

  1099.             return noErr;

  1100. 

  1101.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1102.         case 'DPFo':

  1103.             *static_cast<uint32_t*>(outData) = fLastFactoryProgram;

  1104.             return noErr;

  1105.        #endif

  1106. 

  1107.        #if DISTRHO_PLUGIN_WANT_STATE

  1108.         case 'DPFl':

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

  1110.                                                                        fStateCount,

  1111.                                                                        &kCFTypeArrayCallBacks))

  1112.             {

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

  1114.                 {

  1115.                     const CFStringRef keyRef = CFStringCreateWithCString(nullptr,

  1116.                                                                          fPlugin.getStateKey(i),

  1117.                                                                          kCFStringEncodingASCII);

  1118.                     CFArrayAppendValue(keysRef, keyRef);

  1119.                     CFRelease(keyRef);

  1120.                 }

  1121. 

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

  1123.                 return noErr;

  1124.             }

  1125.             return kAudio_ParamError;

  1126. 

  1127.         case 'DPFs':

  1128.             {

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

  1130.                #if DISTRHO_PLUGIN_WANT_FULL_STATE

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

  1132.                #endif

  1133. 

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

  1135.                                                                                 fStateMap[key],

  1136.                                                                                 kCFStringEncodingUTF8);

  1137.             }

  1138.             return noErr;

  1139.        #endif

  1140. 

  1141.        #if DISTRHO_PLUGIN_HAS_UI && DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1142.         case 'DPFa':

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

  1144.             return noErr;

  1145.        #endif

  1146.         }

  1147. 

  1148.         d_stdout("TODO GetProperty(%d:%x:%s, %d:%s, %d, ...)",

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

  1150.         return kAudioUnitErr_InvalidProperty;

  1151.     }

  1152. 

  1153.     OSStatus auSetProperty(const AudioUnitPropertyID inProp,

  1154.                            const AudioUnitScope inScope,

  1155.                            const AudioUnitElement inElement,

  1156.                            const void* const inData,

  1157.                            const UInt32 inDataSize)

  1158.     {

  1159.         switch (inProp)

  1160.         {

  1161.         case kAudioUnitProperty_ClassInfo:

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

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

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

  1165.             {

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

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

  1168. 

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

  1170.             }

  1171.             return noErr;

  1172. 

  1173.         case kAudioUnitProperty_MakeConnection:

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

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

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

  1177.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1178.             {

  1179.                 const AudioUnitConnection conn = *static_cast<const AudioUnitConnection*>(inData);

  1180. 

  1181.                 if (conn.sourceAudioUnit == nullptr)

  1182.                 {

  1183.                     fInputConnectionBus = 0;

  1184.                     fInputConnectionUnit = nullptr;

  1185.                     return noErr;

  1186.                 }

  1187. 

  1188.                 AudioStreamBasicDescription desc;

  1189.                 std::memset(&desc, 0, sizeof(desc));

  1190.                 UInt32 dataSize = sizeof(AudioStreamBasicDescription);

  1191.                 if (AudioUnitGetProperty(conn.sourceAudioUnit,

  1192.                                          kAudioUnitProperty_StreamFormat,

  1193.                                          kAudioUnitScope_Output,

  1194.                                          conn.sourceOutputNumber, &desc, &dataSize) != noErr)

  1195.                     return kAudioUnitErr_InvalidPropertyValue;

  1196. 

  1197.                 DISTRHO_SAFE_ASSERT_INT_RETURN(desc.mFormatID == kAudioFormatLinearPCM,

  1198.                                                desc.mFormatID, kAudioUnitErr_FormatNotSupported);

  1199.                 DISTRHO_SAFE_ASSERT_INT_RETURN(desc.mBitsPerChannel == 32,

  1200.                                                desc.mBitsPerChannel, kAudioUnitErr_FormatNotSupported);

  1201.                 DISTRHO_SAFE_ASSERT_INT_RETURN(desc.mBytesPerFrame == sizeof(float),

  1202.                                                desc.mBytesPerFrame, kAudioUnitErr_FormatNotSupported);

  1203.                 DISTRHO_SAFE_ASSERT_INT_RETURN(desc.mBytesPerPacket == sizeof(float),

  1204.                                                desc.mBytesPerPacket, kAudioUnitErr_FormatNotSupported);

  1205.                 DISTRHO_SAFE_ASSERT_INT_RETURN(desc.mFramesPerPacket == 1,

  1206.                                                desc.mFramesPerPacket, kAudioUnitErr_FormatNotSupported);

  1207.                 DISTRHO_SAFE_ASSERT_INT_RETURN(desc.mFormatFlags == kWantedAudioFormat,

  1208.                                                desc.mFormatFlags, kAudioUnitErr_FormatNotSupported);

  1209.                #ifdef DISTRHO_PLUGIN_EXTRA_IO

  1210.                 DISTRHO_SAFE_ASSERT_UINT_RETURN(desc.mChannelsPerFrame == fNumInputs,

  1211.                                                 desc.mChannelsPerFrame, kAudioUnitErr_FormatNotSupported);

  1212.                #else

  1213.                 DISTRHO_SAFE_ASSERT_UINT_RETURN(desc.mChannelsPerFrame == DISTRHO_PLUGIN_NUM_INPUTS,

  1214.                                                 desc.mChannelsPerFrame, kAudioUnitErr_FormatNotSupported);

  1215.                #endif

  1216. 

  1217.                 fInputConnectionBus = conn.sourceOutputNumber;

  1218.                 fInputConnectionUnit = conn.sourceAudioUnit;

  1219.             }

  1220.             return noErr;

  1221.            #else

  1222.             return kAudioUnitErr_PropertyNotInUse;

  1223.            #endif

  1224. 

  1225.         case kAudioUnitProperty_SampleRate:

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

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

  1228.            #elif DISTRHO_PLUGIN_NUM_OUTPUTS != 0

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

  1230.            #else

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

  1232.            #endif

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

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

  1235.             {

  1236.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0 || DISTRHO_PLUGIN_NUM_OUTPUTS != 0

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

  1238.                #endif

  1239. 

  1240.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1241.                 if (inScope == kAudioUnitScope_Input)

  1242.                 {

  1243.                     if (d_isNotEqual(fSampleRateForInput, sampleRate))

  1244.                     {

  1245.                         fSampleRateForInput = sampleRate;

  1246.                         d_nextSampleRate = sampleRate;

  1247. 

  1248.                        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1249.                         if (d_isEqual(fSampleRateForOutput, sampleRate))

  1250.                        #endif

  1251.                         {

  1252.                             fPlugin.setSampleRate(sampleRate, true);

  1253.                         }

  1254. 

  1255.                         notifyPropertyListeners(inProp, inScope, inElement);

  1256.                     }

  1257.                     return noErr;

  1258.                 }

  1259.                #endif

  1260. 

  1261.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1262.                 if (inScope == kAudioUnitScope_Output)

  1263.                 {

  1264.                     if (d_isNotEqual(fSampleRateForOutput, sampleRate))

  1265.                     {

  1266.                         fSampleRateForOutput = sampleRate;

  1267.                         d_nextSampleRate = sampleRate;

  1268. 

  1269.                        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1270.                         if (d_isEqual(fSampleRateForInput, sampleRate))

  1271.                        #endif

  1272.                         {

  1273.                             fPlugin.setSampleRate(sampleRate, true);

  1274.                         }

  1275. 

  1276.                         notifyPropertyListeners(inProp, inScope, inElement);

  1277.                     }

  1278.                     return noErr;

  1279.                 }

  1280.                #endif

  1281.             }

  1282.             return kAudioUnitErr_PropertyNotInUse;

  1283. 

  1284.         case kAudioUnitProperty_StreamFormat:

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

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

  1287.            #elif DISTRHO_PLUGIN_NUM_OUTPUTS != 0

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

  1289.            #else

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

  1291.            #endif

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

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

  1294.             {

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

  1296. 

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

  1298.                     return kAudioUnitErr_FormatNotSupported;

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

  1300.                     return kAudioUnitErr_FormatNotSupported;

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

  1302.                     return kAudioUnitErr_FormatNotSupported;

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

  1304.                     return kAudioUnitErr_FormatNotSupported;

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

  1306.                     return kAudioUnitErr_FormatNotSupported;

  1307.                 if (desc->mFormatFlags != kWantedAudioFormat)

  1308.                     return kAudioUnitErr_FormatNotSupported;

  1309. 

  1310.                #ifndef DISTRHO_PLUGIN_EXTRA_IO

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

  1312.                                                                                  : DISTRHO_PLUGIN_NUM_OUTPUTS))

  1313.                     return kAudioUnitErr_FormatNotSupported;

  1314.                #endif

  1315. 

  1316.                #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1317.                 if (inScope == kAudioUnitScope_Input)

  1318.                 {

  1319.                     bool changed = false;

  1320. 

  1321.                    #ifdef DISTRHO_PLUGIN_EXTRA_IO

  1322.                     if (! isInputNumChannelsValid(desc->mChannelsPerFrame))

  1323.                         return kAudioUnitErr_FormatNotSupported;

  1324. 

  1325.                     if (fNumInputs != desc->mChannelsPerFrame)

  1326.                     {

  1327.                         changed = true;

  1328.                         fNumInputs = desc->mChannelsPerFrame;

  1329. 

  1330.                        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1331.                         if (isNumChannelsComboValid(fNumInputs, fNumOutputs))

  1332.                        #endif

  1333.                         {

  1334.                             fPlugin.setAudioPortIO(fNumInputs, fNumOutputs);

  1335.                         }

  1336.                     }

  1337.                    #endif

  1338. 

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

  1340.                     {

  1341.                         changed = true;

  1342.                         fSampleRateForInput = desc->mSampleRate;

  1343. 

  1344.                        #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

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

  1346.                        #endif

  1347.                         {

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

  1349.                         }

  1350. 

  1351.                         notifyPropertyListeners(kAudioUnitProperty_SampleRate, inScope, inElement);

  1352.                     }

  1353. 

  1354.                     if (changed)

  1355.                         notifyPropertyListeners(inProp, inScope, inElement);

  1356. 

  1357.                     return noErr;

  1358.                 }

  1359.                #endif

  1360. 

  1361.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1362.                 if (inScope == kAudioUnitScope_Output)

  1363.                 {

  1364.                     bool changed = false;

  1365. 

  1366.                    #ifdef DISTRHO_PLUGIN_EXTRA_IO

  1367.                     if (! isOutputNumChannelsValid(desc->mChannelsPerFrame))

  1368.                         return kAudioUnitErr_FormatNotSupported;

  1369. 

  1370.                     if (fNumOutputs != desc->mChannelsPerFrame)

  1371.                     {

  1372.                         changed = true;

  1373.                         fNumOutputs = desc->mChannelsPerFrame;

  1374. 

  1375.                        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1376.                         if (isNumChannelsComboValid(fNumInputs, fNumOutputs))

  1377.                        #endif

  1378.                         {

  1379.                             fPlugin.setAudioPortIO(fNumInputs, fNumOutputs);

  1380.                         }

  1381.                     }

  1382.                    #endif

  1383. 

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

  1385.                     {

  1386.                         changed = true;

  1387.                         fSampleRateForOutput = desc->mSampleRate;

  1388. 

  1389.                        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

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

  1391.                        #endif

  1392.                         {

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

  1394.                         }

  1395. 

  1396.                         notifyPropertyListeners(kAudioUnitProperty_SampleRate, inScope, inElement);

  1397.                     }

  1398. 

  1399.                     if (changed)

  1400.                         notifyPropertyListeners(inProp, inScope, inElement);

  1401. 

  1402.                     return noErr;

  1403.                 }

  1404.                #endif

  1405.             }

  1406.             return kAudioUnitErr_PropertyNotInUse;

  1407. 

  1408.         case kAudioUnitProperty_MaximumFramesPerSlice:

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

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

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

  1412.             {

  1413.                 const UInt32 bufferSize = *static_cast<const UInt32*>(inData);

  1414. 

  1415.                 if (fPlugin.setBufferSize(bufferSize, true))

  1416.                     notifyPropertyListeners(inProp, inScope, inElement);

  1417.             }

  1418.             return noErr;

  1419. 

  1420.         case kAudioUnitProperty_BypassEffect:

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

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

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

  1424.             DISTRHO_SAFE_ASSERT_RETURN(fBypassParameterIndex != UINT32_MAX, kAudioUnitErr_PropertyNotInUse);

  1425.             {

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

  1427. 

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

  1429.                 {

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

  1431.                     fLastParameterValues[fBypassParameterIndex] = value;

  1432.                     fPlugin.setParameterValue(fBypassParameterIndex, value);

  1433. 	                notifyPropertyListeners(inProp, inScope, inElement);

  1434.                 }

  1435.             }

  1436.             return noErr;

  1437. 

  1438.         case kAudioUnitProperty_SetRenderCallback:

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

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

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

  1442.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1443.             std::memcpy(&fInputRenderCallback, inData, sizeof(AURenderCallbackStruct));

  1444.             return noErr;

  1445.            #else

  1446.             return kAudioUnitErr_PropertyNotInUse;

  1447.            #endif

  1448. 

  1449.         case kAudioUnitProperty_HostCallbacks:

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

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

  1452.            #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1453.             {

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

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

  1456. 

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

  1458. 

  1459.                 if (sizeof(HostCallbackInfo) > usableDataSize)

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

  1461. 

  1462.                 if (changed)

  1463.                     notifyPropertyListeners(inProp, inScope, inElement);

  1464.             }

  1465.             return noErr;

  1466.            #else

  1467.             return kAudioUnitErr_PropertyNotInUse;

  1468.            #endif

  1469. 

  1470.         case kAudioUnitProperty_InPlaceProcessing:

  1471.             // nothing to do

  1472.             return noErr;

  1473. 

  1474.         case kAudioUnitProperty_PresentPreset:

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

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

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

  1478.             {

  1479.                 const int32_t presetNumber = static_cast<const AUPreset*>(inData)->presetNumber;

  1480. 

  1481.                #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1482.                 if (presetNumber >= 0)

  1483.                 {

  1484.                     if (fCurrentProgram != presetNumber)

  1485.                     {

  1486.                         fCurrentProgram = presetNumber;

  1487.                         fLastFactoryProgram = presetNumber;

  1488.                         fPlugin.loadProgram(fLastFactoryProgram);

  1489.                         notifyPropertyListeners('DPFo', kAudioUnitScope_Global, 0);

  1490.                     }

  1491.                 }

  1492.                 else

  1493.                 {

  1494.                     fCurrentProgram = presetNumber;

  1495.                     CFRelease(fUserPresetData.presetName);

  1496.                     std::memcpy(&fUserPresetData, inData, sizeof(AUPreset));

  1497.                 }

  1498.                #else

  1499.                 DISTRHO_SAFE_ASSERT_INT_RETURN(presetNumber < 0, presetNumber, kAudioUnitErr_InvalidPropertyValue);

  1500.                 CFRelease(fUserPresetData.presetName);

  1501.                 std::memcpy(&fUserPresetData, inData, sizeof(AUPreset));

  1502.                #endif

  1503.             }

  1504.             return noErr;

  1505. 

  1506.         case kAudioUnitProperty_MIDIOutputCallback:

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

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

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

  1510.            #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  1512.             return noErr;

  1513.            #else

  1514.             return kAudioUnitErr_PropertyNotInUse;

  1515.            #endif

  1516. 

  1517.         case 'DPFi':

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

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

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

  1521.             {

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

  1523. 

  1524.                 if (magic != 1337)

  1525.                     return noErr;

  1526. 

  1527.                #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1528.                 notifyPropertyListeners('DPFo', kAudioUnitScope_Global, 0);

  1529.                #endif

  1530. 

  1531.                #if DISTRHO_PLUGIN_WANT_STATE

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

  1533.                     notifyPropertyListeners('DPFs', kAudioUnitScope_Global, i);

  1534.                #endif

  1535. 

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

  1537.                     notifyPropertyListeners('DPFp', kAudioUnitScope_Global, i);

  1538.             }

  1539.             return noErr;

  1540. 

  1541.         case 'DPFe':

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

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

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

  1545.             {

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

  1547. 

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

  1549.                     return noErr;

  1550. 

  1551.                 AudioUnitEvent event;

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

  1553. 

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

  1555.                                                                     : kAudioUnitEvent_EndParameterChangeGesture;

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

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

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

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

  1560.             }

  1561.             return noErr;

  1562. 

  1563.         case 'DPFp':

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

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

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

  1567.             {

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

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

  1570. 

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

  1572.                     return noErr;

  1573. 

  1574.                 fLastParameterValues[inElement] = value;

  1575.                 fPlugin.setParameterValue(inElement, value);

  1576. 

  1577.                 AudioUnitEvent event;

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

  1579. 

  1580.                 event.mEventType                        = kAudioUnitEvent_ParameterValueChange;

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

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

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

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

  1585. 

  1586.                 if (fBypassParameterIndex == inElement)

  1587. 	                notifyPropertyListeners(kAudioUnitProperty_BypassEffect, kAudioUnitScope_Global, 0);

  1588.             }

  1589.             return noErr;

  1590. 

  1591.         case 'DPFn':

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

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

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

  1595.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1596.             {

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

  1598. 

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

  1600.                     return noErr;

  1601. 

  1602.                 fNotesRingBuffer.writeCustomData(midiData, 3);

  1603.                 fNotesRingBuffer.commitWrite();

  1604.             }

  1605.             return noErr;

  1606.            #else

  1607.             return kAudioUnitErr_PropertyNotInUse;

  1608.            #endif

  1609. 

  1610.         case 'DPFs':

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

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

  1613.            #if DISTRHO_PLUGIN_WANT_STATE

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

  1615.             {

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

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

  1618.                                            kAudioUnitErr_InvalidPropertyValue);

  1619. 

  1620.                 const CFIndex valueLen = CFStringGetLength(valueRef);

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

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

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

  1624.                                            kAudioUnitErr_InvalidPropertyValue);

  1625. 

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

  1627. 

  1628.                 // save this key as needed

  1629.                 if (fPlugin.wantStateKey(key))

  1630.                     fStateMap[key] = value;

  1631. 

  1632.                 fPlugin.setState(key, value);

  1633. 

  1634.                 std::free(value);

  1635.             }

  1636.             return noErr;

  1637.            #else

  1638.             return kAudioUnitErr_PropertyNotInUse;

  1639.            #endif

  1640. 

  1641.         // unwanted properties

  1642.         case kMusicDeviceProperty_DualSchedulingMode:

  1643.             return kAudioUnitErr_PropertyNotInUse;

  1644.         }

  1645. 

  1646.         d_stdout("TODO SetProperty(%d:%x:%s, %d:%s, %d, %p, %u)",

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

  1648.         return kAudioUnitErr_InvalidProperty;

  1649.     }

  1650. 

  1651.     OSStatus auAddPropertyListener(const AudioUnitPropertyID prop,

  1652.                                    const AudioUnitPropertyListenerProc proc,

  1653.                                    void* const userData)

  1654.     {

  1655.         const PropertyListener pl = {

  1656.             prop, proc, userData

  1657.         };

  1658. 

  1659.         fPropertyListeners.push_back(pl);

  1660.         return noErr;

  1661.     }

  1662. 

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

  1664.     {

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

  1666.         {

  1667.             const PropertyListener& pl(*it);

  1668. 

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

  1670.             {

  1671.                 fPropertyListeners.erase(it);

  1672.                 return auRemovePropertyListener(prop, proc);

  1673.             }

  1674.         }

  1675. 

  1676.         return noErr;

  1677.     }

  1678. 

  1679.     OSStatus auRemovePropertyListenerWithUserData(const AudioUnitPropertyID prop,

  1680.                                                   const AudioUnitPropertyListenerProc proc,

  1681.                                                   void* const userData)

  1682.     {

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

  1684.         {

  1685.             const PropertyListener& pl(*it);

  1686. 

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

  1688.             {

  1689.                 fPropertyListeners.erase(it);

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

  1691.             }

  1692.         }

  1693. 

  1694.         return noErr;

  1695.     }

  1696. 

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

  1698.     {

  1699.         fUsingRenderListeners = true;

  1700. 

  1701.         const RenderListener rl = {

  1702.             proc, userData

  1703.         };

  1704. 

  1705.         fRenderListeners.push_back(rl);

  1706.         return noErr;

  1707.     }

  1708. 

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

  1710.     {

  1711.         for (RenderListeners::iterator it = fRenderListeners.begin(); it != fRenderListeners.end(); ++it)

  1712.         {

  1713.             const RenderListener& rl(*it);

  1714. 

  1715.             if (rl.proc == proc && rl.userData == userData)

  1716.             {

  1717.                 fRenderListeners.erase(it);

  1718.                 return auRemoveRenderNotify(proc, userData);

  1719.             }

  1720.         }

  1721. 

  1722.         if (fRenderListeners.empty())

  1723.             fUsingRenderListeners = false;

  1724. 

  1725.         return noErr;

  1726.     }

  1727. 

  1728.     OSStatus auGetParameter(const AudioUnitParameterID param,

  1729.                             const AudioUnitScope scope,

  1730.                             const AudioUnitElement elem,

  1731.                             AudioUnitParameterValue* const value)

  1732.     {

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

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

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

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

  1737. 

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

  1739.         return noErr;

  1740.     }

  1741. 

  1742.     OSStatus auSetParameter(const AudioUnitParameterID param,

  1743.                             const AudioUnitScope scope,

  1744.                             const AudioUnitElement elem,

  1745.                             const AudioUnitParameterValue value,

  1746.                             UInt32 /* bufferOffset */)

  1747.     {

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

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

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

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

  1752. 

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

  1754.         {

  1755.             fLastParameterValues[param] = value;

  1756.             fPlugin.setParameterValue(param, value);

  1757. 

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

  1759.             notifyPropertyListeners('DPFp', kAudioUnitScope_Global, param);

  1760. 

  1761.             if (fBypassParameterIndex == elem)

  1762.                 notifyPropertyListeners(kAudioUnitProperty_BypassEffect, kAudioUnitScope_Global, 0);

  1763.         }

  1764. 

  1765.         return noErr;

  1766.     }

  1767. 

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

  1769.     {

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

  1771.         {

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

  1773. 

  1774.             if (event.eventType == kParameterEvent_Immediate)

  1775.             {

  1776.                 auSetParameter(event.parameter,

  1777.                                event.scope,

  1778.                                event.element,

  1779.                                event.eventValues.immediate.value,

  1780.                                event.eventValues.immediate.bufferOffset);

  1781.             }

  1782.             else

  1783.             {

  1784.                 // TODO?

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

  1786.             }

  1787.         }

  1788.         return noErr;

  1789.     }

  1790. 

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

  1792.     {

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

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

  1795. 

  1796.         if (fPlugin.isActive())

  1797.         {

  1798.             fPlugin.deactivate();

  1799.             fPlugin.activate();

  1800.         }

  1801. 

  1802.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1803.         fMidiEventCount = 0;

  1804.        #endif

  1805.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1806.         fMidiOutputDataOffset = 0;

  1807.         fMidiOutputPackets->numPackets = 0;

  1808.        #endif

  1809.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1810.         fTimePosition.clear();

  1811.         fTimePosition.bbt.ticksPerBeat = kDefaultTicksPerBeat;

  1812.        #endif

  1813.         return noErr;

  1814.     }

  1815. 

  1816.     OSStatus auRender(const AudioUnitRenderActionFlags actionFlags,

  1817.                       const AudioTimeStamp* const inTimeStamp,

  1818.                       const UInt32 inBusNumber,

  1819.                       const UInt32 inFramesToProcess,

  1820.                       AudioBufferList* const ioData)

  1821.     {

  1822.         if ((actionFlags & kAudioUnitRenderAction_DoNotCheckRenderArgs) == 0x0)

  1823.         {

  1824.             DISTRHO_SAFE_ASSERT_RETURN(fPlugin.isActive(), kAudio_ParamError);

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

  1826.            #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1827.             DISTRHO_SAFE_ASSERT_UINT_RETURN(ioData->mNumberBuffers == fAudioBufferList->mNumberBuffers,

  1828.                                             ioData->mNumberBuffers, kAudio_ParamError);

  1829.            #else

  1830.             DISTRHO_SAFE_ASSERT_UINT_RETURN(ioData->mNumberBuffers == 0, ioData->mNumberBuffers, kAudio_ParamError);

  1831.            #endif

  1832. 

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

  1834.             {

  1835.                 setLastRenderError(kAudioUnitErr_TooManyFramesToProcess);

  1836.                 return kAudioUnitErr_TooManyFramesToProcess;

  1837.             }

  1838. 

  1839.            #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1840.             for (uint16_t i = 0; i < ioData->mNumberBuffers; ++i)

  1841.             {

  1842.                 if (ioData->mBuffers[i].mDataByteSize != sizeof(float) * inFramesToProcess)

  1843.                 {

  1844.                     setLastRenderError(kAudio_ParamError);

  1845.                     return kAudio_ParamError;

  1846.                 }

  1847.             }

  1848.            #endif

  1849.         }

  1850. 

  1851.       #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1852.        #ifdef DISTRHO_PLUGIN_EXTRA_IO

  1853.         const uint32_t numInputs = fNumInputs;

  1854.        #else

  1855.         constexpr const uint32_t numInputs = DISTRHO_PLUGIN_NUM_INPUTS;

  1856.        #endif

  1857.         const float* inputs[numInputs];

  1858.       #else

  1859.         constexpr const float** inputs = nullptr;

  1860.       #endif

  1861. 

  1862.       #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1863.        #ifdef DISTRHO_PLUGIN_EXTRA_IO

  1864.         const uint32_t numOutputs = fNumOutputs;

  1865.        #else

  1866.         constexpr const uint32_t numOutputs = DISTRHO_PLUGIN_NUM_OUTPUTS;

  1867.        #endif

  1868.         float* outputs[numOutputs];

  1869.       #else

  1870.         constexpr float** outputs = nullptr;

  1871.       #endif

  1872. 

  1873.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1874.         if (fInputConnectionUnit != nullptr)

  1875.         {

  1876.             AudioUnitRenderActionFlags ioActionFlags = 0;

  1877.             const OSStatus err = AudioUnitRender(fInputConnectionUnit,

  1878.                                                  &ioActionFlags,

  1879.                                                  inTimeStamp,

  1880.                                                  fInputConnectionBus,

  1881.                                                  inFramesToProcess,

  1882.                                                  fAudioBufferList);

  1883. 

  1884.             if (err != noErr)

  1885.             {

  1886.                 setLastRenderError(err);

  1887.                 return err;

  1888.             }

  1889. 

  1890.             for (uint16_t i = 0; i < numInputs; ++i)

  1891.                 inputs[i] = static_cast<const float*>(fAudioBufferList->mBuffers[i].mData);

  1892. 

  1893.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1894.             for (uint16_t i = 0; i < numOutputs; ++i)

  1895.             {

  1896.                 if (ioData->mBuffers[i].mData == nullptr)

  1897.                     ioData->mBuffers[i].mData = fAudioBufferList->mBuffers[i].mData;

  1898. 

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

  1900.             }

  1901.            #endif

  1902.         }

  1903.         else if (fInputRenderCallback.inputProc != nullptr)

  1904.         {

  1905.             bool adjustDataByteSize, usingHostBuffer = true;

  1906.             UInt32 prevDataByteSize;

  1907. 

  1908.             for (uint16_t i = 0; i < ioData->mNumberBuffers; ++i)

  1909.             {

  1910.                 if (ioData->mBuffers[i].mData == nullptr)

  1911.                 {

  1912.                     usingHostBuffer = false;

  1913.                     ioData->mBuffers[i].mData = fAudioBufferList->mBuffers[i].mData;

  1914.                 }

  1915.             }

  1916. 

  1917.             if (! usingHostBuffer)

  1918.             {

  1919.                 prevDataByteSize = fAudioBufferList->mBuffers[0].mDataByteSize;

  1920.                 adjustDataByteSize = prevDataByteSize != sizeof(float) * inFramesToProcess;

  1921. 

  1922.                 if (adjustDataByteSize)

  1923.                 {

  1924.                     for (uint16_t i = 0; i < ioData->mNumberBuffers; ++i)

  1925.                         fAudioBufferList->mBuffers[i].mDataByteSize = sizeof(float) * inFramesToProcess;

  1926.                 }

  1927.             }

  1928.             else

  1929.             {

  1930.                 adjustDataByteSize = false;

  1931.             }

  1932. 

  1933.             AudioUnitRenderActionFlags rActionFlags = 0;

  1934.             AudioBufferList* const rData = usingHostBuffer ? ioData : fAudioBufferList;

  1935.             const OSStatus err = fInputRenderCallback.inputProc(fInputRenderCallback.inputProcRefCon,

  1936.                                                                 &rActionFlags,

  1937.                                                                 inTimeStamp,

  1938.                                                                 inBusNumber,

  1939.                                                                 inFramesToProcess,

  1940.                                                                 rData);

  1941. 

  1942.             if (err != noErr)

  1943.             {

  1944.                 if (adjustDataByteSize)

  1945.                 {

  1946.                     for (uint16_t i = 0; i < ioData->mNumberBuffers; ++i)

  1947.                         fAudioBufferList->mBuffers[i].mDataByteSize = prevDataByteSize;

  1948.                 }

  1949. 

  1950.                 setLastRenderError(err);

  1951.                 return err;

  1952.             }

  1953. 

  1954.             if (usingHostBuffer)

  1955.             {

  1956.                 for (uint16_t i = 0; i < numInputs; ++i)

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

  1958. 

  1959.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1960.                 for (uint16_t i = 0; i < numOutputs; ++i)

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

  1962.                #endif

  1963. 

  1964.             }

  1965.             else

  1966.             {

  1967.                 for (uint16_t i = 0; i < numInputs; ++i)

  1968.                     inputs[i] = static_cast<const float*>(fAudioBufferList->mBuffers[i].mData);

  1969. 

  1970.                #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1971.                 for (uint16_t i = 0; i < numOutputs; ++i)

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

  1973.                #endif

  1974.             }

  1975.         }

  1976.         else

  1977.        #endif // DISTRHO_PLUGIN_NUM_INPUTS != 0

  1978.         {

  1979.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1980.             for (uint16_t i = 0; i < numInputs; ++i)

  1981.             {

  1982.                 if (ioData->mBuffers[i].mData == nullptr)

  1983.                 {

  1984.                     ioData->mBuffers[i].mData = fAudioBufferList->mBuffers[i].mData;

  1985.                     std::memset(ioData->mBuffers[i].mData, 0, sizeof(float) * inFramesToProcess);

  1986.                 }

  1987. 

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

  1989.             }

  1990.            #endif

  1991. 

  1992.            #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  1993.             for (uint16_t i = 0; i < numOutputs; ++i)

  1994.             {

  1995.                 if (ioData->mBuffers[i].mData == nullptr)

  1996.                     ioData->mBuffers[i].mData = fAudioBufferList->mBuffers[i].mData;

  1997. 

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

  1999.             }

  2000.            #endif

  2001.         }

  2002. 

  2003.         if (fUsingRenderListeners)

  2004.         {

  2005.             AudioUnitRenderActionFlags ioActionFlags = actionFlags | kAudioUnitRenderAction_PreRender;

  2006.             notifyRenderListeners(&ioActionFlags, inTimeStamp, inBusNumber, inFramesToProcess, ioData);

  2007.         }

  2008. 

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

  2010. 

  2011.         if (fUsingRenderListeners)

  2012.         {

  2013.             AudioUnitRenderActionFlags ioActionFlags = actionFlags | kAudioUnitRenderAction_PostRender;

  2014.             notifyRenderListeners(&ioActionFlags, inTimeStamp, inBusNumber, inFramesToProcess, ioData);

  2015.         }

  2016. 

  2017.         return noErr;

  2018.     }

  2019. 

  2020.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2021.     OSStatus auMIDIEvent(const UInt32 inStatus,

  2022.                          const UInt32 inData1,

  2023.                          const UInt32 inData2,

  2024.                          const UInt32 inOffsetSampleFrame)

  2025.     {

  2026.         if (fMidiEventCount >= kMaxMidiEvents)

  2027.             return noErr;

  2028. 

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

  2030.         midiEvent.frame   = inOffsetSampleFrame;

  2031.         midiEvent.data[0] = inStatus;

  2032.         midiEvent.data[1] = inData1;

  2033.         midiEvent.data[2] = inData2;

  2034. 

  2035.         switch (inStatus & 0xF0)

  2036.         {

  2037.         case 0x80:

  2038.         case 0x90:

  2039.         case 0xA0:

  2040.         case 0xB0:

  2041.         case 0xE0:

  2042.             midiEvent.size = 3;

  2043.             break;

  2044.         case 0xC0:

  2045.         case 0xD0:

  2046.             midiEvent.size = 2;

  2047.             break;

  2048.         case 0xF0:

  2049.             switch (inStatus & 0x0F)

  2050.             {

  2051.             case 0x0:

  2052.             case 0x4:

  2053.             case 0x5:

  2054.             case 0x7:

  2055.             case 0x9:

  2056.             case 0xD:

  2057.                 // unsupported

  2058.                 return kAudioUnitErr_InvalidPropertyValue;

  2059.             case 0x1:

  2060.             case 0x2:

  2061.             case 0x3:

  2062.             case 0xE:

  2063.                 midiEvent.size = 3;

  2064.                 break;

  2065.             case 0x6:

  2066.             case 0x8:

  2067.             case 0xA:

  2068.             case 0xB:

  2069.             case 0xC:

  2070.             case 0xF:

  2071.                 midiEvent.size = 1;

  2072.                 break;

  2073.             }

  2074.             break;

  2075.         default:

  2076.             // invalid

  2077.             d_debug("auMIDIEvent received invalid event %u %u %u %u @ %u",

  2078.                     inStatus, inData1, inData2, inOffsetSampleFrame, fMidiEventCount);

  2079.             return kAudioUnitErr_InvalidPropertyValue;

  2080.         }

  2081. 

  2082.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  2083.         // handle case of plugin having no working audio, simulate audio-side processing

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

  2085.        #endif

  2086. 

  2087.         return noErr;

  2088.     }

  2089. 

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

  2091.     {

  2092.         if (fMidiEventCount >= kMaxMidiEvents)

  2093.             return noErr;

  2094. 

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

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

  2097.         midiEvent.size  = inLength;

  2098. 

  2099.         // FIXME who owns inData ??

  2100.         if (inLength > MidiEvent::kDataSize)

  2101.         {

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

  2103.             midiEvent.dataExt = inData;

  2104.         }

  2105.         else

  2106.         {

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

  2108.         }

  2109. 

  2110.        #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  2111.         // handle case of plugin having no working audio, simulate audio-side processing

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

  2113.        #endif

  2114. 

  2115.         return noErr;

  2116.     }

  2117.    #endif

  2118. 

  2119.     // ----------------------------------------------------------------------------------------------------------------

  2120. 

  2121. private:

  2122.     PluginExporter fPlugin;

  2123. 

  2124.     // AU component

  2125.     const AudioUnit fComponent;

  2126. 

  2127.     // AUv2 related fields

  2128.     OSStatus fLastRenderError;

  2129.     PropertyListeners fPropertyListeners;

  2130.     RenderListeners fRenderListeners;

  2131.   #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  2132.     UInt32 fInputConnectionBus;

  2133.     AudioUnit fInputConnectionUnit;

  2134.     AURenderCallbackStruct fInputRenderCallback;

  2135.     Float64 fSampleRateForInput;

  2136.    #ifdef DISTRHO_PLUGIN_EXTRA_IO

  2137.     uint32_t fNumInputs;

  2138.    #endif

  2139.   #endif

  2140.   #if DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  2141.     Float64 fSampleRateForOutput;

  2142.    #ifdef DISTRHO_PLUGIN_EXTRA_IO

  2143.     uint32_t fNumOutputs;

  2144.    #endif

  2145.   #endif

  2146.    #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  2147.     AudioBufferList* fAudioBufferList;

  2148.    #endif

  2149.     bool fUsingRenderListeners;

  2150. 

  2151.     // Caching

  2152.     const uint32_t fParameterCount;

  2153.     float* fLastParameterValues;

  2154.     uint32_t fBypassParameterIndex;

  2155. 

  2156.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2157.     uint32_t fMidiEventCount;

  2158.     MidiEvent fMidiEvents[kMaxMidiEvents];

  2159.     SmallStackRingBuffer fNotesRingBuffer;

  2160.    #endif

  2161. 

  2162.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2163.     uint32_t fMidiOutputDataOffset;

  2164.     MIDIPacketList* fMidiOutputPackets;

  2165.     AUMIDIOutputCallbackStruct fMidiOutput;

  2166.    #endif

  2167. 

  2168.    #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2169.     int32_t fCurrentProgram;

  2170.     uint32_t fLastFactoryProgram;

  2171.     uint32_t fProgramCount;

  2172.     AUPreset* fFactoryPresetsData;

  2173.    #endif

  2174.     AUPreset fUserPresetData;

  2175. 

  2176.    #if DISTRHO_PLUGIN_WANT_STATE

  2177.     const uint32_t fStateCount;

  2178.     StringMap fStateMap;

  2179.    #endif

  2180. 

  2181.    #if DISTRHO_PLUGIN_WANT_TIMEPOS

  2182.     HostCallbackInfo fHostCallbackInfo;

  2183.     TimePosition fTimePosition;

  2184.    #endif

  2185. 

  2186.     // ----------------------------------------------------------------------------------------------------------------

  2187. 

  2188.     void notifyPropertyListeners(const AudioUnitPropertyID prop, const AudioUnitScope scope, const AudioUnitElement elem)

  2189.     {

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

  2191.         {

  2192.             const PropertyListener& pl(*it);

  2193. 

  2194.             if (pl.prop == prop)

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

  2196.         }

  2197.     }

  2198. 

  2199.     void notifyRenderListeners(AudioUnitRenderActionFlags* const ioActionFlags,

  2200.                                const AudioTimeStamp* const inTimeStamp,

  2201.                                const UInt32 inBusNumber,

  2202.                                const UInt32 inNumberFrames,

  2203.                                AudioBufferList* const ioData)

  2204.     {

  2205.         for (RenderListeners::iterator it = fRenderListeners.begin(); it != fRenderListeners.end(); ++it)

  2206.         {

  2207.             const RenderListener& rl(*it);

  2208. 

  2209.             rl.proc(rl.userData, ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, ioData);

  2210.         }

  2211.     }

  2212. 

  2213.     // ----------------------------------------------------------------------------------------------------------------

  2214. 

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

  2216.     {

  2217.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  2219.         {

  2220.             uint8_t midiData[3];

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

  2222. 

  2223.             while (fNotesRingBuffer.isDataAvailableForReading())

  2224.             {

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

  2226.                     break;

  2227. 

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

  2229.                 midiEvent.frame = frame;

  2230.                 midiEvent.size  = 3;

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

  2232. 

  2233.                 if (fMidiEventCount == kMaxMidiEvents)

  2234.                     break;

  2235.             }

  2236.         }

  2237.        #endif

  2238. 

  2239.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2240.         fMidiOutputDataOffset = 0;

  2241.         fMidiOutputPackets->numPackets = 0;

  2242.        #endif

  2243. 

  2244.        #if DISTRHO_PLUGIN_WANT_TIMEPOS

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

  2246.             fHostCallbackInfo.musicalTimeLocationProc != nullptr ||

  2247.             fHostCallbackInfo.transportStateProc != nullptr)

  2248.         {

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

  2250.             Boolean b1 = false;

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

  2252.             Float64 g1 = 0.0;

  2253.             Float64 g2 = 0.0;

  2254.             UInt32 u1 = 0;

  2255. 

  2256.             if (fHostCallbackInfo.musicalTimeLocationProc != nullptr

  2257.                 && fHostCallbackInfo.musicalTimeLocationProc(fHostCallbackInfo.hostUserData,

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

  2259.             {

  2260.                 fTimePosition.bbt.beatsPerBar = f1;

  2261.                 fTimePosition.bbt.beatType    = u1;

  2262.             }

  2263.             else

  2264.             {

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

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

  2267.             }

  2268. 

  2269.             if (fHostCallbackInfo.beatAndTempoProc != nullptr

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

  2271.             {

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

  2273. 

  2274.                 fTimePosition.bbt.valid = true;

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

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

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

  2278.                 fTimePosition.bbt.beatsPerMinute = g2;

  2279.             }

  2280.             else

  2281.             {

  2282.                 fTimePosition.bbt.valid = false;

  2283.                 fTimePosition.bbt.bar   = 1;

  2284.                 fTimePosition.bbt.beat  = 1;

  2285.                 fTimePosition.bbt.tick  = 0.0;

  2286.                 fTimePosition.bbt.beatsPerMinute = 120.0;

  2287.             }

  2288. 

  2289.             if (fHostCallbackInfo.transportStateProc != nullptr

  2290.                 && fHostCallbackInfo.transportStateProc(fHostCallbackInfo.hostUserData,

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

  2292.             {

  2293.                 fTimePosition.playing = b1;

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

  2295.             }

  2296.             else

  2297.             {

  2298.                 fTimePosition.playing = false;

  2299.                 fTimePosition.frame = 0;

  2300.             }

  2301. 

  2302.             fTimePosition.bbt.barStartTick = kDefaultTicksPerBeat *

  2303.                                              fTimePosition.bbt.beatsPerBar *

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

  2305. 

  2306.             fPlugin.setTimePosition(fTimePosition);

  2307.         }

  2308.        #endif

  2309. 

  2310.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  2312.         fMidiEventCount = 0;

  2313.        #else

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

  2315.        #endif

  2316. 

  2317.        #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2318.         if (fMidiOutputPackets != nullptr &&

  2319.             fMidiOutputPackets->numPackets != 0 &&

  2320.             fMidiOutput.midiOutputCallback != nullptr)

  2321.         {

  2322.             fMidiOutput.midiOutputCallback(fMidiOutput.userData, inTimeStamp, 0, fMidiOutputPackets);

  2323.         }

  2324.        #else

  2325.         // unused

  2326.         (void)inTimeStamp;

  2327.        #endif

  2328. 

  2329.         float value;

  2330.         AudioUnitEvent event;

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

  2332.         event.mEventType                      = kAudioUnitEvent_ParameterValueChange;

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

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

  2335. 

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

  2337.         {

  2338.             if (fPlugin.isParameterOutputOrTrigger(i))

  2339.             {

  2340.                 value = fPlugin.getParameterValue(i);

  2341. 

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

  2343.                     continue;

  2344. 

  2345.                 fLastParameterValues[i] = value;

  2346. 

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

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

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

  2350.                 notifyPropertyListeners('DPFp', kAudioUnitScope_Global, i);

  2351.             }

  2352.         }

  2353.     }

  2354. 

  2355.     void setLastRenderError(const OSStatus err)

  2356.     {

  2357.         if (fLastRenderError != noErr)

  2358.             return;

  2359. 

  2360.         fLastRenderError = err;

  2361.         notifyPropertyListeners(kAudioUnitProperty_LastRenderError, kAudioUnitScope_Global, 0);

  2362.     }

  2363. 

  2364.     // ----------------------------------------------------------------------------------------------------------------

  2365. 

  2366.    #if DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS != 0

  2367.     bool reallocAudioBufferList(const bool alloc)

  2368.     {

  2369.         if (fAudioBufferList != nullptr)

  2370.         {

  2371.             for (uint16_t i = 0; i < fAudioBufferList->mNumberBuffers; ++i)

  2372.                 delete[] static_cast<float*>(fAudioBufferList->mBuffers[i].mData);

  2373.         }

  2374. 

  2375.       #ifdef DISTRHO_PLUGIN_EXTRA_IO

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

  2377.         const uint16_t numBuffers = std::max(fNumInputs, fNumOutputs);

  2378.        #elif DISTRHO_PLUGIN_NUM_INPUTS != 0

  2379.         const uint16_t numBuffers = fNumInputs;

  2380.        #else

  2381.         const uint16_t numBuffers = fNumOutputs;

  2382.        #endif

  2383.       #else

  2384.         constexpr const uint16_t numBuffers = d_max(DISTRHO_PLUGIN_NUM_INPUTS, DISTRHO_PLUGIN_NUM_OUTPUTS);

  2385.       #endif

  2386.         const uint32_t bufferSize = fPlugin.getBufferSize();

  2387. 

  2388.         if (! alloc)

  2389.         {

  2390.             std::free(fAudioBufferList);

  2391.             fAudioBufferList = nullptr;

  2392.             return true;

  2393.         }

  2394. 

  2395.         if (AudioBufferList* const abl = static_cast<AudioBufferList*>(

  2396.             std::realloc(fAudioBufferList, sizeof(uint32_t) + sizeof(AudioBuffer) * numBuffers)))

  2397.         {

  2398.             abl->mNumberBuffers = numBuffers;

  2399. 

  2400.             for (uint16_t i = 0; i < numBuffers; ++i)

  2401.             {

  2402.                 abl->mBuffers[i].mNumberChannels = 1;

  2403.                 abl->mBuffers[i].mData = new float[bufferSize];

  2404.                 abl->mBuffers[i].mDataByteSize = sizeof(float) * bufferSize;

  2405.             }

  2406. 

  2407.             fAudioBufferList = abl;

  2408.             return true;

  2409.         }

  2410. 

  2411.         std::free(fAudioBufferList);

  2412.         fAudioBufferList = nullptr;

  2413.         return false;

  2414.     }

  2415.    #endif

  2416. 

  2417.     // ----------------------------------------------------------------------------------------------------------------

  2418. 

  2419.     CFMutableDictionaryRef retrieveClassInfo()

  2420.     {

  2421.         CFMutableDictionaryRef clsInfo = CFDictionaryCreateMutable(nullptr,

  2422.                                                                    0,

  2423.                                                                    &kCFTypeDictionaryKeyCallBacks,

  2424.                                                                    &kCFTypeDictionaryValueCallBacks);

  2425.         SInt32 value;

  2426. 

  2427.         value = 0;

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

  2429.         {

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

  2431.             CFRelease(num);

  2432.         }

  2433. 

  2434.         value = kType;

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

  2436.         {

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

  2438.             CFRelease(num);

  2439.         }

  2440. 

  2441.         value = kSubType;

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

  2443.         {

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

  2445.             CFRelease(num);

  2446.         }

  2447. 

  2448.         value = kManufacturer;

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

  2450.         {

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

  2452.             CFRelease(num);

  2453.         }

  2454. 

  2455.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2456.         if (fCurrentProgram >= 0)

  2457.         {

  2458.             CFDictionarySetValue(clsInfo, CFSTR(kAUPresetNameKey), fFactoryPresetsData[fCurrentProgram].presetName);

  2459.         }

  2460.         else

  2461.        #endif

  2462.         {

  2463.             CFDictionarySetValue(clsInfo, CFSTR(kAUPresetNameKey), fUserPresetData.presetName);

  2464.         }

  2465. 

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

  2467.                                                                           0,

  2468.                                                                           &kCFTypeDictionaryKeyCallBacks,

  2469.                                                                           &kCFTypeDictionaryValueCallBacks))

  2470.         {

  2471.            #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2472.             const SInt32 program = fCurrentProgram;

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

  2474.             {

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

  2476.                CFRelease(programRef);

  2477.             }

  2478.            #endif

  2479. 

  2480.            #if DISTRHO_PLUGIN_WANT_FULL_STATE

  2481.             // Update current state

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

  2483.             {

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

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

  2486.             }

  2487.            #endif

  2488. 

  2489.            #if DISTRHO_PLUGIN_WANT_STATE

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

  2491.                                                                          fStateCount,

  2492.                                                                          &kCFTypeArrayCallBacks))

  2493.             {

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

  2495.                 {

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

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

  2498. 

  2499.                    #if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS && ! DISTRHO_PLUGIN_HAS_UI

  2500.                     bool wantStateKey = true;

  2501. 

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

  2503.                     {

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

  2505.                         {

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

  2507.                                 wantStateKey = false;

  2508. 

  2509.                             break;

  2510.                         }

  2511.                     }

  2512. 

  2513.                     if (! wantStateKey)

  2514.                         continue;

  2515.                    #endif

  2516. 

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

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

  2519. 

  2520.                     if (CFDictionaryRef dictRef = CFDictionaryCreate(nullptr,

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

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

  2523.                                                                      1,

  2524.                                                                      &kCFTypeDictionaryKeyCallBacks,

  2525.                                                                      &kCFTypeDictionaryValueCallBacks))

  2526.                     {

  2527.                         CFArrayAppendValue(statesRef, dictRef);

  2528.                         CFRelease(dictRef);

  2529.                     }

  2530. 

  2531.                     CFRelease(keyRef);

  2532.                     CFRelease(valueRef);

  2533.                 }

  2534. 

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

  2536.                 CFRelease(statesRef);

  2537.             }

  2538.            #endif

  2539. 

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

  2541.                                                                          fParameterCount,

  2542.                                                                          &kCFTypeArrayCallBacks))

  2543.             {

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

  2545.                 {

  2546.                     if (fPlugin.isParameterOutputOrTrigger(i))

  2547.                         continue;

  2548. 

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

  2550. 

  2551.                     CFStringRef keyRef = CFStringCreateWithCString(nullptr,

  2552.                                                                    fPlugin.getParameterSymbol(i),

  2553.                                                                    kCFStringEncodingASCII);

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

  2555. 

  2556.                     if (CFDictionaryRef dictRef = CFDictionaryCreate(nullptr,

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

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

  2559.                                                                      1,

  2560.                                                                      &kCFTypeDictionaryKeyCallBacks,

  2561.                                                                      &kCFTypeDictionaryValueCallBacks))

  2562.                     {

  2563.                         CFArrayAppendValue(paramsRef, dictRef);

  2564.                         CFRelease(dictRef);

  2565.                     }

  2566. 

  2567.                     CFRelease(keyRef);

  2568.                     CFRelease(valueRef);

  2569.                 }

  2570. 

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

  2572.                 CFRelease(paramsRef);

  2573.             }

  2574. 

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

  2576.             CFRelease(data);

  2577.         }

  2578. 

  2579.         return clsInfo;

  2580.     }

  2581. 

  2582.     void restoreClassInfo(const CFDictionaryRef clsInfo)

  2583.     {

  2584.         CFDictionaryRef data = nullptr;

  2585.         DISTRHO_SAFE_ASSERT_RETURN(CFDictionaryGetValueIfPresent(clsInfo,

  2586.                                                                  CFSTR(kAUPresetDataKey),

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

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

  2589. 

  2590.        #if DISTRHO_PLUGIN_WANT_PROGRAMS

  2591.         CFNumberRef programRef = nullptr;

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

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

  2594.         {

  2595.             SInt32 program = -1;

  2596.             if (CFNumberGetValue(programRef, kCFNumberSInt32Type, &program))

  2597.             {

  2598.                 fCurrentProgram = program;

  2599. 

  2600.                 if (program >= 0)

  2601.                 {

  2602.                     fLastFactoryProgram = program;

  2603.                     fPlugin.loadProgram(fLastFactoryProgram);

  2604.                     notifyPropertyListeners('DPFo', kAudioUnitScope_Global, 0);

  2605.                 }

  2606. 

  2607.                 notifyPropertyListeners(kAudioUnitProperty_PresentPreset, kAudioUnitScope_Global, 0);

  2608.             }

  2609.         }

  2610.        #endif

  2611. 

  2612.        #if DISTRHO_PLUGIN_WANT_STATE

  2613.         CFArrayRef statesRef = nullptr;

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

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

  2616.         {

  2617.             const CFIndex numStates = CFArrayGetCount(statesRef);

  2618.             char* key = nullptr;

  2619.             char* value = nullptr;

  2620.             CFIndex keyLen = -1;

  2621.             CFIndex valueLen = -1;

  2622. 

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

  2624.             {

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

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

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

  2628. 

  2629.                 CFStringRef keyRef = nullptr;

  2630.                 CFStringRef valueRef = nullptr;

  2631.                 CFDictionaryGetKeysAndValues(state,

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

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

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

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

  2636. 

  2637.                 const CFIndex keyRefLen = CFStringGetLength(keyRef);

  2638.                 if (keyLen < keyRefLen)

  2639.                 {

  2640.                     keyLen = keyRefLen;

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

  2642.                 }

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

  2644. 

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

  2646.                     continue;

  2647. 

  2648.                 const CFIndex valueRefLen = CFStringGetLength(valueRef);

  2649.                 if (valueLen < valueRefLen)

  2650.                 {

  2651.                     valueLen = valueRefLen;

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

  2653.                 }

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

  2655. 

  2656.                 const String dkey(key);

  2657.                 fStateMap[dkey] = value;

  2658.                 fPlugin.setState(key, value);

  2659. 

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

  2661.                 {

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

  2663.                     {

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

  2665.                             notifyPropertyListeners('DPFs', kAudioUnitScope_Global, j);

  2666. 

  2667.                         break;

  2668.                     }

  2669.                 }

  2670.             }

  2671. 

  2672.             std::free(key);

  2673.             std::free(value);

  2674.         }

  2675.        #endif

  2676. 

  2677.         CFArrayRef paramsRef = nullptr;

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

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

  2680.         {

  2681.             const CFIndex numParams = CFArrayGetCount(paramsRef);

  2682.             char* symbol = nullptr;

  2683.             CFIndex symbolLen = -1;

  2684. 

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

  2686.             {

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

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

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

  2690. 

  2691.                 CFStringRef keyRef = nullptr;

  2692.                 CFNumberRef valueRef = nullptr;

  2693.                 CFDictionaryGetKeysAndValues(param,

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

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

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

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

  2698. 

  2699.                 float value = 0.f;

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

  2701. 

  2702.                 const CFIndex keyRefLen = CFStringGetLength(keyRef);

  2703.                 if (symbolLen < keyRefLen)

  2704.                 {

  2705.                     symbolLen = keyRefLen;

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

  2707.                 }

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

  2709. 

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

  2711.                 {

  2712.                     if (fPlugin.isParameterOutputOrTrigger(j))

  2713.                         continue;

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

  2715.                         continue;

  2716. 

  2717.                     fLastParameterValues[j] = value;

  2718.                     fPlugin.setParameterValue(j, value);

  2719.                     notifyPropertyListeners('DPFp', kAudioUnitScope_Global, j);

  2720. 

  2721.                     if (fBypassParameterIndex == j)

  2722.                         notifyPropertyListeners(kAudioUnitProperty_BypassEffect, kAudioUnitScope_Global, 0);

  2723. 

  2724.                     break;

  2725.                 }

  2726.             }

  2727. 

  2728.             std::free(symbol);

  2729.         }

  2730.     }

  2731. 

  2732.     // ----------------------------------------------------------------------------------------------------------------

  2733.     // DPF callbacks

  2734. 

  2735.    #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  2736.     bool writeMidi(const MidiEvent& midiEvent)

  2737.     {

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

  2739.         DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_RETURN("Out of memory", fMidiOutputPackets != nullptr, false);

  2740. 

  2741.         if (fMidiOutputDataOffset + kMIDIPacketNonDataSize + midiEvent.size >= kMIDIPacketListMaxDataSize)

  2742.             return false;

  2743. 

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

  2745.         MIDIPacket* const packet = reinterpret_cast<MIDIPacket*>(

  2746.              reinterpret_cast<uint8_t*>(fMidiOutputPackets->packet) + fMidiOutputDataOffset);

  2747. 

  2748.         packet->timeStamp = midiEvent.frame;

  2749.         packet->length = midiEvent.size;

  2750.         std::memcpy(packet->data, midiData, midiEvent.size);

  2751. 

  2752.         ++fMidiOutputPackets->numPackets;

  2753.         fMidiOutputDataOffset += kMIDIPacketNonDataSize + midiEvent.size;

  2754.         return true;

  2755.     }

  2756. 

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

  2758.     {

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

  2760.     }

  2761.    #endif

  2762. 

  2763.    #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

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

  2765.     {

  2766.         AudioUnitEvent event;

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

  2768.         event.mEventType                        = kAudioUnitEvent_ParameterValueChange;

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

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

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

  2772. 

  2773.         fLastParameterValues[index] = value;

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

  2775.         notifyPropertyListeners('DPFp', kAudioUnitScope_Global, index);

  2776.         return true;

  2777.     }

  2778. 

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

  2780.     {

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

  2782.     }

  2783.    #endif

  2784. 

  2785.    #if DISTRHO_PLUGIN_WANT_STATE

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

  2787.     {

  2788.         fPlugin.setState(key, newValue);

  2789. 

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

  2791.         {

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

  2793.             {

  2794.                 const String dkey(key);

  2795.                 fStateMap[dkey] = newValue;

  2796. 

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

  2798.                     notifyPropertyListeners('DPFs', kAudioUnitScope_Global, i);

  2799. 

  2800.                 return true;

  2801.             }

  2802.         }

  2803. 

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

  2805.         return false;

  2806.     }

  2807. 

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

  2809.     {

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

  2811.     }

  2812.    #endif

  2813. 

  2814.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginAU)

  2815. };

  2816. 

  2817. // --------------------------------------------------------------------------------------------------------------------

  2818. 

  2819. struct AudioComponentPlugInInstance {

  2820. 	AudioComponentPlugInInterface acpi;

  2821.     PluginAU* plugin;

  2822. 

  2823.     AudioComponentPlugInInstance() noexcept

  2824.         : acpi(),

  2825.           plugin(nullptr)

  2826.     {

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

  2828.         acpi.Open = Open;

  2829. 		acpi.Close = Close;

  2830. 		acpi.Lookup = Lookup;

  2831. 		acpi.reserved = nullptr;

  2832.     }

  2833. 

  2834.     ~AudioComponentPlugInInstance()

  2835.     {

  2836.         delete plugin;

  2837.     }

  2838. 

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

  2840.     {

  2841.         d_debug("AudioComponentPlugInInstance::Open(%p)", self);

  2842. 

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

  2844.         return noErr;

  2845.     }

  2846. 

  2847. 	static OSStatus Close(void* const self)

  2848.     {

  2849.         d_debug("AudioComponentPlugInInstance::Close(%p)", self);

  2850. 

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

  2852.         return noErr;

  2853.     }

  2854. 

  2855.     static AudioComponentMethod Lookup(const SInt16 selector)

  2856.     {

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

  2858. 

  2859.         switch (selector)

  2860.         {

  2861.         case kAudioUnitInitializeSelect:

  2862.             return reinterpret_cast<AudioComponentMethod>(Initialize);

  2863.         case kAudioUnitUninitializeSelect:

  2864.             return reinterpret_cast<AudioComponentMethod>(Uninitialize);

  2865.         case kAudioUnitGetPropertyInfoSelect:

  2866.             return reinterpret_cast<AudioComponentMethod>(GetPropertyInfo);

  2867.         case kAudioUnitGetPropertySelect:

  2868.             return reinterpret_cast<AudioComponentMethod>(GetProperty);

  2869.         case kAudioUnitSetPropertySelect:

  2870.             return reinterpret_cast<AudioComponentMethod>(SetProperty);

  2871.         case kAudioUnitAddPropertyListenerSelect:

  2872.             return reinterpret_cast<AudioComponentMethod>(AddPropertyListener);

  2873.         case kAudioUnitRemovePropertyListenerSelect:

  2874.             return reinterpret_cast<AudioComponentMethod>(RemovePropertyListener);

  2875.         case kAudioUnitRemovePropertyListenerWithUserDataSelect:

  2876.             return reinterpret_cast<AudioComponentMethod>(RemovePropertyListenerWithUserData);

  2877.         case kAudioUnitAddRenderNotifySelect:

  2878.             return reinterpret_cast<AudioComponentMethod>(AddRenderNotify);

  2879.         case kAudioUnitRemoveRenderNotifySelect:

  2880.             return reinterpret_cast<AudioComponentMethod>(RemoveRenderNotify);

  2881.         case kAudioUnitGetParameterSelect:

  2882.             return reinterpret_cast<AudioComponentMethod>(GetParameter);

  2883.         case kAudioUnitSetParameterSelect:

  2884.             return reinterpret_cast<AudioComponentMethod>(SetParameter);

  2885.         case kAudioUnitScheduleParametersSelect:

  2886.             return reinterpret_cast<AudioComponentMethod>(ScheduleParameters);

  2887.         case kAudioUnitRenderSelect:

  2888.             return reinterpret_cast<AudioComponentMethod>(Render);

  2889.         /*

  2890.         case kAudioUnitComplexRenderSelect:

  2891.             return reinterpret_cast<AudioComponentMethod>(ComplexRender);

  2892.         */

  2893.         case kAudioUnitResetSelect:

  2894.             return reinterpret_cast<AudioComponentMethod>(Reset);

  2895.         /*

  2896.         case kAudioUnitProcessSelect:

  2897.             return reinterpret_cast<AudioComponentMethod>(Process);

  2898.         case kAudioUnitProcessMultipleSelect:

  2899.             return reinterpret_cast<AudioComponentMethod>(ProcessMultiple);

  2900.         */

  2901.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  2902.         case kMusicDeviceMIDIEventSelect:

  2903.             return reinterpret_cast<AudioComponentMethod>(MIDIEvent);

  2904.         case kMusicDeviceSysExSelect:

  2905.             return reinterpret_cast<AudioComponentMethod>(SysEx);

  2906.        #else

  2907.         case kMusicDeviceMIDIEventSelect:

  2908.         case kMusicDeviceSysExSelect:

  2909.             return nullptr;

  2910.        #endif

  2911.         }

  2912. 

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

  2914.         return nullptr;

  2915.     }

  2916. 

  2917.     static OSStatus Initialize(AudioComponentPlugInInstance* const self)

  2918.     {

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

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

  2921.     }

  2922. 

  2923.     static OSStatus Uninitialize(AudioComponentPlugInInstance* const self)

  2924.     {

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

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

  2927.     }

  2928. 

  2929.     static OSStatus GetPropertyInfo(AudioComponentPlugInInstance* const self,

  2930.                                     const AudioUnitPropertyID inProp,

  2931.                                     const AudioUnitScope inScope,

  2932.                                     const AudioUnitElement inElement,

  2933.                                     UInt32* const outDataSize,

  2934.                                     Boolean* const outWritable)

  2935.     {

  2936.         d_debug("AudioComponentPlugInInstance::GetPropertyInfo(%p, %d:%x:%s, %d:%s, %d, ...)",

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

  2938. 

  2939. 		UInt32 dataSize = 0;

  2940. 		Boolean writable = false;

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

  2942. 

  2943. 		if (outDataSize != nullptr)

  2944. 			*outDataSize = dataSize;

  2945. 

  2946. 		if (outWritable != nullptr)

  2947. 			*outWritable = writable;

  2948. 

  2949.         return res;

  2950.     }

  2951. 

  2952.     static OSStatus GetProperty(AudioComponentPlugInInstance* const self,

  2953.                                 const AudioUnitPropertyID inProp,

  2954.                                 const AudioUnitScope inScope,

  2955.                                 const AudioUnitElement inElement,

  2956.                                 void* const outData,

  2957.                                 UInt32* const ioDataSize)

  2958.     {

  2959.        #ifdef DEBUG

  2960.         switch (inProp) {

  2961.         case kAudioUnitProperty_PresentPreset:

  2962.             break;

  2963.         default:

  2964.             d_debug("AudioComponentPlugInInstance::GetProperty(%p, %d:%x:%s, %d:%s, %d, ...)",

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

  2966.             break;

  2967.         }

  2968.        #endif

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

  2970. 

  2971.         Boolean writable;

  2972.         UInt32 outDataSize = 0;

  2973.         OSStatus res;

  2974. 

  2975.         if (outData == nullptr)

  2976.         {

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

  2978.             *ioDataSize = outDataSize;

  2979.             return res;

  2980.         }

  2981. 

  2982.         const UInt32 inDataSize = *ioDataSize;

  2983.         if (inDataSize == 0)

  2984.             return kAudio_ParamError;

  2985. 

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

  2987. 

  2988.         if (res != noErr)

  2989.             return res;

  2990. 

  2991. 		void* outBuffer;

  2992.         uint8_t* tmpBuffer;

  2993.         if (inDataSize < outDataSize)

  2994. 		{

  2995. 			tmpBuffer = new uint8_t[outDataSize];

  2996. 			outBuffer = tmpBuffer;

  2997. 		}

  2998.         else

  2999.         {

  3000. 			tmpBuffer = nullptr;

  3001. 			outBuffer = outData;

  3002. 		}

  3003. 

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

  3005. 

  3006. 		if (res != noErr)

  3007.         {

  3008. 			*ioDataSize = 0;

  3009.             return res;

  3010.         }

  3011. 

  3012.         if (tmpBuffer != nullptr)

  3013.         {

  3014.             memcpy(outData, tmpBuffer, inDataSize);

  3015.             delete[] tmpBuffer;

  3016.         }

  3017.         else

  3018.         {

  3019.             *ioDataSize = outDataSize;

  3020.         }

  3021. 

  3022.         return noErr;

  3023.     }

  3024. 

  3025.     static OSStatus SetProperty(AudioComponentPlugInInstance* const self,

  3026.                                 const AudioUnitPropertyID inProp,

  3027.                                 const AudioUnitScope inScope,

  3028.                                 const AudioUnitElement inElement,

  3029.                                 const void* const inData,

  3030.                                 const UInt32 inDataSize)

  3031.     {

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

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

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

  3035.     }

  3036. 

  3037.     static OSStatus AddPropertyListener(AudioComponentPlugInInstance* const self,

  3038.                                         const AudioUnitPropertyID prop,

  3039.                                         const AudioUnitPropertyListenerProc proc,

  3040.                                         void* const userData)

  3041.     {

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

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

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

  3045.     }

  3046. 

  3047.     static OSStatus RemovePropertyListener(AudioComponentPlugInInstance* const self,

  3048.                                            const AudioUnitPropertyID prop,

  3049.                                            const AudioUnitPropertyListenerProc proc)

  3050.     {

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

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

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

  3054.     }

  3055. 

  3056.     static OSStatus RemovePropertyListenerWithUserData(AudioComponentPlugInInstance* const self,

  3057.                                                        const AudioUnitPropertyID prop,

  3058.                                                        const AudioUnitPropertyListenerProc proc,

  3059.                                                        void* const userData)

  3060.     {

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

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

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

  3064.     }

  3065. 

  3066.     static OSStatus AddRenderNotify(AudioComponentPlugInInstance* const self,

  3067.                                     const AURenderCallback proc,

  3068.                                     void* const userData)

  3069.     {

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

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

  3072.     }

  3073. 

  3074.     static OSStatus RemoveRenderNotify(AudioComponentPlugInInstance* const self,

  3075.                                        const AURenderCallback proc,

  3076.                                        void* const userData)

  3077.     {

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

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

  3080.     }

  3081. 

  3082.     static OSStatus GetParameter(AudioComponentPlugInInstance* const self,

  3083.                                  const AudioUnitParameterID param,

  3084.                                  const AudioUnitScope scope,

  3085.                                  const AudioUnitElement elem,

  3086.                                  AudioUnitParameterValue* const value)

  3087.     {

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

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

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

  3091.     }

  3092. 

  3093.     static OSStatus SetParameter(AudioComponentPlugInInstance* const self,

  3094.                                  const AudioUnitParameterID param,

  3095.                                  const AudioUnitScope scope,

  3096.                                  const AudioUnitElement elem,

  3097.                                  const AudioUnitParameterValue value,

  3098.                                  const UInt32 bufferOffset)

  3099.     {

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

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

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

  3103.     }

  3104. 

  3105.     static OSStatus ScheduleParameters(AudioComponentPlugInInstance* const self,

  3106.                                        const AudioUnitParameterEvent* const events,

  3107.                                        const UInt32 numEvents)

  3108.     {

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

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

  3111.     }

  3112. 

  3113.     static OSStatus Reset(AudioComponentPlugInInstance* const self,

  3114.                           const AudioUnitScope scope,

  3115.                           const AudioUnitElement elem)

  3116.     {

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

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

  3119.     }

  3120. 

  3121.     static OSStatus Render(AudioComponentPlugInInstance* const self,

  3122.                            AudioUnitRenderActionFlags* ioActionFlags,

  3123.                            const AudioTimeStamp* const inTimeStamp,

  3124.                            const UInt32 inOutputBusNumber,

  3125.                            const UInt32 inNumberFrames,

  3126.                            AudioBufferList* const ioData)

  3127.     {

  3128.         const AudioUnitRenderActionFlags actionFlags = ioActionFlags != nullptr ? *ioActionFlags : 0;

  3129. 

  3130.         if ((actionFlags & kAudioUnitRenderAction_DoNotCheckRenderArgs) == 0x0)

  3131.         {

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

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

  3134.         }

  3135. 

  3136.         return self->plugin->auRender(actionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData);

  3137.     }

  3138. 

  3139.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  3140.     static OSStatus MIDIEvent(AudioComponentPlugInInstance* const self,

  3141.                               const UInt32 inStatus,

  3142.                               const UInt32 inData1,

  3143.                               const UInt32 inData2,

  3144.                               const UInt32 inOffsetSampleFrame)

  3145.     {

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

  3147.     }

  3148. 

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

  3150.     {

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

  3152.     }

  3153.    #endif

  3154. 

  3155.     DISTRHO_DECLARE_NON_COPYABLE(AudioComponentPlugInInstance)

  3156. };

  3157. 

  3158. #if 0

  3159. static OSStatus FastDispatchGetParameter(void* const self,

  3160.                                          const AudioUnitParameterID param,

  3161.                                          const AudioUnitScope scope,

  3162.                                          const AudioUnitElement elem,

  3163.                                          Float32* const value)

  3164. {

  3165.     d_debug("FastDispatchGetParameter(%p, %d, %d:%s, %d, %p)",

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

  3167.     return static_cast<AudioComponentPlugInInstance*>(self)->plugin->auGetParameter(param, scope, elem, value);

  3168. }

  3169. 

  3170. static OSStatus FastDispatchSetParameter(void* const self,

  3171.                                          const AudioUnitParameterID param,

  3172.                                          const AudioUnitScope scope,

  3173.                                          const AudioUnitElement elem,

  3174.                                          const Float32 value,

  3175.                                          const UInt32 bufferOffset)

  3176. {

  3177.     d_debug("FastDispatchSetParameter(%p, %d %d:%s, %d, %f, %u)",

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

  3179.     return static_cast<AudioComponentPlugInInstance*>(self)->plugin->auSetParameter(param, scope, elem, value, bufferOffset);

  3180. }

  3181. 

  3182. static OSStatus FastDispatchRender(void* const self,

  3183.                                    AudioUnitRenderActionFlags* const ioActionFlags,

  3184.                                    const AudioTimeStamp* const inTimeStamp,

  3185.                                    const UInt32 inBusNumber,

  3186.                                    const UInt32 inNumberFrames,

  3187.                                    AudioBufferList* const ioData)

  3188. {

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

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

  3191. 

  3192.     return static_cast<AudioComponentPlugInInstance*>(self)->plugin->auRender(ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, *ioData);

  3193. }

  3194. #endif

  3195. 

  3196. // --------------------------------------------------------------------------------------------------------------------

  3197. 

  3198. END_NAMESPACE_DISTRHO

  3199. 

  3200. DISTRHO_PLUGIN_EXPORT

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

  3202. {

  3203.     USE_NAMESPACE_DISTRHO

  3204. 

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

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

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

  3208. 

  3209.     if (d_nextBufferSize == 0)

  3210.         d_nextBufferSize = 1156;

  3211. 

  3212.     if (d_isZero(d_nextSampleRate))

  3213.         d_nextSampleRate = 44100.0;

  3214. 

  3215.     if (d_nextBundlePath == nullptr)

  3216.     {

  3217.         static String bundlePath;

  3218. 

  3219.         String tmpPath(getBinaryFilename());

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

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

  3222. 

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

  3224.         {

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

  3226.             bundlePath = tmpPath;

  3227.         }

  3228.         else

  3229.         {

  3230.             bundlePath = "error";

  3231.         }

  3232. 

  3233.         d_nextBundlePath = bundlePath.buffer();

  3234.     }

  3235. 

  3236.     d_nextCanRequestParameterValueChanges = true;

  3237. 

  3238.     return new AudioComponentPlugInInstance();

  3239. }

  3240. 

  3241. // --------------------------------------------------------------------------------------------------------------------