An Effect class that handles a wide range of effects. ??Mac only?? More...

#include <AudioUnitEffect.h>

Inheritance diagram for AudioUnitEffect:

Collaboration diagram for AudioUnitEffect:

Public Member Functions
	AudioUnitEffect (const PluginPath &path, const wxString &name, AudioComponent component, AudioUnitEffect *master=NULL)

virtual	~AudioUnitEffect ()

PluginPath	GetPath () override

ComponentInterfaceSymbol	GetSymbol () override

VendorSymbol	GetVendor () override

wxString	GetVersion () override

TranslatableString	GetDescription () override

EffectType	GetType () override

EffectFamilySymbol	GetFamily () override

bool	IsInteractive () override

bool	IsDefault () override

bool	IsLegacy () override

bool	SupportsRealtime () override

bool	SupportsAutomation () override

bool	SetHost (EffectHostInterface *host) override

unsigned	GetAudioInCount () override

unsigned	GetAudioOutCount () override

int	GetMidiInCount () override

int	GetMidiOutCount () override

void	SetSampleRate (double rate) override

size_t	SetBlockSize (size_t maxBlockSize) override

size_t	GetBlockSize () const override

sampleCount	GetLatency () override

size_t	GetTailSize () override

bool	IsReady () override

bool	ProcessInitialize (sampleCount totalLen, ChannelNames chanMap=NULL) override

bool	ProcessFinalize () override

size_t	ProcessBlock (float inBlock, float outBlock, size_t blockLen) override

bool	RealtimeInitialize () override

bool	RealtimeAddProcessor (unsigned numChannels, float sampleRate) override

bool	RealtimeFinalize () override

bool	RealtimeSuspend () override

bool	RealtimeResume () override

bool	RealtimeProcessStart () override

size_t	RealtimeProcess (int group, float inbuf, float outbuf, size_t numSamples) override

bool	RealtimeProcessEnd () override

bool	ShowInterface (wxWindow &parent, const EffectDialogFactory &factory, bool forceModal=false) override

bool	GetAutomationParameters (CommandParameters &parms) override

bool	SetAutomationParameters (CommandParameters &parms) override

bool	LoadUserPreset (const RegistryPath &name) override

bool	SaveUserPreset (const RegistryPath &name) override

bool	LoadFactoryPreset (int id) override

bool	LoadFactoryDefaults () override

RegistryPaths	GetFactoryPresets () override

void	SetHostUI (EffectUIHostInterface *host) override

bool	PopulateUI (ShuttleGui &S) override

bool	IsGraphicalUI () override

bool	ValidateUI () override

bool	HideUI () override

bool	CloseUI () override

bool	CanExportPresets () override

void	ExportPresets () override

void	ImportPresets () override

bool	HasOptions () override

void	ShowOptions () override

Public Member Functions inherited from EffectClientInterface
virtual	~EffectClientInterface ()

Public Member Functions inherited from EffectDefinitionInterface
virtual	~EffectDefinitionInterface ()

virtual EffectType	GetClassification ()

Public Member Functions inherited from ComponentInterface
virtual	~ComponentInterface ()

TranslatableString	GetName ()

virtual bool	DefineParams (ShuttleParams &WXUNUSED(S))

Public Member Functions inherited from EffectUIClientInterface
virtual	~EffectUIClientInterface ()

Private Member Functions
bool	SetRateAndChannels ()

bool	CopyParameters (AudioUnit srcUnit, AudioUnit dstUnit)

TranslatableString	Export (const wxString &path)

TranslatableString	Import (const wxString &path)

void	Notify (AudioUnit unit, AudioUnitParameterID parm)

unsigned	GetChannelCount ()

void	SetChannelCount (unsigned numChannels)

OSStatus	Render (AudioUnitRenderActionFlags inActionFlags, const AudioTimeStamp inTimeStamp, UInt32 inBusNumber, UInt32 inNumFrames, AudioBufferList *ioData)

void	EventListener (const AudioUnitEvent *inEvent, AudioUnitParameterValue inParameterValue)

void	GetChannelCounts ()

bool	LoadPreset (const RegistryPath &group)

bool	SavePreset (const RegistryPath &group)

bool	BypassEffect (bool bypass)

Static Private Member Functions
static OSStatus	RenderCallback (void inRefCon, AudioUnitRenderActionFlags inActionFlags, const AudioTimeStamp inTimeStamp, UInt32 inBusNumber, UInt32 inNumFrames, AudioBufferList ioData)

static void	EventListenerCallback (void inCallbackRefCon, void inObject, const AudioUnitEvent *inEvent, UInt64 inEventHostTime, AudioUnitParameterValue inParameterValue)

Private Attributes
PluginPath	mPath

wxString	mName

wxString	mVendor

AudioComponent	mComponent

AudioUnit	mUnit

bool	mUnitInitialized

bool	mSupportsMono

bool	mSupportsStereo

EffectHostInterface *	mHost

unsigned	mAudioIns

unsigned	mAudioOuts

bool	mInteractive

bool	mLatencyDone

UInt32	mBlockSize

double	mSampleRate

int	mBufferSize

bool	mUseLatency

AudioTimeStamp	mTimeStamp

bool	mReady

ArrayOf< AudioBufferList >	mInputList

ArrayOf< AudioBufferList >	mOutputList

EffectUIHostInterface *	mUIHost

wxWindow *	mParent

wxDialog *	mDialog

wxString	mUIType

bool	mIsGraphical

AudioUnitEffect *	mMaster

AudioUnitEffectArray	mSlaves

unsigned	mNumChannels

ArraysOf< float >	mMasterIn

ArraysOf< float >	mMasterOut

size_t	mNumSamples

AUEventListenerRef	mEventListenerRef

AUControl *	mpControl {}

Friends
class	AudioUnitEffectExportDialog

class	AudioUnitEffectImportDialog

Additional Inherited Members
Public Types inherited from EffectClientInterface
using	EffectDialogFactory = std::function< wxDialog (wxWindow &parent, EffectHostInterface , EffectUIClientInterface *) >

Detailed Description

An Effect class that handles a wide range of effects. ??Mac only??

Definition at line 40 of file AudioUnitEffect.h.

Constructor & Destructor Documentation

◆ AudioUnitEffect()

AudioUnitEffect::AudioUnitEffect	(	const PluginPath &	path,
		const wxString &	name,
		AudioComponent	component,
		AudioUnitEffect *	master = `NULL`
	)

Definition at line 824 of file AudioUnitEffect.cpp.

 {
    mPath = path;
    mName = name.AfterFirst(wxT(':')).Trim(true).Trim(false);
    mVendor = name.BeforeFirst(wxT(':')).Trim(true).Trim(false);
    mComponent = component;
    mMaster = master;
  
    mpControl = NULL;
    mUnit = NULL;
    
    mBlockSize = 0.0;
    mInteractive = false;
    mIsGraphical = false;
  
    mUIHost = NULL;
    mDialog = NULL;
    mParent = NULL;
  
    mUnitInitialized = false;
  
    mEventListenerRef = NULL;
  
    mReady = false;
 }

References mBlockSize, mComponent, mDialog, mEventListenerRef, mInteractive, mIsGraphical, mMaster, mName, mParent, mPath, mpControl, mReady, mUIHost, mUnit, mUnitInitialized, mVendor, and name.

◆ ~AudioUnitEffect()

AudioUnitEffect::~AudioUnitEffect ( )

virtual

Definition at line 853 of file AudioUnitEffect.cpp.

 {
    if (mUnitInitialized)
    {
       AudioUnitUninitialize(mUnit);
    }
  
    if (mEventListenerRef)
    {
       AUListenerDispose(mEventListenerRef);
    }
  
    if (mUnit)
    {
       AudioComponentInstanceDispose(mUnit);
    }
 }

References mEventListenerRef, mUnit, and mUnitInitialized.

Member Function Documentation

◆ BypassEffect()

bool AudioUnitEffect::BypassEffect ( bool bypass )

private

Definition at line 2682 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
  
    UInt32 value = (bypass ? 1 : 0);
  
    result = AudioUnitSetProperty(mUnit,
                                  kAudioUnitProperty_BypassEffect,
                                  kAudioUnitScope_Global,
                                  0,
                                  &value,
                                  sizeof(value));
    if (result != noErr)
    {
       return false;
    }
  
    return true;
 }

References mUnit.

Referenced by ProcessInitialize(), RealtimeResume(), and RealtimeSuspend().

Here is the caller graph for this function:

◆ CanExportPresets()

bool AudioUnitEffect::CanExportPresets ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1843 of file AudioUnitEffect.cpp.

 {
    return true;
 }

◆ CloseUI()

bool AudioUnitEffect::CloseUI ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1821 of file AudioUnitEffect.cpp.

 {
 #ifdef __WXMAC__
 #ifdef __WX_EVTLOOP_BUSY_WAITING__
    wxEventLoop::SetBusyWaiting(false);
 #endif
    if (mpControl)
    {
       mParent->RemoveEventHandler(this);
  
       mpControl->Close();
       mpControl = nullptr;
    }
 #endif
  
    mUIHost = NULL;
    mParent = NULL;
    mDialog = NULL;
  
    return true;
 }

References AUControl::Close(), mDialog, mParent, mpControl, and mUIHost.

Here is the call graph for this function:

◆ CopyParameters()

bool AudioUnitEffect::CopyParameters	(	AudioUnit	srcUnit,
		AudioUnit	dstUnit
	)

private

