DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
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.
12503 Commits
9 Branches
4.0GB
Tree: cdbefa3b51
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cdbefa3b51'
${ noResults }
JUCE/modules/juce_audio_plugin_client/AU/juce_AU_Wrapper.mm

2657 lines
101KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2020 - Raw Material Software Limited

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    By using JUCE, you agree to the terms of both the JUCE 6 End-User License

  11.    Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).

  12. 

  13.    End User License Agreement: www.juce.com/juce-6-licence

  14.    Privacy Policy: www.juce.com/juce-privacy-policy

  15. 

  16.    Or: You may also use this code under the terms of the GPL v3 (see

  17.    www.gnu.org/licenses).

  18. 

  19.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  20.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  21.    DISCLAIMED.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. #include <juce_core/system/juce_TargetPlatform.h>

  27. #include <juce_core/system/juce_CompilerWarnings.h>

  28. #include "../utility/juce_CheckSettingMacros.h"

  29. 

  30. #if JucePlugin_Build_AU

  31. 

  32. #if __LP64__

  33.  #undef JUCE_SUPPORT_CARBON

  34.  #define JUCE_SUPPORT_CARBON 0

  35. #endif

  36. 

  37. JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wshorten-64-to-32",

  38.                                      "-Wunused-parameter",

  39.                                      "-Wdeprecated-declarations",

  40.                                      "-Wsign-conversion",

  41.                                      "-Wconversion",

  42.                                      "-Woverloaded-virtual",

  43.                                      "-Wextra-semi",

  44.                                      "-Wcast-align",

  45.                                      "-Wshadow",

  46.                                      "-Wswitch-enum",

  47.                                      "-Wzero-as-null-pointer-constant",

  48.                                      "-Wnullable-to-nonnull-conversion",

  49.                                      "-Wgnu-zero-variadic-macro-arguments",

  50.                                      "-Wformat-pedantic",

  51.                                      "-Wdeprecated-anon-enum-enum-conversion")

  52. 

  53. #include "../utility/juce_IncludeSystemHeaders.h"

  54. 

  55. #include <AudioUnit/AUCocoaUIView.h>

  56. #include <AudioUnit/AudioUnit.h>

  57. #include <AudioToolbox/AudioUnitUtilities.h>

  58. #include <CoreMIDI/MIDIServices.h>

  59. #include <QuartzCore/QuartzCore.h>

  60. #include "CoreAudioUtilityClasses/MusicDeviceBase.h"

  61. 

  62. /** The BUILD_AU_CARBON_UI flag lets you specify whether old-school carbon hosts are supported as

  63.     well as ones that can open a cocoa view. If this is enabled, you'll need to also add the AUCarbonBase

  64.     files to your project.

  65. */

  66. #if ! (defined (BUILD_AU_CARBON_UI) || JUCE_64BIT)

  67.  #define BUILD_AU_CARBON_UI 1

  68. #endif

  69. 

  70. #ifdef __LP64__

  71.  #undef BUILD_AU_CARBON_UI  // (not possible in a 64-bit build)

  72. #endif

  73. 

  74. #if BUILD_AU_CARBON_UI

  75.  #include "CoreAudioUtilityClasses/AUCarbonViewBase.h"

  76. #endif

  77. 

  78. JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  79. 

  80. #define JUCE_MAC_WINDOW_VISIBITY_BODGE 1

  81. #define JUCE_CORE_INCLUDE_OBJC_HELPERS 1

  82. 

  83. #include "../utility/juce_IncludeModuleHeaders.h"

  84. #include "../utility/juce_CarbonVisibility.h"

  85. 

  86. #include <juce_audio_basics/native/juce_mac_CoreAudioLayouts.h>

  87. #include <juce_audio_processors/format_types/juce_LegacyAudioParameter.cpp>

  88. #include <juce_audio_processors/format_types/juce_AU_Shared.h>

  89. 

  90. //==============================================================================

  91. using namespace juce;

  92. 

  93. static Array<void*> activePlugins, activeUIs;

  94. 

  95. static const AudioUnitPropertyID juceFilterObjectPropertyID = 0x1a45ffe9;

  96. 

  97. template <> struct ContainerDeletePolicy<const __CFString>   { static void destroy (const __CFString* o) { if (o != nullptr) CFRelease (o); } };

  98. 

  99. // make sure the audio processor is initialized before the AUBase class

  100. struct AudioProcessorHolder

  101. {

  102.     AudioProcessorHolder (bool initialiseGUI)

  103.     {

  104.         if (initialiseGUI)

  105.         {

  106.            #if BUILD_AU_CARBON_UI

  107.             NSApplicationLoad();

  108.            #endif

  109. 

  110.             initialiseJuce_GUI();

  111.         }

  112. 

  113.         juceFilter.reset (createPluginFilterOfType (AudioProcessor::wrapperType_AudioUnit));

  114. 

  115.         // audio units do not have a notion of enabled or un-enabled buses

  116.         juceFilter->enableAllBuses();

  117.     }

  118. 

  119.     std::unique_ptr<AudioProcessor> juceFilter;

  120. };

  121. 

  122. //==============================================================================

  123. class JuceAU   : public AudioProcessorHolder,

  124.                  public MusicDeviceBase,

  125.                  public AudioProcessorListener,

  126.                  public AudioPlayHead,

  127.                  public AudioProcessorParameter::Listener

  128. {

  129. public:

  130.     JuceAU (AudioUnit component)

  131.         : AudioProcessorHolder (activePlugins.size() + activeUIs.size() == 0),

  132.           MusicDeviceBase (component,

  133.                            (UInt32) AudioUnitHelpers::getBusCountForWrapper (*juceFilter, true),

  134.                            (UInt32) AudioUnitHelpers::getBusCountForWrapper (*juceFilter, false)),

  135.           mapper (*juceFilter)

  136.     {

  137.         inParameterChangedCallback = false;

  138. 

  139.        #ifdef JucePlugin_PreferredChannelConfigurations

  140.         short configs[][2] = {JucePlugin_PreferredChannelConfigurations};

  141.         const int numConfigs = sizeof (configs) / sizeof (short[2]);

  142. 

  143.         jassert (numConfigs > 0 && (configs[0][0] > 0 || configs[0][1] > 0));

  144.         juceFilter->setPlayConfigDetails (configs[0][0], configs[0][1], 44100.0, 1024);

  145. 

  146.         for (int i = 0; i < numConfigs; ++i)

  147.         {

  148.             AUChannelInfo info;

  149. 

  150.             info.inChannels  = configs[i][0];

  151.             info.outChannels = configs[i][1];

  152. 

  153.             channelInfo.add (info);

  154.         }

  155.        #else

  156.         channelInfo = AudioUnitHelpers::getAUChannelInfo (*juceFilter);

  157.        #endif

  158. 

  159.         AddPropertyListener (kAudioUnitProperty_ContextName, auPropertyListenerDispatcher, this);

  160. 

  161.         totalInChannels  = juceFilter->getTotalNumInputChannels();

  162.         totalOutChannels = juceFilter->getTotalNumOutputChannels();

  163. 

  164.         juceFilter->setPlayHead (this);

  165.         juceFilter->addListener (this);

  166. 

  167.         addParameters();

  168. 

  169.         activePlugins.add (this);

  170. 

  171.         zerostruct (auEvent);

  172.         auEvent.mArgument.mParameter.mAudioUnit = GetComponentInstance();

  173.         auEvent.mArgument.mParameter.mScope = kAudioUnitScope_Global;

  174.         auEvent.mArgument.mParameter.mElement = 0;

  175. 

  176.         zerostruct (midiCallback);

  177. 

  178.         CreateElements();

  179. 

  180.         if (syncAudioUnitWithProcessor() != noErr)

  181.             jassertfalse;

  182.     }

  183. 

  184.     ~JuceAU() override

  185.     {

  186.         if (bypassParam != nullptr)

  187.             bypassParam->removeListener (this);

  188. 

  189.         deleteActiveEditors();

  190.         juceFilter = nullptr;

  191.         clearPresetsArray();

  192. 

  193.         jassert (activePlugins.contains (this));

  194.         activePlugins.removeFirstMatchingValue (this);

  195. 

  196.         if (activePlugins.size() + activeUIs.size() == 0)

  197.             shutdownJuce_GUI();

  198.     }

  199. 

  200.     //==============================================================================

  201.     ComponentResult Initialize() override

  202.     {

  203.         ComponentResult err;

  204. 

  205.         if ((err = syncProcessorWithAudioUnit()) != noErr)

  206.             return err;

  207. 

  208.         if ((err = MusicDeviceBase::Initialize()) != noErr)

  209.             return err;

  210. 

  211.         mapper.alloc();

  212.         pulledSucceeded.calloc (static_cast<size_t> (AudioUnitHelpers::getBusCountForWrapper (*juceFilter, true)));

  213. 

  214.         prepareToPlay();

  215. 

  216.         return noErr;

  217.     }

  218. 

  219.     void Cleanup() override

  220.     {

  221.         MusicDeviceBase::Cleanup();

  222. 

  223.         pulledSucceeded.free();

  224.         mapper.release();

  225. 

  226.         if (juceFilter != nullptr)

  227.             juceFilter->releaseResources();

  228. 

  229.         audioBuffer.release();

  230.         midiEvents.clear();

  231.         incomingEvents.clear();

  232.         prepared = false;

  233.     }

  234. 

  235.     ComponentResult Reset (AudioUnitScope inScope, AudioUnitElement inElement) override

  236.     {

  237.         if (! prepared)

  238.             prepareToPlay();

  239. 

  240.         if (juceFilter != nullptr)

  241.             juceFilter->reset();

  242. 

  243.         return MusicDeviceBase::Reset (inScope, inElement);

  244.     }

  245. 

  246.     //==============================================================================

  247.     void prepareToPlay()

  248.     {

  249.         if (juceFilter != nullptr)

  250.         {

  251.             juceFilter->setRateAndBufferSizeDetails (getSampleRate(), (int) GetMaxFramesPerSlice());

  252. 

  253.             audioBuffer.prepare (totalInChannels, totalOutChannels, (int) GetMaxFramesPerSlice() + 32);

  254.             juceFilter->prepareToPlay (getSampleRate(), (int) GetMaxFramesPerSlice());

  255. 

  256.             midiEvents.ensureSize (2048);

  257.             midiEvents.clear();

  258.             incomingEvents.ensureSize (2048);

  259.             incomingEvents.clear();

  260. 

  261.             prepared = true;

  262.         }

  263.     }

  264. 

  265.     //==============================================================================

  266.     static OSStatus ComponentEntryDispatch (ComponentParameters* params, JuceAU* effect)

  267.     {

  268.         if (effect == nullptr)

  269.             return paramErr;

  270. 

  271.         switch (params->what)

  272.         {

  273.             case kMusicDeviceMIDIEventSelect:

  274.             case kMusicDeviceSysExSelect:

  275.                 return AUMIDIBase::ComponentEntryDispatch (params, effect);

  276.             default:

  277.                 break;

  278.         }

  279. 

  280.         return MusicDeviceBase::ComponentEntryDispatch (params, effect);

  281.     }

  282. 

  283.     //==============================================================================

  284.     bool BusCountWritable (AudioUnitScope scope) override

  285.     {

  286.        #ifdef JucePlugin_PreferredChannelConfigurations

  287.         ignoreUnused (scope);

  288. 

  289.         return false;

  290.        #else

  291.         bool isInput;

  292. 

  293.         if (scopeToDirection (scope, isInput) != noErr)

  294.             return false;

  295. 

  296.        #if JucePlugin_IsMidiEffect

  297.         return false;

  298.        #elif JucePlugin_IsSynth

  299.         if (isInput) return false;

  300.        #endif

  301. 

  302.         const int busCount = AudioUnitHelpers::getBusCount (*juceFilter, isInput);

  303.         return (juceFilter->canAddBus (isInput) || (busCount > 0 && juceFilter->canRemoveBus (isInput)));

  304.        #endif

  305.     }

  306. 

  307.     OSStatus SetBusCount (AudioUnitScope scope, UInt32 count) override

  308.     {

  309.         OSStatus err = noErr;

  310.         bool isInput;

  311. 

  312.         if ((err = scopeToDirection (scope, isInput)) != noErr)

  313.             return err;

  314. 

  315.         if (count != (UInt32) AudioUnitHelpers::getBusCount (*juceFilter, isInput))

  316.         {

  317.            #ifdef JucePlugin_PreferredChannelConfigurations

  318.             return kAudioUnitErr_PropertyNotWritable;

  319.            #else

  320.             const int busCount = AudioUnitHelpers::getBusCount (*juceFilter, isInput);

  321. 

  322.             if  ((! juceFilter->canAddBus (isInput)) && ((busCount == 0) || (! juceFilter->canRemoveBus (isInput))))

  323.                 return kAudioUnitErr_PropertyNotWritable;

  324. 

  325.             // we need to already create the underlying elements so that we can change their formats

  326.             err = MusicDeviceBase::SetBusCount (scope, count);

  327. 

  328.             if (err != noErr)

  329.                 return err;

  330. 

  331.             // however we do need to update the format tag: we need to do the same thing in SetFormat, for example

  332.             const int requestedNumBus = static_cast<int> (count);

  333.             {

  334.                 (isInput ? currentInputLayout : currentOutputLayout).resize (requestedNumBus);

  335. 

  336.                 int busNr;

  337. 

  338.                 for (busNr = (busCount - 1); busNr != (requestedNumBus - 1); busNr += (requestedNumBus > busCount ? 1 : -1))

  339.                 {

  340.                     if (requestedNumBus > busCount)

  341.                     {

  342.                         if (! juceFilter->addBus (isInput))

  343.                             break;

  344. 

  345.                         err = syncAudioUnitWithChannelSet (isInput, busNr,

  346.                                                            juceFilter->getBus (isInput, busNr + 1)->getDefaultLayout());

  347.                         if (err != noErr)

  348.                             break;

  349.                     }

  350.                     else

  351.                     {

  352.                         if (! juceFilter->removeBus (isInput))

  353.                             break;

  354.                     }

  355.                 }

  356. 

  357.                 err = (busNr == (requestedNumBus - 1) ? (OSStatus) noErr : (OSStatus) kAudioUnitErr_FormatNotSupported);

  358.             }

  359. 

  360.             // was there an error?

  361.             if (err != noErr)

  362.             {

  363.                 // restore bus state

  364.                 const int newBusCount = AudioUnitHelpers::getBusCount (*juceFilter, isInput);

  365.                 for (int i = newBusCount; i != busCount; i += (busCount > newBusCount ? 1 : -1))

  366.                 {

  367.                     if (busCount > newBusCount)

  368.                         juceFilter->addBus (isInput);

  369.                     else

  370.                         juceFilter->removeBus (isInput);

  371.                 }

  372. 

  373.                 (isInput ? currentInputLayout : currentOutputLayout).resize (busCount);

  374.                 MusicDeviceBase::SetBusCount (scope, static_cast<UInt32> (busCount));

  375. 

  376.                 return kAudioUnitErr_FormatNotSupported;

  377.             }

  378. 

  379.             // update total channel count

  380.             totalInChannels  = juceFilter->getTotalNumInputChannels();

  381.             totalOutChannels = juceFilter->getTotalNumOutputChannels();

  382. 

  383.             addSupportedLayoutTagsForDirection (isInput);

  384. 

  385.             if (err != noErr)

  386.                 return err;

  387.            #endif

  388.         }

  389. 

  390.         return noErr;

  391.     }

  392. 

  393.     UInt32 SupportedNumChannels (const AUChannelInfo** outInfo) override

  394.     {

  395.         if (outInfo != nullptr)

  396.             *outInfo = channelInfo.getRawDataPointer();

  397. 

  398.         return (UInt32) channelInfo.size();

  399.     }

  400. 

  401.     //==============================================================================

  402.     ComponentResult GetPropertyInfo (AudioUnitPropertyID inID,

  403.                                      AudioUnitScope inScope,

  404.                                      AudioUnitElement inElement,

  405.                                      UInt32& outDataSize,

  406.                                      Boolean& outWritable) override

  407.     {

  408.         if (inScope == kAudioUnitScope_Global)

  409.         {

  410.             switch (inID)

  411.             {

  412.                 case juceFilterObjectPropertyID:

  413.                     outWritable = false;

  414.                     outDataSize = sizeof (void*) * 2;

  415.                     return noErr;

  416. 

  417.                 case kAudioUnitProperty_OfflineRender:

  418.                     outWritable = true;

  419.                     outDataSize = sizeof (UInt32);

  420.                     return noErr;

  421. 

  422.                 case kMusicDeviceProperty_InstrumentCount:

  423.                     outDataSize = sizeof (UInt32);

  424.                     outWritable = false;

  425.                     return noErr;

  426. 

  427.                 case kAudioUnitProperty_CocoaUI:

  428.                     outDataSize = sizeof (AudioUnitCocoaViewInfo);

  429.                     outWritable = true;

  430.                     return noErr;

  431. 

  432.                #if JucePlugin_ProducesMidiOutput || JucePlugin_IsMidiEffect

  433.                 case kAudioUnitProperty_MIDIOutputCallbackInfo:

  434.                     outDataSize = sizeof (CFArrayRef);

  435.                     outWritable = false;

  436.                     return noErr;

  437. 

  438.                 case kAudioUnitProperty_MIDIOutputCallback:

  439.                     outDataSize = sizeof (AUMIDIOutputCallbackStruct);

  440.                     outWritable = true;

  441.                     return noErr;

  442.                #endif

  443. 

  444.                 case kAudioUnitProperty_ParameterStringFromValue:

  445.                      outDataSize = sizeof (AudioUnitParameterStringFromValue);

  446.                      outWritable = false;

  447.                      return noErr;

  448. 

  449.                 case kAudioUnitProperty_ParameterValueFromString:

  450.                      outDataSize = sizeof (AudioUnitParameterValueFromString);

  451.                      outWritable = false;

  452.                      return noErr;

  453. 

  454.                 case kAudioUnitProperty_BypassEffect:

  455.                     outDataSize = sizeof (UInt32);

  456.                     outWritable = true;

  457.                     return noErr;

  458. 

  459.                 case kAudioUnitProperty_SupportsMPE:

  460.                     outDataSize = sizeof (UInt32);

  461.                     outWritable = false;

  462.                     return noErr;

  463. 

  464.                 default: break;

  465.             }

  466.         }

  467. 

  468.         return MusicDeviceBase::GetPropertyInfo (inID, inScope, inElement, outDataSize, outWritable);

  469.     }

  470. 

  471.     ComponentResult GetProperty (AudioUnitPropertyID inID,

  472.                                  AudioUnitScope inScope,

  473.                                  AudioUnitElement inElement,

  474.                                  void* outData) override

  475.     {

  476.         if (inScope == kAudioUnitScope_Global)

  477.         {

  478.             switch (inID)

  479.             {

  480.                 case kAudioUnitProperty_ParameterClumpName:

  481. 

  482.                     if (auto* clumpNameInfo = (AudioUnitParameterNameInfo*) outData)

  483.                     {

  484.                         if (juceFilter != nullptr)

  485.                         {

  486.                             auto clumpIndex = clumpNameInfo->inID - 1;

  487.                             const auto* group = parameterGroups[(int) clumpIndex];

  488.                             auto name = group->getName();

  489. 

  490.                             while (group->getParent() != &juceFilter->getParameterTree())

  491.                             {

  492.                                 group = group->getParent();

  493.                                 name = group->getName() + group->getSeparator() + name;

  494.                             }

  495. 

  496.                             clumpNameInfo->outName = name.toCFString();

  497.                             return noErr;

  498.                         }

  499.                     }

  500. 

  501.                     // Failed to find a group corresponding to the clump ID.

  502.                     jassertfalse;

  503.                     break;

  504. 

  505.                 case juceFilterObjectPropertyID:

  506.                     ((void**) outData)[0] = (void*) static_cast<AudioProcessor*> (juceFilter.get());

  507.                     ((void**) outData)[1] = (void*) this;

  508.                     return noErr;

  509. 

  510.                 case kAudioUnitProperty_OfflineRender:

  511.                     *(UInt32*) outData = (juceFilter != nullptr && juceFilter->isNonRealtime()) ? 1 : 0;

  512.                     return noErr;

  513. 

  514.                 case kMusicDeviceProperty_InstrumentCount:

  515.                     *(UInt32*) outData = 1;

  516.                     return noErr;

  517. 

  518.                 case kAudioUnitProperty_BypassEffect:

  519.                     if (bypassParam != nullptr)

  520.                         *(UInt32*) outData = (bypassParam->getValue() != 0.0f ? 1 : 0);

  521.                     else

  522.                         *(UInt32*) outData = isBypassed ? 1 : 0;

  523.                     return noErr;

  524. 

  525.                 case kAudioUnitProperty_SupportsMPE:

  526.                     *(UInt32*) outData = (juceFilter != nullptr && juceFilter->supportsMPE()) ? 1 : 0;

  527.                     return noErr;

  528. 

  529.                 case kAudioUnitProperty_CocoaUI:

  530.                     {

  531.                         JUCE_AUTORELEASEPOOL

  532.                         {

  533.                             static JuceUICreationClass cls;

  534. 

  535.                             // (NB: this may be the host's bundle, not necessarily the component's)

  536.                             NSBundle* bundle = [NSBundle bundleForClass: cls.cls];

  537. 

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

  539.                             info->mCocoaAUViewClass[0] = (CFStringRef) [juceStringToNS (class_getName (cls.cls)) retain];

  540.                             info->mCocoaAUViewBundleLocation = (CFURLRef) [[NSURL fileURLWithPath: [bundle bundlePath]] retain];

  541.                         }

  542. 

  543.                         return noErr;

  544.                     }

  545. 

  546.                     break;

  547. 

  548.                #if JucePlugin_ProducesMidiOutput || JucePlugin_IsMidiEffect

  549.                 case kAudioUnitProperty_MIDIOutputCallbackInfo:

  550.                 {

  551.                     CFStringRef strs[1];

  552.                     strs[0] = CFSTR ("MIDI Callback");

  553. 

  554.                     CFArrayRef callbackArray = CFArrayCreate (nullptr, (const void**) strs, 1, &kCFTypeArrayCallBacks);

  555.                     *(CFArrayRef*) outData = callbackArray;

  556.                     return noErr;

  557.                 }

  558.                #endif

  559. 

  560.                 case kAudioUnitProperty_ParameterValueFromString:

  561.                 {

  562.                     if (AudioUnitParameterValueFromString* pv = (AudioUnitParameterValueFromString*) outData)

  563.                     {

  564.                         if (juceFilter != nullptr)

  565.                         {

  566.                             if (auto* param = getParameterForAUParameterID (pv->inParamID))

  567.                             {

  568.                                 const String text (String::fromCFString (pv->inString));

  569. 

  570.                                 if (LegacyAudioParameter::isLegacy (param))

  571.                                     pv->outValue = text.getFloatValue();

  572.                                 else

  573.                                     pv->outValue = param->getValueForText (text) * getMaximumParameterValue (param);

  574. 

  575. 

  576.                                 return noErr;

  577.                             }

  578.                         }

  579.                     }

  580.                 }

  581.                 break;

  582. 

  583.                 case kAudioUnitProperty_ParameterStringFromValue:

  584.                 {

  585.                     if (AudioUnitParameterStringFromValue* pv = (AudioUnitParameterStringFromValue*) outData)

  586.                     {

  587.                         if (juceFilter != nullptr)

  588.                         {

  589.                             if (auto* param = getParameterForAUParameterID (pv->inParamID))

  590.                             {

  591.                                 const float value = (float) *(pv->inValue);

  592.                                 String text;

  593. 

  594.                                 if (LegacyAudioParameter::isLegacy (param))

  595.                                     text = String (value);

  596.                                 else

  597.                                     text = param->getText (value / getMaximumParameterValue (param), 0);

  598. 

  599.                                 pv->outString = text.toCFString();

  600. 

  601.                                 return noErr;

  602.                             }

  603.                         }

  604.                     }

  605.                 }

  606.                 break;

  607. 

  608.                 default:

  609.                     break;

  610.             }

  611.         }

  612. 

  613.         return MusicDeviceBase::GetProperty (inID, inScope, inElement, outData);

  614.     }

  615. 

  616.     ComponentResult SetProperty (AudioUnitPropertyID inID,

  617.                                  AudioUnitScope inScope,

  618.                                  AudioUnitElement inElement,

  619.                                  const void* inData,

  620.                                  UInt32 inDataSize) override

  621.     {

  622.         if (inScope == kAudioUnitScope_Global)

  623.         {

  624.             switch (inID)

  625.             {

  626.                #if JucePlugin_ProducesMidiOutput || JucePlugin_IsMidiEffect

  627.                 case kAudioUnitProperty_MIDIOutputCallback:

  628.                     if (inDataSize < sizeof (AUMIDIOutputCallbackStruct))

  629.                         return kAudioUnitErr_InvalidPropertyValue;

  630. 

  631.                     if (AUMIDIOutputCallbackStruct* callbackStruct = (AUMIDIOutputCallbackStruct*) inData)

  632.                         midiCallback = *callbackStruct;

  633. 

  634.                     return noErr;

  635.                #endif

  636. 

  637.                 case kAudioUnitProperty_BypassEffect:

  638.                 {

  639.                     if (inDataSize < sizeof (UInt32))

  640.                         return kAudioUnitErr_InvalidPropertyValue;

  641. 

  642.                     const bool newBypass = *((UInt32*) inData) != 0;

  643.                     const bool currentlyBypassed = (bypassParam != nullptr ? (bypassParam->getValue() != 0.0f) : isBypassed);

  644. 

  645.                     if (newBypass != currentlyBypassed)

  646.                     {

  647.                         if (bypassParam != nullptr)

  648.                             bypassParam->setValueNotifyingHost (newBypass ? 1.0f : 0.0f);

  649.                         else

  650.                             isBypassed = newBypass;

  651. 

  652.                         if (! currentlyBypassed && IsInitialized()) // turning bypass off and we're initialized

  653.                             Reset (0, 0);

  654.                     }

  655. 

  656.                     return noErr;

  657.                 }

  658. 

  659.                 case kAudioUnitProperty_OfflineRender:

  660.                 {

  661.                     const auto shouldBeOffline = (*reinterpret_cast<const UInt32*> (inData) != 0);

  662. 

  663.                     if (juceFilter != nullptr)

  664.                     {

  665.                         const auto isOffline = juceFilter->isNonRealtime();

  666. 

  667.                         if (isOffline != shouldBeOffline)

  668.                         {

  669.                             const ScopedLock sl (juceFilter->getCallbackLock());

  670. 

  671.                             juceFilter->setNonRealtime (shouldBeOffline);

  672.                             juceFilter->prepareToPlay (getSampleRate(), (int) GetMaxFramesPerSlice());

  673.                         }

  674.                     }

  675. 

  676.                     return noErr;

  677.                 }

  678. 

  679.                #if defined (MAC_OS_X_VERSION_10_12)

  680.                 case kAudioUnitProperty_AUHostIdentifier:

  681.                 {

  682.                     if (inDataSize < sizeof (AUHostVersionIdentifier))

  683.                         return kAudioUnitErr_InvalidPropertyValue;

  684. 

  685.                     const auto* identifier = static_cast<const AUHostVersionIdentifier*> (inData);

  686.                     PluginHostType::hostIdReportedByWrapper = String::fromCFString (identifier->hostName);

  687. 

  688.                     return noErr;

  689.                 }

  690.                #endif

  691. 

  692.                 default: break;

  693.             }

  694.         }

  695. 

  696.         return MusicDeviceBase::SetProperty (inID, inScope, inElement, inData, inDataSize);

  697.     }

  698. 

  699.     //==============================================================================

  700.     ComponentResult SaveState (CFPropertyListRef* outData) override

  701.     {

  702.         ComponentResult err = MusicDeviceBase::SaveState (outData);

  703. 

  704.         if (err != noErr)

  705.             return err;

  706. 

  707.         jassert (CFGetTypeID (*outData) == CFDictionaryGetTypeID());

  708. 

  709.         CFMutableDictionaryRef dict = (CFMutableDictionaryRef) *outData;

  710. 

  711.         if (juceFilter != nullptr)

  712.         {

  713.             juce::MemoryBlock state;

  714. 

  715.            #if JUCE_AU_WRAPPERS_SAVE_PROGRAM_STATES

  716.             juceFilter->getCurrentProgramStateInformation (state);

  717.            #else

  718.             juceFilter->getStateInformation (state);

  719.            #endif

  720. 

  721.             if (state.getSize() > 0)

  722.             {

  723.                 CFUniquePtr<CFDataRef> ourState (CFDataCreate (kCFAllocatorDefault, (const UInt8*) state.getData(), (CFIndex) state.getSize()));

  724.                 CFUniquePtr<CFStringRef> key (CFStringCreateWithCString (kCFAllocatorDefault, JUCE_STATE_DICTIONARY_KEY, kCFStringEncodingUTF8));

  725.                 CFDictionarySetValue (dict, key.get(), ourState.get());

  726.             }

  727.         }

  728. 

  729.         return noErr;

  730.     }

  731. 

  732.     ComponentResult RestoreState (CFPropertyListRef inData) override

  733.     {

  734.         {

  735.             // Remove the data entry from the state to prevent the superclass loading the parameters

  736.             CFUniquePtr<CFMutableDictionaryRef> copyWithoutData (CFDictionaryCreateMutableCopy (nullptr, 0, (CFDictionaryRef) inData));

  737.             CFDictionaryRemoveValue (copyWithoutData.get(), CFSTR (kAUPresetDataKey));

  738.             ComponentResult err = MusicDeviceBase::RestoreState (copyWithoutData.get());

  739. 

  740.             if (err != noErr)

  741.                 return err;

  742.         }

  743. 

  744.         if (juceFilter != nullptr)

  745.         {

  746.             CFDictionaryRef dict = (CFDictionaryRef) inData;

  747.             CFDataRef data = nullptr;

  748. 

  749.             CFUniquePtr<CFStringRef> key (CFStringCreateWithCString (kCFAllocatorDefault, JUCE_STATE_DICTIONARY_KEY, kCFStringEncodingUTF8));

  750. 

  751.             bool valuePresent = CFDictionaryGetValueIfPresent (dict, key.get(), (const void**) &data);

  752. 

  753.             if (valuePresent)

  754.             {

  755.                 if (data != nullptr)

  756.                 {

  757.                     const int numBytes = (int) CFDataGetLength (data);

  758.                     const juce::uint8* const rawBytes = CFDataGetBytePtr (data);

  759. 

  760.                     if (numBytes > 0)

  761.                     {

  762.                        #if JUCE_AU_WRAPPERS_SAVE_PROGRAM_STATES

  763.                         juceFilter->setCurrentProgramStateInformation (rawBytes, numBytes);

  764.                        #else

  765.                         juceFilter->setStateInformation (rawBytes, numBytes);

  766.                        #endif

  767.                     }

  768.                 }

  769.             }

  770.         }

  771. 

  772.         return noErr;

  773.     }

  774. 

  775.     //==============================================================================

  776.     bool busIgnoresLayout (bool isInput, int busNr) const

  777.     {

  778.        #ifdef JucePlugin_PreferredChannelConfigurations

  779.         ignoreUnused (isInput, busNr);

  780. 

  781.         return true;

  782.        #else

  783.         if (const AudioProcessor::Bus* bus = juceFilter->getBus (isInput, busNr))

  784.         {

  785.             AudioChannelSet discreteRangeSet;

  786.             const int n = bus->getDefaultLayout().size();

  787.             for (int i = 0; i < n; ++i)

  788.                 discreteRangeSet.addChannel ((AudioChannelSet::ChannelType) (256 + i));

  789. 

  790.             // if the audioprocessor supports this it cannot

  791.             // really be interested in the bus layouts

  792.             return bus->isLayoutSupported (discreteRangeSet);

  793.         }

  794. 

  795.         return true;

  796.        #endif

  797.     }

  798. 

  799.     UInt32 GetAudioChannelLayout (AudioUnitScope scope, AudioUnitElement element,

  800.                                   AudioChannelLayout* outLayoutPtr, Boolean& outWritable) override

  801.     {

  802.         outWritable = false;

  803. 

  804.         const auto info = getElementInfo (scope, element);

  805. 

  806.         if (info.error != noErr)

  807.             return 0;

  808. 

  809.         if (busIgnoresLayout (info.isInput, info.busNr))

  810.             return 0;

  811. 

  812.         outWritable = true;

  813. 

  814.         const size_t sizeInBytes = sizeof (AudioChannelLayout) - sizeof (AudioChannelDescription);

  815. 

  816.         if (outLayoutPtr != nullptr)

  817.         {

  818.             zeromem (outLayoutPtr, sizeInBytes);

  819.             outLayoutPtr->mChannelLayoutTag = getCurrentLayout (info.isInput, info.busNr);

  820.         }

  821. 

  822.         return sizeInBytes;

  823.     }

  824. 

  825.     UInt32 GetChannelLayoutTags (AudioUnitScope scope, AudioUnitElement element, AudioChannelLayoutTag* outLayoutTags) override

  826.     {

  827.         const auto info = getElementInfo (scope, element);

  828. 

  829.         if (info.error != noErr)

  830.             return 0;

  831. 

  832.         if (busIgnoresLayout (info.isInput, info.busNr))

  833.             return 0;

  834. 

  835.         const Array<AudioChannelLayoutTag>& layouts = getSupportedBusLayouts (info.isInput, info.busNr);

  836. 

  837.         if (outLayoutTags != nullptr)

  838.             std::copy (layouts.begin(), layouts.end(), outLayoutTags);

  839. 

  840.         return (UInt32) layouts.size();

  841.     }

  842. 

  843.     OSStatus SetAudioChannelLayout (AudioUnitScope scope, AudioUnitElement element, const AudioChannelLayout* inLayout) override

  844.     {

  845.         const auto info = getElementInfo (scope, element);

  846. 

  847.         if (info.error != noErr)

  848.             return info.error;

  849. 

  850.         if (busIgnoresLayout (info.isInput, info.busNr))

  851.             return kAudioUnitErr_PropertyNotWritable;

  852. 

  853.         if (inLayout == nullptr)

  854.             return kAudioUnitErr_InvalidPropertyValue;

  855. 

  856.         if (const AUIOElement* ioElement = GetIOElement (info.isInput ? kAudioUnitScope_Input : kAudioUnitScope_Output, element))

  857.         {

  858.             const AudioChannelSet newChannelSet = CoreAudioLayouts::fromCoreAudio (*inLayout);

  859.             const int currentNumChannels = static_cast<int> (ioElement->GetStreamFormat().NumberChannels());

  860.             const int newChannelNum = newChannelSet.size();

  861. 

  862.             if (currentNumChannels != newChannelNum)

  863.                 return kAudioUnitErr_InvalidPropertyValue;

  864. 

  865.             // check if the new layout could be potentially set

  866.            #ifdef JucePlugin_PreferredChannelConfigurations

  867.             short configs[][2] = {JucePlugin_PreferredChannelConfigurations};

  868. 

  869.             if (! AudioUnitHelpers::isLayoutSupported (*juceFilter, info.isInput, info.busNr, newChannelNum, configs))

  870.                 return kAudioUnitErr_FormatNotSupported;

  871.            #else

  872.             if (! juceFilter->getBus (info.isInput, info.busNr)->isLayoutSupported (newChannelSet))

  873.                 return kAudioUnitErr_FormatNotSupported;

  874.            #endif

  875. 

  876.             getCurrentLayout (info.isInput, info.busNr) = CoreAudioLayouts::toCoreAudio (newChannelSet);

  877. 

  878.             return noErr;

  879.         }

  880.         else

  881.             jassertfalse;

  882. 

  883.         return kAudioUnitErr_InvalidElement;

  884.     }

  885. 

  886.     //==============================================================================

  887.     // When parameters are discrete we need to use integer values.

  888.     float getMaximumParameterValue (AudioProcessorParameter* juceParam)

  889.     {

  890.        #if JUCE_FORCE_LEGACY_PARAMETER_AUTOMATION_TYPE

  891.         ignoreUnused (juceParam);

  892.         return 1.0f;

  893.        #else

  894.         return juceParam->isDiscrete() ? (float) (juceParam->getNumSteps() - 1) : 1.0f;

  895.        #endif

  896.     }

  897. 

  898.     ComponentResult GetParameterInfo (AudioUnitScope inScope,

  899.                                       AudioUnitParameterID inParameterID,

  900.                                       AudioUnitParameterInfo& outParameterInfo) override

  901.     {

  902.         if (inScope == kAudioUnitScope_Global && juceFilter != nullptr)

  903.         {

  904.             if (auto* param = getParameterForAUParameterID (inParameterID))

  905.             {

  906.                 outParameterInfo.unit = kAudioUnitParameterUnit_Generic;

  907.                 outParameterInfo.flags = (UInt32) (kAudioUnitParameterFlag_IsWritable

  908.                                                     | kAudioUnitParameterFlag_IsReadable

  909.                                                     | kAudioUnitParameterFlag_HasCFNameString

  910.                                                     | kAudioUnitParameterFlag_ValuesHaveStrings);

  911. 

  912.                #if ! JUCE_FORCE_LEGACY_PARAMETER_AUTOMATION_TYPE

  913.                 outParameterInfo.flags |= (UInt32) kAudioUnitParameterFlag_IsHighResolution;

  914.                #endif

  915. 

  916.                 const String name = param->getName (1024);

  917. 

  918.                 // Set whether the param is automatable (unnamed parameters aren't allowed to be automated)

  919.                 if (name.isEmpty() || ! param->isAutomatable())

  920.                     outParameterInfo.flags |= kAudioUnitParameterFlag_NonRealTime;

  921. 

  922.                 const bool isParameterDiscrete = param->isDiscrete();

  923. 

  924.                 if (! isParameterDiscrete)

  925.                     outParameterInfo.flags |= kAudioUnitParameterFlag_CanRamp;

  926. 

  927.                 if (param->isMetaParameter())

  928.                     outParameterInfo.flags |= kAudioUnitParameterFlag_IsGlobalMeta;

  929. 

  930.                 auto parameterGroupHierarchy = juceFilter->getParameterTree().getGroupsForParameter (param);

  931. 

  932.                 if (! parameterGroupHierarchy.isEmpty())

  933.                 {

  934.                     outParameterInfo.flags |= kAudioUnitParameterFlag_HasClump;

  935.                     outParameterInfo.clumpID = (UInt32) parameterGroups.indexOf (parameterGroupHierarchy.getLast()) + 1;

  936.                 }

  937. 

  938.                 // Is this a meter?

  939.                 if ((((unsigned int) param->getCategory() & 0xffff0000) >> 16) == 2)

  940.                 {

  941.                     outParameterInfo.flags &= ~kAudioUnitParameterFlag_IsWritable;

  942.                     outParameterInfo.flags |= kAudioUnitParameterFlag_MeterReadOnly | kAudioUnitParameterFlag_DisplayLogarithmic;

  943.                     outParameterInfo.unit = kAudioUnitParameterUnit_LinearGain;

  944.                 }

  945.                 else

  946.                 {

  947.                    #if ! JUCE_FORCE_LEGACY_PARAMETER_AUTOMATION_TYPE

  948.                     if (isParameterDiscrete)

  949.                         outParameterInfo.unit = param->isBoolean() ? kAudioUnitParameterUnit_Boolean

  950.                                                                    : kAudioUnitParameterUnit_Indexed;

  951.                    #endif

  952.                 }

  953. 

  954.                 MusicDeviceBase::FillInParameterName (outParameterInfo, name.toCFString(), true);

  955. 

  956.                 outParameterInfo.minValue = 0.0f;

  957.                 outParameterInfo.maxValue = getMaximumParameterValue (param);

  958.                 outParameterInfo.defaultValue = param->getDefaultValue() * getMaximumParameterValue (param);

  959.                 jassert (outParameterInfo.defaultValue >= outParameterInfo.minValue

  960.                       && outParameterInfo.defaultValue <= outParameterInfo.maxValue);

  961. 

  962.                 return noErr;

  963.             }

  964.         }

  965. 

  966.         return kAudioUnitErr_InvalidParameter;

  967.     }

  968. 

  969.     ComponentResult GetParameterValueStrings (AudioUnitScope inScope,

  970.                                               AudioUnitParameterID inParameterID,

  971.                                               CFArrayRef *outStrings) override

  972.     {

  973.         if (outStrings == nullptr)

  974.             return noErr;

  975. 

  976.         if (inScope == kAudioUnitScope_Global && juceFilter != nullptr)

  977.         {

  978.             if (auto* param = getParameterForAUParameterID (inParameterID))

  979.             {

  980.                 if (param->isDiscrete())

  981.                 {

  982.                     auto index = LegacyAudioParameter::getParamIndex (*juceFilter, param);

  983. 

  984.                     if (auto* valueStrings = parameterValueStringArrays[index])

  985.                     {

  986.                         *outStrings = CFArrayCreate (nullptr,

  987.                                                      (const void **) valueStrings->getRawDataPointer(),

  988.                                                      valueStrings->size(),

  989.                                                      nullptr);

  990. 

  991.                         return noErr;

  992.                     }

  993.                 }

  994.             }

  995.         }

  996. 

  997.         return kAudioUnitErr_InvalidParameter;

  998.     }

  999. 

  1000.     ComponentResult GetParameter (AudioUnitParameterID inID,

  1001.                                   AudioUnitScope inScope,

  1002.                                   AudioUnitElement inElement,

  1003.                                   Float32& outValue) override

  1004.     {

  1005.         if (inScope == kAudioUnitScope_Global && juceFilter != nullptr)

  1006.         {

  1007.             if (auto* param = getParameterForAUParameterID (inID))

  1008.             {

  1009.                 const auto normValue = param->getValue();

  1010. 

  1011.                 outValue = normValue * getMaximumParameterValue (param);

  1012.                 return noErr;

  1013.             }

  1014.         }

  1015. 

  1016.         return MusicDeviceBase::GetParameter (inID, inScope, inElement, outValue);

  1017.     }

  1018. 

  1019.     ComponentResult SetParameter (AudioUnitParameterID inID,

  1020.                                   AudioUnitScope inScope,

  1021.                                   AudioUnitElement inElement,

  1022.                                   Float32 inValue,

  1023.                                   UInt32 inBufferOffsetInFrames) override

  1024.     {

  1025.         if (inScope == kAudioUnitScope_Global && juceFilter != nullptr)

  1026.         {

  1027.             if (auto* param = getParameterForAUParameterID (inID))

  1028.             {

  1029.                 auto value = inValue / getMaximumParameterValue (param);

  1030. 

  1031.                 if (value != param->getValue())

  1032.                 {

  1033.                     inParameterChangedCallback = true;

  1034.                     param->setValueNotifyingHost (value);

  1035.                 }

  1036. 

  1037.                 return noErr;

  1038.             }

  1039.         }

  1040. 

  1041.         return MusicDeviceBase::SetParameter (inID, inScope, inElement, inValue, inBufferOffsetInFrames);

  1042.     }

  1043. 

  1044.     // No idea what this method actually does or what it should return. Current Apple docs say nothing about it.

  1045.     // (Note that this isn't marked 'override' in case older versions of the SDK don't include it)

  1046.     bool CanScheduleParameters() const override          { return false; }

  1047. 

  1048.     //==============================================================================

  1049.     ComponentResult Version() override                   { return JucePlugin_VersionCode; }

  1050.     bool SupportsTail() override                         { return true; }

  1051.     Float64 GetTailTime() override                       { return juceFilter->getTailLengthSeconds(); }

  1052. 

  1053.     double getSampleRate()

  1054.     {

  1055.         if (AudioUnitHelpers::getBusCountForWrapper (*juceFilter, false) > 0)

  1056.             return GetOutput (0)->GetStreamFormat().mSampleRate;

  1057. 

  1058.         return 44100.0;

  1059.     }

  1060. 

  1061.     Float64 GetLatency() override

  1062.     {

  1063.         const double rate = getSampleRate();

  1064.         jassert (rate > 0);

  1065.         return rate > 0 ? juceFilter->getLatencySamples() / rate : 0;

  1066.     }

  1067. 

  1068.     //==============================================================================

  1069.    #if BUILD_AU_CARBON_UI

  1070.     int GetNumCustomUIComponents() override

  1071.     {

  1072.         return getHostType().isDigitalPerformer() ? 0 : 1;

  1073.     }

  1074. 

  1075.     void GetUIComponentDescs (ComponentDescription* inDescArray) override

  1076.     {

  1077.         inDescArray[0].componentType = kAudioUnitCarbonViewComponentType;

  1078.         inDescArray[0].componentSubType = JucePlugin_AUSubType;

  1079.         inDescArray[0].componentManufacturer = JucePlugin_AUManufacturerCode;

  1080.         inDescArray[0].componentFlags = 0;

  1081.         inDescArray[0].componentFlagsMask = 0;

  1082.     }

  1083.    #endif

  1084. 

  1085.     //==============================================================================

  1086.     bool getCurrentPosition (AudioPlayHead::CurrentPositionInfo& info) override

  1087.     {

  1088.         info.timeSigNumerator = 0;

  1089.         info.timeSigDenominator = 0;

  1090.         info.editOriginTime = 0;

  1091.         info.ppqPositionOfLastBarStart = 0;

  1092.         info.isRecording = false;

  1093. 

  1094.         switch (lastTimeStamp.mSMPTETime.mType)

  1095.         {

  1096.             case kSMPTETimeType2398:        info.frameRate = AudioPlayHead::fps23976;    break;

  1097.             case kSMPTETimeType24:          info.frameRate = AudioPlayHead::fps24;       break;

  1098.             case kSMPTETimeType25:          info.frameRate = AudioPlayHead::fps25;       break;

  1099.             case kSMPTETimeType30Drop:      info.frameRate = AudioPlayHead::fps30drop;   break;

  1100.             case kSMPTETimeType30:          info.frameRate = AudioPlayHead::fps30;       break;

  1101.             case kSMPTETimeType2997:        info.frameRate = AudioPlayHead::fps2997;     break;

  1102.             case kSMPTETimeType2997Drop:    info.frameRate = AudioPlayHead::fps2997drop; break;

  1103.             case kSMPTETimeType60:          info.frameRate = AudioPlayHead::fps60;       break;

  1104.             case kSMPTETimeType60Drop:      info.frameRate = AudioPlayHead::fps60drop;   break;

  1105.             case kSMPTETimeType5994:

  1106.             case kSMPTETimeType5994Drop:

  1107.             case kSMPTETimeType50:

  1108.             default:                        info.frameRate = AudioPlayHead::fpsUnknown;  break;

  1109.         }

  1110. 

  1111.         if (CallHostBeatAndTempo (&info.ppqPosition, &info.bpm) != noErr)

  1112.         {

  1113.             info.ppqPosition = 0;

  1114.             info.bpm = 0;

  1115.         }

  1116. 

  1117.         UInt32 outDeltaSampleOffsetToNextBeat;

  1118.         double outCurrentMeasureDownBeat;

  1119.         float num;

  1120.         UInt32 den;

  1121. 

  1122.         if (CallHostMusicalTimeLocation (&outDeltaSampleOffsetToNextBeat, &num, &den,

  1123.                                          &outCurrentMeasureDownBeat) == noErr)

  1124.         {

  1125.             info.timeSigNumerator   = (int) num;

  1126.             info.timeSigDenominator = (int) den;

  1127.             info.ppqPositionOfLastBarStart = outCurrentMeasureDownBeat;

  1128.         }

  1129. 

  1130.         double outCurrentSampleInTimeLine, outCycleStartBeat = 0, outCycleEndBeat = 0;

  1131.         Boolean playing = false, looping = false, playchanged;

  1132. 

  1133.         if (CallHostTransportState (&playing,

  1134.                                     &playchanged,

  1135.                                     &outCurrentSampleInTimeLine,

  1136.                                     &looping,

  1137.                                     &outCycleStartBeat,

  1138.                                     &outCycleEndBeat) != noErr)

  1139.         {

  1140.             // If the host doesn't support this callback, then use the sample time from lastTimeStamp:

  1141.             outCurrentSampleInTimeLine = lastTimeStamp.mSampleTime;

  1142.         }

  1143. 

  1144.         info.isPlaying = playing;

  1145.         info.timeInSamples = (int64) (outCurrentSampleInTimeLine + 0.5);

  1146.         info.timeInSeconds = info.timeInSamples / getSampleRate();

  1147.         info.isLooping = looping;

  1148.         info.ppqLoopStart = outCycleStartBeat;

  1149.         info.ppqLoopEnd = outCycleEndBeat;

  1150. 

  1151.         return true;

  1152.     }

  1153. 

  1154.     void sendAUEvent (const AudioUnitEventType type, const int juceParamIndex)

  1155.     {

  1156.         auEvent.mEventType = type;

  1157.         auEvent.mArgument.mParameter.mParameterID = getAUParameterIDForIndex (juceParamIndex);

  1158.         AUEventListenerNotify (nullptr, nullptr, &auEvent);

  1159.     }

  1160. 

  1161.     void audioProcessorParameterChanged (AudioProcessor*, int index, float /*newValue*/) override

  1162.     {

  1163.         if (inParameterChangedCallback.get())

  1164.         {

  1165.             inParameterChangedCallback = false;

  1166.             return;

  1167.         }

  1168. 

  1169.         sendAUEvent (kAudioUnitEvent_ParameterValueChange, index);

  1170.     }

  1171. 

  1172.     void audioProcessorParameterChangeGestureBegin (AudioProcessor*, int index) override

  1173.     {

  1174.         sendAUEvent (kAudioUnitEvent_BeginParameterChangeGesture, index);

  1175.     }

  1176. 

  1177.     void audioProcessorParameterChangeGestureEnd (AudioProcessor*, int index) override

  1178.     {

  1179.         sendAUEvent (kAudioUnitEvent_EndParameterChangeGesture, index);

  1180.     }

  1181. 

  1182.     void audioProcessorChanged (AudioProcessor*, const ChangeDetails& details) override

  1183.     {

  1184.         audioProcessorChangedUpdater.update (details);

  1185.     }

  1186. 

  1187.     //==============================================================================

  1188.     // this will only ever be called by the bypass parameter

  1189.     void parameterValueChanged (int, float) override

  1190.     {

  1191.         PropertyChanged (kAudioUnitProperty_BypassEffect, kAudioUnitScope_Global, 0);

  1192.     }

  1193. 

  1194.     void parameterGestureChanged (int, bool) override {}

  1195. 

  1196.     //==============================================================================

  1197.     bool StreamFormatWritable (AudioUnitScope scope, AudioUnitElement element) override

  1198.     {

  1199.         const auto info = getElementInfo (scope, element);

  1200. 

  1201.         return ((! IsInitialized()) && (info.error == noErr));

  1202.     }

  1203. 

  1204.     bool ValidFormat (AudioUnitScope scope, AudioUnitElement element, const CAStreamBasicDescription& format) override

  1205.     {

  1206.         // DSP Quattro incorrectly uses global scope for the ValidFormat call

  1207.         if (scope == kAudioUnitScope_Global)

  1208.             return ValidFormat (kAudioUnitScope_Input,  element, format)

  1209.                 || ValidFormat (kAudioUnitScope_Output, element, format);

  1210. 

  1211.         const auto info = getElementInfo (scope, element);

  1212. 

  1213.         if (info.error != noErr)

  1214.             return false;

  1215. 

  1216.         if (info.kind == BusKind::wrapperOnly)

  1217.             return true;

  1218. 

  1219.         const int newNumChannels = static_cast<int> (format.NumberChannels());

  1220.         const int oldNumChannels = juceFilter->getChannelCountOfBus (info.isInput, info.busNr);

  1221. 

  1222.         if (newNumChannels == oldNumChannels)

  1223.             return true;

  1224. 

  1225.         if (AudioProcessor::Bus* bus = juceFilter->getBus (info.isInput, info.busNr))

  1226.         {

  1227.             if (! MusicDeviceBase::ValidFormat (scope, element, format))

  1228.                 return false;

  1229. 

  1230.            #ifdef JucePlugin_PreferredChannelConfigurations

  1231.             short configs[][2] = {JucePlugin_PreferredChannelConfigurations};

  1232. 

  1233.             ignoreUnused (bus);

  1234.             return AudioUnitHelpers::isLayoutSupported (*juceFilter, info.isInput, info.busNr, newNumChannels, configs);

  1235.            #else

  1236.             return bus->isNumberOfChannelsSupported (newNumChannels);

  1237.            #endif

  1238.         }

  1239. 

  1240.         return false;

  1241.     }

  1242. 

  1243.     // AU requires us to override this for the sole reason that we need to find a default layout tag if the number of channels have changed

  1244.     OSStatus ChangeStreamFormat (AudioUnitScope scope, AudioUnitElement element, const CAStreamBasicDescription& old, const CAStreamBasicDescription& format) override

  1245.     {

  1246.         const auto info = getElementInfo (scope, element);

  1247. 

  1248.         if (info.error != noErr)

  1249.             return info.error;

  1250. 

  1251.         AudioChannelLayoutTag& currentTag = getCurrentLayout (info.isInput, info.busNr);

  1252. 

  1253.         const int newNumChannels = static_cast<int> (format.NumberChannels());

  1254.         const int oldNumChannels = juceFilter->getChannelCountOfBus (info.isInput, info.busNr);

  1255. 

  1256.        #ifdef JucePlugin_PreferredChannelConfigurations

  1257.         short configs[][2] = {JucePlugin_PreferredChannelConfigurations};

  1258. 

  1259.         if (! AudioUnitHelpers::isLayoutSupported (*juceFilter, info.isInput, info.busNr, newNumChannels, configs))

  1260.             return kAudioUnitErr_FormatNotSupported;

  1261.        #endif

  1262. 

  1263.         // predict channel layout

  1264.         const auto set = [&]

  1265.         {

  1266.             if (info.kind == BusKind::wrapperOnly)

  1267.                 return AudioChannelSet::discreteChannels (newNumChannels);

  1268. 

  1269.             if (newNumChannels != oldNumChannels)

  1270.                 return juceFilter->getBus (info.isInput, info.busNr)->supportedLayoutWithChannels (newNumChannels);

  1271. 

  1272.             return juceFilter->getChannelLayoutOfBus (info.isInput, info.busNr);

  1273.         }();

  1274. 

  1275.         if (set == AudioChannelSet())

  1276.             return kAudioUnitErr_FormatNotSupported;

  1277. 

  1278.         const auto err = MusicDeviceBase::ChangeStreamFormat (scope, element, old, format);

  1279. 

  1280.         if (err == noErr)

  1281.             currentTag = CoreAudioLayouts::toCoreAudio (set);

  1282. 

  1283.         return err;

  1284.     }

  1285. 

  1286.     //==============================================================================

  1287.     ComponentResult Render (AudioUnitRenderActionFlags& ioActionFlags,

  1288.                             const AudioTimeStamp& inTimeStamp,

  1289.                             const UInt32 nFrames) override

  1290.     {

  1291.         lastTimeStamp = inTimeStamp;

  1292. 

  1293.         // prepare buffers

  1294.         {

  1295.             pullInputAudio (ioActionFlags, inTimeStamp, nFrames);

  1296.             prepareOutputBuffers (nFrames);

  1297.             audioBuffer.reset();

  1298.         }

  1299. 

  1300.         ioActionFlags &= ~kAudioUnitRenderAction_OutputIsSilence;

  1301. 

  1302.         const int numInputBuses  = AudioUnitHelpers::getBusCount (*juceFilter, true);

  1303.         const int numOutputBuses = AudioUnitHelpers::getBusCount (*juceFilter, false);

  1304. 

  1305.         // set buffer pointers to minimize copying

  1306.         {

  1307.             int chIdx = 0, numChannels = 0;

  1308.             bool interleaved = false;

  1309.             AudioBufferList* buffer = nullptr;

  1310. 

  1311.             // use output pointers

  1312.             for (int busIdx = 0; busIdx < numOutputBuses; ++busIdx)

  1313.             {

  1314.                 GetAudioBufferList (false, busIdx, buffer, interleaved, numChannels);

  1315.                 const int* outLayoutMap = mapper.get (false, busIdx);

  1316. 

  1317.                 for (int ch = 0; ch < numChannels; ++ch)

  1318.                     audioBuffer.setBuffer (chIdx++, interleaved ? nullptr : static_cast<float*> (buffer->mBuffers[outLayoutMap[ch]].mData));

  1319.             }

  1320. 

  1321.             // use input pointers on remaining channels

  1322.             for (int busIdx = 0; chIdx < totalInChannels;)

  1323.             {

  1324.                 int channelIndexInBus = juceFilter->getOffsetInBusBufferForAbsoluteChannelIndex (true, chIdx, busIdx);

  1325.                 const bool badData = ! pulledSucceeded[busIdx];

  1326. 

  1327.                 if (! badData)

  1328.                     GetAudioBufferList (true, busIdx, buffer, interleaved, numChannels);

  1329. 

  1330.                 const int* inLayoutMap = mapper.get (true, busIdx);

  1331. 

  1332.                 const int n = juceFilter->getChannelCountOfBus (true, busIdx);

  1333.                 for (int ch = channelIndexInBus; ch < n; ++ch)

  1334.                     audioBuffer.setBuffer (chIdx++, interleaved || badData ? nullptr : static_cast<float*> (buffer->mBuffers[inLayoutMap[ch]].mData));

  1335.             }

  1336.         }

  1337. 

  1338.         // copy input

  1339.         {

  1340.             for (int busIdx = 0; busIdx < numInputBuses; ++busIdx)

  1341.             {

  1342.                 if (pulledSucceeded[busIdx])

  1343.                 {

  1344.                     audioBuffer.push (GetInput ((UInt32) busIdx)->GetBufferList(), mapper.get (true, busIdx));

  1345.                 }

  1346.                 else

  1347.                 {

  1348.                     const int n = juceFilter->getChannelCountOfBus (true, busIdx);

  1349. 

  1350.                     for (int ch = 0; ch < n; ++ch)

  1351.                         zeromem (audioBuffer.push(), sizeof (float) * nFrames);

  1352.                 }

  1353.             }

  1354. 

  1355.             // clear remaining channels

  1356.             for (int i = totalInChannels; i < totalOutChannels; ++i)

  1357.                 zeromem (audioBuffer.push(), sizeof (float) * nFrames);

  1358.         }

  1359. 

  1360.         // swap midi buffers

  1361.         {

  1362.             const ScopedLock sl (incomingMidiLock);

  1363.             midiEvents.clear();

  1364.             incomingEvents.swapWith (midiEvents);

  1365.         }

  1366. 

  1367.         // process audio

  1368.         processBlock (audioBuffer.getBuffer (nFrames), midiEvents);

  1369. 

  1370.         // copy back

  1371.         {

  1372.             for (int busIdx = 0; busIdx < numOutputBuses; ++busIdx)

  1373.                 audioBuffer.pop (GetOutput ((UInt32) busIdx)->GetBufferList(), mapper.get (false, busIdx));

  1374.         }

  1375. 

  1376.         // process midi output

  1377.       #if JucePlugin_ProducesMidiOutput || JucePlugin_IsMidiEffect

  1378.         if (! midiEvents.isEmpty() && midiCallback.midiOutputCallback != nullptr)

  1379.             pushMidiOutput (nFrames);

  1380.       #endif

  1381. 

  1382.         midiEvents.clear();

  1383. 

  1384.         return noErr;

  1385.     }

  1386. 

  1387.     //==============================================================================

  1388.     ComponentResult StartNote (MusicDeviceInstrumentID, MusicDeviceGroupID, NoteInstanceID*, UInt32, const MusicDeviceNoteParams&) override { return noErr; }

  1389.     ComponentResult StopNote (MusicDeviceGroupID, NoteInstanceID, UInt32) override   { return noErr; }

  1390. 

  1391.     //==============================================================================

  1392.     OSStatus HandleMidiEvent (UInt8 nStatus, UInt8 inChannel, UInt8 inData1, UInt8 inData2, UInt32 inStartFrame) override

  1393.     {

  1394.        #if JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect

  1395.         const juce::uint8 data[] = { (juce::uint8) (nStatus | inChannel),

  1396.                                      (juce::uint8) inData1,

  1397.                                      (juce::uint8) inData2 };

  1398. 

  1399.         const ScopedLock sl (incomingMidiLock);

  1400.         incomingEvents.addEvent (data, 3, (int) inStartFrame);

  1401.         return noErr;

  1402.        #else

  1403.         ignoreUnused (nStatus, inChannel, inData1);

  1404.         ignoreUnused (inData2, inStartFrame);

  1405.         return kAudioUnitErr_PropertyNotInUse;

  1406.        #endif

  1407.     }

  1408. 

  1409.     OSStatus HandleSysEx (const UInt8* inData, UInt32 inLength) override

  1410.     {

  1411.        #if JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect

  1412.         const ScopedLock sl (incomingMidiLock);

  1413.         incomingEvents.addEvent (inData, (int) inLength, 0);

  1414.         return noErr;

  1415.        #else

  1416.         ignoreUnused (inData, inLength);

  1417.         return kAudioUnitErr_PropertyNotInUse;

  1418.        #endif

  1419.     }

  1420. 

  1421.     //==============================================================================

  1422.     ComponentResult GetPresets (CFArrayRef* outData) const override

  1423.     {

  1424.         if (outData != nullptr)

  1425.         {

  1426.             const int numPrograms = juceFilter->getNumPrograms();

  1427. 

  1428.             clearPresetsArray();

  1429.             presetsArray.insertMultiple (0, AUPreset(), numPrograms);

  1430. 

  1431.             CFMutableArrayRef presetsArrayRef = CFArrayCreateMutable (nullptr, numPrograms, nullptr);

  1432. 

  1433.             for (int i = 0; i < numPrograms; ++i)

  1434.             {

  1435.                 String name (juceFilter->getProgramName(i));

  1436.                 if (name.isEmpty())

  1437.                     name = "Untitled";

  1438. 

  1439.                 AUPreset& p = presetsArray.getReference(i);

  1440.                 p.presetNumber = i;

  1441.                 p.presetName = name.toCFString();

  1442. 

  1443.                 CFArrayAppendValue (presetsArrayRef, &p);

  1444.             }

  1445. 

  1446.             *outData = (CFArrayRef) presetsArrayRef;

  1447.         }

  1448. 

  1449.         return noErr;

  1450.     }

  1451. 

  1452.     OSStatus NewFactoryPresetSet (const AUPreset& inNewFactoryPreset) override

  1453.     {

  1454.         const int numPrograms = juceFilter->getNumPrograms();

  1455.         const SInt32 chosenPresetNumber = (int) inNewFactoryPreset.presetNumber;

  1456. 

  1457.         if (chosenPresetNumber >= numPrograms)

  1458.             return kAudioUnitErr_InvalidProperty;

  1459. 

  1460.         AUPreset chosenPreset;

  1461.         chosenPreset.presetNumber = chosenPresetNumber;

  1462.         chosenPreset.presetName = juceFilter->getProgramName (chosenPresetNumber).toCFString();

  1463. 

  1464.         juceFilter->setCurrentProgram (chosenPresetNumber);

  1465.         SetAFactoryPresetAsCurrent (chosenPreset);

  1466. 

  1467.         return noErr;

  1468.     }

  1469. 

  1470.     //==============================================================================

  1471.     class EditorCompHolder  : public Component

  1472.     {

  1473.     public:

  1474.         EditorCompHolder (AudioProcessorEditor* const editor)

  1475.         {

  1476.             addAndMakeVisible (editor);

  1477. 

  1478.            #if ! JucePlugin_EditorRequiresKeyboardFocus

  1479.             setWantsKeyboardFocus (false);

  1480.            #else

  1481.             setWantsKeyboardFocus (true);

  1482.            #endif

  1483. 

  1484.             setBounds (getSizeToContainChild());

  1485. 

  1486.             lastBounds = getBounds();

  1487.         }

  1488. 

  1489.         ~EditorCompHolder() override

  1490.         {

  1491.             deleteAllChildren(); // note that we can't use a std::unique_ptr because the editor may

  1492.                                  // have been transferred to another parent which takes over ownership.

  1493.         }

  1494. 

  1495.         Rectangle<int> getSizeToContainChild()

  1496.         {

  1497.             if (auto* editor = getChildComponent (0))

  1498.                 return getLocalArea (editor, editor->getLocalBounds());

  1499. 

  1500.             return {};

  1501.         }

  1502. 

  1503.         static NSView* createViewFor (AudioProcessor* filter, JuceAU* au, AudioProcessorEditor* const editor)

  1504.         {

  1505.             auto* editorCompHolder = new EditorCompHolder (editor);

  1506.             auto r = convertToHostBounds (makeNSRect (editorCompHolder->getSizeToContainChild()));

  1507. 

  1508.             static JuceUIViewClass cls;

  1509.             auto* view = [[cls.createInstance() initWithFrame: r] autorelease];

  1510. 

  1511.             JuceUIViewClass::setFilter (view, filter);

  1512.             JuceUIViewClass::setAU (view, au);

  1513.             JuceUIViewClass::setEditor (view, editorCompHolder);

  1514. 

  1515.             [view setHidden: NO];

  1516.             [view setPostsFrameChangedNotifications: YES];

  1517. 

  1518.             [[NSNotificationCenter defaultCenter] addObserver: view

  1519.                                                      selector: @selector (applicationWillTerminate:)

  1520.                                                          name: NSApplicationWillTerminateNotification

  1521.                                                        object: nil];

  1522.             activeUIs.add (view);

  1523. 

  1524.             editorCompHolder->addToDesktop (0, (void*) view);

  1525.             editorCompHolder->setVisible (view);

  1526. 

  1527.             return view;

  1528.         }

  1529. 

  1530.         void parentSizeChanged() override

  1531.         {

  1532.             resizeHostWindow();

  1533. 

  1534.             if (auto* editor = getChildComponent (0))

  1535.                 editor->repaint();

  1536.         }

  1537. 

  1538.         void childBoundsChanged (Component*) override

  1539.         {

  1540.             auto b = getSizeToContainChild();

  1541. 

  1542.             if (lastBounds != b)

  1543.             {

  1544.                 lastBounds = b;

  1545.                 setSize (jmax (32, b.getWidth()), jmax (32, b.getHeight()));

  1546. 

  1547.                 resizeHostWindow();

  1548.             }

  1549.         }

  1550. 

  1551.         bool keyPressed (const KeyPress&) override

  1552.         {

  1553.             if (getHostType().isAbletonLive())

  1554.             {

  1555.                 static NSTimeInterval lastEventTime = 0; // check we're not recursively sending the same event

  1556.                 NSTimeInterval eventTime = [[NSApp currentEvent] timestamp];

  1557. 

  1558.                 if (lastEventTime != eventTime)

  1559.                 {

  1560.                     lastEventTime = eventTime;

  1561. 

  1562.                     NSView* view = (NSView*) getWindowHandle();

  1563.                     NSView* hostView = [view superview];

  1564.                     NSWindow* hostWindow = [hostView window];

  1565. 

  1566.                     [hostWindow makeFirstResponder: hostView];

  1567.                     [hostView keyDown: (NSEvent*) [NSApp currentEvent]];

  1568.                     [hostWindow makeFirstResponder: view];

  1569.                 }

  1570.             }

  1571. 

  1572.             return false;

  1573.         }

  1574. 

  1575.         void resizeHostWindow()

  1576.         {

  1577.             [CATransaction begin];

  1578.             [CATransaction setValue:(id) kCFBooleanTrue forKey:kCATransactionDisableActions];

  1579. 

  1580.             auto rect = convertToHostBounds (makeNSRect (lastBounds));

  1581.             auto* view = (NSView*) getWindowHandle();

  1582. 

  1583.             auto superRect = [[view superview] frame];

  1584.             superRect.size.width  = rect.size.width;

  1585.             superRect.size.height = rect.size.height;

  1586. 

  1587.             [[view superview] setFrame: superRect];

  1588.             [view setFrame: rect];

  1589.             [CATransaction commit];

  1590. 

  1591.             [view setNeedsDisplay: YES];

  1592.         }

  1593. 

  1594.     private:

  1595.         Rectangle<int> lastBounds;

  1596. 

  1597.         JUCE_DECLARE_NON_COPYABLE (EditorCompHolder)

  1598.     };

  1599. 

  1600.     void deleteActiveEditors()

  1601.     {

  1602.         for (int i = activeUIs.size(); --i >= 0;)

  1603.         {

  1604.             id ui = (id) activeUIs.getUnchecked(i);

  1605. 

  1606.             if (JuceUIViewClass::getAU (ui) == this)

  1607.                 JuceUIViewClass::deleteEditor (ui);

  1608.         }

  1609.     }

  1610. 

  1611.     //==============================================================================

  1612.     struct JuceUIViewClass  : public ObjCClass<NSView>

  1613.     {

  1614.         JuceUIViewClass()  : ObjCClass<NSView> ("JUCEAUView_")

  1615.         {

  1616.             addIvar<AudioProcessor*> ("filter");

  1617.             addIvar<JuceAU*> ("au");

  1618.             addIvar<EditorCompHolder*> ("editor");

  1619. 

  1620.             addMethod (@selector (dealloc),                     dealloc,                    "v@:");

  1621.             addMethod (@selector (applicationWillTerminate:),   applicationWillTerminate,   "v@:@");

  1622.             addMethod (@selector (viewDidMoveToWindow),         viewDidMoveToWindow,        "v@:");

  1623.             addMethod (@selector (mouseDownCanMoveWindow),      mouseDownCanMoveWindow,     "c@:");

  1624. 

  1625.             registerClass();

  1626.         }

  1627. 

  1628.         static void deleteEditor (id self)

  1629.         {

  1630.             std::unique_ptr<EditorCompHolder> editorComp (getEditor (self));

  1631. 

  1632.             if (editorComp != nullptr)

  1633.             {

  1634.                 if (editorComp->getChildComponent(0) != nullptr

  1635.                      && activePlugins.contains (getAU (self))) // plugin may have been deleted before the UI

  1636.                 {

  1637.                     AudioProcessor* const filter = getIvar<AudioProcessor*> (self, "filter");

  1638.                     filter->editorBeingDeleted ((AudioProcessorEditor*) editorComp->getChildComponent(0));

  1639.                 }

  1640. 

  1641.                 editorComp = nullptr;

  1642.                 setEditor (self, nullptr);

  1643.             }

  1644.         }

  1645. 

  1646.         static JuceAU* getAU (id self)                          { return getIvar<JuceAU*> (self, "au"); }

  1647.         static EditorCompHolder* getEditor (id self)            { return getIvar<EditorCompHolder*> (self, "editor"); }

  1648. 

  1649.         static void setFilter (id self, AudioProcessor* filter) { object_setInstanceVariable (self, "filter", filter); }

  1650.         static void setAU (id self, JuceAU* au)                 { object_setInstanceVariable (self, "au", au); }

  1651.         static void setEditor (id self, EditorCompHolder* e)    { object_setInstanceVariable (self, "editor", e); }

  1652. 

  1653.     private:

  1654.         static void dealloc (id self, SEL)

  1655.         {

  1656.             if (activeUIs.contains (self))

  1657.                 shutdown (self);

  1658. 

  1659.             sendSuperclassMessage<void> (self, @selector (dealloc));

  1660.         }

  1661. 

  1662.         static void applicationWillTerminate (id self, SEL, NSNotification*)

  1663.         {

  1664.             shutdown (self);

  1665.         }

  1666. 

  1667.         static void shutdown (id self)

  1668.         {

  1669.             [[NSNotificationCenter defaultCenter] removeObserver: self];

  1670.             deleteEditor (self);

  1671. 

  1672.             jassert (activeUIs.contains (self));

  1673.             activeUIs.removeFirstMatchingValue (self);

  1674. 

  1675.             if (activePlugins.size() + activeUIs.size() == 0)

  1676.             {

  1677.                 // there's some kind of component currently modal, but the host

  1678.                 // is trying to delete our plugin..

  1679.                 jassert (Component::getCurrentlyModalComponent() == nullptr);

  1680. 

  1681.                 shutdownJuce_GUI();

  1682.             }

  1683.         }

  1684. 

  1685.         static void viewDidMoveToWindow (id self, SEL)

  1686.         {

  1687.             if (NSWindow* w = [(NSView*) self window])

  1688.             {

  1689.                 [w setAcceptsMouseMovedEvents: YES];

  1690. 

  1691.                 if (EditorCompHolder* const editorComp = getEditor (self))

  1692.                     [w makeFirstResponder: (NSView*) editorComp->getWindowHandle()];

  1693.             }

  1694.         }

  1695. 

  1696.         static BOOL mouseDownCanMoveWindow (id, SEL)

  1697.         {

  1698.             return NO;

  1699.         }

  1700.     };

  1701. 

  1702.     //==============================================================================

  1703.     struct JuceUICreationClass  : public ObjCClass<NSObject>

  1704.     {

  1705.         JuceUICreationClass()  : ObjCClass<NSObject> ("JUCE_AUCocoaViewClass_")

  1706.         {

  1707.             addMethod (@selector (interfaceVersion),             interfaceVersion,    @encode (unsigned int), "@:");

  1708.             addMethod (@selector (description),                  description,         @encode (NSString*),    "@:");

  1709.             addMethod (@selector (uiViewForAudioUnit:withSize:), uiViewForAudioUnit,  @encode (NSView*),      "@:", @encode (AudioUnit), @encode (NSSize));

  1710. 

  1711.             addProtocol (@protocol (AUCocoaUIBase));

  1712. 

  1713.             registerClass();

  1714.         }

  1715. 

  1716.     private:

  1717.         static unsigned int interfaceVersion (id, SEL)   { return 0; }

  1718. 

  1719.         static NSString* description (id, SEL)

  1720.         {

  1721.             return [NSString stringWithString: nsStringLiteral (JucePlugin_Name)];

  1722.         }

  1723. 

  1724.         static NSView* uiViewForAudioUnit (id, SEL, AudioUnit inAudioUnit, NSSize)

  1725.         {

  1726.             void* pointers[2];

  1727.             UInt32 propertySize = sizeof (pointers);

  1728. 

  1729.             if (AudioUnitGetProperty (inAudioUnit, juceFilterObjectPropertyID,

  1730.                                       kAudioUnitScope_Global, 0, pointers, &propertySize) == noErr)

  1731.             {

  1732.                 if (AudioProcessor* filter = static_cast<AudioProcessor*> (pointers[0]))

  1733.                     if (AudioProcessorEditor* editorComp = filter->createEditorIfNeeded())

  1734.                         return EditorCompHolder::createViewFor (filter, static_cast<JuceAU*> (pointers[1]), editorComp);

  1735.             }

  1736. 

  1737.             return nil;

  1738.         }

  1739.     };

  1740. 

  1741. private:

  1742.     //==============================================================================

  1743.     /*  The call to AUBase::PropertyChanged may allocate hence the need for this class */

  1744.     class AudioProcessorChangedUpdater final  : private AsyncUpdater

  1745.     {

  1746.     public:

  1747.         explicit AudioProcessorChangedUpdater (JuceAU& o) : owner (o) {}

  1748.         ~AudioProcessorChangedUpdater() override { cancelPendingUpdate(); }

  1749. 

  1750.         void update (const ChangeDetails& details)

  1751.         {

  1752.             int flags = 0;

  1753. 

  1754.             if (details.latencyChanged)

  1755.                 flags |= latencyChangedFlag;

  1756. 

  1757.             if (details.parameterInfoChanged)

  1758.                 flags |= parameterInfoChangedFlag;

  1759. 

  1760.             if (details.programChanged)

  1761.                 flags |= programChangedFlag;

  1762. 

  1763.             if (flags != 0)

  1764.             {

  1765.                 callbackFlags.fetch_or (flags);

  1766. 

  1767.                 if (MessageManager::getInstance()->isThisTheMessageThread())

  1768.                     handleAsyncUpdate();

  1769.                 else

  1770.                     triggerAsyncUpdate();

  1771.             }

  1772.         }

  1773. 

  1774.     private:

  1775.         void handleAsyncUpdate() override

  1776.         {

  1777.             const auto flags = callbackFlags.exchange (0);

  1778. 

  1779.             if ((flags & latencyChangedFlag) != 0)

  1780.                 owner.PropertyChanged (kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0);

  1781. 

  1782.             if ((flags & parameterInfoChangedFlag) != 0)

  1783.             {

  1784.                 owner.PropertyChanged (kAudioUnitProperty_ParameterList, kAudioUnitScope_Global, 0);

  1785.                 owner.PropertyChanged (kAudioUnitProperty_ParameterInfo, kAudioUnitScope_Global, 0);

  1786.             }

  1787. 

  1788.             owner.PropertyChanged (kAudioUnitProperty_ClassInfo, kAudioUnitScope_Global, 0);

  1789. 

  1790.             if ((flags & programChangedFlag) != 0)

  1791.             {

  1792.                 owner.refreshCurrentPreset();

  1793.                 owner.PropertyChanged (kAudioUnitProperty_PresentPreset, kAudioUnitScope_Global, 0);

  1794.             }

  1795.         }

  1796. 

  1797.         JuceAU& owner;

  1798. 

  1799.         static constexpr int latencyChangedFlag       = 1 << 0,

  1800.                              parameterInfoChangedFlag = 1 << 1,

  1801.                              programChangedFlag       = 1 << 2;

  1802. 

  1803.         std::atomic<int> callbackFlags { 0 };

  1804.     };

  1805. 

  1806.     //==============================================================================

  1807.     AudioUnitHelpers::CoreAudioBufferList audioBuffer;

  1808.     MidiBuffer midiEvents, incomingEvents;

  1809.     bool prepared = false, isBypassed = false;

  1810. 

  1811.     //==============================================================================

  1812.    #if JUCE_FORCE_USE_LEGACY_PARAM_IDS

  1813.     static constexpr bool forceUseLegacyParamIDs = true;

  1814.    #else

  1815.     static constexpr bool forceUseLegacyParamIDs = false;

  1816.    #endif

  1817. 

  1818.     //==============================================================================

  1819.     LegacyAudioParametersWrapper juceParameters;

  1820.     HashMap<int32, AudioProcessorParameter*> paramMap;

  1821.     Array<AudioUnitParameterID> auParamIDs;

  1822.     Array<const AudioProcessorParameterGroup*> parameterGroups;

  1823. 

  1824.     //==============================================================================

  1825.     // According to the docs, this is the maximum size of a MIDIPacketList.

  1826.     static constexpr UInt32 packetListBytes = 65536;

  1827. 

  1828.     AudioUnitEvent auEvent;

  1829.     mutable Array<AUPreset> presetsArray;

  1830.     CriticalSection incomingMidiLock;

  1831.     AUMIDIOutputCallbackStruct midiCallback;

  1832.     AudioTimeStamp lastTimeStamp;

  1833.     int totalInChannels, totalOutChannels;

  1834.     HeapBlock<bool> pulledSucceeded;

  1835.     HeapBlock<MIDIPacketList> packetList { packetListBytes, 1 };

  1836. 

  1837.     ThreadLocalValue<bool> inParameterChangedCallback;

  1838. 

  1839.     AudioProcessorChangedUpdater audioProcessorChangedUpdater { *this };

  1840. 

  1841.     //==============================================================================

  1842.     Array<AUChannelInfo> channelInfo;

  1843.     Array<Array<AudioChannelLayoutTag>> supportedInputLayouts, supportedOutputLayouts;

  1844.     Array<AudioChannelLayoutTag> currentInputLayout, currentOutputLayout;

  1845. 

  1846.     //==============================================================================

  1847.     AudioUnitHelpers::ChannelRemapper mapper;

  1848. 

  1849.     //==============================================================================

  1850.     OwnedArray<OwnedArray<const __CFString>> parameterValueStringArrays;

  1851. 

  1852.     //==============================================================================

  1853.     AudioProcessorParameter* bypassParam = nullptr;

  1854. 

  1855.     //==============================================================================

  1856.     static NSRect convertToHostBounds (NSRect pluginRect)

  1857.     {

  1858.         auto desktopScale = Desktop::getInstance().getGlobalScaleFactor();

  1859. 

  1860.         if (approximatelyEqual (desktopScale, 1.0f))

  1861.             return pluginRect;

  1862. 

  1863.         return NSMakeRect (static_cast<CGFloat> (pluginRect.origin.x    * desktopScale),

  1864.                            static_cast<CGFloat> (pluginRect.origin.y    * desktopScale),

  1865.                            static_cast<CGFloat> (pluginRect.size.width  * desktopScale),

  1866.                            static_cast<CGFloat> (pluginRect.size.height * desktopScale));

  1867.     }

  1868. 

  1869.     static NSRect convertFromHostBounds (NSRect hostRect)

  1870.     {

  1871.         auto desktopScale = Desktop::getInstance().getGlobalScaleFactor();

  1872. 

  1873.         if (approximatelyEqual (desktopScale, 1.0f))

  1874.             return hostRect;

  1875. 

  1876.         return NSMakeRect (static_cast<CGFloat> (hostRect.origin.x    / desktopScale),

  1877.                            static_cast<CGFloat> (hostRect.origin.y    / desktopScale),

  1878.                            static_cast<CGFloat> (hostRect.size.width  / desktopScale),

  1879.                            static_cast<CGFloat> (hostRect.size.height / desktopScale));

  1880.     }

  1881. 

  1882.     //==============================================================================

  1883.     void pullInputAudio (AudioUnitRenderActionFlags& flags, const AudioTimeStamp& timestamp, const UInt32 nFrames) noexcept

  1884.     {

  1885.         const unsigned int numInputBuses = GetScope (kAudioUnitScope_Input).GetNumberOfElements();

  1886. 

  1887.         for (unsigned int i = 0; i < numInputBuses; ++i)

  1888.         {

  1889.             if (AUInputElement* input = GetInput (i))

  1890.             {

  1891.                 const bool succeeded = (input->PullInput (flags, timestamp, i, nFrames) == noErr);

  1892. 

  1893.                 if ((flags & kAudioUnitRenderAction_OutputIsSilence) != 0 && succeeded)

  1894.                     AudioUnitHelpers::clearAudioBuffer (input->GetBufferList());

  1895. 

  1896.                 pulledSucceeded[i] = succeeded;

  1897.             }

  1898.         }

  1899.     }

  1900. 

  1901.     void prepareOutputBuffers (const UInt32 nFrames) noexcept

  1902.     {

  1903.         const auto numProcessorBuses = AudioUnitHelpers::getBusCount (*juceFilter, false);

  1904.         const auto numWrapperBuses = GetScope (kAudioUnitScope_Output).GetNumberOfElements();

  1905. 

  1906.         for (UInt32 busIdx = 0; busIdx < numWrapperBuses; ++busIdx)

  1907.         {

  1908.             AUOutputElement* output = GetOutput (busIdx);

  1909. 

  1910.             if (output->WillAllocateBuffer())

  1911.                 output->PrepareBuffer (nFrames);

  1912. 

  1913.             if (busIdx >= (UInt32) numProcessorBuses)

  1914.                 AudioUnitHelpers::clearAudioBuffer (output->GetBufferList());

  1915.         }

  1916.     }

  1917. 

  1918.     void processBlock (juce::AudioBuffer<float>& buffer, MidiBuffer& midiBuffer) noexcept

  1919.     {

  1920.         const ScopedLock sl (juceFilter->getCallbackLock());

  1921. 

  1922.         if (juceFilter->isSuspended())

  1923.         {

  1924.             buffer.clear();

  1925.         }

  1926.         else if (bypassParam == nullptr && isBypassed)

  1927.         {

  1928.             juceFilter->processBlockBypassed (buffer, midiBuffer);

  1929.         }

  1930.         else

  1931.         {

  1932.             juceFilter->processBlock (buffer, midiBuffer);

  1933.         }

  1934.     }

  1935. 

  1936.     void pushMidiOutput (UInt32 nFrames) noexcept

  1937.     {

  1938.         MIDIPacket* end = nullptr;

  1939. 

  1940.         const auto init = [&]

  1941.         {

  1942.             end = MIDIPacketListInit (packetList);

  1943.         };

  1944. 

  1945.         const auto send = [&]

  1946.         {

  1947.             midiCallback.midiOutputCallback (midiCallback.userData, &lastTimeStamp, 0, packetList);

  1948.         };

  1949. 

  1950.         const auto add = [&] (const MidiMessageMetadata& metadata)

  1951.         {

  1952.             end = MIDIPacketListAdd (packetList,

  1953.                                      packetListBytes,

  1954.                                      end,

  1955.                                      static_cast<MIDITimeStamp> (metadata.samplePosition),

  1956.                                      static_cast<ByteCount> (metadata.numBytes),

  1957.                                      metadata.data);

  1958.         };

  1959. 

  1960.         init();

  1961. 

  1962.         for (const auto metadata : midiEvents)

  1963.         {

  1964.             jassert (isPositiveAndBelow (metadata.samplePosition, nFrames));

  1965.             ignoreUnused (nFrames);

  1966. 

  1967.             add (metadata);

  1968. 

  1969.             if (end == nullptr)

  1970.             {

  1971.                 send();

  1972.                 init();

  1973.                 add (metadata);

  1974. 

  1975.                 if (end == nullptr)

  1976.                 {

  1977.                     // If this is hit, the size of this midi packet exceeds the maximum size of

  1978.                     // a MIDIPacketList. Large SysEx messages should be broken up into smaller

  1979.                     // chunks.

  1980.                     jassertfalse;

  1981.                     init();

  1982.                 }

  1983.             }

  1984.         }

  1985. 

  1986.         send();

  1987.     }

  1988. 

  1989.     void GetAudioBufferList (bool isInput, int busIdx, AudioBufferList*& bufferList, bool& interleaved, int& numChannels)

  1990.     {

  1991.         AUIOElement* element = GetElement (isInput ? kAudioUnitScope_Input : kAudioUnitScope_Output, static_cast<UInt32> (busIdx))->AsIOElement();

  1992.         jassert (element != nullptr);

  1993. 

  1994.         bufferList = &element->GetBufferList();

  1995. 

  1996.         jassert (bufferList->mNumberBuffers > 0);

  1997. 

  1998.         interleaved = AudioUnitHelpers::isAudioBufferInterleaved (*bufferList);

  1999.         numChannels = static_cast<int> (interleaved ? bufferList->mBuffers[0].mNumberChannels : bufferList->mNumberBuffers);

  2000.     }

  2001. 

  2002.     //==============================================================================

  2003.     static OSStatus scopeToDirection (AudioUnitScope scope, bool& isInput) noexcept

  2004.     {

  2005.         isInput = (scope == kAudioUnitScope_Input);

  2006. 

  2007.         return (scope != kAudioUnitScope_Input

  2008.              && scope != kAudioUnitScope_Output)

  2009.               ? (OSStatus) kAudioUnitErr_InvalidScope : (OSStatus) noErr;

  2010.     }

  2011. 

  2012.     enum class BusKind

  2013.     {

  2014.         processor,

  2015.         wrapperOnly,

  2016.     };

  2017. 

  2018.     struct ElementInfo

  2019.     {

  2020.         int busNr;

  2021.         BusKind kind;

  2022.         bool isInput;

  2023.         OSStatus error;

  2024.     };

  2025. 

  2026.     ElementInfo getElementInfo (AudioUnitScope scope, AudioUnitElement element) noexcept

  2027.     {

  2028.         bool isInput = false;

  2029.         OSStatus err;

  2030. 

  2031.         if ((err = scopeToDirection (scope, isInput)) != noErr)

  2032.             return { {}, {}, {}, err };

  2033. 

  2034.         const auto busIdx = static_cast<int> (element);

  2035. 

  2036.         if (isPositiveAndBelow (busIdx, AudioUnitHelpers::getBusCount (*juceFilter, isInput)))

  2037.             return { busIdx, BusKind::processor, isInput, noErr };

  2038. 

  2039.         if (isPositiveAndBelow (busIdx, AudioUnitHelpers::getBusCountForWrapper (*juceFilter, isInput)))

  2040.             return { busIdx, BusKind::wrapperOnly, isInput, noErr };

  2041. 

  2042.         return { {}, {}, {}, kAudioUnitErr_InvalidElement };

  2043.     }

  2044. 

  2045.     //==============================================================================

  2046.     void addParameters()

  2047.     {

  2048.         parameterGroups = juceFilter->getParameterTree().getSubgroups (true);

  2049. 

  2050.         juceParameters.update (*juceFilter, forceUseLegacyParamIDs);

  2051.         const int numParams = juceParameters.getNumParameters();

  2052. 

  2053.         if (forceUseLegacyParamIDs)

  2054.         {

  2055.             Globals()->UseIndexedParameters (numParams);

  2056.         }

  2057.         else

  2058.         {

  2059.             for (auto* param : juceParameters)

  2060.             {

  2061.                 const AudioUnitParameterID auParamID = generateAUParameterID (param);

  2062. 

  2063.                 // Consider yourself very unlucky if you hit this assertion. The hash codes of your

  2064.                 // parameter ids are not unique.

  2065.                 jassert (! paramMap.contains (static_cast<int32> (auParamID)));

  2066. 

  2067.                 auParamIDs.add (auParamID);

  2068.                 paramMap.set (static_cast<int32> (auParamID), param);

  2069.                 Globals()->SetParameter (auParamID, param->getValue());

  2070.             }

  2071.         }

  2072. 

  2073.        #if JUCE_DEBUG

  2074.         // Some hosts can't handle the huge numbers of discrete parameter values created when

  2075.         // using the default number of steps.

  2076.         for (auto* param : juceParameters)

  2077.             if (param->isDiscrete())

  2078.                 jassert (param->getNumSteps() != AudioProcessor::getDefaultNumParameterSteps());

  2079.        #endif

  2080. 

  2081.         parameterValueStringArrays.ensureStorageAllocated (numParams);

  2082. 

  2083.         for (auto* param : juceParameters)

  2084.         {

  2085.             OwnedArray<const __CFString>* stringValues = nullptr;

  2086. 

  2087.             auto initialValue = param->getValue();

  2088.             bool paramIsLegacy = dynamic_cast<LegacyAudioParameter*> (param) != nullptr;

  2089. 

  2090.             if (param->isDiscrete() && (! forceUseLegacyParamIDs))

  2091.             {

  2092.                 const auto numSteps = param->getNumSteps();

  2093.                 stringValues = new OwnedArray<const __CFString>();

  2094.                 stringValues->ensureStorageAllocated (numSteps);

  2095. 

  2096.                 const auto maxValue = getMaximumParameterValue (param);

  2097. 

  2098.                 auto getTextValue = [param, paramIsLegacy] (float value)

  2099.                 {

  2100.                     if (paramIsLegacy)

  2101.                     {

  2102.                         param->setValue (value);

  2103.                         return param->getCurrentValueAsText();

  2104.                     }

  2105. 

  2106.                     return param->getText (value, 256);

  2107.                 };

  2108. 

  2109.                 for (int i = 0; i < numSteps; ++i)

  2110.                 {

  2111.                     auto value = (float) i / maxValue;

  2112.                     stringValues->add (CFStringCreateCopy (nullptr, (getTextValue (value).toCFString())));

  2113.                 }

  2114.             }

  2115. 

  2116.             if (paramIsLegacy)

  2117.                 param->setValue (initialValue);

  2118. 

  2119.             parameterValueStringArrays.add (stringValues);

  2120.         }

  2121. 

  2122.         if ((bypassParam = juceFilter->getBypassParameter()) != nullptr)

  2123.             bypassParam->addListener (this);

  2124.     }

  2125. 

  2126.     //==============================================================================

  2127.     AudioUnitParameterID generateAUParameterID (AudioProcessorParameter* param) const

  2128.     {

  2129.         const String& juceParamID = LegacyAudioParameter::getParamID (param, forceUseLegacyParamIDs);

  2130.         AudioUnitParameterID paramHash = static_cast<AudioUnitParameterID> (juceParamID.hashCode());

  2131. 

  2132.        #if JUCE_USE_STUDIO_ONE_COMPATIBLE_PARAMETERS

  2133.         // studio one doesn't like negative parameters

  2134.         paramHash &= ~(((AudioUnitParameterID) 1) << (sizeof (AudioUnitParameterID) * 8 - 1));

  2135.        #endif

  2136. 

  2137.         return forceUseLegacyParamIDs ? static_cast<AudioUnitParameterID> (juceParamID.getIntValue())

  2138.                                       : paramHash;

  2139.     }

  2140. 

  2141.     inline AudioUnitParameterID getAUParameterIDForIndex (int paramIndex) const noexcept

  2142.     {

  2143.         return forceUseLegacyParamIDs ? static_cast<AudioUnitParameterID> (paramIndex)

  2144.                                       : auParamIDs.getReference (paramIndex);

  2145.     }

  2146. 

  2147.     AudioProcessorParameter* getParameterForAUParameterID (AudioUnitParameterID address) const noexcept

  2148.     {

  2149.         auto index = static_cast<int32> (address);

  2150.         return forceUseLegacyParamIDs ? juceParameters.getParamForIndex (index)

  2151.                                       : paramMap[index];

  2152.     }

  2153. 

  2154.     //==============================================================================

  2155.     OSStatus syncAudioUnitWithProcessor()

  2156.     {

  2157.         OSStatus err = noErr;

  2158.         const auto numWrapperInputs  = AudioUnitHelpers::getBusCountForWrapper (*juceFilter, true);

  2159.         const auto numWrapperOutputs = AudioUnitHelpers::getBusCountForWrapper (*juceFilter, false);

  2160. 

  2161.         if ((err =  MusicDeviceBase::SetBusCount (kAudioUnitScope_Input,  static_cast<UInt32> (numWrapperInputs))) != noErr)

  2162.             return err;

  2163. 

  2164.         if ((err =  MusicDeviceBase::SetBusCount (kAudioUnitScope_Output, static_cast<UInt32> (numWrapperOutputs))) != noErr)

  2165.             return err;

  2166. 

  2167.         addSupportedLayoutTags();

  2168. 

  2169.         const auto numProcessorInputs  = AudioUnitHelpers::getBusCount (*juceFilter, true);

  2170.         const auto numProcessorOutputs = AudioUnitHelpers::getBusCount (*juceFilter, false);

  2171. 

  2172.         for (int i = 0; i < numProcessorInputs; ++i)

  2173.             if ((err = syncAudioUnitWithChannelSet (true,  i, juceFilter->getChannelLayoutOfBus (true,  i))) != noErr)

  2174.                 return err;

  2175. 

  2176.         for (int i = 0; i < numProcessorOutputs; ++i)

  2177.             if ((err = syncAudioUnitWithChannelSet (false, i, juceFilter->getChannelLayoutOfBus (false, i))) != noErr)

  2178.                 return err;

  2179. 

  2180.         return noErr;

  2181.     }

  2182. 

  2183.     OSStatus syncProcessorWithAudioUnit()

  2184.     {

  2185.         const int numInputBuses  = AudioUnitHelpers::getBusCount (*juceFilter, true);

  2186.         const int numOutputBuses = AudioUnitHelpers::getBusCount (*juceFilter, false);

  2187. 

  2188.         const int numInputElements  = static_cast<int> (GetScope(kAudioUnitScope_Input). GetNumberOfElements());

  2189.         const int numOutputElements = static_cast<int> (GetScope(kAudioUnitScope_Output).GetNumberOfElements());

  2190. 

  2191.         AudioProcessor::BusesLayout requestedLayouts;

  2192.         for (int dir = 0; dir < 2; ++dir)

  2193.         {

  2194.             const bool isInput = (dir == 0);

  2195.             const int n = (isInput ? numInputBuses : numOutputBuses);

  2196.             const int numAUElements  = (isInput ? numInputElements : numOutputElements);

  2197.             Array<AudioChannelSet>& requestedBuses = (isInput ? requestedLayouts.inputBuses : requestedLayouts.outputBuses);

  2198. 

  2199.             for (int busIdx = 0; busIdx < n; ++busIdx)

  2200.             {

  2201.                 const AUIOElement* element = (busIdx < numAUElements ? GetIOElement (isInput ? kAudioUnitScope_Input :  kAudioUnitScope_Output, (UInt32) busIdx) : nullptr);

  2202.                 const int numChannels = (element != nullptr ? static_cast<int> (element->GetStreamFormat().NumberChannels()) : 0);

  2203. 

  2204.                 AudioChannelLayoutTag currentLayoutTag = isInput ? currentInputLayout[busIdx] : currentOutputLayout[busIdx];

  2205.                 const int tagNumChannels = currentLayoutTag & 0xffff;

  2206. 

  2207.                 if (numChannels != tagNumChannels)

  2208.                     return kAudioUnitErr_FormatNotSupported;

  2209. 

  2210.                 requestedBuses.add (CoreAudioLayouts::fromCoreAudio (currentLayoutTag));

  2211.             }

  2212.         }

  2213. 

  2214.        #ifdef JucePlugin_PreferredChannelConfigurations

  2215.         short configs[][2] = {JucePlugin_PreferredChannelConfigurations};

  2216. 

  2217.         if (! AudioProcessor::containsLayout (requestedLayouts, configs))

  2218.             return kAudioUnitErr_FormatNotSupported;

  2219.        #endif

  2220. 

  2221.         if (! AudioUnitHelpers::setBusesLayout (juceFilter.get(), requestedLayouts))

  2222.             return kAudioUnitErr_FormatNotSupported;

  2223. 

  2224.         // update total channel count

  2225.         totalInChannels  = juceFilter->getTotalNumInputChannels();

  2226.         totalOutChannels = juceFilter->getTotalNumOutputChannels();

  2227. 

  2228.         return noErr;

  2229.     }

  2230. 

  2231.     OSStatus syncAudioUnitWithChannelSet (bool isInput, int busNr, const AudioChannelSet& channelSet)

  2232.     {

  2233.         const int numChannels = channelSet.size();

  2234. 

  2235.         getCurrentLayout (isInput, busNr) = CoreAudioLayouts::toCoreAudio (channelSet);

  2236. 

  2237.         // is this bus activated?

  2238.         if (numChannels == 0)

  2239.             return noErr;

  2240. 

  2241.         if (AUIOElement* element = GetIOElement (isInput ? kAudioUnitScope_Input :  kAudioUnitScope_Output, (UInt32) busNr))

  2242.         {

  2243.             element->SetName ((CFStringRef) juceStringToNS (juceFilter->getBus (isInput, busNr)->getName()));

  2244. 

  2245.             CAStreamBasicDescription streamDescription;

  2246.             streamDescription.mSampleRate = getSampleRate();

  2247. 

  2248.             streamDescription.SetCanonical ((UInt32) numChannels, false);

  2249.             return element->SetStreamFormat (streamDescription);

  2250.         }

  2251.         else

  2252.             jassertfalse;

  2253. 

  2254.         return kAudioUnitErr_InvalidElement;

  2255.     }

  2256. 

  2257.     //==============================================================================

  2258.     void clearPresetsArray() const

  2259.     {

  2260.         for (int i = presetsArray.size(); --i >= 0;)

  2261.             CFRelease (presetsArray.getReference(i).presetName);

  2262. 

  2263.         presetsArray.clear();

  2264.     }

  2265. 

  2266.     void refreshCurrentPreset()

  2267.     {

  2268.         // this will make the AU host re-read and update the current preset name

  2269.         // in case it was changed here in the plug-in:

  2270. 

  2271.         const int currentProgramNumber = juceFilter->getCurrentProgram();

  2272.         const String currentProgramName = juceFilter->getProgramName (currentProgramNumber);

  2273. 

  2274.         AUPreset currentPreset;

  2275.         currentPreset.presetNumber = currentProgramNumber;

  2276.         currentPreset.presetName = currentProgramName.toCFString();

  2277. 

  2278.         SetAFactoryPresetAsCurrent (currentPreset);

  2279.     }

  2280. 

  2281.     //==============================================================================

  2282.     Array<AudioChannelLayoutTag>&       getSupportedBusLayouts (bool isInput, int bus) noexcept       { return (isInput ? supportedInputLayouts : supportedOutputLayouts).getReference (bus); }

  2283.     const Array<AudioChannelLayoutTag>& getSupportedBusLayouts (bool isInput, int bus) const noexcept { return (isInput ? supportedInputLayouts : supportedOutputLayouts).getReference (bus); }

  2284.     AudioChannelLayoutTag& getCurrentLayout (bool isInput, int bus) noexcept               { return (isInput ? currentInputLayout : currentOutputLayout).getReference (bus); }

  2285.     AudioChannelLayoutTag  getCurrentLayout (bool isInput, int bus) const noexcept         { return (isInput ? currentInputLayout : currentOutputLayout)[bus]; }

  2286. 

  2287.     //==============================================================================

  2288.     void addSupportedLayoutTagsForBus (bool isInput, int busNum, Array<AudioChannelLayoutTag>& tags)

  2289.     {

  2290.         if (AudioProcessor::Bus* bus = juceFilter->getBus (isInput, busNum))

  2291.         {

  2292.            #ifndef JucePlugin_PreferredChannelConfigurations

  2293.             auto& knownTags = CoreAudioLayouts::getKnownCoreAudioTags();

  2294. 

  2295.             for (auto tag : knownTags)

  2296.                 if (bus->isLayoutSupported (CoreAudioLayouts::fromCoreAudio (tag)))

  2297.                     tags.addIfNotAlreadyThere (tag);

  2298.            #endif

  2299. 

  2300.             // add discrete layout tags

  2301.             int n = bus->getMaxSupportedChannels (maxChannelsToProbeFor());

  2302. 

  2303.             for (int ch = 0; ch < n; ++ch)

  2304.             {

  2305.                #ifdef JucePlugin_PreferredChannelConfigurations

  2306.                 const short configs[][2] = { JucePlugin_PreferredChannelConfigurations };

  2307.                 if (AudioUnitHelpers::isLayoutSupported (*juceFilter, isInput, busNum, ch, configs))

  2308.                     tags.addIfNotAlreadyThere (static_cast<AudioChannelLayoutTag> ((int) kAudioChannelLayoutTag_DiscreteInOrder | ch));

  2309.                #else

  2310.                 if (bus->isLayoutSupported (AudioChannelSet::discreteChannels (ch)))

  2311.                     tags.addIfNotAlreadyThere (static_cast<AudioChannelLayoutTag> ((int) kAudioChannelLayoutTag_DiscreteInOrder | ch));

  2312.                #endif

  2313.             }

  2314.         }

  2315.     }

  2316. 

  2317.     void addSupportedLayoutTagsForDirection (bool isInput)

  2318.     {

  2319.         auto& layouts = isInput ? supportedInputLayouts : supportedOutputLayouts;

  2320.         layouts.clearQuick();

  2321.         auto numBuses = AudioUnitHelpers::getBusCount (*juceFilter, isInput);

  2322. 

  2323.         for (int busNr = 0; busNr < numBuses; ++busNr)

  2324.         {

  2325.             Array<AudioChannelLayoutTag> busLayouts;

  2326.             addSupportedLayoutTagsForBus (isInput, busNr, busLayouts);

  2327. 

  2328.             layouts.add (busLayouts);

  2329.         }

  2330.     }

  2331. 

  2332.     void addSupportedLayoutTags()

  2333.     {

  2334.         currentInputLayout.clear(); currentOutputLayout.clear();

  2335. 

  2336.         currentInputLayout. resize (AudioUnitHelpers::getBusCountForWrapper (*juceFilter, true));

  2337.         currentOutputLayout.resize (AudioUnitHelpers::getBusCountForWrapper (*juceFilter, false));

  2338. 

  2339.         addSupportedLayoutTagsForDirection (true);

  2340.         addSupportedLayoutTagsForDirection (false);

  2341.     }

  2342. 

  2343.     static int maxChannelsToProbeFor()

  2344.     {

  2345.         return (getHostType().isLogic() ? 8 : 64);

  2346.     }

  2347. 

  2348.     //==============================================================================

  2349.     void auPropertyListener (AudioUnitPropertyID propId, AudioUnitScope scope, AudioUnitElement)

  2350.     {

  2351.         if (scope == kAudioUnitScope_Global && propId == kAudioUnitProperty_ContextName

  2352.              && juceFilter != nullptr && mContextName != nullptr)

  2353.         {

  2354.             AudioProcessor::TrackProperties props;

  2355.             props.name = String::fromCFString (mContextName);

  2356. 

  2357.             juceFilter->updateTrackProperties (props);

  2358.         }

  2359.     }

  2360. 

  2361.     static void auPropertyListenerDispatcher (void* inRefCon, AudioUnit, AudioUnitPropertyID propId,

  2362.                                               AudioUnitScope scope, AudioUnitElement element)

  2363.     {

  2364.         static_cast<JuceAU*> (inRefCon)->auPropertyListener (propId, scope, element);

  2365.     }

  2366. 

  2367.     JUCE_DECLARE_NON_COPYABLE (JuceAU)

  2368. };

  2369. 

  2370. //==============================================================================

  2371. #if BUILD_AU_CARBON_UI

  2372. 

  2373. class JuceAUView  : public AUCarbonViewBase

  2374. {

  2375. public:

  2376.     JuceAUView (AudioUnitCarbonView auview)

  2377.       : AUCarbonViewBase (auview),

  2378.         juceFilter (nullptr)

  2379.     {

  2380.     }

  2381. 

  2382.     ~JuceAUView()

  2383.     {

  2384.         deleteUI();

  2385.     }

  2386. 

  2387.     ComponentResult CreateUI (Float32 /*inXOffset*/, Float32 /*inYOffset*/) override

  2388.     {

  2389.         JUCE_AUTORELEASEPOOL

  2390.         {

  2391.             if (juceFilter == nullptr)

  2392.             {

  2393.                 void* pointers[2];

  2394.                 UInt32 propertySize = sizeof (pointers);

  2395. 

  2396.                 AudioUnitGetProperty (GetEditAudioUnit(),

  2397.                                       juceFilterObjectPropertyID,

  2398.                                       kAudioUnitScope_Global,

  2399.                                       0,

  2400.                                       pointers,

  2401.                                       &propertySize);

  2402. 

  2403.                 juceFilter = (AudioProcessor*) pointers[0];

  2404.             }

  2405. 

  2406.             if (juceFilter != nullptr)

  2407.             {

  2408.                 deleteUI();

  2409. 

  2410.                 if (AudioProcessorEditor* editorComp = juceFilter->createEditorIfNeeded())

  2411.                 {

  2412.                     editorComp->setOpaque (true);

  2413.                     windowComp.reset (new ComponentInHIView (editorComp, mCarbonPane));

  2414.                 }

  2415.             }

  2416.             else

  2417.             {

  2418.                 jassertfalse; // can't get a pointer to our effect

  2419.             }

  2420.         }

  2421. 

  2422.         return noErr;

  2423.     }

  2424. 

  2425.     AudioUnitCarbonViewEventListener getEventListener() const   { return mEventListener; }

  2426.     void* getEventListenerUserData() const                      { return mEventListenerUserData; }

  2427. 

  2428. private:

  2429.     //==============================================================================

  2430.     AudioProcessor* juceFilter;

  2431.     std::unique_ptr<Component> windowComp;

  2432. 

  2433.     void deleteUI()

  2434.     {

  2435.         if (windowComp != nullptr)

  2436.         {

  2437.             PopupMenu::dismissAllActiveMenus();

  2438. 

  2439.             /* This assertion is triggered when there's some kind of modal component active, and the

  2440.                host is trying to delete our plugin.

  2441.                If you must use modal components, always use them in a non-blocking way, by never

  2442.                calling runModalLoop(), but instead using enterModalState() with a callback that

  2443.                will be performed on completion. (Note that this assertion could actually trigger

  2444.                a false alarm even if you're doing it correctly, but is here to catch people who

  2445.                aren't so careful) */

  2446.             jassert (Component::getCurrentlyModalComponent() == nullptr);

  2447. 

  2448.             if (JuceAU::EditorCompHolder* editorCompHolder = dynamic_cast<JuceAU::EditorCompHolder*> (windowComp->getChildComponent(0)))

  2449.                 if (AudioProcessorEditor* audioProcessEditor = dynamic_cast<AudioProcessorEditor*> (editorCompHolder->getChildComponent(0)))

  2450.                     juceFilter->editorBeingDeleted (audioProcessEditor);

  2451. 

  2452.             windowComp = nullptr;

  2453.         }

  2454.     }

  2455. 

  2456.     //==============================================================================

  2457.     // Uses a child NSWindow to sit in front of a HIView and display our component

  2458.     class ComponentInHIView  : public Component

  2459.     {

  2460.     public:

  2461.         ComponentInHIView (AudioProcessorEditor* ed, HIViewRef parentHIView)

  2462.             : parentView (parentHIView),

  2463.               editor (ed),

  2464.               recursive (false)

  2465.         {

  2466.             JUCE_AUTORELEASEPOOL

  2467.             {

  2468.                 jassert (ed != nullptr);

  2469.                 addAndMakeVisible (editor);

  2470.                 setOpaque (true);

  2471.                 setVisible (true);

  2472.                 setBroughtToFrontOnMouseClick (true);

  2473. 

  2474.                 setSize (editor.getWidth(), editor.getHeight());

  2475.                 SizeControl (parentHIView, (SInt16) editor.getWidth(), (SInt16) editor.getHeight());

  2476. 

  2477.                 WindowRef windowRef = HIViewGetWindow (parentHIView);

  2478.                 hostWindow = [[NSWindow alloc] initWithWindowRef: windowRef];

  2479. 

  2480.                 // not really sure why this is needed in older OS X versions

  2481.                 // but JUCE plug-ins crash without it

  2482.                 if ((SystemStats::getOperatingSystemType() & 0xff) < 12)

  2483.                     [hostWindow retain];

  2484. 

  2485.                 [hostWindow setCanHide: YES];

  2486.                 [hostWindow setReleasedWhenClosed: YES];

  2487. 

  2488.                 updateWindowPos();

  2489. 

  2490.                #if ! JucePlugin_EditorRequiresKeyboardFocus

  2491.                 addToDesktop (ComponentPeer::windowIsTemporary | ComponentPeer::windowIgnoresKeyPresses);

  2492.                 setWantsKeyboardFocus (false);

  2493.                #else

  2494.                 addToDesktop (ComponentPeer::windowIsTemporary);

  2495.                 setWantsKeyboardFocus (true);

  2496.                #endif

  2497. 

  2498.                 setVisible (true);

  2499.                 toFront (false);

  2500. 

  2501.                 addSubWindow();

  2502. 

  2503.                 NSWindow* pluginWindow = [((NSView*) getWindowHandle()) window];

  2504.                 [pluginWindow setNextResponder: hostWindow];

  2505. 

  2506.                 attachWindowHidingHooks (this, (WindowRef) windowRef, hostWindow);

  2507.             }

  2508.         }

  2509. 

  2510.         ~ComponentInHIView()

  2511.         {

  2512.             JUCE_AUTORELEASEPOOL

  2513.             {

  2514.                 removeWindowHidingHooks (this);

  2515. 

  2516.                 NSWindow* pluginWindow = [((NSView*) getWindowHandle()) window];

  2517.                 [hostWindow removeChildWindow: pluginWindow];

  2518.                 removeFromDesktop();

  2519. 

  2520.                 [hostWindow release];

  2521.                 hostWindow = nil;

  2522.             }

  2523.         }

  2524. 

  2525.         void updateWindowPos()

  2526.         {

  2527.             HIPoint f;

  2528.             f.x = f.y = 0;

  2529.             HIPointConvert (&f, kHICoordSpaceView, parentView, kHICoordSpaceScreenPixel, 0);

  2530.             setTopLeftPosition ((int) f.x, (int) f.y);

  2531.         }

  2532. 

  2533.         void addSubWindow()

  2534.         {

  2535.             NSWindow* pluginWindow = [((NSView*) getWindowHandle()) window];

  2536.             [pluginWindow setExcludedFromWindowsMenu: YES];

  2537.             [pluginWindow setCanHide: YES];

  2538. 

  2539.             [hostWindow addChildWindow: pluginWindow

  2540.                                ordered: NSWindowAbove];

  2541.             [hostWindow orderFront: nil];

  2542.             [pluginWindow orderFront: nil];

  2543.         }

  2544. 

  2545.         void resized() override

  2546.         {

  2547.             if (Component* const child = getChildComponent (0))

  2548.                 child->setBounds (getLocalBounds());

  2549.         }

  2550. 

  2551.         void paint (Graphics&) override {}

  2552. 

  2553.         void childBoundsChanged (Component*) override

  2554.         {

  2555.             if (! recursive)

  2556.             {

  2557.                 recursive = true;

  2558. 

  2559.                 const int w = jmax (32, editor.getWidth());

  2560.                 const int h = jmax (32, editor.getHeight());

  2561. 

  2562.                 SizeControl (parentView, (SInt16) w, (SInt16) h);

  2563. 

  2564.                 if (getWidth() != w || getHeight() != h)

  2565.                     setSize (w, h);

  2566. 

  2567.                 editor.repaint();

  2568. 

  2569.                 updateWindowPos();

  2570.                 addSubWindow(); // (need this for AULab)

  2571. 

  2572.                 recursive = false;

  2573.             }

  2574.         }

  2575. 

  2576.         bool keyPressed (const KeyPress& kp) override

  2577.         {

  2578.             if (! kp.getModifiers().isCommandDown())

  2579.             {

  2580.                 // If we have an unused keypress, move the key-focus to a host window

  2581.                 // and re-inject the event..

  2582.                 static NSTimeInterval lastEventTime = 0; // check we're not recursively sending the same event

  2583.                 NSTimeInterval eventTime = [[NSApp currentEvent] timestamp];

  2584. 

  2585.                 if (lastEventTime != eventTime)

  2586.                 {

  2587.                     lastEventTime = eventTime;

  2588. 

  2589.                     [[hostWindow parentWindow] makeKeyWindow];

  2590.                     repostCurrentNSEvent();

  2591.                 }

  2592.             }

  2593. 

  2594.             return false;

  2595.         }

  2596. 

  2597.     private:

  2598.         HIViewRef parentView;

  2599.         NSWindow* hostWindow;

  2600.         JuceAU::EditorCompHolder editor;

  2601.         bool recursive;

  2602.     };

  2603. };

  2604. 

  2605. #endif

  2606. 

  2607. //==============================================================================

  2608. #define JUCE_COMPONENT_ENTRYX(Class, Name, Suffix) \

  2609.     extern "C" __attribute__((visibility("default"))) ComponentResult Name ## Suffix (ComponentParameters* params, Class* obj); \

  2610.     extern "C" __attribute__((visibility("default"))) ComponentResult Name ## Suffix (ComponentParameters* params, Class* obj) \

  2611.     { \

  2612.         PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_AudioUnit; \

  2613.         return ComponentEntryPoint<Class>::Dispatch (params, obj); \

  2614.     }

  2615. 

  2616. #if JucePlugin_ProducesMidiOutput || JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect

  2617.  #define FACTORY_BASE_CLASS AUMIDIEffectFactory

  2618. #else

  2619.  #define FACTORY_BASE_CLASS AUBaseFactory

  2620. #endif

  2621. 

  2622. #define JUCE_FACTORY_ENTRYX(Class, Name) \

  2623.     extern "C" __attribute__((visibility("default"))) void* Name ## Factory (const AudioComponentDescription* desc); \

  2624.     extern "C" __attribute__((visibility("default"))) void* Name ## Factory (const AudioComponentDescription* desc) \

  2625.     { \

  2626.         PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_AudioUnit; \

  2627.         return FACTORY_BASE_CLASS<Class>::Factory (desc); \

  2628.     }

  2629. 

  2630. #define JUCE_COMPONENT_ENTRY(Class, Name, Suffix)   JUCE_COMPONENT_ENTRYX(Class, Name, Suffix)

  2631. #define JUCE_FACTORY_ENTRY(Class, Name)             JUCE_FACTORY_ENTRYX(Class, Name)

  2632. 

  2633. //==============================================================================

  2634. JUCE_COMPONENT_ENTRY (JuceAU, JucePlugin_AUExportPrefix, Entry)

  2635. 

  2636. #ifndef AUDIOCOMPONENT_ENTRY

  2637.  #define JUCE_DISABLE_AU_FACTORY_ENTRY 1

  2638. #endif

  2639. 

  2640. #if ! JUCE_DISABLE_AU_FACTORY_ENTRY  // (You might need to disable this for old Xcode 3 builds)

  2641. JUCE_FACTORY_ENTRY   (JuceAU, JucePlugin_AUExportPrefix)

  2642. #endif

  2643. 

  2644. #if BUILD_AU_CARBON_UI

  2645.  JUCE_COMPONENT_ENTRY (JuceAUView, JucePlugin_AUExportPrefix, ViewEntry)

  2646. #endif

  2647. 

  2648. #if ! JUCE_DISABLE_AU_FACTORY_ENTRY

  2649.  JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wcast-align", "-Wzero-as-null-pointer-constant")

  2650. 

  2651.  #include "CoreAudioUtilityClasses/AUPlugInDispatch.cpp"

  2652. 

  2653.  JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  2654. #endif

  2655. 

  2656. #endif