1422 lines
43 KiB
C++
1422 lines
43 KiB
C++
/*
|
|
File: CAAudioUnit.cpp
|
|
Abstract: CAAudioUnit.h
|
|
Version: 1.1
|
|
|
|
Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
|
Inc. ("Apple") in consideration of your agreement to the following
|
|
terms, and your use, installation, modification or redistribution of
|
|
this Apple software constitutes acceptance of these terms. If you do
|
|
not agree with these terms, please do not use, install, modify or
|
|
redistribute this Apple software.
|
|
|
|
In consideration of your agreement to abide by the following terms, and
|
|
subject to these terms, Apple grants you a personal, non-exclusive
|
|
license, under Apple's copyrights in this original Apple software (the
|
|
"Apple Software"), to use, reproduce, modify and redistribute the Apple
|
|
Software, with or without modifications, in source and/or binary forms;
|
|
provided that if you redistribute the Apple Software in its entirety and
|
|
without modifications, you must retain this notice and the following
|
|
text and disclaimers in all such redistributions of the Apple Software.
|
|
Neither the name, trademarks, service marks or logos of Apple Inc. may
|
|
be used to endorse or promote products derived from the Apple Software
|
|
without specific prior written permission from Apple. Except as
|
|
expressly stated in this notice, no other rights or licenses, express or
|
|
implied, are granted by Apple herein, including but not limited to any
|
|
patent rights that may be infringed by your derivative works or by other
|
|
works in which the Apple Software may be incorporated.
|
|
|
|
The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
|
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
|
THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
|
FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
|
OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
|
|
|
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
|
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
|
MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
|
AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
|
STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
Copyright (C) 2014 Apple Inc. All Rights Reserved.
|
|
|
|
*/
|
|
#include "CAAudioUnit.h"
|
|
|
|
#if !TARGET_OS_IPHONE
|
|
#if !defined(__COREAUDIO_USE_FLAT_INCLUDES__)
|
|
#include <CoreServices/../Frameworks/CarbonCore.framework/Headers/Components.h>
|
|
#include <dlfcn.h>
|
|
#else
|
|
#include <Components.h>
|
|
#endif
|
|
#endif
|
|
|
|
#include "CAXException.h"
|
|
#include "CAReferenceCounted.h"
|
|
#include "AUOutputBL.h" //this is for the Preroll only
|
|
|
|
struct StackAUChannelInfo {
|
|
StackAUChannelInfo (UInt32 inSize) : mChanInfo ((AUChannelInfo*)malloc (inSize)) {}
|
|
~StackAUChannelInfo() { free (mChanInfo); }
|
|
|
|
AUChannelInfo* mChanInfo;
|
|
};
|
|
|
|
// is this symbol is not defined then we use the default setting which is that fast dispatch
|
|
// is supported on a desktop environment
|
|
#ifndef CA_AU_USE_FAST_DISPATCH
|
|
#define CA_AU_USE_FAST_DISPATCH !TARGET_OS_IPHONE
|
|
#endif
|
|
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
static void *LoadGetComponentInstanceStorage (void *inst);
|
|
#endif
|
|
|
|
|
|
class CAAudioUnit::AUState : public CAReferenceCounted {
|
|
public:
|
|
AUState (AudioComponent inComp)
|
|
: mUnit(0), mNode (0)
|
|
{
|
|
OSStatus result = ::AudioComponentInstanceNew (inComp, &mUnit);
|
|
if (result)
|
|
throw result;
|
|
Init();
|
|
}
|
|
|
|
AUState (const AUNode &inNode, const AudioUnit& inUnit)
|
|
: mUnit (inUnit), mNode (inNode)
|
|
{
|
|
Init();
|
|
}
|
|
|
|
~AUState();
|
|
|
|
AudioUnit mUnit;
|
|
AUNode mNode;
|
|
|
|
OSStatus GetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
|
|
Float32 &outValue) const
|
|
{
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
if (mGetParamProc != NULL) {
|
|
return (mGetParamProc) (mConnInstanceStorage, inID, scope, element, &outValue);
|
|
}
|
|
#endif
|
|
return AudioUnitGetParameter(mUnit, inID, scope, element, &outValue);
|
|
}
|
|
|
|
OSStatus SetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
|
|
Float32 value, UInt32 bufferOffsetFrames)
|
|
{
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
if (mSetParamProc != NULL) {
|
|
return (mSetParamProc) (mConnInstanceStorage, inID, scope, element, value, bufferOffsetFrames);
|
|
}
|
|
#endif
|
|
return AudioUnitSetParameter(mUnit, inID, scope, element, value, bufferOffsetFrames);
|
|
}
|
|
|
|
OSStatus Render (AudioUnitRenderActionFlags * ioActionFlags,
|
|
const AudioTimeStamp * inTimeStamp,
|
|
UInt32 inOutputBusNumber,
|
|
UInt32 inNumberFrames,
|
|
AudioBufferList * ioData)
|
|
{
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
if (mRenderProc != NULL) {
|
|
return (mRenderProc) (mConnInstanceStorage, ioActionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData);
|
|
}
|
|
#endif
|
|
return AudioUnitRender(mUnit, ioActionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData);
|
|
}
|
|
|
|
OSStatus MIDIEvent (UInt32 inStatus,
|
|
UInt32 inData1,
|
|
UInt32 inData2,
|
|
UInt32 inOffsetSampleFrame)
|
|
{
|
|
#if !TARGET_OS_WIN32
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
if (mMIDIEventProc != NULL) {
|
|
return (mMIDIEventProc) (mConnInstanceStorage, inStatus, inData1, inData2, inOffsetSampleFrame);
|
|
}
|
|
#endif
|
|
return MusicDeviceMIDIEvent (mUnit, inStatus, inData1, inData2, inOffsetSampleFrame);
|
|
#else // ON WINDOWS _ NO MIDI EVENT dispatch
|
|
return paramErr;
|
|
#endif
|
|
}
|
|
|
|
OSStatus StartNote (MusicDeviceInstrumentID inInstrument,
|
|
MusicDeviceGroupID inGroupID,
|
|
NoteInstanceID * outNoteInstanceID,
|
|
UInt32 inOffsetSampleFrame,
|
|
const MusicDeviceNoteParams * inParams)
|
|
{
|
|
#if !TARGET_OS_WIN32
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
if (mStartNoteProc != NULL) {
|
|
return (mStartNoteProc) (mConnInstanceStorage, inInstrument, inGroupID, outNoteInstanceID, inOffsetSampleFrame, inParams);
|
|
}
|
|
#endif
|
|
return MusicDeviceStartNote (mUnit, inInstrument, inGroupID, outNoteInstanceID, inOffsetSampleFrame, inParams);
|
|
#else
|
|
return paramErr;
|
|
#endif
|
|
}
|
|
OSStatus StopNote (MusicDeviceGroupID inGroupID,
|
|
NoteInstanceID inNoteInstanceID,
|
|
UInt32 inOffsetSampleFrame)
|
|
{
|
|
#if !TARGET_OS_WIN32
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
if (mStopNoteProc != NULL) {
|
|
return (mStopNoteProc) (mConnInstanceStorage, inGroupID, inNoteInstanceID, inOffsetSampleFrame);
|
|
}
|
|
#endif
|
|
return MusicDeviceStopNote (mUnit, inGroupID, inNoteInstanceID, inOffsetSampleFrame);
|
|
#else
|
|
return paramErr;
|
|
#endif
|
|
}
|
|
|
|
private:
|
|
// get the fast dispatch pointers
|
|
void Init()
|
|
{
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
UInt32 size = sizeof(AudioUnitRenderProc);
|
|
if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
|
|
kAudioUnitScope_Global, kAudioUnitRenderSelect,
|
|
&mRenderProc, &size) != noErr)
|
|
mRenderProc = NULL;
|
|
|
|
size = sizeof(AudioUnitGetParameterProc);
|
|
if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
|
|
kAudioUnitScope_Global, kAudioUnitGetParameterSelect,
|
|
&mGetParamProc, &size) != noErr)
|
|
mGetParamProc = NULL;
|
|
|
|
size = sizeof(AudioUnitSetParameterProc);
|
|
if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
|
|
kAudioUnitScope_Global, kAudioUnitSetParameterSelect,
|
|
&mSetParamProc, &size) != noErr)
|
|
mSetParamProc = NULL;
|
|
|
|
size = sizeof(MusicDeviceMIDIEventProc);
|
|
if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
|
|
kAudioUnitScope_Global, kMusicDeviceMIDIEventSelect,
|
|
&mMIDIEventProc, &size) != noErr)
|
|
mMIDIEventProc = NULL;
|
|
|
|
size = sizeof(MusicDeviceStartNoteProc);
|
|
if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
|
|
kAudioUnitScope_Global, kMusicDeviceStartNoteSelect,
|
|
&mStartNoteProc, &size) != noErr)
|
|
mStartNoteProc = NULL;
|
|
|
|
size = sizeof(MusicDeviceStopNoteProc);
|
|
if (AudioUnitGetProperty(mUnit, kAudioUnitProperty_FastDispatch,
|
|
kAudioUnitScope_Global, kMusicDeviceStopNoteSelect,
|
|
&mStopNoteProc, &size) != noErr)
|
|
mStopNoteProc = NULL;
|
|
|
|
if (mRenderProc || mGetParamProc || mSetParamProc || mMIDIEventProc || mStartNoteProc || mStopNoteProc) {
|
|
mConnInstanceStorage = LoadGetComponentInstanceStorage ( mUnit );
|
|
} else
|
|
mConnInstanceStorage = NULL;
|
|
#else
|
|
mConnInstanceStorage = NULL;
|
|
#endif
|
|
}
|
|
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
AudioUnitRenderProc mRenderProc;
|
|
AudioUnitGetParameterProc mGetParamProc;
|
|
AudioUnitSetParameterProc mSetParamProc;
|
|
MusicDeviceMIDIEventProc mMIDIEventProc;
|
|
MusicDeviceStartNoteProc mStartNoteProc;
|
|
MusicDeviceStopNoteProc mStopNoteProc;
|
|
#endif
|
|
|
|
void * mConnInstanceStorage;
|
|
|
|
private:
|
|
// get the compiler to tell us when we do a bad thing!!!
|
|
AUState () {}
|
|
AUState (const AUState&);
|
|
AUState& operator= (const AUState&);
|
|
};
|
|
|
|
|
|
CAAudioUnit::AUState::~AUState ()
|
|
{
|
|
if (mUnit && (mNode == 0)) {
|
|
::AudioComponentInstanceDispose (mUnit);
|
|
}
|
|
mNode = 0;
|
|
mUnit = 0;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::Open (const CAComponent& inComp, CAAudioUnit &outUnit)
|
|
{
|
|
try {
|
|
outUnit = inComp;
|
|
return noErr;
|
|
} catch (OSStatus res) {
|
|
return res;
|
|
} catch (...) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
CAAudioUnit::CAAudioUnit (const AudioUnit& inUnit)
|
|
: mComp (inUnit), mDataPtr (new AUState (kCAAU_DoNotKnowIfAUNode, inUnit))
|
|
{
|
|
}
|
|
|
|
CAAudioUnit::CAAudioUnit (const CAComponent& inComp)
|
|
: mComp (inComp), mDataPtr (new AUState (mComp.Comp()))
|
|
{
|
|
}
|
|
|
|
CAAudioUnit::CAAudioUnit (const AUNode &inNode, const AudioUnit& inUnit)
|
|
: mComp (inUnit), mDataPtr(new AUState (inNode, inUnit))
|
|
{
|
|
}
|
|
|
|
CAAudioUnit::~CAAudioUnit ()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
void CAAudioUnit::Close()
|
|
{
|
|
if (mDataPtr) {
|
|
mDataPtr->release();
|
|
mDataPtr = NULL;
|
|
}
|
|
}
|
|
|
|
CAAudioUnit& CAAudioUnit::operator= (const CAAudioUnit &a)
|
|
{
|
|
if (mDataPtr != a.mDataPtr) {
|
|
if (mDataPtr)
|
|
mDataPtr->release();
|
|
|
|
if ((mDataPtr = a.mDataPtr) != NULL)
|
|
mDataPtr->retain();
|
|
|
|
mComp = a.mComp;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
bool CAAudioUnit::operator== (const CAAudioUnit& y) const
|
|
{
|
|
if (mDataPtr == y.mDataPtr) return true;
|
|
AudioUnit au1 = mDataPtr ? mDataPtr->mUnit : 0;
|
|
AudioUnit au2 = y.mDataPtr ? y.mDataPtr->mUnit : 0;
|
|
return au1 == au2;
|
|
}
|
|
|
|
bool CAAudioUnit::operator== (const AudioUnit& y) const
|
|
{
|
|
if (!mDataPtr) return false;
|
|
return mDataPtr->mUnit == y;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::RemovePropertyListener (AudioUnitPropertyID inID,
|
|
AudioUnitPropertyListenerProc inProc,
|
|
void * inProcUserData)
|
|
{
|
|
// we call this first. If it fails we call the old API as the failure can
|
|
// mean that the AU doesn't implement that selector.
|
|
OSStatus result = AudioUnitRemovePropertyListenerWithUserData(AU(), inID,
|
|
inProc, inProcUserData);
|
|
#if !__LP64__ && !TARGET_OS_IPHONE
|
|
if (result) result = AudioUnitRemovePropertyListener (AU(), inID, inProc);
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
#pragma mark __State Management
|
|
|
|
bool CAAudioUnit::IsValid () const
|
|
{
|
|
return mDataPtr ? mDataPtr->mUnit != 0 : false;
|
|
}
|
|
|
|
AudioUnit CAAudioUnit::AU() const
|
|
{
|
|
return mDataPtr ? mDataPtr->mUnit : 0;
|
|
}
|
|
|
|
AUNode CAAudioUnit::GetAUNode () const
|
|
{
|
|
return mDataPtr ? mDataPtr->mNode : 0;
|
|
}
|
|
|
|
#pragma mark __Format Handling
|
|
|
|
bool CAAudioUnit::CanDo ( int inChannelsIn,
|
|
int inChannelsOut) const
|
|
{
|
|
// this is the default assumption of an audio effect unit
|
|
Boolean* isWritable = 0;
|
|
UInt32 dataSize = 0;
|
|
// lets see if the unit has any channel restrictions
|
|
OSStatus result = AudioUnitGetPropertyInfo (AU(),
|
|
kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0,
|
|
&dataSize, isWritable); //don't care if this is writable
|
|
|
|
// if this property is NOT implemented an FX unit
|
|
// is expected to deal with same channel valance in and out
|
|
if (result)
|
|
{
|
|
if ((Comp().Desc().IsEffect() && inChannelsIn == inChannelsOut)
|
|
|| (Comp().Desc().IsOffline() && inChannelsIn == inChannelsOut))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// the au should either really tell us about this
|
|
// or we will assume the worst
|
|
return false;
|
|
}
|
|
}
|
|
|
|
StackAUChannelInfo info (dataSize);
|
|
|
|
result = GetProperty (kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0,
|
|
info.mChanInfo, &dataSize);
|
|
if (result) { return false; }
|
|
|
|
return ValidateChannelPair (inChannelsIn, inChannelsOut, info.mChanInfo, (dataSize / sizeof (AUChannelInfo)));
|
|
}
|
|
|
|
int CAAudioUnit::GetChannelInfo (AUChannelInfo** chaninfo, UInt32& cnt)
|
|
{
|
|
// this is the default assumption of an audio effect unit
|
|
Boolean* isWritable = 0;
|
|
UInt32 dataSize = 0;
|
|
// lets see if the unit has any channel restrictions
|
|
OSStatus result = AudioUnitGetPropertyInfo (AU(),
|
|
kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0,
|
|
&dataSize, isWritable); //don't care if this is writable
|
|
|
|
// if this property is NOT implemented an FX unit
|
|
// is expected to deal with same channel valance in and out
|
|
|
|
if (result)
|
|
{
|
|
if (Comp().Desc().IsEffect())
|
|
{
|
|
return 1;
|
|
}
|
|
else if (Comp().Desc().IsGenerator() || Comp().Desc().IsMusicDevice()) {
|
|
// directly query Bus Formats
|
|
// Note that that these may refer to different subBusses
|
|
// (eg. Kick, Snare,.. on a Drummachine)
|
|
// eventually the Bus-Name for each configuration should be exposed
|
|
// for the User to select..
|
|
|
|
UInt32 elCountIn, elCountOut;
|
|
|
|
if (GetElementCount (kAudioUnitScope_Input, elCountIn)) return -1;
|
|
if (GetElementCount (kAudioUnitScope_Output, elCountOut)) return -1;
|
|
|
|
cnt = std::max(elCountIn, elCountOut);
|
|
|
|
*chaninfo = (AUChannelInfo*) malloc (sizeof (AUChannelInfo) * cnt);
|
|
|
|
for (unsigned int i = 0; i < elCountIn; ++i) {
|
|
UInt32 numChans;
|
|
if (NumberChannels (kAudioUnitScope_Input, i, numChans)) return -1;
|
|
(*chaninfo)[i].inChannels = numChans;
|
|
}
|
|
for (unsigned int i = elCountIn; i < cnt; ++i) {
|
|
(*chaninfo)[i].inChannels = 0;
|
|
}
|
|
|
|
for (unsigned int i = 0; i < elCountOut; ++i) {
|
|
UInt32 numChans;
|
|
if (NumberChannels (kAudioUnitScope_Output, i, numChans)) return -1;
|
|
(*chaninfo)[i].outChannels = numChans;
|
|
}
|
|
for (unsigned int i = elCountOut; i < cnt; ++i) {
|
|
(*chaninfo)[i].outChannels = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
// the au should either really tell us about this
|
|
// or we will assume the worst
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
*chaninfo = (AUChannelInfo*) malloc (dataSize);
|
|
cnt = dataSize / sizeof (AUChannelInfo);
|
|
|
|
result = GetProperty (kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0,
|
|
*chaninfo, &dataSize);
|
|
|
|
if (result) { return -1; }
|
|
return 0;
|
|
}
|
|
|
|
bool CAAudioUnit::ValidateChannelPair (int inChannelsIn,
|
|
int inChannelsOut,
|
|
const AUChannelInfo * info,
|
|
UInt32 numChanInfo) const
|
|
{
|
|
// we've the following cases (some combinations) to test here:
|
|
/*
|
|
>0 An explicit number of channels on either side
|
|
0 that side (generally input!) has no elements
|
|
-1 wild card:
|
|
-1,-1 any num channels as long as same channels on in and out
|
|
-1,-2 any num channels channels on in and out - special meaning
|
|
-2+ indicates total num channs AU can handle
|
|
- elements configurable to any num channels,
|
|
- element count in scope must be writable
|
|
*/
|
|
|
|
//now chan layout can contain -1 for either scope (ie. doesn't care)
|
|
for (unsigned int i = 0; i < numChanInfo; ++i)
|
|
{
|
|
//less than zero on both sides - check for special attributes
|
|
if ((info[i].inChannels < 0) && (info[i].outChannels < 0))
|
|
{
|
|
// these are our wild card matches
|
|
if (info[i].inChannels == -1 && info[i].outChannels == -1) {
|
|
if (inChannelsIn && inChannelsOut) {
|
|
if (inChannelsOut == inChannelsIn)
|
|
return true;
|
|
} else
|
|
return true; // if one of these is zero, then a -1 means any
|
|
}
|
|
else if ((info[i].inChannels == -1 && info[i].outChannels == -2)
|
|
|| (info[i].inChannels == -2 && info[i].outChannels == -1))
|
|
{
|
|
return true;
|
|
}
|
|
// these are our total num channels matches
|
|
// element count MUST be writable
|
|
else {
|
|
bool outWrite = false; bool inWrite = false;
|
|
IsElementCountWritable (kAudioUnitScope_Output, outWrite);
|
|
IsElementCountWritable (kAudioUnitScope_Input, inWrite);
|
|
if (inWrite && outWrite) {
|
|
if ((inChannelsOut <= abs(info[i].outChannels))
|
|
&& (inChannelsIn <= abs(info[i].inChannels)))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// special meaning on input, specific num on output
|
|
else if (info[i].inChannels < 0) {
|
|
if (info[i].outChannels == inChannelsOut)
|
|
{
|
|
// can do any in channels
|
|
if (info[i].inChannels == -1) {
|
|
return true;
|
|
}
|
|
// total chans on input
|
|
else {
|
|
bool inWrite = false;
|
|
IsElementCountWritable (kAudioUnitScope_Input, inWrite);
|
|
if (inWrite && (inChannelsIn <= abs(info[i].inChannels))) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// special meaning on output, specific num on input
|
|
else if (info[i].outChannels < 0) {
|
|
if (info[i].inChannels == inChannelsIn)
|
|
{
|
|
// can do any out channels
|
|
if (info[i].outChannels == -1) {
|
|
return true;
|
|
}
|
|
// total chans on output
|
|
else {
|
|
bool outWrite = false;
|
|
IsElementCountWritable (kAudioUnitScope_Output, outWrite);
|
|
if (outWrite && (inChannelsOut <= abs(info[i].outChannels))) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// both chans in struct >= 0 - thus has to explicitly match
|
|
else if ((info[i].inChannels == inChannelsIn) && (info[i].outChannels == inChannelsOut)) {
|
|
return true;
|
|
}
|
|
|
|
// now check to see if a wild card on the args (inChannelsIn or inChannelsOut chans is zero) is found
|
|
// tells us to match just one side of the scopes
|
|
else if (inChannelsIn == 0) {
|
|
if (info[i].outChannels == inChannelsOut) {
|
|
return true;
|
|
}
|
|
}
|
|
else if (inChannelsOut == 0) {
|
|
if (info[i].inChannels == inChannelsIn) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static
|
|
bool CheckDynCount (SInt32 inTotalChans, const CAAUChanHelper &inHelper)
|
|
{
|
|
int totalChans = 0;
|
|
for (unsigned int i = 0; i < inHelper.mNumEls; ++i)
|
|
totalChans += inHelper.mChans[i];
|
|
return (totalChans <= inTotalChans);
|
|
}
|
|
|
|
bool CAAudioUnit::CheckOneSide (const CAAUChanHelper &inHelper,
|
|
bool checkOutput,
|
|
const AUChannelInfo *info,
|
|
UInt32 numInfo) const
|
|
{
|
|
// now we can use the wildcard option (see above impl) to see if this matches
|
|
for (unsigned int el = 0; el < inHelper.mNumEls; ++el) {
|
|
bool testAlready = false;
|
|
for (unsigned int i = 0; i < el; ++i) {
|
|
if (inHelper.mChans[i] == inHelper.mChans[el]) {
|
|
testAlready = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!testAlready) {
|
|
if (checkOutput) {
|
|
if (!ValidateChannelPair (0, inHelper.mChans[el], info, numInfo)) return false;
|
|
} else {
|
|
if (!ValidateChannelPair (inHelper.mChans[el], 0, info, numInfo)) return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CAAudioUnit::CanDo (const CAAUChanHelper &inputs,
|
|
const CAAUChanHelper &outputs) const
|
|
|
|
{
|
|
// first check our state
|
|
// huh!
|
|
if (inputs.mNumEls == 0 && outputs.mNumEls == 0) return false;
|
|
|
|
UInt32 elCount;
|
|
if (GetElementCount (kAudioUnitScope_Input, elCount)) { return false; }
|
|
if (elCount != inputs.mNumEls) return false;
|
|
|
|
if (GetElementCount (kAudioUnitScope_Output, elCount)) { return false; }
|
|
if (elCount != outputs.mNumEls) return false;
|
|
|
|
// (1) special cases (effects and sources (generators and instruments) only)
|
|
UInt32 dataSize = 0;
|
|
if (GetPropertyInfo (kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0, &dataSize, NULL) != noErr)
|
|
{
|
|
if (Comp().Desc().IsEffect() || Comp().Desc().IsOffline()) {
|
|
UInt32 numChan = outputs.mNumEls > 0 ? outputs.mChans[0] : inputs.mChans[0];
|
|
for (unsigned int in = 0; in < inputs.mNumEls; ++in)
|
|
if (numChan != inputs.mChans[in]) return false;
|
|
for (unsigned int out = 0; out < outputs.mNumEls; ++out)
|
|
if (numChan != outputs.mChans[out]) return false;
|
|
return true;
|
|
}
|
|
|
|
// in this case, all the channels have to match the current config
|
|
if (Comp().Desc().IsGenerator() || Comp().Desc().IsMusicDevice()) {
|
|
for (unsigned int in = 0; in < inputs.mNumEls; ++in) {
|
|
UInt32 chan;
|
|
if (NumberChannels (kAudioUnitScope_Input, in, chan)) return false;
|
|
if (chan != UInt32(inputs.mChans[in])) return false;
|
|
}
|
|
for (unsigned int out = 0; out < outputs.mNumEls; ++out) {
|
|
UInt32 chan;
|
|
if (NumberChannels (kAudioUnitScope_Output, out, chan)) return false;
|
|
if (chan != UInt32(outputs.mChans[out])) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// if we get here we can't determine anything about channel capabilities
|
|
return false;
|
|
}
|
|
|
|
StackAUChannelInfo info (dataSize);
|
|
|
|
if (GetProperty (kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0,
|
|
info.mChanInfo, &dataSize) != noErr)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int numInfo = dataSize / sizeof(AUChannelInfo);
|
|
|
|
// (2) Test for dynamic capability (or no elements on that scope)
|
|
SInt32 dynInChans = 0;
|
|
if (ValidateDynamicScope (kAudioUnitScope_Input, dynInChans, info.mChanInfo, numInfo)) {
|
|
if (CheckDynCount (dynInChans, inputs) == false) return false;
|
|
}
|
|
|
|
SInt32 dynOutChans = 0;
|
|
if (ValidateDynamicScope (kAudioUnitScope_Output, dynOutChans, info.mChanInfo, numInfo)) {
|
|
if (CheckDynCount (dynOutChans, outputs) == false) return false;
|
|
}
|
|
|
|
if (dynOutChans && dynInChans) { return true; }
|
|
|
|
// (3) Just need to test one side
|
|
if (dynInChans || (inputs.mNumEls == 0)) {
|
|
return CheckOneSide (outputs, true, info.mChanInfo, numInfo);
|
|
}
|
|
|
|
if (dynOutChans || (outputs.mNumEls == 0)) {
|
|
return CheckOneSide (inputs, false, info.mChanInfo, numInfo);
|
|
}
|
|
|
|
// (4) - not a dynamic AU, has ins and outs, and has channel constraints so we test every possible pairing
|
|
for (unsigned int in = 0; in < inputs.mNumEls; ++in)
|
|
{
|
|
bool testInAlready = false;
|
|
for (unsigned int i = 0; i < in; ++i) {
|
|
if (inputs.mChans[i] == inputs.mChans[in]) {
|
|
testInAlready = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!testInAlready) {
|
|
for (unsigned int out = 0; out < outputs.mNumEls; ++out) {
|
|
// try to save a little bit and not test the same pairing multiple times...
|
|
bool testOutAlready = false;
|
|
for (unsigned int i = 0; i < out; ++i) {
|
|
if (outputs.mChans[i] == outputs.mChans[out]) {
|
|
testOutAlready = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!testOutAlready) {
|
|
if (!ValidateChannelPair (inputs.mChans[in], outputs.mChans[out],info.mChanInfo, numInfo)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CAAudioUnit::SupportsNumChannels () const
|
|
{
|
|
// this is the default assumption of an audio effect unit
|
|
Boolean* isWritable = 0;
|
|
UInt32 dataSize = 0;
|
|
// lets see if the unit has any channel restrictions
|
|
OSStatus result = AudioUnitGetPropertyInfo (AU(),
|
|
kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0,
|
|
&dataSize, isWritable); //don't care if this is writable
|
|
|
|
// if this property is NOT implemented an FX unit
|
|
// is expected to deal with same channel valance in and out
|
|
if (result) {
|
|
if (Comp().Desc().IsEffect() || Comp().Desc().IsOffline())
|
|
return true;
|
|
}
|
|
return result == noErr;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::GetChannelLayoutTags (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
ChannelTagVector &outChannelVector) const
|
|
{
|
|
if (HasChannelLayouts (inScope, inEl) == false) return kAudioUnitErr_InvalidProperty;
|
|
|
|
UInt32 dataSize;
|
|
OSStatus result = AudioUnitGetPropertyInfo (AU(),
|
|
kAudioUnitProperty_SupportedChannelLayoutTags,
|
|
inScope, inEl,
|
|
&dataSize, NULL);
|
|
|
|
if (result) return result;
|
|
|
|
// OK lets get our channel layouts and see if the one we want is present
|
|
AudioChannelLayoutTag* info = (AudioChannelLayoutTag*)malloc (dataSize);
|
|
result = AudioUnitGetProperty (AU(),
|
|
kAudioUnitProperty_SupportedChannelLayoutTags,
|
|
inScope, inEl,
|
|
info, &dataSize);
|
|
if (result) goto home;
|
|
|
|
outChannelVector.erase (outChannelVector.begin(), outChannelVector.end());
|
|
for (unsigned int i = 0; i < (dataSize / sizeof (AudioChannelLayoutTag)); ++i)
|
|
outChannelVector.push_back (info[i]);
|
|
|
|
home:
|
|
free (info);
|
|
return result;
|
|
}
|
|
|
|
bool CAAudioUnit::HasChannelLayouts (AudioUnitScope inScope,
|
|
AudioUnitElement inEl) const
|
|
{
|
|
OSStatus result = AudioUnitGetPropertyInfo (AU(),
|
|
kAudioUnitProperty_SupportedChannelLayoutTags,
|
|
inScope, inEl,
|
|
NULL, NULL);
|
|
return !result;
|
|
}
|
|
|
|
bool CAAudioUnit::HasChannelLayout (AudioUnitScope inScope,
|
|
AudioUnitElement inEl) const
|
|
{
|
|
Boolean writable;
|
|
UInt32 size;
|
|
|
|
return AudioUnitGetPropertyInfo (AU(),
|
|
kAudioUnitProperty_AudioChannelLayout,
|
|
inScope, inEl,
|
|
&size, &writable) == noErr;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::GetChannelLayout (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
CAAudioChannelLayout &outLayout) const
|
|
{
|
|
UInt32 size;
|
|
OSStatus result = AudioUnitGetPropertyInfo (AU(), kAudioUnitProperty_AudioChannelLayout,
|
|
inScope, inEl, &size, NULL);
|
|
if (result) return result;
|
|
|
|
AudioChannelLayout *layout = (AudioChannelLayout*)malloc (size);
|
|
|
|
ca_require_noerr (result = AudioUnitGetProperty (AU(), kAudioUnitProperty_AudioChannelLayout,
|
|
inScope, inEl, layout, &size), home);
|
|
|
|
outLayout = CAAudioChannelLayout (layout);
|
|
|
|
home:
|
|
free (layout);
|
|
return result;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetChannelLayout (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
const CAAudioChannelLayout &inLayout)
|
|
{
|
|
OSStatus result = AudioUnitSetProperty (AU(),
|
|
kAudioUnitProperty_AudioChannelLayout,
|
|
inScope, inEl,
|
|
inLayout, inLayout.Size());
|
|
return result;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetChannelLayout (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
const AudioChannelLayout &inLayout,
|
|
UInt32 inSize)
|
|
{
|
|
OSStatus result = AudioUnitSetProperty (AU(),
|
|
kAudioUnitProperty_AudioChannelLayout,
|
|
inScope, inEl,
|
|
&inLayout, inSize);
|
|
return result;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::ClearChannelLayout (AudioUnitScope inScope,
|
|
AudioUnitElement inEl)
|
|
{
|
|
return AudioUnitSetProperty (AU(),
|
|
kAudioUnitProperty_AudioChannelLayout,
|
|
inScope, inEl, NULL, 0);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::GetFormat (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
AudioStreamBasicDescription &outFormat) const
|
|
{
|
|
UInt32 dataSize = sizeof (AudioStreamBasicDescription);
|
|
return AudioUnitGetProperty (AU(), kAudioUnitProperty_StreamFormat,
|
|
inScope, inEl,
|
|
&outFormat, &dataSize);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetFormat (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
const AudioStreamBasicDescription &inFormat)
|
|
{
|
|
return AudioUnitSetProperty (AU(), kAudioUnitProperty_StreamFormat,
|
|
inScope, inEl,
|
|
const_cast<AudioStreamBasicDescription*>(&inFormat),
|
|
sizeof (AudioStreamBasicDescription));
|
|
}
|
|
|
|
OSStatus CAAudioUnit::GetSampleRate (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
Float64 &outRate) const
|
|
{
|
|
UInt32 dataSize = sizeof (Float64);
|
|
return AudioUnitGetProperty (AU(), kAudioUnitProperty_SampleRate,
|
|
inScope, inEl,
|
|
&outRate, &dataSize);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetSampleRate (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
Float64 inRate)
|
|
{
|
|
AudioStreamBasicDescription desc;
|
|
OSStatus result = GetFormat (inScope, inEl, desc);
|
|
if (result) return result;
|
|
desc.mSampleRate = inRate;
|
|
return SetFormat (inScope, inEl, desc);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetSampleRate (Float64 inSampleRate)
|
|
{
|
|
OSStatus result;
|
|
|
|
UInt32 elCount;
|
|
ca_require_noerr (result = GetElementCount(kAudioUnitScope_Input, elCount), home);
|
|
if (elCount) {
|
|
for (unsigned int i = 0; i < elCount; ++i) {
|
|
ca_require_noerr (result = SetSampleRate (kAudioUnitScope_Input, i, inSampleRate), home);
|
|
}
|
|
}
|
|
|
|
ca_require_noerr (result = GetElementCount(kAudioUnitScope_Output, elCount), home);
|
|
if (elCount) {
|
|
for (unsigned int i = 0; i < elCount; ++i) {
|
|
ca_require_noerr (result = SetSampleRate (kAudioUnitScope_Output, i, inSampleRate), home);
|
|
}
|
|
}
|
|
|
|
home:
|
|
return result;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::NumberChannels (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
UInt32 &outChans) const
|
|
{
|
|
AudioStreamBasicDescription desc;
|
|
OSStatus result = GetFormat (inScope, inEl, desc);
|
|
if (!result)
|
|
outChans = desc.mChannelsPerFrame;
|
|
return result;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetNumberChannels (AudioUnitScope inScope,
|
|
AudioUnitElement inEl,
|
|
UInt32 inChans)
|
|
{
|
|
// set this as the output of the AU
|
|
CAStreamBasicDescription desc;
|
|
OSStatus result = GetFormat (inScope, inEl, desc);
|
|
if (result) return result;
|
|
desc.ChangeNumberChannels (inChans, desc.IsInterleaved());
|
|
result = SetFormat (inScope, inEl, desc);
|
|
return result;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::IsElementCountWritable (AudioUnitScope inScope, bool &outWritable) const
|
|
{
|
|
Boolean isWritable;
|
|
UInt32 outDataSize;
|
|
OSStatus result = GetPropertyInfo (kAudioUnitProperty_ElementCount, inScope, 0, &outDataSize, &isWritable);
|
|
if (result)
|
|
return result;
|
|
outWritable = isWritable ? true : false;
|
|
return noErr;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::GetElementCount (AudioUnitScope inScope, UInt32 &outCount) const
|
|
{
|
|
UInt32 propSize = sizeof(outCount);
|
|
return GetProperty (kAudioUnitProperty_ElementCount, inScope, 0, &outCount, &propSize);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetElementCount (AudioUnitScope inScope, UInt32 inCount)
|
|
{
|
|
return SetProperty (kAudioUnitProperty_ElementCount, inScope, 0, &inCount, sizeof(inCount));
|
|
}
|
|
|
|
bool CAAudioUnit::HasDynamicScope (AudioUnitScope inScope, SInt32 &outTotalNumChannels) const
|
|
{
|
|
// ok - now we need to check the AU's capability here.
|
|
// this is the default assumption of an audio effect unit
|
|
Boolean* isWritable = 0;
|
|
UInt32 dataSize = 0;
|
|
OSStatus result = GetPropertyInfo (kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0,
|
|
&dataSize, isWritable); //don't care if this is writable
|
|
|
|
// AU has to explicitly tell us about this.
|
|
if (result) return false;
|
|
|
|
StackAUChannelInfo info (dataSize);
|
|
|
|
result = GetProperty (kAudioUnitProperty_SupportedNumChannels,
|
|
kAudioUnitScope_Global, 0,
|
|
info.mChanInfo, &dataSize);
|
|
if (result) return false;
|
|
|
|
return ValidateDynamicScope (inScope, outTotalNumChannels, info.mChanInfo, (dataSize / sizeof(AUChannelInfo)));
|
|
}
|
|
|
|
// as we've already checked that the element count is writable
|
|
// the following conditions will match this..
|
|
/*
|
|
-1, -2 -> signifies no restrictions
|
|
-2, -1 -> signifies no restrictions -> in this case outTotalNumChannels == -1 (any num channels)
|
|
|
|
-N (where N is less than -2), signifies the total channel count on the scope side (in or out)
|
|
*/
|
|
bool CAAudioUnit::ValidateDynamicScope (AudioUnitScope inScope,
|
|
SInt32 &outTotalNumChannels,
|
|
const AUChannelInfo *info,
|
|
UInt32 numInfo) const
|
|
{
|
|
bool writable = false;
|
|
OSStatus result = IsElementCountWritable (inScope, writable);
|
|
if (result || (writable == false))
|
|
return false;
|
|
|
|
//now chan layout can contain -1 for either scope (ie. doesn't care)
|
|
for (unsigned int i = 0; i < numInfo; ++i)
|
|
{
|
|
// lets test the special wild card case first...
|
|
// this says the AU can do any num channels on input or output - for eg. Matrix Mixer
|
|
if (((info[i].inChannels == -1) && (info[i].outChannels == -2))
|
|
|| ((info[i].inChannels == -2) && (info[i].outChannels == -1)))
|
|
{
|
|
outTotalNumChannels = -1;
|
|
return true;
|
|
}
|
|
|
|
// ok lets now test our special case....
|
|
if (inScope == kAudioUnitScope_Input) {
|
|
// isn't dynamic on this side at least
|
|
if (info[i].inChannels >= 0)
|
|
continue;
|
|
|
|
if (info[i].inChannels < -2) {
|
|
outTotalNumChannels = abs (info[i].inChannels);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
else if (inScope == kAudioUnitScope_Output) {
|
|
// isn't dynamic on this side at least
|
|
if (info[i].outChannels >= 0)
|
|
continue;
|
|
|
|
if (info[i].outChannels < -2) {
|
|
outTotalNumChannels = abs (info[i].outChannels);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
else {
|
|
break; // wrong scope was specified
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::ConfigureDynamicScope (AudioUnitScope inScope,
|
|
UInt32 inNumElements,
|
|
UInt32 *inChannelsPerElement,
|
|
Float64 inSampleRate)
|
|
{
|
|
SInt32 numChannels = 0;
|
|
bool isDyamic = HasDynamicScope (inScope, numChannels);
|
|
if (isDyamic == false)
|
|
return kAudioUnitErr_InvalidProperty;
|
|
|
|
//lets to a sanity check...
|
|
// if numChannels == -1, then it can do "any"...
|
|
if (numChannels > 0) {
|
|
SInt32 count = 0;
|
|
for (unsigned int i = 0; i < inNumElements; ++i)
|
|
count += inChannelsPerElement[i];
|
|
if (count > numChannels)
|
|
return kAudioUnitErr_InvalidPropertyValue;
|
|
}
|
|
|
|
OSStatus result = SetElementCount (inScope, inNumElements);
|
|
if (result)
|
|
return result;
|
|
|
|
for (unsigned int i = 0; i < inNumElements; ++i) {
|
|
CAStreamBasicDescription desc;
|
|
result = GetFormat (inScope, i, desc);
|
|
if (result) return result;
|
|
desc.ChangeNumberChannels (inChannelsPerElement[i], desc.IsInterleaved());
|
|
desc.mSampleRate = inSampleRate;
|
|
result = SetFormat (inScope, i, desc);
|
|
if (result)
|
|
return result;
|
|
}
|
|
return noErr;
|
|
}
|
|
|
|
#pragma mark __Properties
|
|
|
|
bool CAAudioUnit::CanBypass () const
|
|
{
|
|
Boolean outWritable;
|
|
OSStatus result = AudioUnitGetPropertyInfo (AU(), kAudioUnitProperty_BypassEffect,
|
|
kAudioUnitScope_Global, 0,
|
|
NULL, &outWritable);
|
|
return (!result && outWritable);
|
|
}
|
|
|
|
bool CAAudioUnit::GetBypass () const
|
|
{
|
|
UInt32 dataSize = sizeof (UInt32);
|
|
UInt32 outBypass;
|
|
OSStatus result = AudioUnitGetProperty (AU(), kAudioUnitProperty_BypassEffect,
|
|
kAudioUnitScope_Global, 0,
|
|
&outBypass, &dataSize);
|
|
return (result ? false : outBypass);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetBypass (bool inBypass) const
|
|
{
|
|
UInt32 bypass = inBypass ? 1 : 0;
|
|
return AudioUnitSetProperty (AU(), kAudioUnitProperty_BypassEffect,
|
|
kAudioUnitScope_Global, 0,
|
|
&bypass, sizeof (UInt32));
|
|
}
|
|
|
|
OSStatus CAAudioUnit::GetMaxFramesPerSlice (UInt32& outMaxFrames) const
|
|
{
|
|
UInt32 dataSize = sizeof(outMaxFrames);
|
|
return AudioUnitGetProperty (AU(), kAudioUnitProperty_MaximumFramesPerSlice,
|
|
kAudioUnitScope_Global, 0,
|
|
&outMaxFrames, &dataSize);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetMaxFramesPerSlice (UInt32 inMaxFrames)
|
|
{
|
|
return AudioUnitSetProperty (AU(), kAudioUnitProperty_MaximumFramesPerSlice,
|
|
kAudioUnitScope_Global, 0,
|
|
&inMaxFrames, sizeof (UInt32));
|
|
}
|
|
|
|
Float64 CAAudioUnit::Latency () const
|
|
{
|
|
Float64 secs;
|
|
UInt32 size = sizeof(secs);
|
|
if (GetProperty (kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0, &secs, &size))
|
|
return 0;
|
|
return secs;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::GetAUPreset (CFPropertyListRef &outData) const
|
|
{
|
|
UInt32 dataSize = sizeof(outData);
|
|
return AudioUnitGetProperty (AU(), kAudioUnitProperty_ClassInfo,
|
|
kAudioUnitScope_Global, 0,
|
|
&outData, &dataSize);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetAUPreset (CFPropertyListRef &inData)
|
|
{
|
|
return AudioUnitSetProperty (AU(), kAudioUnitProperty_ClassInfo,
|
|
kAudioUnitScope_Global, 0,
|
|
&inData, sizeof (CFPropertyListRef));
|
|
}
|
|
|
|
#if !TARGET_OS_IPHONE
|
|
OSStatus CAAudioUnit::SetAUPresetFromDocument (CFPropertyListRef &inData)
|
|
{
|
|
return AudioUnitSetProperty (AU(), kAudioUnitProperty_ClassInfoFromDocument,
|
|
kAudioUnitScope_Global, 0,
|
|
&inData, sizeof (CFPropertyListRef));
|
|
}
|
|
#endif
|
|
|
|
OSStatus CAAudioUnit::GetPresentPreset (AUPreset &outData) const
|
|
{
|
|
UInt32 dataSize = sizeof(outData);
|
|
OSStatus result = AudioUnitGetProperty (AU(), kAudioUnitProperty_PresentPreset,
|
|
kAudioUnitScope_Global, 0,
|
|
&outData, &dataSize);
|
|
#if !TARGET_OS_IPHONE
|
|
#ifndef __LP64__
|
|
if (result == kAudioUnitErr_InvalidProperty) {
|
|
dataSize = sizeof(outData);
|
|
result = AudioUnitGetProperty (AU(), kAudioUnitProperty_CurrentPreset,
|
|
kAudioUnitScope_Global, 0,
|
|
&outData, &dataSize);
|
|
if (result == noErr) {
|
|
// we now retain the CFString in the preset so for the client of this API
|
|
// it is consistent (ie. the string should be released when done)
|
|
if (outData.presetName)
|
|
CFRetain (outData.presetName);
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetPresentPreset (AUPreset &inData)
|
|
{
|
|
OSStatus result = AudioUnitSetProperty (AU(), kAudioUnitProperty_PresentPreset,
|
|
kAudioUnitScope_Global, 0,
|
|
&inData, sizeof (AUPreset));
|
|
#if !TARGET_OS_IPHONE
|
|
#ifndef __LP64__
|
|
if (result == kAudioUnitErr_InvalidProperty) {
|
|
result = AudioUnitSetProperty (AU(), kAudioUnitProperty_CurrentPreset,
|
|
kAudioUnitScope_Global, 0,
|
|
&inData, sizeof (AUPreset));
|
|
}
|
|
#endif
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
bool CAAudioUnit::HasCustomView () const
|
|
{
|
|
#if !TARGET_OS_IPHONE
|
|
UInt32 dataSize = 0;
|
|
OSStatus result = -4/*unimpErr*/;
|
|
#ifndef __LP64__
|
|
result = GetPropertyInfo(kAudioUnitProperty_GetUIComponentList,
|
|
kAudioUnitScope_Global, 0,
|
|
&dataSize, NULL);
|
|
#endif
|
|
if (result || !dataSize) {
|
|
dataSize = 0;
|
|
result = GetPropertyInfo(kAudioUnitProperty_CocoaUI,
|
|
kAudioUnitScope_Global, 0,
|
|
&dataSize, NULL);
|
|
if (result || !dataSize)
|
|
return false;
|
|
}
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
|
|
}
|
|
|
|
OSStatus CAAudioUnit::GetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
|
|
Float32 &outValue) const
|
|
{
|
|
return mDataPtr ? mDataPtr->GetParameter (inID, scope, element, outValue) : static_cast<OSStatus>(paramErr);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::SetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
|
|
Float32 value, UInt32 bufferOffsetFrames)
|
|
{
|
|
return mDataPtr ? mDataPtr->SetParameter (inID, scope, element, value, bufferOffsetFrames) : static_cast<OSStatus>(paramErr);
|
|
}
|
|
|
|
OSStatus CAAudioUnit::MIDIEvent (UInt32 inStatus,
|
|
UInt32 inData1,
|
|
UInt32 inData2,
|
|
UInt32 inOffsetSampleFrame)
|
|
{
|
|
return mDataPtr ? mDataPtr->MIDIEvent (inStatus, inData1, inData2, inOffsetSampleFrame) : paramErr;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::StartNote (MusicDeviceInstrumentID inInstrument,
|
|
MusicDeviceGroupID inGroupID,
|
|
NoteInstanceID * outNoteInstanceID,
|
|
UInt32 inOffsetSampleFrame,
|
|
const MusicDeviceNoteParams * inParams)
|
|
{
|
|
return mDataPtr ? mDataPtr->StartNote (inInstrument, inGroupID, outNoteInstanceID, inOffsetSampleFrame, inParams)
|
|
: paramErr;
|
|
}
|
|
|
|
OSStatus CAAudioUnit::StopNote (MusicDeviceGroupID inGroupID,
|
|
NoteInstanceID inNoteInstanceID,
|
|
UInt32 inOffsetSampleFrame)
|
|
{
|
|
return mDataPtr ? mDataPtr->StopNote (inGroupID, inNoteInstanceID, inOffsetSampleFrame) : paramErr;
|
|
}
|
|
|
|
|
|
#pragma mark __Render
|
|
|
|
OSStatus CAAudioUnit::Render (AudioUnitRenderActionFlags * ioActionFlags,
|
|
const AudioTimeStamp * inTimeStamp,
|
|
UInt32 inOutputBusNumber,
|
|
UInt32 inNumberFrames,
|
|
AudioBufferList * ioData)
|
|
{
|
|
return mDataPtr ? mDataPtr->Render (ioActionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData) : static_cast<OSStatus>(paramErr);
|
|
}
|
|
|
|
extern "C" OSStatus
|
|
AudioUnitProcess ( AudioUnit inUnit,
|
|
AudioUnitRenderActionFlags * ioActionFlags,
|
|
const AudioTimeStamp * inTimeStamp,
|
|
UInt32 inNumberFrames,
|
|
AudioBufferList * ioData);
|
|
|
|
OSStatus CAAudioUnit::Process (AudioUnitRenderActionFlags & ioActionFlags,
|
|
const AudioTimeStamp & inTimeStamp,
|
|
UInt32 inNumberFrames,
|
|
AudioBufferList & ioData)
|
|
{
|
|
#if defined(__MAC_10_7) || defined(__IPHONE_4_0)
|
|
return AudioUnitProcess (AU(), &ioActionFlags, &inTimeStamp, inNumberFrames, &ioData);
|
|
#else
|
|
return -4/*unimpErr*/;
|
|
#endif
|
|
}
|
|
|
|
extern "C" OSStatus
|
|
AudioUnitProcessMultiple ( AudioUnit inUnit,
|
|
AudioUnitRenderActionFlags * ioActionFlags,
|
|
const AudioTimeStamp * inTimeStamp,
|
|
UInt32 inNumberFrames,
|
|
UInt32 inNumberInputBufferLists,
|
|
const AudioBufferList ** inInputBufferLists,
|
|
UInt32 inNumberOutputBufferLists,
|
|
AudioBufferList ** ioOutputBufferLists);
|
|
|
|
OSStatus CAAudioUnit::ProcessMultiple (AudioUnitRenderActionFlags & ioActionFlags,
|
|
const AudioTimeStamp & inTimeStamp,
|
|
UInt32 inNumberFrames,
|
|
UInt32 inNumberInputBufferLists,
|
|
const AudioBufferList ** inInputBufferLists,
|
|
UInt32 inNumberOutputBufferLists,
|
|
AudioBufferList ** ioOutputBufferLists)
|
|
{
|
|
#if defined(__MAC_10_7) || defined(__IPHONE_4_0)
|
|
return AudioUnitProcessMultiple (AU(), &ioActionFlags, &inTimeStamp, inNumberFrames,
|
|
inNumberInputBufferLists, inInputBufferLists, inNumberOutputBufferLists, ioOutputBufferLists);
|
|
#else
|
|
return -4/*unimpErr*/;
|
|
#endif
|
|
}
|
|
|
|
#pragma mark __CAAUChanHelper
|
|
|
|
CAAUChanHelper::CAAUChanHelper(const CAAudioUnit &inAU, AudioUnitScope inScope)
|
|
:mChans(NULL), mNumEls(0), mDidAllocate(false)
|
|
{
|
|
UInt32 elCount;
|
|
if (inAU.GetElementCount (inScope, elCount)) return;
|
|
if (elCount > kStaticElCount) {
|
|
mChans = new UInt32[elCount];
|
|
mDidAllocate = true;
|
|
memset (mChans, 0, sizeof(int) * elCount);
|
|
} else {
|
|
mChans = mStaticChans;
|
|
memset (mChans, 0, sizeof(int) * kStaticElCount);
|
|
}
|
|
for (unsigned int i = 0; i < elCount; ++i) {
|
|
UInt32 numChans;
|
|
if (inAU.NumberChannels (inScope, i, numChans)) return;
|
|
mChans[i] = numChans;
|
|
}
|
|
mNumEls = elCount;
|
|
}
|
|
|
|
CAAUChanHelper::CAAUChanHelper(UInt32 inMaxElems)
|
|
: mNumEls(inMaxElems), mDidAllocate(false)
|
|
{
|
|
if (inMaxElems > kStaticElCount) {
|
|
mChans = new UInt32[inMaxElems];
|
|
mDidAllocate = true;
|
|
memset (mChans, 0, sizeof(int) * inMaxElems);
|
|
} else {
|
|
mChans = mStaticChans;
|
|
memset (mChans, 0, sizeof(int) * kStaticElCount);
|
|
}
|
|
}
|
|
|
|
CAAUChanHelper::~CAAUChanHelper()
|
|
{
|
|
if (mDidAllocate) delete [] mChans;
|
|
}
|
|
|
|
CAAUChanHelper& CAAUChanHelper::operator= (const CAAUChanHelper &c)
|
|
{
|
|
if (mDidAllocate) delete [] mChans;
|
|
if (c.mDidAllocate) {
|
|
mChans = new UInt32[c.mNumEls];
|
|
mDidAllocate = true;
|
|
} else {
|
|
mDidAllocate = false;
|
|
mChans = mStaticChans;
|
|
}
|
|
memcpy (mChans, c.mChans, c.mNumEls * sizeof(int));
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
#pragma mark __Print Utilities
|
|
|
|
void CAAudioUnit::Print (FILE* file) const
|
|
{
|
|
fprintf (file, "AudioUnit:%p\n", AU());
|
|
if (IsValid()) {
|
|
fprintf (file, "\tnode=%ld\t", (long)GetAUNode()); Comp().Print (file);
|
|
}
|
|
}
|
|
|
|
#if CA_AU_USE_FAST_DISPATCH
|
|
// Handle GetComponentInstanceStorage(ComponentInstance aComponentInstance)
|
|
static void *LoadGetComponentInstanceStorage (void *inst)
|
|
{
|
|
typedef void* (*GetComponentInstanceStorageProc)(void* aComponentInstance);
|
|
static GetComponentInstanceStorageProc sGetComponentInstanceStorageProc = NULL;
|
|
|
|
static int sDoCSLoad = 1;
|
|
if (sDoCSLoad) {
|
|
sDoCSLoad = 0;
|
|
void *theImage = dlopen("/System/Library/Frameworks/CoreServices.framework/CoreServices", RTLD_LAZY);
|
|
if (!theImage) return NULL;
|
|
|
|
sGetComponentInstanceStorageProc = (GetComponentInstanceStorageProc) dlsym(theImage, "GetComponentInstanceStorage");
|
|
}
|
|
if (sGetComponentInstanceStorageProc)
|
|
return (*sGetComponentInstanceStorageProc)(inst);
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|