Definition at line 2245 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
  
    // Retrieve the class state from the source AU
    CFPropertyListRef content;
    UInt32 size = sizeof(content);
    result = AudioUnitGetProperty(srcUnit,
                                  kAudioUnitProperty_ClassInfo,
                                  kAudioUnitScope_Global,
                                  0,
                                  &content,
                                  &size);
    if (result != noErr)
    {
       return false;
    }
  
    // Make sure it get's freed
    CFunique_ptr<char /* CFPropertyList */> ucontent { (char *) content };
  
    // Set the destination AUs state from the source AU's content
    result = AudioUnitSetProperty(dstUnit,
                                  kAudioUnitProperty_ClassInfo,
                                  kAudioUnitScope_Global,
                                  0,
                                  &content,
                                  sizeof(content));
    if (result != noErr)
    {
       return false;
    }
  
    // Notify interested parties
    Notify(dstUnit, kAUParameterListener_AnyParameter);
  
    return true;
 }

References Notify().

Referenced by RealtimeAddProcessor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EventListener()

void AudioUnitEffect::EventListener	(	const AudioUnitEvent *	inEvent,
		AudioUnitParameterValue	inParameterValue
	)

private

Definition at line 2473 of file AudioUnitEffect.cpp.

 {
    // Handle property changes
    if (inEvent->mEventType == kAudioUnitEvent_PropertyChange)
    {
       // Handle latency changes
       if (inEvent->mArgument.mProperty.mPropertyID == kAudioUnitProperty_Latency)
       {
          // Allow change to be used
          //mLatencyDone = false;
       }
  
       return;
    }
  
    // Only parameter changes at this point
  
    if (mMaster)
    {
       // We're a slave, so just set the parameter
       AudioUnitSetParameter(mUnit,
                             inEvent->mArgument.mParameter.mParameterID,
                             kAudioUnitScope_Global,
                             0,
                             inParameterValue,
                             0);
    }
    else
    {
       // We're the master, so propagate 
       for (size_t i = 0, cnt = mSlaves.size(); i < cnt; i++)
       {
          mSlaves[i]->EventListener(inEvent, inParameterValue);
       }
    }
 }

References mMaster, mSlaves, and mUnit.

◆ EventListenerCallback()

void AudioUnitEffect::EventListenerCallback	(	void *	inCallbackRefCon,
		void *	inObject,
		const AudioUnitEvent *	inEvent,
		UInt64	inEventHostTime,
		AudioUnitParameterValue	inParameterValue
	)

staticprivate

Definition at line 2512 of file AudioUnitEffect.cpp.

 {
    ((AudioUnitEffect *) inCallbackRefCon)->EventListener(inEvent,
                                                          inParameterValue);
 }

Referenced by SetHost().

Here is the caller graph for this function:

◆ Export()

TranslatableString AudioUnitEffect::Export ( const wxString & path )

private

Definition at line 2294 of file AudioUnitEffect.cpp.

 {
    // Create the file
    wxFFile f(path, wxT("wb"));
    if (!f.IsOpened())
    {
       return XO("Couldn't open \"%s\"").Format(path);
    }
  
    // First set the name of the preset
    wxCFStringRef cfname(wxFileName(path).GetName());
  
    // Define the preset property
    AUPreset preset;
    preset.presetNumber = -1; // indicates user preset
    preset.presetName = cfname;
  
    // And set it in the audio unit
    OSStatus result;
    result = AudioUnitSetProperty(mUnit,
                                  kAudioUnitProperty_PresentPreset,
                                  kAudioUnitScope_Global,
                                  0,
                                  &preset,
                                  sizeof(preset));
    if (result != noErr)
    {
       return XO("Failed to set preset name");
    }
  
    // Now retrieve the preset content
    CFPropertyListRef content;
    UInt32 size = sizeof(content);
    result = AudioUnitGetProperty(mUnit,
                                  kAudioUnitProperty_ClassInfo,
                                  kAudioUnitScope_Global,
                                  0,
                                  &content,
                                  &size);
    CFunique_ptr<char /* CFPropertyList */> ucontent { (char *) content };
    if (result != noErr)
    {
       return XO("Failed to retrieve preset content");
    }
  
    // And convert it to serialized XML data
    CFunique_ptr<const __CFData> data
    {
       CFPropertyListCreateData(kCFAllocatorDefault,
                                content,
                                kCFPropertyListXMLFormat_v1_0,
                                0,
                                NULL)
    };
    if (!data)
    {
       return XO("Failed to convert property list to XML data");
    }
  
    // Nothing to do if we don't have any data
    SInt32 length = CFDataGetLength(data.get());
    if (!length)
    {
       return XO("XML data is empty after conversion");
    }
  
    // Write XML data
    if (f.Write(CFDataGetBytePtr(data.get()), length) != length || f.Error())
    {
       return XO("Failed to write XML preset to \"%s\"").Format(path);
    }
  
    f.Close();
  
    return {};
 }

References ComponentInterface::GetName(), mUnit, and XO.

Referenced by ExportPresets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExportPresets()

void AudioUnitEffect::ExportPresets ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1848 of file AudioUnitEffect.cpp.

 {
    // Generate the user domain path
    wxFileName fn;
    fn.SetPath(PRESET_USER_PATH);
    fn.AppendDir(mVendor);
    fn.AppendDir(mName);
    fn.Normalize();
    FilePath path = fn.GetFullPath();
  
    if (!fn.Mkdir(fn.GetFullPath(), 0755, wxPATH_MKDIR_FULL))
    {
       wxLogError(wxT("Couldn't create the \"%s\" directory"), fn.GetPath());
       return;
    }
  
    // Ask the user for the name to use
    //
    // Passing a valid parent will cause some effects dialogs to malfunction
    // upon returning from the SelectFile().
    path = SelectFile(FileNames::Operation::_None,
       XO("Export Audio Unit Preset As %s:").Format(fn.GetFullPath()),
       fn.GetFullPath(),
       wxEmptyString,
       wxT("aupreset"),
       {
         { XO("Standard Audio Unit preset file"), { wxT("aupreset") }, true },
       },
       wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxRESIZE_BORDER,
       NULL);
  
    // User canceled...
    if (path.empty())
    {
       return;
    }
  
    auto msg = Export(path);
    if (!msg.empty())
    {
       AudacityMessageBox(
          XO("Could not export \"%s\" preset\n\n%s").Format(path, msg),
          XO("Export Audio Unit Presets"),
          wxOK | wxCENTRE,
          mParent);
    }
 }

References AudacityMessageBox(), Export(), fn, mName, mParent, mVendor, PRESET_USER_PATH, SelectFile(), and XO.

Here is the call graph for this function:

◆ GetAudioInCount()

unsigned AudioUnitEffect::GetAudioInCount ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1164 of file AudioUnitEffect.cpp.

 {
    return mAudioIns;
 }

References mAudioIns.

◆ GetAudioOutCount()

unsigned AudioUnitEffect::GetAudioOutCount ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1169 of file AudioUnitEffect.cpp.

 {
    return mAudioOuts;
 }

References mAudioOuts.

◆ GetAutomationParameters()

bool AudioUnitEffect::GetAutomationParameters ( CommandParameters & parms )

overridevirtual

Implements EffectClientInterface.

Definition at line 1499 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
    UInt32 dataSize;
    Boolean isWritable;
  
    result = AudioUnitGetPropertyInfo(mUnit,
                                      kAudioUnitProperty_ParameterList,
                                      kAudioUnitScope_Global,
                                      0,
                                      &dataSize,
                                      &isWritable);
    if (result != noErr)
    {
       return false;
    }
  
    UInt32 cnt = dataSize / sizeof(AudioUnitParameterID);
    ArrayOf<AudioUnitParameterID> array {cnt};
  
    result = AudioUnitGetProperty(mUnit,
                                  kAudioUnitProperty_ParameterList,
                                  kAudioUnitScope_Global,
                                  0,
                                  array.get(),
                                  &dataSize);  
    if (result != noErr)
    {
       return false;
    }
  
    for (int i = 0; i < cnt; i++)
    {
       ParameterInfo pi;
  
       if (!pi.Get(mUnit, array[i]))
       {
          // Probably failed because of invalid parameter which can happen
          // if a plug-in is in a certain mode that doesn't contain the
          // parameter.  In any case, just ignore it.
          continue;
       }
  
       AudioUnitParameterValue value;
       result = AudioUnitGetParameter(mUnit,
                                      array[i],
                                      kAudioUnitScope_Global,
                                      0,
                                      &value);
       if (result != noErr)
       {
          // Probably failed because of invalid parameter which can happen
          // if a plug-in is in a certain mode that doesn't contain the
          // parameter.  In any case, just ignore it.
          continue;
       }
  
       parms.Write(pi.name, value);
    }
  
    return true;
 }

References ParameterInfo::Get(), mUnit, and ParameterInfo::name.

Here is the call graph for this function:

◆ GetBlockSize()

size_t AudioUnitEffect::GetBlockSize ( ) const

overridevirtual

Implements EffectClientInterface.

Definition at line 1194 of file AudioUnitEffect.cpp.

 {
    return mBlockSize;
 }

References mBlockSize.

◆ GetChannelCount()

unsigned AudioUnitEffect::GetChannelCount ( )

private

Definition at line 2284 of file AudioUnitEffect.cpp.

 {
    return mNumChannels;
 }

References mNumChannels.

◆ GetChannelCounts()

void AudioUnitEffect::GetChannelCounts ( )

private

Definition at line 2522 of file AudioUnitEffect.cpp.

 {
    Boolean isWritable = 0;
    UInt32  dataSize = 0;
    OSStatus result;
  
    // Does AU have channel info
    result = AudioUnitGetPropertyInfo(mUnit,
                                      kAudioUnitProperty_SupportedNumChannels,
                                      kAudioUnitScope_Global,
                                      0,
                                      &dataSize,
                                      &isWritable);
    if (result)
    {
       // None supplied.  Apparently all FX type units can do any number of INs
       // and OUTs as long as they are the same number.  In this case, we'll
       // just say stereo.
       //
       // We should probably check to make sure we're dealing with an FX type.
       mAudioIns = 2;
       mAudioOuts = 2;
       return;
    }
  
    ArrayOf<char> buffer{ dataSize };
    auto info = (AUChannelInfo *) buffer.get();
  
    // Retrieve the channel info
    result = AudioUnitGetProperty(mUnit,
                                  kAudioUnitProperty_SupportedNumChannels,
                                  kAudioUnitScope_Global,
                                  0,
                                  info,
                                  &dataSize);
    if (result)
    {
       // Oh well, not much we can do out this case
       mAudioIns = 2;
       mAudioOuts = 2;
  
       return;
    }
  
    // This is where it gets weird...not sure what is the best
    // way to do this really.  If we knew how many ins/outs we
    // really needed, we could make a better choice.
  
    bool haven2m = false;   // nothing -> mono
    bool haven2s = false;   // nothing -> stereo
    bool havem2n = false;   // mono -> nothing
    bool haves2n = false;   // stereo -> nothing
    bool havem2m = false;   // mono -> mono
    bool haves2s = false;   // stereo -> stereo
    bool havem2s = false;   // mono -> stereo
    bool haves2m = false;   // stereo -> mono
  
    mAudioIns = 2;
    mAudioOuts = 2;
  
    // Look only for exact channel constraints
    for (int i = 0; i < dataSize / sizeof(AUChannelInfo); i++)
    {
       AUChannelInfo *ci = &info[i];
  
       int ic = ci->inChannels;
       int oc = ci->outChannels;
  
       if (ic < 0 && oc >= 0)
       {
          ic = 2;
       }
       else if (ic >= 0 && oc < 0)
       {
          oc = 2;
       }
       else if (ic < 0 && oc < 0)
       {
          ic = 2;
          oc = 2;
       }
  
       if (ic == 2 && oc == 2)
       {
          haves2s = true;
       }
       else if (ic == 1 && oc == 1)
       {
          havem2m = true;
       }   
       else if (ic == 1 && oc == 2)
       {
          havem2s = true;
       }
       else if (ic == 2 && oc == 1)
       {
          haves2m = true;
       }
       else if (ic == 0 && oc == 2)
       {
          haven2s = true;
       }
       else if (ic == 0 && oc == 1)
       {
          haven2m = true;
       }
       else if (ic == 1 && oc == 0)
       {
          havem2n = true;
       }
       else if (ic == 2 && oc == 0)
       {
          haves2n = true;
       }
    }
  
    if (haves2s)
    {
       mAudioIns = 2;
       mAudioOuts = 2;
    }
    else if (havem2m)
    {
       mAudioIns = 1;
       mAudioOuts = 1;
    }
    else if (havem2s)
    {
       mAudioIns = 1;
       mAudioOuts = 2;
    }
    else if (haves2m)
    {
       mAudioIns = 2;
       mAudioOuts = 1;
    }
    else if (haven2m)
    {
       mAudioIns = 0;
       mAudioOuts = 1;
    }
    else if (haven2s)
    {
       mAudioIns = 0;
       mAudioOuts = 2;
    }
    else if (haves2n)
    {
       mAudioIns = 2;
       mAudioOuts = 0;
    }
    else if (havem2n)
    {
       mAudioIns = 1;
       mAudioOuts = 0;
    }
  
    return;
 }

References mAudioIns, mAudioOuts, and mUnit.

Referenced by SetHost().

Here is the caller graph for this function:

◆ GetDescription()

TranslatableString AudioUnitEffect::GetDescription ( )

overridevirtual

Implements ComponentInterface.

Definition at line 902 of file AudioUnitEffect.cpp.

 {
    /* i18n-hint: Can mean "not available," "not applicable," "no answer" */
    return XO("n/a");
 }

References XO.

◆ GetFactoryPresets()

RegistryPaths AudioUnitEffect::GetFactoryPresets ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1679 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
    RegistryPaths presets;
  
    // Retrieve the list of factory presets
    CFArrayRef array{};
    UInt32 dataSize = sizeof(CFArrayRef);
    result = AudioUnitGetProperty(mUnit,
                                  kAudioUnitProperty_FactoryPresets,
                                  kAudioUnitScope_Global,
                                  0,
                                  &array,
                                  &dataSize);
    CFunique_ptr<const __CFArray> uarray { array };
    if (result == noErr)
    {
       for (CFIndex i = 0, cnt = CFArrayGetCount(array); i < cnt; i++)
       {
          AUPreset *preset = (AUPreset *) CFArrayGetValueAtIndex(array, i);
          presets.push_back(wxCFStringRef::AsString(preset->presetName));
       }
    }
                         
    return presets;
 }

References mUnit.

◆ GetFamily()

EffectFamilySymbol AudioUnitEffect::GetFamily ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 932 of file AudioUnitEffect.cpp.

 {
    return AUDIOUNITEFFECTS_FAMILY;
 }

References AUDIOUNITEFFECTS_FAMILY.

◆ GetLatency()

sampleCount AudioUnitEffect::GetLatency ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1199 of file AudioUnitEffect.cpp.

 {
    // Retrieve the latency (can be updated via an event)
    if (mUseLatency && !mLatencyDone)
    {
       mLatencyDone = true;
  
       Float64 latency = 0.0;
       UInt32 dataSize = sizeof(latency);
       AudioUnitGetProperty(mUnit,
                            kAudioUnitProperty_Latency,
                            kAudioUnitScope_Global,
                            0,
                            &latency,
                            &dataSize);  
  
       return sampleCount(latency * mSampleRate);
    }
  
    return 0;
 }

References mLatencyDone, mSampleRate, mUnit, and mUseLatency.

◆ GetMidiInCount()

int AudioUnitEffect::GetMidiInCount ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1174 of file AudioUnitEffect.cpp.

 {
    return 0;
 }

◆ GetMidiOutCount()

int AudioUnitEffect::GetMidiOutCount ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1179 of file AudioUnitEffect.cpp.

 {
    return 0;
 }

◆ GetPath()

PluginPath AudioUnitEffect::GetPath ( )

overridevirtual

Implements ComponentInterface.

Definition at line 875 of file AudioUnitEffect.cpp.

 {
    return mPath;
 }

References mPath.

◆ GetSymbol()

ComponentInterfaceSymbol AudioUnitEffect::GetSymbol ( )

overridevirtual

Implements ComponentInterface.

Definition at line 880 of file AudioUnitEffect.cpp.

 {
    return mName;
 }

References mName.

Referenced by SetRateAndChannels().

Here is the caller graph for this function:

◆ GetTailSize()

size_t AudioUnitEffect::GetTailSize ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1221 of file AudioUnitEffect.cpp.

 {
    // Retrieve the tail time
    Float64 tailTime = 0.0;
    UInt32 dataSize = sizeof(tailTime);
    AudioUnitGetProperty(mUnit,
                         kAudioUnitProperty_TailTime,
                         kAudioUnitScope_Global,
                         0,
                         &tailTime,
                         &dataSize);  
  
    return tailTime * mSampleRate;
 }

References mSampleRate, and mUnit.

◆ GetType()

EffectType AudioUnitEffect::GetType ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 912 of file AudioUnitEffect.cpp.

 {
    if (mAudioIns == 0 && mAudioOuts == 0)
    {
       return EffectTypeNone;
    }
  
    if (mAudioIns == 0)
    {
       return EffectTypeGenerate;
    }
  
    if (mAudioOuts == 0)
    {
       return EffectTypeAnalyze;
    }
  
    return EffectTypeProcess;
 }

References EffectTypeAnalyze, EffectTypeGenerate, EffectTypeNone, EffectTypeProcess, mAudioIns, and mAudioOuts.

Referenced by HideUI(), ShowInterface(), SupportsRealtime(), and ValidateUI().

Here is the caller graph for this function:

◆ GetVendor()

VendorSymbol AudioUnitEffect::GetVendor ( )

overridevirtual

Implements ComponentInterface.

Definition at line 885 of file AudioUnitEffect.cpp.

 {
    return { mVendor };
 }

References mVendor.

◆ GetVersion()

wxString AudioUnitEffect::GetVersion ( )

overridevirtual

Implements ComponentInterface.

Definition at line 890 of file AudioUnitEffect.cpp.

 {
    UInt32 version;
  
    OSStatus result = AudioComponentGetVersion(mComponent, &version);
  
    return wxString::Format(wxT("%d.%d.%d"),
                            (version >> 16) & 0xffff,
                            (version >> 8) & 0xff,
                            version & 0xff);
 }

References mComponent.

◆ HasOptions()

bool AudioUnitEffect::HasOptions ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1938 of file AudioUnitEffect.cpp.

 {
    return true;
 }

◆ HideUI()

bool AudioUnitEffect::HideUI ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1810 of file AudioUnitEffect.cpp.

 {
 #if 0
    if (GetType() == EffectTypeAnalyze || mNumOutputControls > 0)
    {
       return false;
    }
 #endif
    return true;
 }

References EffectTypeAnalyze, and GetType().

Here is the call graph for this function:

◆ Import()

TranslatableString AudioUnitEffect::Import ( const wxString & path )

private

Definition at line 2371 of file AudioUnitEffect.cpp.

 {
    // Open the preset
    wxFFile f(path, wxT("r"));
    if (!f.IsOpened())
    {
       return XO("Couldn't open \"%s\"").Format(path);
    }
  
    // Load it into the buffer
    size_t len = f.Length();
    wxMemoryBuffer buf(len);
    if (f.Read(buf.GetData(), len) != len || f.Error())
    {
       return XO("Unable to read the preset from \"%s\"").Format(path);
    }
  
    // Create a CFData object that references the decoded preset
    CFunique_ptr<const __CFData> data
    {
       CFDataCreateWithBytesNoCopy(kCFAllocatorDefault,
                                   (const UInt8 *) buf.GetData(),
                                   len,
                                   kCFAllocatorNull)
    };
    if (!data)
    {
       return XO("Failed to convert preset to internal format");
    }
  
    // Convert it back to a property list.
    CFPropertyListRef content
    {
       CFPropertyListCreateWithData(kCFAllocatorDefault,
                                    data.get(),
                                    kCFPropertyListImmutable,
                                    NULL,
                                    NULL)
    };
    if (!content)
    {
       return XO("Failed to create property list for preset");
    }
    CFunique_ptr<char /* CFPropertyList */> ucontent { (char *) content };
  
    // Finally, update the properties and parameters
    OSStatus result;
    result = AudioUnitSetProperty(mUnit,
                                  kAudioUnitProperty_ClassInfo,
                                  kAudioUnitScope_Global,
                                  0,
                                  &content,
                                  sizeof(content));
    if (result != noErr)
    {
       return XO("Failed to set class info for \"%s\" preset");
    }
  
    // Notify interested parties of change and propagate to slaves
    Notify(mUnit, kAUParameterListener_AnyParameter);
  
    return {};
 }

References mUnit, Notify(), and XO.

Referenced by ImportPresets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImportPresets()

void AudioUnitEffect::ImportPresets ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1896 of file AudioUnitEffect.cpp.

 {
    // Generate the user domain path
    wxFileName fn;
    fn.SetPath(PRESET_USER_PATH);
    fn.AppendDir(mVendor);
    fn.AppendDir(mName);
    fn.Normalize();
    FilePath path = fn.GetFullPath();
  
    // Ask the user for the name to use
    //
    // Passing a valid parent will cause some effects dialogs to malfunction
    // upon returning from the SelectFile().
    path = SelectFile(FileNames::Operation::_None,
       XO("Import Audio Unit Preset As %s:").Format(fn.GetFullPath()),
       fn.GetFullPath(),
       wxEmptyString,
       wxT("aupreset"),
       {
         { XO("Standard Audio Unit preset file"), { wxT("aupreset") }, true },
       },
       wxFD_OPEN | wxRESIZE_BORDER,
       NULL);
  
    // User canceled...
    if (path.empty())
    {
       return;
    }
  
    auto msg = Import(path);
    if (!msg.empty())
    {
       AudacityMessageBox(
          XO("Could not import \"%s\" preset\n\n%s").Format(path, msg),
          XO("Import Audio Unit Presets"),
          wxOK | wxCENTRE,
          mParent);
    }
 }

References AudacityMessageBox(), fn, Import(), mName, mParent, mVendor, PRESET_USER_PATH, SelectFile(), and XO.

Here is the call graph for this function:

◆ IsDefault()

bool AudioUnitEffect::IsDefault ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 942 of file AudioUnitEffect.cpp.

 {
    return false;
 }

◆ IsGraphicalUI()

bool AudioUnitEffect::IsGraphicalUI ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1781 of file AudioUnitEffect.cpp.

 {
    return mUIType != wxT("Plain");
 }

References mUIType.

◆ IsInteractive()

bool AudioUnitEffect::IsInteractive ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 937 of file AudioUnitEffect.cpp.

 {
    return mInteractive;
 }

References mInteractive.

◆ IsLegacy()

bool AudioUnitEffect::IsLegacy ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 947 of file AudioUnitEffect.cpp.

 {
    return false;
 }

◆ IsReady()

bool AudioUnitEffect::IsReady ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1236 of file AudioUnitEffect.cpp.

 {
    return mReady;
 }

References mReady.

◆ LoadFactoryDefaults()

bool AudioUnitEffect::LoadFactoryDefaults ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1674 of file AudioUnitEffect.cpp.

 {
    return LoadPreset(mHost->GetFactoryDefaultsGroup());
 }

References EffectHostInterface::GetFactoryDefaultsGroup(), LoadPreset(), and mHost.

Here is the call graph for this function:

◆ LoadFactoryPreset()

bool AudioUnitEffect::LoadFactoryPreset ( int id )

overridevirtual

Implements EffectClientInterface.

Definition at line 1633 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
  
    // Retrieve the list of factory presets
    CFArrayRef array{};
    UInt32 dataSize = sizeof(CFArrayRef);
    result = AudioUnitGetProperty(mUnit,
                                  kAudioUnitProperty_FactoryPresets,
                                  kAudioUnitScope_Global,
                                  0,
                                  &array,
                                  &dataSize);
    CFunique_ptr<const __CFArray> uarray { array };
    if (result != noErr)
    {
       return false;
    }
  
    if (id < 0 || id >= CFArrayGetCount(array))
    {
       return false;
    }
  
    const AUPreset *preset = (const AUPreset *) CFArrayGetValueAtIndex(array, id);
  
    result = AudioUnitSetProperty(mUnit,
                                  kAudioUnitProperty_PresentPreset,
                                  kAudioUnitScope_Global,
                                  0,
                                  preset,
                                  sizeof(AUPreset));
    if (result == noErr)
    {
       // Notify interested parties of change and propagate to slaves
       Notify(mUnit, kAUParameterListener_AnyParameter);
    }
  
    return result == noErr;
 }

References mUnit, and Notify().

Here is the call graph for this function:

◆ LoadPreset()

bool AudioUnitEffect::LoadPreset ( const RegistryPath & group )

private

Definition at line 1958 of file AudioUnitEffect.cpp.

 {
    wxString parms;
  
    // Attempt to load old preset parameters and resave using new method
    if (mHost->GetPrivateConfig(group, wxT("Parameters"), parms, wxEmptyString))
    {
       CommandParameters eap;
       if (eap.SetParameters(parms))
       {
          if (SetAutomationParameters(eap))
          {
             if (SavePreset(group))
             {
                mHost->RemovePrivateConfig(group, wxT("Parameters"));
             }
          }
       }
       return true;
    }
  
    // Retrieve the preset
    if (!mHost->GetPrivateConfig(group, PRESET_KEY, parms, wxEmptyString))
    {
       // Commented "CurrentSettings" gets tried a lot and useless messages appear
       // in the log
       //wxLogError(wxT("Preset key \"%s\" not found in group \"%s\""), PRESET_KEY, group);
       return false;
    }
    
    // Decode it
    wxMemoryBuffer buf = wxBase64Decode(parms);
    size_t bufLen = buf.GetDataLen();
    if (!bufLen)
    {
       wxLogError(wxT("Failed to decode \"%s\" preset"), group);
       return false;
    }
    const uint8_t *bufPtr = (uint8_t *) buf.GetData();
  
    // Create a CFData object that references the decoded preset
    CFunique_ptr<const __CFData> data
    {
       CFDataCreateWithBytesNoCopy(kCFAllocatorDefault,
                                   bufPtr,
                                   bufLen,
                                   kCFAllocatorNull)
    };
    if (!data)
    {
       wxLogError(wxT("Failed to convert \"%s\" preset to internal format"), group);
       return false;
    }
  
    // Convert it back to a property list.
    CFPropertyListRef content
    {
       CFPropertyListCreateWithData(kCFAllocatorDefault,
                                    data.get(),
                                    kCFPropertyListImmutable,
                                    NULL,
                                    NULL)
    };
    if (!content)
    {
       wxLogError(wxT("Failed to create property list for \"%s\" preset"), group);
       return false;
    }
    CFunique_ptr<char /* CFPropertyList */> ucontent { (char *) content };
  
    // See AUView::viewWillDraw
    if (mpControl)
    {
       mpControl->ForceRedraw();
    }
  
    // Finally, update the properties and parameters
    OSStatus result;
    result = AudioUnitSetProperty(mUnit,
                                  kAudioUnitProperty_ClassInfo,
                                  kAudioUnitScope_Global,
                                  0,
                                  &content,
                                  sizeof(content));
    if (result != noErr)
    {
       wxLogError(wxT("Failed to set class info for \"%s\" preset"), group);
       return false;
    }
  
    // Notify interested parties of change and propagate to slaves
    Notify(mUnit, kAUParameterListener_AnyParameter);
  
    return true;
 }

References AUControl::ForceRedraw(), ConfigClientInterface::GetPrivateConfig(), mHost, mpControl, mUnit, Notify(), PRESET_KEY, ConfigClientInterface::RemovePrivateConfig(), SavePreset(), SetAutomationParameters(), and CommandParameters::SetParameters().

Referenced by LoadFactoryDefaults(), LoadUserPreset(), and SetHost().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadUserPreset()

bool AudioUnitEffect::LoadUserPreset ( const RegistryPath & name )

overridevirtual

Implements EffectClientInterface.

Definition at line 1623 of file AudioUnitEffect.cpp.

 {
    return LoadPreset(name);
 }

References LoadPreset(), and name.

Here is the call graph for this function:

◆ Notify()

void AudioUnitEffect::Notify	(	AudioUnit	unit,
		AudioUnitParameterID	parm
	)

private

Definition at line 2435 of file AudioUnitEffect.cpp.

 {
    // Notify any interested parties
    AudioUnitParameter aup = {};
    aup.mAudioUnit = unit;
    aup.mParameterID = parm;
    aup.mScope = kAudioUnitScope_Global;
    aup.mElement = 0;
    AUParameterListenerNotify(NULL, NULL, &aup);
 }

Referenced by CopyParameters(), Import(), LoadFactoryPreset(), LoadPreset(), and SetAutomationParameters().

Here is the caller graph for this function:

◆ PopulateUI()

bool AudioUnitEffect::PopulateUI ( ShuttleGui & S )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1715 of file AudioUnitEffect.cpp.

 {
    // OSStatus result;
  
    auto parent = S.GetParent();
    mDialog = static_cast<wxDialog *>(wxGetTopLevelParent(parent));
    mParent = parent;
    mpControl = NULL;
  
    wxPanel *container;
    {
       auto mainSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
  
       wxASSERT(mParent); // To justify safenew
       container = safenew wxPanelWrapper(mParent, wxID_ANY);
       mainSizer->Add(container, 1, wxEXPAND);
  
       mParent->SetSizer(mainSizer.release());
    }
  
 #if defined(HAVE_AUDIOUNIT_BASIC_SUPPORT)
    if (mUIType == wxT("Basic"))
    {
       if (!CreatePlain(mParent))
       {
          return false;
       }
    }
    else
 #endif
    {
       auto pControl = Destroy_ptr<AUControl>(safenew AUControl);
       if (!pControl)
       {
          return false;
       }
  
       if (!pControl->Create(container, mComponent, mUnit, mUIType == wxT("Full")))
       {
          return false;
       }
  
       {
          auto innerSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
  
          innerSizer->Add((mpControl = pControl.release()), 1, wxEXPAND);
          container->SetSizer(innerSizer.release());
       }
  
       mParent->SetMinSize(wxDefaultSize);
  
 #ifdef __WXMAC__
 #ifdef __WX_EVTLOOP_BUSY_WAITING__
       wxEventLoop::SetBusyWaiting(true);
 #endif
 #endif
    }
  
    if (mpControl)
    {
       mParent->PushEventHandler(this);
    }
  
    return true;
 }

References ShuttleGuiBase::GetParent(), mComponent, mDialog, mParent, mpControl, mUIType, mUnit, and safenew.

Here is the call graph for this function:

◆ ProcessBlock()

size_t AudioUnitEffect::ProcessBlock	(	float **	inBlock,
		float **	outBlock,
		size_t	blockLen
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1304 of file AudioUnitEffect.cpp.

 {
    for (size_t i = 0; i < mAudioIns; i++)
    {
       mInputList[0].mBuffers[i].mNumberChannels = 1;
       mInputList[0].mBuffers[i].mData = inBlock[i];
       mInputList[0].mBuffers[i].mDataByteSize = sizeof(float) * blockLen;
    }
  
    for (size_t i = 0; i < mAudioOuts; i++)
    {
       mOutputList[0].mBuffers[i].mNumberChannels = 1;
       mOutputList[0].mBuffers[i].mData = outBlock[i];
       mOutputList[0].mBuffers[i].mDataByteSize = sizeof(float) * blockLen;
    }
  
    AudioUnitRenderActionFlags flags = 0;
    OSStatus result;
  
    result = AudioUnitRender(mUnit,
                             &flags,
                             &mTimeStamp,
                             0,
                             blockLen,
                             mOutputList.get());
    if (result != noErr)
    {
       wxPrintf("Render failed: %d %4.4s\n", (int)result, (char *)&result);
       return 0;
    }
  
    mTimeStamp.mSampleTime += blockLen;
  
    return blockLen;
 }

References mAudioIns, mAudioOuts, mInputList, mOutputList, mTimeStamp, and mUnit.

Referenced by RealtimeProcessEnd().

Here is the caller graph for this function:

◆ ProcessFinalize()

bool AudioUnitEffect::ProcessFinalize ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1294 of file AudioUnitEffect.cpp.

 {
    mReady = false;
  
    mOutputList.reset();
    mInputList.reset();
  
    return true;
 }

References mInputList, mOutputList, and mReady.

Referenced by RealtimeFinalize().

Here is the caller graph for this function:

◆ ProcessInitialize()

bool AudioUnitEffect::ProcessInitialize	(	sampleCount	totalLen,
		ChannelNames	chanMap = `NULL`
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1241 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
  
    mInputList.reinit(mAudioIns);
    mInputList[0].mNumberBuffers = mAudioIns;
    
    mOutputList.reinit(mAudioOuts);
    mOutputList[0].mNumberBuffers = mAudioOuts;
  
    memset(&mTimeStamp, 0, sizeof(AudioTimeStamp));
    mTimeStamp.mSampleTime = 0; // This is a double-precision number that should
                                // accumulate the number of frames processed so far
    mTimeStamp.mFlags = kAudioTimeStampSampleTimeValid;
  
    if (!SetRateAndChannels())
    {
       return false;
    }
  
    AURenderCallbackStruct callbackStruct;
    callbackStruct.inputProc = RenderCallback;
    callbackStruct.inputProcRefCon = this;
    result = AudioUnitSetProperty(mUnit,
                                  kAudioUnitProperty_SetRenderCallback,
                                  kAudioUnitScope_Input,
                                  0,
                                  &callbackStruct,
                                  sizeof(AURenderCallbackStruct));
    if (result != noErr)
    {
       wxPrintf("Setting input render callback failed.\n");
       return false;
    }
  
    result = AudioUnitReset(mUnit, kAudioUnitScope_Global, 0);
    if (result != noErr)
    {
       return false;
    }
  
    if (!BypassEffect(false))
    {
       return false;
    }
  
    mLatencyDone = false;
  
    mReady = true;
  
    return true;
 }

References BypassEffect(), mAudioIns, mAudioOuts, mInputList, mLatencyDone, mOutputList, mReady, mTimeStamp, mUnit, ArrayOf< X >::reinit(), RenderCallback(), and SetRateAndChannels().

Referenced by RealtimeInitialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RealtimeAddProcessor()

bool AudioUnitEffect::RealtimeAddProcessor	(	unsigned	numChannels,
		float	sampleRate
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1347 of file AudioUnitEffect.cpp.

 {
    auto slave = std::make_unique<AudioUnitEffect>(mPath, mName, mComponent, this);
    if (!slave->SetHost(NULL))
    {
       return false;
    }
  
    slave->SetBlockSize(mBlockSize);
    slave->SetChannelCount(numChannels);
    slave->SetSampleRate(sampleRate);
  
    if (!CopyParameters(mUnit, slave->mUnit))
    {
       return false;
    }
  
    auto pSlave = slave.get();
    mSlaves.push_back(std::move(slave));
  
    return pSlave->ProcessInitialize(0);
 }

References CopyParameters(), mBlockSize, mComponent, mName, mPath, mSlaves, and mUnit.

Here is the call graph for this function:

◆ RealtimeFinalize()

bool AudioUnitEffect::RealtimeFinalize ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1370 of file AudioUnitEffect.cpp.

 {
    for (size_t i = 0, cnt = mSlaves.size(); i < cnt; i++)
    {
       mSlaves[i]->ProcessFinalize();
    }
    mSlaves.clear();
  
    mMasterIn.reset();
    mMasterOut.reset();
  
    return ProcessFinalize();
 }

References mMasterIn, mMasterOut, mSlaves, and ProcessFinalize().

Here is the call graph for this function:

◆ RealtimeInitialize()

bool AudioUnitEffect::RealtimeInitialize ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1340 of file AudioUnitEffect.cpp.

 {
    mMasterIn.reinit(mAudioIns, mBlockSize, true);
    mMasterOut.reinit(mAudioOuts, mBlockSize);
    return ProcessInitialize(0);
 }

References mAudioIns, mAudioOuts, mBlockSize, mMasterIn, mMasterOut, ProcessInitialize(), and ArraysOf< X >::reinit().

Here is the call graph for this function:

◆ RealtimeProcess()

size_t AudioUnitEffect::RealtimeProcess	(	int	group,
		float **	inbuf,
		float **	outbuf,
		size_t	numSamples
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1432 of file AudioUnitEffect.cpp.

 {
    wxASSERT(numSamples <= mBlockSize);
  
    for (size_t c = 0; c < mAudioIns; c++)
    {
       for (decltype(numSamples) s = 0; s < numSamples; s++)
       {
          mMasterIn[c][s] += inbuf[c][s];
       }
    }
    mNumSamples = wxMax(numSamples, mNumSamples);
  
    return mSlaves[group]->ProcessBlock(inbuf, outbuf, numSamples);
 }

References mAudioIns, mBlockSize, mMasterIn, mNumSamples, and mSlaves.

◆ RealtimeProcessEnd()

bool AudioUnitEffect::RealtimeProcessEnd ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1451 of file AudioUnitEffect.cpp.

 {
    ProcessBlock(reinterpret_cast<float**>(mMasterIn.get()),
                 reinterpret_cast<float**>(mMasterOut.get()),
                 mNumSamples);
  
    return true;
 }

References mMasterIn, mMasterOut, mNumSamples, and ProcessBlock().

Here is the call graph for this function:

◆ RealtimeProcessStart()

bool AudioUnitEffect::RealtimeProcessStart ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1420 of file AudioUnitEffect.cpp.

 {
    for (size_t i = 0; i < mAudioIns; i++)
    {
       memset(mMasterIn[i].get(), 0, mBlockSize * sizeof(float));
    }
  
    mNumSamples = 0;
  
    return true;
 }

References mAudioIns, mBlockSize, mMasterIn, and mNumSamples.

◆ RealtimeResume()

bool AudioUnitEffect::RealtimeResume ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1402 of file AudioUnitEffect.cpp.

 {
    if (!BypassEffect(false))
    {
       return false;
    }
  
    for (size_t i = 0, cnt = mSlaves.size(); i < cnt; i++)
    {
       if (!mSlaves[i]->BypassEffect(false))
       {
          return false;
       }
    }
  
    return true;
 }

References BypassEffect(), and mSlaves.

Here is the call graph for this function:

◆ RealtimeSuspend()

bool AudioUnitEffect::RealtimeSuspend ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1384 of file AudioUnitEffect.cpp.

 {
    if (!BypassEffect(true))
    {
       return false;
    }
  
    for (size_t i = 0, cnt = mSlaves.size(); i < cnt; i++)
    {
       if (!mSlaves[i]->BypassEffect(true))
       {
          return false;
       }
    }
  
    return true;
 }

References BypassEffect(), and mSlaves.

Here is the call graph for this function:

◆ Render()

OSStatus AudioUnitEffect::Render	(	AudioUnitRenderActionFlags *	inActionFlags,
		const AudioTimeStamp *	inTimeStamp,
		UInt32	inBusNumber,
		UInt32	inNumFrames,
		AudioBufferList *	ioData
	)

private

Definition at line 2446 of file AudioUnitEffect.cpp.

 {
    for (int i = 0; i < ioData->mNumberBuffers; i++)
       ioData->mBuffers[i].mData = mInputList[0].mBuffers[i].mData;
  
    return 0;
 }

References mInputList.

◆ RenderCallback()

OSStatus AudioUnitEffect::RenderCallback	(	void *	inRefCon,
		AudioUnitRenderActionFlags *	inActionFlags,
		const AudioTimeStamp *	inTimeStamp,
		UInt32	inBusNumber,
		UInt32	inNumFrames,
		AudioBufferList *	ioData
	)

staticprivate

Definition at line 2459 of file AudioUnitEffect.cpp.

 {
    return ((AudioUnitEffect *) inRefCon)->Render(inActionFlags,
                                                  inTimeStamp,
                                                  inBusNumber,
                                                  inNumFrames,
                                                  ioData);
 }

Referenced by ProcessInitialize().

Here is the caller graph for this function:

◆ SavePreset()

bool AudioUnitEffect::SavePreset ( const RegistryPath & group )

private

Definition at line 2054 of file AudioUnitEffect.cpp.

 {
    // First set the name of the preset
    wxCFStringRef cfname(wxFileNameFromPath(group));
  
    // Define the preset property
    AUPreset preset;
    preset.presetNumber = -1; // indicates user preset
    preset.presetName = cfname;
  
    // And set it in the audio unit
    AudioUnitSetProperty(mUnit,
                         kAudioUnitProperty_PresentPreset,
                         kAudioUnitScope_Global,
                         0,
                         &preset,
                         sizeof(preset));
  
    // Now retrieve the preset content
    CFPropertyListRef content;
    UInt32 size = sizeof(content);
    AudioUnitGetProperty(mUnit,
                         kAudioUnitProperty_ClassInfo,
                         kAudioUnitScope_Global,
                         0,
                         &content,
                         &size);
    CFunique_ptr<char /* CFPropertyList */> ucontent { (char *) content };
  
    // And convert it to serialized binary data
    CFunique_ptr<const __CFData> data
    {
       CFPropertyListCreateData(kCFAllocatorDefault,
                                content,
                                PRESET_FORMAT,
                                0,
                                NULL)
    };
    if (!data)
    {
       return false;
    }
  
    // Nothing to do if we don't have any data
    SInt32 length = CFDataGetLength(data.get());
    if (length)
    {
       // Base64 encode the returned binary property list
       wxString parms = wxBase64Encode(CFDataGetBytePtr(data.get()), length);
  
       // And write it to the config
       if (!mHost->SetPrivateConfig(group, PRESET_KEY, parms))
       {
          return false;
       }
    }
  
    return true;
 }

References mHost, mUnit, PRESET_FORMAT, PRESET_KEY, and ConfigClientInterface::SetPrivateConfig().

Referenced by LoadPreset(), SaveUserPreset(), and SetHost().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveUserPreset()

bool AudioUnitEffect::SaveUserPreset ( const RegistryPath & name )

overridevirtual

Implements EffectClientInterface.

Definition at line 1628 of file AudioUnitEffect.cpp.

 {
    return SavePreset(name);
 }

References name, and SavePreset().

Here is the call graph for this function:

◆ SetAutomationParameters()

bool AudioUnitEffect::SetAutomationParameters ( CommandParameters & parms )

overridevirtual

Implements EffectClientInterface.

Definition at line 1562 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
    UInt32 dataSize;
    Boolean isWritable;
  
    result = AudioUnitGetPropertyInfo(mUnit,
                                      kAudioUnitProperty_ParameterList,
                                      kAudioUnitScope_Global,
                                      0,
                                      &dataSize,
                                      &isWritable);
    if (result != noErr)
    {
       return false;
    }
  
    UInt32 cnt = dataSize / sizeof(AudioUnitParameterID);
    ArrayOf<AudioUnitParameterID> array {cnt};
  
    result = AudioUnitGetProperty(mUnit,
                                  kAudioUnitProperty_ParameterList,
                                  kAudioUnitScope_Global,
                                  0,
                                  array.get(),
                                  &dataSize);  
    if (result != noErr)
    {
       return false;
    }
  
    for (int i = 0; i < cnt; i++)
    {
       ParameterInfo pi;
  
       if (!pi.Get(mUnit, array[i]))
       {
          // Probably failed because of invalid parameter which can happen
          // if a plug-in is in a certain mode that doesn't contain the
          // parameter.  In any case, just ignore it.
          continue;
       }
  
       double d = 0.0;
       if (parms.Read(pi.name, &d))
       {
          AudioUnitParameterValue value = d;
          AudioUnitSetParameter(mUnit,
                                array[i],
                                kAudioUnitScope_Global,
                                0,
                                value,
                                0);
  
          Notify(mUnit, array[i]);
       }
    }
  
    return true;
 }

References ParameterInfo::Get(), mUnit, ParameterInfo::name, and Notify().

Referenced by LoadPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetBlockSize()

size_t AudioUnitEffect::SetBlockSize ( size_t maxBlockSize )

overridevirtual

Implements EffectClientInterface.

Definition at line 1189 of file AudioUnitEffect.cpp.

 {
    return mBlockSize;
 }

References mBlockSize.

◆ SetChannelCount()

void AudioUnitEffect::SetChannelCount ( unsigned numChannels )

private

Definition at line 2289 of file AudioUnitEffect.cpp.

 {
    mNumChannels = numChannels;
 }

References mNumChannels.

◆ SetHost()

bool AudioUnitEffect::SetHost ( EffectHostInterface * host )

overridevirtual

Implements EffectClientInterface.

Definition at line 1009 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
    
    mHost = host;
  
    mSampleRate = 44100;
    result = AudioComponentInstanceNew(mComponent, &mUnit);
    if (!mUnit)
    {
       return false;
    }
  
    GetChannelCounts();
  
    SetRateAndChannels();
  
    // Retrieve the desired number of frames per slice
    UInt32 dataSize = sizeof(mBlockSize);
    mBlockSize = 512;
    AudioUnitGetProperty(mUnit,
                         kAudioUnitProperty_MaximumFramesPerSlice,
                         kAudioUnitScope_Global,
                         0,
                         &mBlockSize,
                         &dataSize);
  
    // mHost will be null during registration
    if (mHost)
    {
       mHost->GetSharedConfig(wxT("Options"), wxT("UseLatency"), mUseLatency, true);
       mHost->GetSharedConfig(wxT("Options"), wxT("UIType"), mUIType, wxT("Full"));
  
       bool haveDefaults;
       mHost->GetPrivateConfig(mHost->GetFactoryDefaultsGroup(), wxT("Initialized"), haveDefaults, false);
       if (!haveDefaults)
       {
          SavePreset(mHost->GetFactoryDefaultsGroup());
          mHost->SetPrivateConfig(mHost->GetFactoryDefaultsGroup(), wxT("Initialized"), true);
       }
  
       LoadPreset(mHost->GetCurrentSettingsGroup());
    } 
  
    if (!mMaster)
    {
      result = AUEventListenerCreate(AudioUnitEffect::EventListenerCallback,
                                     this,
                                     (CFRunLoopRef)GetCFRunLoopFromEventLoop(GetCurrentEventLoop()),
                                     kCFRunLoopDefaultMode,
                                     0.0,
                                     0.0,
                                     &mEventListenerRef);
       if (result != noErr)
       {
          return false;
       }
  
       AudioUnitEvent event;
  
       event.mEventType = kAudioUnitEvent_ParameterValueChange;
       event.mArgument.mParameter.mAudioUnit = mUnit;
       event.mArgument.mParameter.mScope = kAudioUnitScope_Global;
       event.mArgument.mParameter.mElement = 0;
  
       UInt32 dataSize;
       Boolean isWritable;
  
       // Retrieve the list of parameters
       result = AudioUnitGetPropertyInfo(mUnit,
                                         kAudioUnitProperty_ParameterList,
                                         kAudioUnitScope_Global,
                                         0,
                                         &dataSize,
                                         &isWritable);
       if (result != noErr)
       {
          return false;
       }
  
       // And get them
       UInt32 cnt = dataSize / sizeof(AudioUnitParameterID);
       if (cnt != 0)
       {
          ArrayOf<AudioUnitParameterID> array {cnt};
  
          result = AudioUnitGetProperty(mUnit,
                                        kAudioUnitProperty_ParameterList,
                                        kAudioUnitScope_Global,
                                        0,
                                        array.get(),
                                        &dataSize);  
          if (result != noErr)
          {
             return false;
          }
  
          // Register them as something we're interested in
          for (int i = 0; i < cnt; i++)
          {
             event.mArgument.mParameter.mParameterID = array[i];
             result = AUEventListenerAddEventType(mEventListenerRef,
                                                  this,
                                                  &event);
             if (result != noErr)
             {
                return false;
             }
          }
       }
  
       event.mEventType = kAudioUnitEvent_PropertyChange;
       event.mArgument.mProperty.mAudioUnit = mUnit;
       event.mArgument.mProperty.mPropertyID = kAudioUnitProperty_Latency;
       event.mArgument.mProperty.mScope = kAudioUnitScope_Global;
       event.mArgument.mProperty.mElement = 0;
  
       result = AUEventListenerAddEventType(mEventListenerRef,
                                            this,
                                            &event);
       if (result != noErr)
       {
          return false;
       }
  
       AudioUnitCocoaViewInfo cocoaViewInfo;
       dataSize = sizeof(AudioUnitCocoaViewInfo);
    
       // Check for a Cocoa UI
       result = AudioUnitGetProperty(mUnit,
                                     kAudioUnitProperty_CocoaUI,
                                     kAudioUnitScope_Global,
                                     0,
                                     &cocoaViewInfo,
                                     &dataSize);
  
       bool hasCocoa = result == noErr;
  
       // Check for a Carbon UI
       AudioComponentDescription compDesc;
       dataSize = sizeof(compDesc);
       result = AudioUnitGetProperty(mUnit,
                                     kAudioUnitProperty_GetUIComponentList,
                                     kAudioUnitScope_Global,
                                     0,
                                     &compDesc,
                                     &dataSize);
       bool hasCarbon = result == noErr;
  
       mInteractive = (cnt > 0) || hasCocoa || hasCarbon;
    }
  
    return true;
 }

References EventListenerCallback(), GetChannelCounts(), EffectHostInterface::GetCurrentSettingsGroup(), EffectHostInterface::GetFactoryDefaultsGroup(), ConfigClientInterface::GetPrivateConfig(), ConfigClientInterface::GetSharedConfig(), LoadPreset(), mBlockSize, mComponent, mEventListenerRef, mHost, mInteractive, mMaster, mSampleRate, mUIType, mUnit, mUseLatency, SavePreset(), ConfigClientInterface::SetPrivateConfig(), and SetRateAndChannels().

Referenced by AudioUnitEffectsModule::DiscoverPluginsAtPath().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHostUI()

void AudioUnitEffect::SetHostUI ( EffectUIHostInterface * host )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1710 of file AudioUnitEffect.cpp.

 {
    mUIHost = host;
 }

References mUIHost.

◆ SetRateAndChannels()

bool AudioUnitEffect::SetRateAndChannels ( )

private

Definition at line 2114 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
  
    if (mUnitInitialized)
    {
       AudioUnitUninitialize(mUnit);
  
       mUnitInitialized = false;
    }
  
    AudioStreamBasicDescription streamFormat {
       // Float64 mSampleRate;
       mSampleRate,
  
       // UInt32  mFormatID;
       kAudioFormatLinearPCM,
  
       // UInt32  mFormatFlags;
       (kAudioFormatFlagsNativeFloatPacked |
           kAudioFormatFlagIsNonInterleaved),
  
       // UInt32  mBytesPerPacket;
       sizeof(float),
  
       // UInt32  mFramesPerPacket;
       1,
  
       // UInt32  mBytesPerFrame;
       sizeof(float),
  
       // UInt32  mChannelsPerFrame;
       mAudioIns,
  
       // UInt32  mBitsPerChannel;
       sizeof(float) * 8,
  
       // UInt32  mReserved;
       0
    };
  
    result = AudioUnitSetProperty(mUnit,
                                  kAudioUnitProperty_SampleRate,
                                  kAudioUnitScope_Global,
                                  0,
                                  &mSampleRate,
                                  sizeof(Float64));
    if (result != noErr)
    {
       wxPrintf("%ls Didn't accept sample rate on global\n",
                // Exposing internal name only in debug printf
                GetSymbol().Internal().wx_str());
       return false;
    }
  
    if (mAudioIns > 0)
    {
       result = AudioUnitSetProperty(mUnit,
                                     kAudioUnitProperty_SampleRate,
                                     kAudioUnitScope_Input,
                                     0,
                                     &mSampleRate,
                                     sizeof(Float64));
       if (result != noErr)
       {
          wxPrintf("%ls Didn't accept sample rate on input\n",
                // Exposing internal name only in debug printf
                GetSymbol().Internal().wx_str());
          return false;
       }
  
       result = AudioUnitSetProperty(mUnit,
                                     kAudioUnitProperty_StreamFormat,
                                     kAudioUnitScope_Input,
                                     0,
                                     &streamFormat,
                                     sizeof(AudioStreamBasicDescription));
       if (result != noErr)
       {
          wxPrintf("%ls didn't accept stream format on input\n",
                // Exposing internal name only in debug printf
                GetSymbol().Internal().wx_str());
          return false;
       }
    }
  
    if (mAudioOuts > 0)
    {
       result = AudioUnitSetProperty(mUnit,
                                     kAudioUnitProperty_SampleRate,
                                     kAudioUnitScope_Output,
                                     0,
                                     &mSampleRate,
                                     sizeof(Float64));
       if (result != noErr)
       {
          wxPrintf("%ls Didn't accept sample rate on output\n",
                // Exposing internal name only in debug printf
                GetSymbol().Internal().wx_str());
          return false;
       }
    
       streamFormat.mChannelsPerFrame = mAudioOuts;
       result = AudioUnitSetProperty(mUnit,
                                     kAudioUnitProperty_StreamFormat,
                                     kAudioUnitScope_Output,
                                     0,
                                     &streamFormat,
                                     sizeof(AudioStreamBasicDescription));
    
       if (result != noErr)
       {
          wxPrintf("%ls didn't accept stream format on output\n",
                // Exposing internal name only in debug printf
                GetSymbol().Internal().wx_str());
          return false;
       }
    }
  
    result = AudioUnitInitialize(mUnit);
    if (result != noErr)
    {
       wxPrintf("Couldn't initialize audio unit\n");
       return false;
    }
  
    mUnitInitialized = true;
  
    return true;
 }

References GetSymbol(), Internal, mAudioIns, mAudioOuts, mSampleRate, mUnit, and mUnitInitialized.

Referenced by ProcessInitialize(), and SetHost().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetSampleRate()

void AudioUnitEffect::SetSampleRate ( double rate )

overridevirtual

Implements EffectClientInterface.

Definition at line 1184 of file AudioUnitEffect.cpp.

 {
    mSampleRate = rate;
 }

References mSampleRate.

◆ ShowInterface()

bool AudioUnitEffect::ShowInterface	(	wxWindow &	parent,
		const EffectDialogFactory &	factory,
		bool	forceModal = `false`
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1460 of file AudioUnitEffect.cpp.

 {
    if (mDialog)
    {
       if (mDialog->Close(true))
       {
          mDialog = nullptr;
       }
       return false;
    }
  
    // mDialog is null
    auto cleanup = valueRestorer(mDialog);
  
    if (factory)
    {
       mDialog = factory(parent, mHost, this);
    }
  
    if (!mDialog)
    {
       return false;
    }
  
    if ((SupportsRealtime() || GetType() == EffectTypeAnalyze) && !forceModal)
    {
       mDialog->Show();
       cleanup.release();
  
       return false;
    }
  
    bool res = mDialog->ShowModal() != 0;
  
    return res;
 }

References EffectTypeAnalyze, factory, GetType(), mDialog, mHost, SupportsRealtime(), and valueRestorer().

Here is the call graph for this function:

◆ ShowOptions()

void AudioUnitEffect::ShowOptions ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1943 of file AudioUnitEffect.cpp.

 {
    AudioUnitEffectOptionsDialog dlg(mParent, mHost);
    if (dlg.ShowModal())
    {
       // Reinitialize configuration settings
       mHost->GetSharedConfig(wxT("Options"), wxT("UseLatency"), mUseLatency, true);
       mHost->GetSharedConfig(wxT("Options"), wxT("UIType"), mUIType, wxT("Full"));
    }
 }

References ConfigClientInterface::GetSharedConfig(), mHost, mParent, mUIType, and mUseLatency.

Here is the call graph for this function:

◆ SupportsAutomation()

bool AudioUnitEffect::SupportsAutomation ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 957 of file AudioUnitEffect.cpp.

 {
    OSStatus result;
    UInt32 dataSize;
    Boolean isWritable;
  
    result = AudioUnitGetPropertyInfo(mUnit,
                                      kAudioUnitProperty_ParameterList,
                                      kAudioUnitScope_Global,
                                      0,
                                      &dataSize,
                                      &isWritable);
    if (result != noErr)
    {
       return false;
    }
  
    UInt32 cnt = dataSize / sizeof(AudioUnitParameterID);
    ArrayOf<AudioUnitParameterID> array{cnt};
  
    result = AudioUnitGetProperty(mUnit,
                                  kAudioUnitProperty_ParameterList,
                                  kAudioUnitScope_Global,
                                  0,
                                  array.get(),
                                  &dataSize);  
    if (result != noErr)
    {
       return false;
    }
  
    for (int i = 0; i < cnt; i++)
    {
       ParameterInfo pi;
  
       if (pi.Get(mUnit, array[i]))
       {
          if (pi.info.flags & kAudioUnitParameterFlag_IsWritable)
          {
             // All we need is one
             return true;
          }
       }
    }
  
    return false;
 }

References ParameterInfo::Get(), ParameterInfo::info, and mUnit.

Here is the call graph for this function:

◆ SupportsRealtime()

bool AudioUnitEffect::SupportsRealtime ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 952 of file AudioUnitEffect.cpp.

 {
    return GetType() == EffectTypeProcess;
 }

References EffectTypeProcess, and GetType().

Referenced by ShowInterface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ValidateUI()

bool AudioUnitEffect::ValidateUI ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1786 of file AudioUnitEffect.cpp.

 {
 #if 0
    if (!mParent->Validate())
    {
       return false;
    }
  
    if (GetType() == EffectTypeGenerate)
    {
       mHost->SetDuration(mDuration->GetValue());
    }
 #endif
    return true;
 }

References EffectTypeGenerate, GetType(), mHost, mParent, and EffectHostInterface::SetDuration().

Here is the call graph for this function:

Friends And Related Function Documentation

◆ AudioUnitEffectExportDialog

friend class AudioUnitEffectExportDialog

friend

Definition at line 222 of file AudioUnitEffect.h.

◆ AudioUnitEffectImportDialog

friend class AudioUnitEffectImportDialog

friend

Definition at line 223 of file AudioUnitEffect.h.

Member Data Documentation

◆ mAudioIns

unsigned AudioUnitEffect::mAudioIns

private

Definition at line 190 of file AudioUnitEffect.h.

Referenced by GetAudioInCount(), GetChannelCounts(), GetType(), ProcessBlock(), ProcessInitialize(), RealtimeInitialize(), RealtimeProcess(), RealtimeProcessStart(), and SetRateAndChannels().

◆ mAudioOuts

unsigned AudioUnitEffect::mAudioOuts

private

Definition at line 191 of file AudioUnitEffect.h.

Referenced by GetAudioOutCount(), GetChannelCounts(), GetType(), ProcessBlock(), ProcessInitialize(), RealtimeInitialize(), and SetRateAndChannels().

◆ mBlockSize

UInt32 AudioUnitEffect::mBlockSize

private

Definition at line 194 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), GetBlockSize(), RealtimeAddProcessor(), RealtimeInitialize(), RealtimeProcess(), RealtimeProcessStart(), SetBlockSize(), and SetHost().

◆ mBufferSize

int AudioUnitEffect::mBufferSize

private

Definition at line 197 of file AudioUnitEffect.h.

◆ mComponent

AudioComponent AudioUnitEffect::mComponent

private

Definition at line 182 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), GetVersion(), PopulateUI(), RealtimeAddProcessor(), and SetHost().

◆ mDialog

wxDialog* AudioUnitEffect::mDialog

private

Definition at line 208 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), CloseUI(), PopulateUI(), and ShowInterface().

◆ mEventListenerRef

AUEventListenerRef AudioUnitEffect::mEventListenerRef

private

Definition at line 218 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), SetHost(), and ~AudioUnitEffect().

◆ mHost

EffectHostInterface* AudioUnitEffect::mHost

private

Definition at line 189 of file AudioUnitEffect.h.

Referenced by AudioUnitEffectImportDialog::Import(), LoadFactoryDefaults(), LoadPreset(), SavePreset(), SetHost(), ShowInterface(), ShowOptions(), and ValidateUI().

◆ mInputList

ArrayOf<AudioBufferList> AudioUnitEffect::mInputList

private

Definition at line 203 of file AudioUnitEffect.h.

Referenced by ProcessBlock(), ProcessFinalize(), ProcessInitialize(), and Render().

◆ mInteractive

bool AudioUnitEffect::mInteractive

private

Definition at line 192 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), IsInteractive(), and SetHost().

◆ mIsGraphical

bool AudioUnitEffect::mIsGraphical

private

Definition at line 210 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect().

◆ mLatencyDone

bool AudioUnitEffect::mLatencyDone

private

Definition at line 193 of file AudioUnitEffect.h.

Referenced by GetLatency(), and ProcessInitialize().

◆ mMaster

AudioUnitEffect* AudioUnitEffect::mMaster

private

Definition at line 212 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), EventListener(), and SetHost().

◆ mMasterIn

ArraysOf<float> AudioUnitEffect::mMasterIn

private

Definition at line 215 of file AudioUnitEffect.h.

Referenced by RealtimeFinalize(), RealtimeInitialize(), RealtimeProcess(), RealtimeProcessEnd(), and RealtimeProcessStart().

◆ mMasterOut

ArraysOf<float> AudioUnitEffect::mMasterOut

private

Definition at line 215 of file AudioUnitEffect.h.

Referenced by RealtimeFinalize(), RealtimeInitialize(), and RealtimeProcessEnd().

◆ mName

wxString AudioUnitEffect::mName

private

Definition at line 180 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), ExportPresets(), GetSymbol(), ImportPresets(), AudioUnitEffectImportDialog::PopulateOrExchange(), and RealtimeAddProcessor().

◆ mNumChannels

unsigned AudioUnitEffect::mNumChannels

private

Definition at line 214 of file AudioUnitEffect.h.

Referenced by GetChannelCount(), and SetChannelCount().

◆ mNumSamples

size_t AudioUnitEffect::mNumSamples

private

Definition at line 216 of file AudioUnitEffect.h.

Referenced by RealtimeProcess(), RealtimeProcessEnd(), and RealtimeProcessStart().

◆ mOutputList

ArrayOf<AudioBufferList> AudioUnitEffect::mOutputList

private

Definition at line 204 of file AudioUnitEffect.h.

Referenced by ProcessBlock(), ProcessFinalize(), and ProcessInitialize().

◆ mParent

wxWindow* AudioUnitEffect::mParent

private

Definition at line 207 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), CloseUI(), ExportPresets(), ImportPresets(), PopulateUI(), ShowOptions(), and ValidateUI().

◆ mPath

PluginPath AudioUnitEffect::mPath

private

Definition at line 179 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), GetPath(), and RealtimeAddProcessor().

◆ mpControl

AUControl* AudioUnitEffect::mpControl {}

private

Definition at line 220 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), CloseUI(), LoadPreset(), and PopulateUI().

◆ mReady

bool AudioUnitEffect::mReady

private

Definition at line 201 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), IsReady(), ProcessFinalize(), and ProcessInitialize().

◆ mSampleRate

double AudioUnitEffect::mSampleRate

private

Definition at line 195 of file AudioUnitEffect.h.

Referenced by GetLatency(), GetTailSize(), SetHost(), SetRateAndChannels(), and SetSampleRate().

◆ mSlaves

AudioUnitEffectArray AudioUnitEffect::mSlaves

private

Definition at line 213 of file AudioUnitEffect.h.

Referenced by EventListener(), RealtimeAddProcessor(), RealtimeFinalize(), RealtimeProcess(), RealtimeResume(), and RealtimeSuspend().

◆ mSupportsMono

bool AudioUnitEffect::mSupportsMono

private

Definition at line 186 of file AudioUnitEffect.h.

◆ mSupportsStereo

bool AudioUnitEffect::mSupportsStereo

private

Definition at line 187 of file AudioUnitEffect.h.

◆ mTimeStamp

AudioTimeStamp AudioUnitEffect::mTimeStamp

private

Definition at line 200 of file AudioUnitEffect.h.

Referenced by ProcessBlock(), and ProcessInitialize().

◆ mUIHost

EffectUIHostInterface* AudioUnitEffect::mUIHost

private

Definition at line 206 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), CloseUI(), and SetHostUI().

◆ mUIType

wxString AudioUnitEffect::mUIType

private

Definition at line 209 of file AudioUnitEffect.h.

Referenced by IsGraphicalUI(), PopulateUI(), SetHost(), and ShowOptions().

◆ mUnit

AudioUnit AudioUnitEffect::mUnit

private

◆ mUnitInitialized

bool AudioUnitEffect::mUnitInitialized

private

Definition at line 184 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), SetRateAndChannels(), and ~AudioUnitEffect().

◆ mUseLatency

bool AudioUnitEffect::mUseLatency

private

Definition at line 198 of file AudioUnitEffect.h.

Referenced by GetLatency(), SetHost(), and ShowOptions().

◆ mVendor

wxString AudioUnitEffect::mVendor

private

Definition at line 181 of file AudioUnitEffect.h.

Referenced by AudioUnitEffect(), ExportPresets(), GetVendor(), ImportPresets(), and AudioUnitEffectImportDialog::PopulateOrExchange().

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AudioUnitEffect()

◆ ~AudioUnitEffect()

Member Function Documentation

◆ BypassEffect()

◆ CanExportPresets()

◆ CloseUI()

◆ CopyParameters()

◆ EventListener()

◆ EventListenerCallback()

◆ Export()

◆ ExportPresets()

◆ GetAudioInCount()

◆ GetAudioOutCount()

◆ GetAutomationParameters()

◆ GetBlockSize()

◆ GetChannelCount()

◆ GetChannelCounts()

◆ GetDescription()

◆ GetFactoryPresets()

◆ GetFamily()

◆ GetLatency()

◆ GetMidiInCount()

◆ GetMidiOutCount()

◆ GetPath()

◆ GetSymbol()

◆ GetTailSize()

◆ GetType()

◆ GetVendor()

◆ GetVersion()

◆ HasOptions()

◆ HideUI()

◆ Import()

◆ ImportPresets()

◆ IsDefault()

◆ IsGraphicalUI()

◆ IsInteractive()

◆ IsLegacy()

◆ IsReady()

◆ LoadFactoryDefaults()

◆ LoadFactoryPreset()

◆ LoadPreset()

◆ LoadUserPreset()

◆ Notify()

◆ PopulateUI()

◆ ProcessBlock()

◆ ProcessFinalize()

◆ ProcessInitialize()

◆ RealtimeAddProcessor()

◆ RealtimeFinalize()

◆ RealtimeInitialize()

◆ RealtimeProcess()

◆ RealtimeProcessEnd()

◆ RealtimeProcessStart()

◆ RealtimeResume()

◆ RealtimeSuspend()

◆ Render()

◆ RenderCallback()

◆ SavePreset()

◆ SaveUserPreset()

◆ SetAutomationParameters()

◆ SetBlockSize()

◆ SetChannelCount()

◆ SetHost()

◆ SetHostUI()

◆ SetRateAndChannels()

◆ SetSampleRate()

◆ ShowInterface()

◆ ShowOptions()

◆ SupportsAutomation()

◆ SupportsRealtime()

◆ ValidateUI()

Friends And Related Function Documentation