/*

     File: NullAudio.c 

 Abstract:  Part of NullAudio Driver Example  

  Version: 1.0.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) 2013 Apple Inc. All Rights Reserved. 

*/

/*==================================================================================================

    NullAudio.c

==================================================================================================*/

//==================================================================================================

//  Includes

//==================================================================================================

//  System Includes

#include <CoreAudio/AudioServerPlugIn.h>

#include <dispatch/dispatch.h>

#include <mach/mach_time.h>

#include <pthread.h>

#include <stdint.h>

#include <sys/syslog.h>

//==================================================================================================

#pragma mark -

#pragma mark Macros

//==================================================================================================

#if TARGET_RT_BIG_ENDIAN

    #define FourCCToCString(the4CC) { ((char*)&the4CC)[0], ((char*)&the4CC)[1], ((char*)&the4CC)[2], ((char*)&the4CC)[3], 0 }

#else

    #define FourCCToCString(the4CC) { ((char*)&the4CC)[3], ((char*)&the4CC)[2], ((char*)&the4CC)[1], ((char*)&the4CC)[0], 0 }

#endif

#if DEBUG

    #define DebugMsg(inFormat, ...) syslog(LOG_NOTICE, inFormat, ## __VA_ARGS__)

    #define FailIf(inCondition, inHandler, inMessage)                                   \

            if(inCondition)                                                             \

            {                                                                           \

                DebugMsg(inMessage);                                                    \

                goto inHandler;                                                         \

            }

    #define FailWithAction(inCondition, inAction, inHandler, inMessage)                 \

            if(inCondition)                                                             \

            {                                                                           \

                DebugMsg(inMessage);                                                    \

                { inAction; }                                                           \

                goto inHandler;                                                         \

            }

#else

    #define DebugMsg(inFormat, ...)

    #define FailIf(inCondition, inHandler, inMessage)                                   \

            if(inCondition)                                                             \

            {                                                                           \

                goto inHandler;                                                         \

            }

    #define FailWithAction(inCondition, inAction, inHandler, inMessage)                 \

            if(inCondition)                                                             \

            {                                                                           \

                { inAction; }                                                           \

                goto inHandler;                                                         \

            }

#endif

//==================================================================================================

#pragma mark -

#pragma mark NullAudio State

//==================================================================================================

//  The purpose of the NullAudio is to provide the barest of bare bones implementations to

//  illustrate the minimal set of things a driver has to do. As such, the driver has the following

//  qualities:

//  - a box

//  - a device

//      - supports 44100 and 48000 sample rates

//      - provides a rate scalar of 1.0 via hard coding

//  - a single input stream

//      - supports 2 channels of 32 bit float LPCM samples

//      - always produces zeros 

//  - a single output stream

//      - supports 2 channels of 32 bit float LPCM samples

//      - data written to it is ignored

//  - controls

//      - master input volume

//      - master output volume

//      - master input mute

//      - master output mute

//      - master input data source

//      - master output data source

//      - all are for illustration purposes only and do not actually manipulate data

//  Declare the internal object ID numbers for all the objects this driver implements. Note that

//  because the driver has fixed set of objects that never grows or shrinks. If this were not the

//  case, the driver would need to have a means to dynamically allocate these IDs. It is important

//  to realize that a lot of the structure of this driver is vastly simpler when the IDs are all

//  known a priori. Comments in the code will try to identify some of these simplifications and

//  point out what a more complicated driver will need to do.

enum

{

    kObjectID_PlugIn                    = kAudioObjectPlugInObject,

    kObjectID_Box                       = 2,

    kObjectID_Device                    = 3,

    kObjectID_Stream_Input              = 4,

    kObjectID_Volume_Input_Master       = 5,

    kObjectID_Mute_Input_Master         = 6,

    kObjectID_DataSource_Input_Master   = 7,

    kObjectID_Stream_Output             = 8,

    kObjectID_Volume_Output_Master      = 9,

    kObjectID_Mute_Output_Master        = 10,

    kObjectID_DataSource_Output_Master  = 11

};

//  Declare the stuff that tracks the state of the plug-in, the device and its sub-objects.

//  Note that we use global variables here because this driver only ever has a single device. If

//  multiple devices were supported, this state would need to be encapsulated in one or more structs

//  so that each object's state can be tracked individually.

//  Note also that we share a single mutex across all objects to be thread safe for the same reason.

#define                         kPlugIn_BundleID                "com.apple.audio.NullAudio"

static pthread_mutex_t          gPlugIn_StateMutex              = PTHREAD_MUTEX_INITIALIZER;

static UInt32                   gPlugIn_RefCount                = 0;

static AudioServerPlugInHostRef gPlugIn_Host                    = NULL;

#define                         kBox_UID                        "NullAudioBox_UID"

static CFStringRef              gBox_Name                       = NULL;

static Boolean                  gBox_Acquired                   = true;

#define                         kDevice_UID                     "NullAudioDevice_UID"

#define                         kDevice_ModelUID                "NullAudioDevice_ModelUID"

static pthread_mutex_t          gDevice_IOMutex                 = PTHREAD_MUTEX_INITIALIZER;

static Float64                  gDevice_SampleRate              = 44100.0;

static UInt64                   gDevice_IOIsRunning             = 0;

static const UInt32             kDevice_RingBufferSize          = 16384;

static Float64                  gDevice_HostTicksPerFrame       = 0.0;

static UInt64                   gDevice_NumberTimeStamps        = 0;

static Float64                  gDevice_AnchorSampleTime        = 0.0;

static UInt64                   gDevice_AnchorHostTime          = 0;

static bool                     gStream_Input_IsActive          = true;

static bool                     gStream_Output_IsActive         = true;

static const Float32            kVolume_MinDB                   = -96.0;

static const Float32            kVolume_MaxDB                   = 6.0;

static Float32                  gVolume_Input_Master_Value      = 0.0;

static Float32                  gVolume_Output_Master_Value     = 0.0;

static bool                     gMute_Input_Master_Value        = false;

static bool                     gMute_Output_Master_Value       = false;

static const UInt32             kDataSource_NumberItems         = 4;

#define                         kDataSource_ItemNamePattern     "Data Source Item %d"

static UInt32                   gDataSource_Input_Master_Value  = 0;

static UInt32                   gDataSource_Output_Master_Value = 0;

//==================================================================================================

#pragma mark -

#pragma mark AudioServerPlugInDriverInterface Implementation

//==================================================================================================

#pragma mark Prototypes

//  Entry points for the COM methods

void*               NullAudio_Create(CFAllocatorRef inAllocator, CFUUIDRef inRequestedTypeUUID);

static HRESULT      NullAudio_QueryInterface(void* inDriver, REFIID inUUID, LPVOID* outInterface);

static ULONG        NullAudio_AddRef(void* inDriver);

static ULONG        NullAudio_Release(void* inDriver);

static OSStatus     NullAudio_Initialize(AudioServerPlugInDriverRef inDriver, AudioServerPlugInHostRef inHost);

static OSStatus     NullAudio_CreateDevice(AudioServerPlugInDriverRef inDriver, CFDictionaryRef inDescription, const AudioServerPlugInClientInfo* inClientInfo, AudioObjectID* outDeviceObjectID);

static OSStatus     NullAudio_DestroyDevice(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID);

static OSStatus     NullAudio_AddDeviceClient(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, const AudioServerPlugInClientInfo* inClientInfo);

static OSStatus     NullAudio_RemoveDeviceClient(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, const AudioServerPlugInClientInfo* inClientInfo);

static OSStatus     NullAudio_PerformDeviceConfigurationChange(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt64 inChangeAction, void* inChangeInfo);

static OSStatus     NullAudio_AbortDeviceConfigurationChange(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt64 inChangeAction, void* inChangeInfo);

static Boolean      NullAudio_HasProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress);

static OSStatus     NullAudio_IsPropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable);

static OSStatus     NullAudio_GetPropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize);

static OSStatus     NullAudio_GetPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData);

static OSStatus     NullAudio_SetPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData);

static OSStatus     NullAudio_StartIO(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt32 inClientID);

static OSStatus     NullAudio_StopIO(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt32 inClientID);

static OSStatus     NullAudio_GetZeroTimeStamp(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt32 inClientID, Float64* outSampleTime, UInt64* outHostTime, UInt64* outSeed);

static OSStatus     NullAudio_WillDoIOOperation(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt32 inClientID, UInt32 inOperationID, Boolean* outWillDo, Boolean* outWillDoInPlace);

static OSStatus     NullAudio_BeginIOOperation(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt32 inClientID, UInt32 inOperationID, UInt32 inIOBufferFrameSize, const AudioServerPlugInIOCycleInfo* inIOCycleInfo);

static OSStatus     NullAudio_DoIOOperation(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, AudioObjectID inStreamObjectID, UInt32 inClientID, UInt32 inOperationID, UInt32 inIOBufferFrameSize, const AudioServerPlugInIOCycleInfo* inIOCycleInfo, void* ioMainBuffer, void* ioSecondaryBuffer);

static OSStatus     NullAudio_EndIOOperation(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt32 inClientID, UInt32 inOperationID, UInt32 inIOBufferFrameSize, const AudioServerPlugInIOCycleInfo* inIOCycleInfo);

//  Implementation

static Boolean      NullAudio_HasPlugInProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress);

static OSStatus     NullAudio_IsPlugInPropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable);

static OSStatus     NullAudio_GetPlugInPropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize);

static OSStatus     NullAudio_GetPlugInPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData);

static OSStatus     NullAudio_SetPlugInPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData, UInt32* outNumberPropertiesChanged, AudioObjectPropertyAddress outChangedAddresses[2]);

static Boolean      NullAudio_HasBoxProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress);

static OSStatus     NullAudio_IsBoxPropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable);

static OSStatus     NullAudio_GetBoxPropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize);

static OSStatus     NullAudio_GetBoxPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData);

static OSStatus     NullAudio_SetBoxPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData, UInt32* outNumberPropertiesChanged, AudioObjectPropertyAddress outChangedAddresses[2]);

static Boolean      NullAudio_HasDeviceProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress);

static OSStatus     NullAudio_IsDevicePropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable);

static OSStatus     NullAudio_GetDevicePropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize);

static OSStatus     NullAudio_GetDevicePropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData);

static OSStatus     NullAudio_SetDevicePropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData, UInt32* outNumberPropertiesChanged, AudioObjectPropertyAddress outChangedAddresses[2]);

static Boolean      NullAudio_HasStreamProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress);

static OSStatus     NullAudio_IsStreamPropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable);

static OSStatus     NullAudio_GetStreamPropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize);

static OSStatus     NullAudio_GetStreamPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData);

static OSStatus     NullAudio_SetStreamPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData, UInt32* outNumberPropertiesChanged, AudioObjectPropertyAddress outChangedAddresses[2]);

static Boolean      NullAudio_HasControlProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress);

static OSStatus     NullAudio_IsControlPropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable);

static OSStatus     NullAudio_GetControlPropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize);

static OSStatus     NullAudio_GetControlPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData);

static OSStatus     NullAudio_SetControlPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData, UInt32* outNumberPropertiesChanged, AudioObjectPropertyAddress outChangedAddresses[2]);

#pragma mark The Interface

static AudioServerPlugInDriverInterface gAudioServerPlugInDriverInterface =

{

    NULL,

    NullAudio_QueryInterface,

    NullAudio_AddRef,

    NullAudio_Release,

    NullAudio_Initialize,

    NullAudio_CreateDevice,

    NullAudio_DestroyDevice,

    NullAudio_AddDeviceClient,

    NullAudio_RemoveDeviceClient,

    NullAudio_PerformDeviceConfigurationChange,

    NullAudio_AbortDeviceConfigurationChange,

    NullAudio_HasProperty,

    NullAudio_IsPropertySettable,

    NullAudio_GetPropertyDataSize,

    NullAudio_GetPropertyData,

    NullAudio_SetPropertyData,

    NullAudio_StartIO,

    NullAudio_StopIO,

    NullAudio_GetZeroTimeStamp,

    NullAudio_WillDoIOOperation,

    NullAudio_BeginIOOperation,

    NullAudio_DoIOOperation,

    NullAudio_EndIOOperation

};

static AudioServerPlugInDriverInterface*    gAudioServerPlugInDriverInterfacePtr    = &gAudioServerPlugInDriverInterface;

static AudioServerPlugInDriverRef           gAudioServerPlugInDriverRef             = &gAudioServerPlugInDriverInterfacePtr;

#pragma mark Factory

void*   NullAudio_Create(CFAllocatorRef inAllocator, CFUUIDRef inRequestedTypeUUID)

{

    //  This is the CFPlugIn factory function. Its job is to create the implementation for the given

    //  type provided that the type is supported. Because this driver is simple and all its

    //  initialization is handled via static iniitalization when the bundle is loaded, all that

    //  needs to be done is to return the AudioServerPlugInDriverRef that points to the driver's

    //  interface. A more complicated driver would create any base line objects it needs to satisfy

    //  the IUnknown methods that are used to discover that actual interface to talk to the driver.

    //  The majority of the driver's initilization should be handled in the Initialize() method of

    //  the driver's AudioServerPlugInDriverInterface.

    #pragma unused(inAllocator)

    void* theAnswer = NULL;

    if(CFEqual(inRequestedTypeUUID, kAudioServerPlugInTypeUUID))

    {

        theAnswer = gAudioServerPlugInDriverRef;

    }

    return theAnswer;

}

#pragma mark Inheritence

static HRESULT  NullAudio_QueryInterface(void* inDriver, REFIID inUUID, LPVOID* outInterface)

{

    //  This function is called by the HAL to get the interface to talk to the plug-in through.

    //  AudioServerPlugIns are required to support the IUnknown interface and the

    //  AudioServerPlugInDriverInterface. As it happens, all interfaces must also provide the

    //  IUnknown interface, so we can always just return the single interface we made with

    //  gAudioServerPlugInDriverInterfacePtr regardless of which one is asked for.

    //  declare the local variables

    HRESULT theAnswer = 0;

    CFUUIDRef theRequestedUUID = NULL;

    //  validate the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_QueryInterface: bad driver reference");

    FailWithAction(outInterface == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_QueryInterface: no place to store the returned interface");

    //  make a CFUUIDRef from inUUID

    theRequestedUUID = CFUUIDCreateFromUUIDBytes(NULL, inUUID);

    FailWithAction(theRequestedUUID == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_QueryInterface: failed to create the CFUUIDRef");

    //  AudioServerPlugIns only support two interfaces, IUnknown (which has to be supported by all

    //  CFPlugIns and AudioServerPlugInDriverInterface (which is the actual interface the HAL will

    //  use).

    if(CFEqual(theRequestedUUID, IUnknownUUID) || CFEqual(theRequestedUUID, kAudioServerPlugInDriverInterfaceUUID))

    {

        pthread_mutex_lock(&gPlugIn_StateMutex);

        ++gPlugIn_RefCount;

        pthread_mutex_unlock(&gPlugIn_StateMutex);

        *outInterface = gAudioServerPlugInDriverRef;

    }

    else

    {

        theAnswer = E_NOINTERFACE;

    }

    //  make sure to release the UUID we created

    CFRelease(theRequestedUUID);

Done:

    return theAnswer;

}

static ULONG    NullAudio_AddRef(void* inDriver)

{

    //  This call returns the resulting reference count after the increment.

    //  declare the local variables

    ULONG theAnswer = 0;

    //  check the arguments

    FailIf(inDriver != gAudioServerPlugInDriverRef, Done, "NullAudio_AddRef: bad driver reference");

    //  decrement the refcount

    pthread_mutex_lock(&gPlugIn_StateMutex);

    if(gPlugIn_RefCount < UINT32_MAX)

    {

        ++gPlugIn_RefCount;

    }

    theAnswer = gPlugIn_RefCount;

    pthread_mutex_unlock(&gPlugIn_StateMutex);

Done:

    return theAnswer;

}

static ULONG    NullAudio_Release(void* inDriver)

{

    //  This call returns the resulting reference count after the decrement.

    //  declare the local variables

    ULONG theAnswer = 0;

    //  check the arguments

    FailIf(inDriver != gAudioServerPlugInDriverRef, Done, "NullAudio_Release: bad driver reference");

    //  increment the refcount

    pthread_mutex_lock(&gPlugIn_StateMutex);

    if(gPlugIn_RefCount > 0)

    {

        --gPlugIn_RefCount;

        //  Note that we don't do anything special if the refcount goes to zero as the HAL

        //  will never fully release a plug-in it opens. We keep managing the refcount so that

        //  the API semantics are correct though.

    }

    theAnswer = gPlugIn_RefCount;

    pthread_mutex_unlock(&gPlugIn_StateMutex);

Done:

    return theAnswer;

}

#pragma mark Basic Operations

static OSStatus NullAudio_Initialize(AudioServerPlugInDriverRef inDriver, AudioServerPlugInHostRef inHost)

{

    //  The job of this method is, as the name implies, to get the driver initialized. One specific

    //  thing that needs to be done is to store the AudioServerPlugInHostRef so that it can be used

    //  later. Note that when this call returns, the HAL will scan the various lists the driver

    //  maintains (such as the device list) to get the inital set of objects the driver is

    //  publishing. So, there is no need to notifiy the HAL about any objects created as part of the

    //  execution of this method.

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_Initialize: bad driver reference");

    //  store the AudioServerPlugInHostRef

    gPlugIn_Host = inHost;

    //  initialize the box acquired property from the settings

    CFPropertyListRef theSettingsData = NULL;

    gPlugIn_Host->CopyFromStorage(gPlugIn_Host, CFSTR("box acquired"), &theSettingsData);

    if(theSettingsData != NULL)

    {

        if(CFGetTypeID(theSettingsData) == CFBooleanGetTypeID())

        {

            gBox_Acquired = CFBooleanGetValue((CFBooleanRef)theSettingsData);

        }

        else if(CFGetTypeID(theSettingsData) == CFNumberGetTypeID())

        {

            SInt32 theValue = 0;

            CFNumberGetValue((CFNumberRef)theSettingsData, kCFNumberSInt32Type, &theValue);

            gBox_Acquired = theValue ? 1 : 0;

        }

        CFRelease(theSettingsData);

    }

    //  initialize the box name from the settings

    gPlugIn_Host->CopyFromStorage(gPlugIn_Host, CFSTR("box acquired"), &theSettingsData);

    if(theSettingsData != NULL)

    {

        if(CFGetTypeID(theSettingsData) == CFStringGetTypeID())

        {

            gBox_Name = (CFStringRef)theSettingsData;

            CFRetain(gBox_Name);

        }

        CFRelease(theSettingsData);

    }

    //  set the box name directly as a last resort

    if(gBox_Name == NULL)

    {

        gBox_Name = CFSTR("Null Box");

    }

    //  calculate the host ticks per frame

    struct mach_timebase_info theTimeBaseInfo;

    mach_timebase_info(&theTimeBaseInfo);

    Float64 theHostClockFrequency = theTimeBaseInfo.denom / theTimeBaseInfo.numer;

    theHostClockFrequency *= 1000000000.0;

    gDevice_HostTicksPerFrame = theHostClockFrequency / gDevice_SampleRate;

Done:

    return theAnswer;

}

static OSStatus NullAudio_CreateDevice(AudioServerPlugInDriverRef inDriver, CFDictionaryRef inDescription, const AudioServerPlugInClientInfo* inClientInfo, AudioObjectID* outDeviceObjectID)

{

    //  This method is used to tell a driver that implements the Transport Manager semantics to

    //  create an AudioEndpointDevice from a set of AudioEndpoints. Since this driver is not a

    //  Transport Manager, we just check the arguments and return

    //  kAudioHardwareUnsupportedOperationError.

    #pragma unused(inDescription, inClientInfo, outDeviceObjectID)

    //  declare the local variables

    OSStatus theAnswer = kAudioHardwareUnsupportedOperationError;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_CreateDevice: bad driver reference");

Done:

    return theAnswer;

}

static OSStatus NullAudio_DestroyDevice(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID)

{

    //  This method is used to tell a driver that implements the Transport Manager semantics to

    //  destroy an AudioEndpointDevice. Since this driver is not a Transport Manager, we just check

    //  the arguments and return kAudioHardwareUnsupportedOperationError.

    #pragma unused(inDeviceObjectID)

    //  declare the local variables

    OSStatus theAnswer = kAudioHardwareUnsupportedOperationError;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_DestroyDevice: bad driver reference");

Done:

    return theAnswer;

}

static OSStatus NullAudio_AddDeviceClient(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, const AudioServerPlugInClientInfo* inClientInfo)

{

    //  This method is used to inform the driver about a new client that is using the given device.

    //  This allows the device to act differently depending on who the client is. This driver does

    //  not need to track the clients using the device, so we just check the arguments and return

    //  successfully.

    #pragma unused(inClientInfo)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_AddDeviceClient: bad driver reference");

    FailWithAction(inDeviceObjectID != kObjectID_Device, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_AddDeviceClient: bad device ID");

Done:

    return theAnswer;

}

static OSStatus NullAudio_RemoveDeviceClient(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, const AudioServerPlugInClientInfo* inClientInfo)

{

    //  This method is used to inform the driver about a client that is no longer using the given

    //  device. This driver does not track clients, so we just check the arguments and return

    //  successfully.

    #pragma unused(inClientInfo)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_RemoveDeviceClient: bad driver reference");

    FailWithAction(inDeviceObjectID != kObjectID_Device, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_RemoveDeviceClient: bad device ID");

Done:

    return theAnswer;

}

static OSStatus NullAudio_PerformDeviceConfigurationChange(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt64 inChangeAction, void* inChangeInfo)

{

    //  This method is called to tell the device that it can perform the configuation change that it

    //  had requested via a call to the host method, RequestDeviceConfigurationChange(). The

    //  arguments, inChangeAction and inChangeInfo are the same as what was passed to

    //  RequestDeviceConfigurationChange().

    //

    //  The HAL guarantees that IO will be stopped while this method is in progress. The HAL will

    //  also handle figuring out exactly what changed for the non-control related properties. This

    //  means that the only notifications that would need to be sent here would be for either

    //  custom properties the HAL doesn't know about or for controls.

    //

    //  For the device implemented by this driver, only sample rate changes go through this process

    //  as it is the only state that can be changed for the device that isn't a control. For this

    //  change, the new sample rate is passed in the inChangeAction argument.

    #pragma unused(inChangeInfo)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_PerformDeviceConfigurationChange: bad driver reference");

    FailWithAction(inDeviceObjectID != kObjectID_Device, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_PerformDeviceConfigurationChange: bad device ID");

    FailWithAction((inChangeAction != 44100) && (inChangeAction != 48000), theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_PerformDeviceConfigurationChange: bad sample rate");

    //  lock the state mutex

    pthread_mutex_lock(&gPlugIn_StateMutex);

    //  change the sample rate

    gDevice_SampleRate = inChangeAction;

    //  recalculate the state that depends on the sample rate

    struct mach_timebase_info theTimeBaseInfo;

    mach_timebase_info(&theTimeBaseInfo);

    Float64 theHostClockFrequency = theTimeBaseInfo.denom / theTimeBaseInfo.numer;

    theHostClockFrequency *= 1000000000.0;

    gDevice_HostTicksPerFrame = theHostClockFrequency / gDevice_SampleRate;

    //  unlock the state mutex

    pthread_mutex_unlock(&gPlugIn_StateMutex);

Done:

    return theAnswer;

}

static OSStatus NullAudio_AbortDeviceConfigurationChange(AudioServerPlugInDriverRef inDriver, AudioObjectID inDeviceObjectID, UInt64 inChangeAction, void* inChangeInfo)

{

    //  This method is called to tell the driver that a request for a config change has been denied.

    //  This provides the driver an opportunity to clean up any state associated with the request.

    //  For this driver, an aborted config change requires no action. So we just check the arguments

    //  and return

    #pragma unused(inChangeAction, inChangeInfo)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_PerformDeviceConfigurationChange: bad driver reference");

    FailWithAction(inDeviceObjectID != kObjectID_Device, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_PerformDeviceConfigurationChange: bad device ID");

Done:

    return theAnswer;

}

#pragma mark Property Operations

static Boolean  NullAudio_HasProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress)

{

    //  This method returns whether or not the given object has the given property.

    //  declare the local variables

    Boolean theAnswer = false;

    //  check the arguments

    FailIf(inDriver != gAudioServerPlugInDriverRef, Done, "NullAudio_HasProperty: bad driver reference");

    FailIf(inAddress == NULL, Done, "NullAudio_HasProperty: no address");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPropertyData() method.

    switch(inObjectID)

    {

        case kObjectID_PlugIn:

            theAnswer = NullAudio_HasPlugInProperty(inDriver, inObjectID, inClientProcessID, inAddress);

            break;

        case kObjectID_Box:

            theAnswer = NullAudio_HasBoxProperty(inDriver, inObjectID, inClientProcessID, inAddress);

            break;

        case kObjectID_Device:

            theAnswer = NullAudio_HasDeviceProperty(inDriver, inObjectID, inClientProcessID, inAddress);

            break;

        case kObjectID_Stream_Input:

        case kObjectID_Stream_Output:

            theAnswer = NullAudio_HasStreamProperty(inDriver, inObjectID, inClientProcessID, inAddress);

            break;

        case kObjectID_Volume_Input_Master:

        case kObjectID_Volume_Output_Master:

        case kObjectID_Mute_Input_Master:

        case kObjectID_Mute_Output_Master:

        case kObjectID_DataSource_Input_Master:

        case kObjectID_DataSource_Output_Master:

            theAnswer = NullAudio_HasControlProperty(inDriver, inObjectID, inClientProcessID, inAddress);

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_IsPropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable)

{

    //  This method returns whether or not the given property on the object can have its value

    //  changed.

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_IsPropertySettable: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_IsPropertySettable: no address");

    FailWithAction(outIsSettable == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_IsPropertySettable: no place to put the return value");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPropertyData() method.

    switch(inObjectID)

    {

        case kObjectID_PlugIn:

            theAnswer = NullAudio_IsPlugInPropertySettable(inDriver, inObjectID, inClientProcessID, inAddress, outIsSettable);

            break;

        case kObjectID_Box:

            theAnswer = NullAudio_IsBoxPropertySettable(inDriver, inObjectID, inClientProcessID, inAddress, outIsSettable);

            break;

        case kObjectID_Device:

            theAnswer = NullAudio_IsDevicePropertySettable(inDriver, inObjectID, inClientProcessID, inAddress, outIsSettable);

            break;

        case kObjectID_Stream_Input:

        case kObjectID_Stream_Output:

            theAnswer = NullAudio_IsStreamPropertySettable(inDriver, inObjectID, inClientProcessID, inAddress, outIsSettable);

            break;

        case kObjectID_Volume_Input_Master:

        case kObjectID_Volume_Output_Master:

        case kObjectID_Mute_Input_Master:

        case kObjectID_Mute_Output_Master:

        case kObjectID_DataSource_Input_Master:

        case kObjectID_DataSource_Output_Master:

            theAnswer = NullAudio_IsControlPropertySettable(inDriver, inObjectID, inClientProcessID, inAddress, outIsSettable);

            break;

        default:

            theAnswer = kAudioHardwareBadObjectError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_GetPropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize)

{

    //  This method returns the byte size of the property's data.

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetPropertyDataSize: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPropertyDataSize: no address");

    FailWithAction(outDataSize == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPropertyDataSize: no place to put the return value");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPropertyData() method.

    switch(inObjectID)

    {

        case kObjectID_PlugIn:

            theAnswer = NullAudio_GetPlugInPropertyDataSize(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, outDataSize);

            break;

        case kObjectID_Box:

            theAnswer = NullAudio_GetBoxPropertyDataSize(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, outDataSize);

            break;

        case kObjectID_Device:

            theAnswer = NullAudio_GetDevicePropertyDataSize(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, outDataSize);

            break;

        case kObjectID_Stream_Input:

        case kObjectID_Stream_Output:

            theAnswer = NullAudio_GetStreamPropertyDataSize(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, outDataSize);

            break;

        case kObjectID_Volume_Input_Master:

        case kObjectID_Volume_Output_Master:

        case kObjectID_Mute_Input_Master:

        case kObjectID_Mute_Output_Master:

        case kObjectID_DataSource_Input_Master:

        case kObjectID_DataSource_Output_Master:

            theAnswer = NullAudio_GetControlPropertyDataSize(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, outDataSize);

            break;

        default:

            theAnswer = kAudioHardwareBadObjectError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_GetPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData)

{

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetPropertyData: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPropertyData: no address");

    FailWithAction(outDataSize == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPropertyData: no place to put the return value size");

    FailWithAction(outData == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPropertyData: no place to put the return value");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required.

    //

    //  Also, since most of the data that will get returned is static, there are few instances where

    //  it is necessary to lock the state mutex.

    switch(inObjectID)

    {

        case kObjectID_PlugIn:

            theAnswer = NullAudio_GetPlugInPropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, outDataSize, outData);

            break;

        case kObjectID_Box:

            theAnswer = NullAudio_GetBoxPropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, outDataSize, outData);

            break;

        case kObjectID_Device:

            theAnswer = NullAudio_GetDevicePropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, outDataSize, outData);

            break;

        case kObjectID_Stream_Input:

        case kObjectID_Stream_Output:

            theAnswer = NullAudio_GetStreamPropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, outDataSize, outData);

            break;

        case kObjectID_Volume_Input_Master:

        case kObjectID_Volume_Output_Master:

        case kObjectID_Mute_Input_Master:

        case kObjectID_Mute_Output_Master:

        case kObjectID_DataSource_Input_Master:

        case kObjectID_DataSource_Output_Master:

            theAnswer = NullAudio_GetControlPropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, outDataSize, outData);

            break;

        default:

            theAnswer = kAudioHardwareBadObjectError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_SetPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData)

{

    //  declare the local variables

    OSStatus theAnswer = 0;

    UInt32 theNumberPropertiesChanged = 0;

    AudioObjectPropertyAddress theChangedAddresses[2];

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_SetPropertyData: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_SetPropertyData: no address");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPropertyData() method.

    switch(inObjectID)

    {

        case kObjectID_PlugIn:

            theAnswer = NullAudio_SetPlugInPropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, inData, &theNumberPropertiesChanged, theChangedAddresses);

            break;

        case kObjectID_Box:

            theAnswer = NullAudio_SetBoxPropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, inData, &theNumberPropertiesChanged, theChangedAddresses);

            break;

        case kObjectID_Device:

            theAnswer = NullAudio_SetDevicePropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, inData, &theNumberPropertiesChanged, theChangedAddresses);

            break;

        case kObjectID_Stream_Input:

        case kObjectID_Stream_Output:

            theAnswer = NullAudio_SetStreamPropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, inData, &theNumberPropertiesChanged, theChangedAddresses);

            break;

        case kObjectID_Volume_Input_Master:

        case kObjectID_Volume_Output_Master:

        case kObjectID_Mute_Input_Master:

        case kObjectID_Mute_Output_Master:

        case kObjectID_DataSource_Input_Master:

        case kObjectID_DataSource_Output_Master:

            theAnswer = NullAudio_SetControlPropertyData(inDriver, inObjectID, inClientProcessID, inAddress, inQualifierDataSize, inQualifierData, inDataSize, inData, &theNumberPropertiesChanged, theChangedAddresses);

            break;

        default:

            theAnswer = kAudioHardwareBadObjectError;

            break;

    };

    //  send any notifications

    if(theNumberPropertiesChanged > 0)

    {

        gPlugIn_Host->PropertiesChanged(gPlugIn_Host, inObjectID, theNumberPropertiesChanged, theChangedAddresses);

    }

Done:

    return theAnswer;

}

#pragma mark PlugIn Property Operations

static Boolean  NullAudio_HasPlugInProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress)

{

    //  This method returns whether or not the plug-in object has the given property.

    #pragma unused(inClientProcessID)

    //  declare the local variables

    Boolean theAnswer = false;

    //  check the arguments

    FailIf(inDriver != gAudioServerPlugInDriverRef, Done, "NullAudio_HasPlugInProperty: bad driver reference");

    FailIf(inAddress == NULL, Done, "NullAudio_HasPlugInProperty: no address");

    FailIf(inObjectID != kObjectID_PlugIn, Done, "NullAudio_HasPlugInProperty: not the plug-in object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPlugInPropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

        case kAudioObjectPropertyClass:

        case kAudioObjectPropertyOwner:

        case kAudioObjectPropertyManufacturer:

        case kAudioObjectPropertyOwnedObjects:

        case kAudioPlugInPropertyBoxList:

        case kAudioPlugInPropertyTranslateUIDToBox:

        case kAudioPlugInPropertyDeviceList:

        case kAudioPlugInPropertyTranslateUIDToDevice:

        case kAudioPlugInPropertyResourceBundle:

            theAnswer = true;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_IsPlugInPropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable)

{

    //  This method returns whether or not the given property on the plug-in object can have its

    //  value changed.

    #pragma unused(inClientProcessID)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_IsPlugInPropertySettable: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_IsPlugInPropertySettable: no address");

    FailWithAction(outIsSettable == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_IsPlugInPropertySettable: no place to put the return value");

    FailWithAction(inObjectID != kObjectID_PlugIn, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_IsPlugInPropertySettable: not the plug-in object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPlugInPropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

        case kAudioObjectPropertyClass:

        case kAudioObjectPropertyOwner:

        case kAudioObjectPropertyManufacturer:

        case kAudioObjectPropertyOwnedObjects:

        case kAudioPlugInPropertyBoxList:

        case kAudioPlugInPropertyTranslateUIDToBox:

        case kAudioPlugInPropertyDeviceList:

        case kAudioPlugInPropertyTranslateUIDToDevice:

        case kAudioPlugInPropertyResourceBundle:

            *outIsSettable = false;

            break;

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_GetPlugInPropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize)

{

    //  This method returns the byte size of the property's data.

    #pragma unused(inClientProcessID, inQualifierDataSize, inQualifierData)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetPlugInPropertyDataSize: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPlugInPropertyDataSize: no address");

    FailWithAction(outDataSize == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPlugInPropertyDataSize: no place to put the return value");

    FailWithAction(inObjectID != kObjectID_PlugIn, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetPlugInPropertyDataSize: not the plug-in object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPlugInPropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyClass:

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyOwner:

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioObjectPropertyManufacturer:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyOwnedObjects:

            if(gBox_Acquired)

            {

                *outDataSize = 2 * sizeof(AudioClassID);

            }

            else

            {

                *outDataSize = sizeof(AudioClassID);

            }

            break;

        case kAudioPlugInPropertyBoxList:

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioPlugInPropertyTranslateUIDToBox:

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioPlugInPropertyDeviceList:

            if(gBox_Acquired)

            {

                *outDataSize = sizeof(AudioClassID);

            }

            else

            {

                *outDataSize = 0;

            }

            break;

        case kAudioPlugInPropertyTranslateUIDToDevice:

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioPlugInPropertyResourceBundle:

            *outDataSize = sizeof(CFStringRef);

            break;

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_GetPlugInPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData)

{

    #pragma unused(inClientProcessID)

    //  declare the local variables

    OSStatus theAnswer = 0;

    UInt32 theNumberItemsToFetch;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetPlugInPropertyData: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPlugInPropertyData: no address");

    FailWithAction(outDataSize == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPlugInPropertyData: no place to put the return value size");

    FailWithAction(outData == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetPlugInPropertyData: no place to put the return value");

    FailWithAction(inObjectID != kObjectID_PlugIn, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetPlugInPropertyData: not the plug-in object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required.

    //

    //  Also, since most of the data that will get returned is static, there are few instances where

    //  it is necessary to lock the state mutex.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

            //  The base class for kAudioPlugInClassID is kAudioObjectClassID

            FailWithAction(inDataSize < sizeof(AudioClassID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: not enough space for the return value of kAudioObjectPropertyBaseClass for the plug-in");

            *((AudioClassID*)outData) = kAudioObjectClassID;

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyClass:

            //  The class is always kAudioPlugInClassID for regular drivers

            FailWithAction(inDataSize < sizeof(AudioClassID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: not enough space for the return value of kAudioObjectPropertyClass for the plug-in");

            *((AudioClassID*)outData) = kAudioPlugInClassID;

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyOwner:

            //  The plug-in doesn't have an owning object

            FailWithAction(inDataSize < sizeof(AudioObjectID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: not enough space for the return value of kAudioObjectPropertyOwner for the plug-in");

            *((AudioObjectID*)outData) = kAudioObjectUnknown;

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioObjectPropertyManufacturer:

            //  This is the human readable name of the maker of the plug-in.

            FailWithAction(inDataSize < sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: not enough space for the return value of kAudioObjectPropertyManufacturer for the plug-in");

            *((CFStringRef*)outData) = CFSTR("Apple Inc.");

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyOwnedObjects:

            //  Calculate the number of items that have been requested. Note that this

            //  number is allowed to be smaller than the actual size of the list. In such

            //  case, only that number of items will be returned

            theNumberItemsToFetch = inDataSize / sizeof(AudioObjectID);

            //  Clamp that to the number of boxes this driver implements (which is just 1)

            if(theNumberItemsToFetch > (gBox_Acquired ? 2 : 1))

            {

                theNumberItemsToFetch = (gBox_Acquired ? 2 : 1);

            }

            //  Write the devices' object IDs into the return value

            if(theNumberItemsToFetch > 1)

            {

                ((AudioObjectID*)outData)[0] = kObjectID_Box;

                ((AudioObjectID*)outData)[0] = kObjectID_Device;

            }

            else if(theNumberItemsToFetch > 0)

            {

                ((AudioObjectID*)outData)[0] = kObjectID_Box;

            }

            //  Return how many bytes we wrote to

            *outDataSize = theNumberItemsToFetch * sizeof(AudioClassID);

            break;

        case kAudioPlugInPropertyBoxList:

            //  Calculate the number of items that have been requested. Note that this

            //  number is allowed to be smaller than the actual size of the list. In such

            //  case, only that number of items will be returned

            theNumberItemsToFetch = inDataSize / sizeof(AudioObjectID);

            //  Clamp that to the number of boxes this driver implements (which is just 1)

            if(theNumberItemsToFetch > 1)

            {

                theNumberItemsToFetch = 1;

            }

            //  Write the devices' object IDs into the return value

            if(theNumberItemsToFetch > 0)

            {

                ((AudioObjectID*)outData)[0] = kObjectID_Box;

            }

            //  Return how many bytes we wrote to

            *outDataSize = theNumberItemsToFetch * sizeof(AudioClassID);

            break;

        case kAudioPlugInPropertyTranslateUIDToBox:

            //  This property takes the CFString passed in the qualifier and converts that

            //  to the object ID of the box it corresponds to. For this driver, there is

            //  just the one box. Note that it is not an error if the string in the

            //  qualifier doesn't match any devices. In such case, kAudioObjectUnknown is

            //  the object ID to return.

            FailWithAction(inDataSize < sizeof(AudioObjectID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: not enough space for the return value of kAudioPlugInPropertyTranslateUIDToBox");

            FailWithAction(inQualifierDataSize == sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: the qualifier is the wrong size for kAudioPlugInPropertyTranslateUIDToBox");

            FailWithAction(inQualifierData == NULL, theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: no qualifier for kAudioPlugInPropertyTranslateUIDToBox");

            if(CFStringCompare(*((CFStringRef*)inQualifierData), CFSTR(kBox_UID), 0) == kCFCompareEqualTo)

            {

                *((AudioObjectID*)outData) = kObjectID_Box;

            }

            else

            {

                *((AudioObjectID*)outData) = kAudioObjectUnknown;

            }

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioPlugInPropertyDeviceList:

            //  Calculate the number of items that have been requested. Note that this

            //  number is allowed to be smaller than the actual size of the list. In such

            //  case, only that number of items will be returned

            theNumberItemsToFetch = inDataSize / sizeof(AudioObjectID);

            //  Clamp that to the number of devices this driver implements (which is just 1 if the

            //  box has been acquired)

            if(theNumberItemsToFetch > (gBox_Acquired ? 1 : 0))

            {

                theNumberItemsToFetch = (gBox_Acquired ? 1 : 0);

            }

            //  Write the devices' object IDs into the return value

            if(theNumberItemsToFetch > 0)

            {

                ((AudioObjectID*)outData)[0] = kObjectID_Device;

            }

            //  Return how many bytes we wrote to

            *outDataSize = theNumberItemsToFetch * sizeof(AudioClassID);

            break;

        case kAudioPlugInPropertyTranslateUIDToDevice:

            //  This property takes the CFString passed in the qualifier and converts that

            //  to the object ID of the device it corresponds to. For this driver, there is

            //  just the one device. Note that it is not an error if the string in the

            //  qualifier doesn't match any devices. In such case, kAudioObjectUnknown is

            //  the object ID to return.

            FailWithAction(inDataSize < sizeof(AudioObjectID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: not enough space for the return value of kAudioPlugInPropertyTranslateUIDToDevice");

            FailWithAction(inQualifierDataSize == sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: the qualifier is the wrong size for kAudioPlugInPropertyTranslateUIDToDevice");

            FailWithAction(inQualifierData == NULL, theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: no qualifier for kAudioPlugInPropertyTranslateUIDToDevice");

            if(CFStringCompare(*((CFStringRef*)inQualifierData), CFSTR(kDevice_UID), 0) == kCFCompareEqualTo)

            {

                *((AudioObjectID*)outData) = kObjectID_Device;

            }

            else

            {

                *((AudioObjectID*)outData) = kAudioObjectUnknown;

            }

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioPlugInPropertyResourceBundle:

            //  The resource bundle is a path relative to the path of the plug-in's bundle.

            //  To specify that the plug-in bundle itself should be used, we just return the

            //  empty string.

            FailWithAction(inDataSize < sizeof(AudioObjectID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetPlugInPropertyData: not enough space for the return value of kAudioPlugInPropertyResourceBundle");

            *((CFStringRef*)outData) = CFSTR("");

            *outDataSize = sizeof(CFStringRef);

            break;

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_SetPlugInPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData, UInt32* outNumberPropertiesChanged, AudioObjectPropertyAddress outChangedAddresses[2])

{

    #pragma unused(inClientProcessID, inQualifierDataSize, inQualifierData, inDataSize, inData)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_SetPlugInPropertyData: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_SetPlugInPropertyData: no address");

    FailWithAction(outNumberPropertiesChanged == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_SetPlugInPropertyData: no place to return the number of properties that changed");

    FailWithAction(outChangedAddresses == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_SetPlugInPropertyData: no place to return the properties that changed");

    FailWithAction(inObjectID != kObjectID_PlugIn, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_SetPlugInPropertyData: not the plug-in object");

    //  initialize the returned number of changed properties

    *outNumberPropertiesChanged = 0;

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPlugInPropertyData() method.

    switch(inAddress->mSelector)

    {

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

#pragma mark Box Property Operations

static Boolean  NullAudio_HasBoxProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress)

{

    //  This method returns whether or not the box object has the given property.

    #pragma unused(inClientProcessID)

    //  declare the local variables

    Boolean theAnswer = false;

    //  check the arguments

    FailIf(inDriver != gAudioServerPlugInDriverRef, Done, "NullAudio_HasBoxProperty: bad driver reference");

    FailIf(inAddress == NULL, Done, "NullAudio_HasBoxProperty: no address");

    FailIf(inObjectID != kObjectID_Box, Done, "NullAudio_HasBoxProperty: not the box object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetBoxPropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

        case kAudioObjectPropertyClass:

        case kAudioObjectPropertyOwner:

        case kAudioObjectPropertyName:

        case kAudioObjectPropertyModelName:

        case kAudioObjectPropertyManufacturer:

        case kAudioObjectPropertyOwnedObjects:

        case kAudioObjectPropertyIdentify:

        case kAudioObjectPropertySerialNumber:

        case kAudioObjectPropertyFirmwareVersion:

        case kAudioBoxPropertyBoxUID:

        case kAudioBoxPropertyTransportType:

        case kAudioBoxPropertyHasAudio:

        case kAudioBoxPropertyHasVideo:

        case kAudioBoxPropertyHasMIDI:

        case kAudioBoxPropertyIsProtected:

        case kAudioBoxPropertyAcquired:

        case kAudioBoxPropertyAcquisitionFailed:

        case kAudioBoxPropertyDeviceList:

            theAnswer = true;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_IsBoxPropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable)

{

    //  This method returns whether or not the given property on the plug-in object can have its

    //  value changed.

    #pragma unused(inClientProcessID)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_IsBoxPropertySettable: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_IsBoxPropertySettable: no address");

    FailWithAction(outIsSettable == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_IsBoxPropertySettable: no place to put the return value");

    FailWithAction(inObjectID != kObjectID_Box, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_IsBoxPropertySettable: not the plug-in object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetBoxPropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

        case kAudioObjectPropertyClass:

        case kAudioObjectPropertyOwner:

        case kAudioObjectPropertyModelName:

        case kAudioObjectPropertyManufacturer:

        case kAudioObjectPropertyOwnedObjects:

        case kAudioObjectPropertySerialNumber:

        case kAudioObjectPropertyFirmwareVersion:

        case kAudioBoxPropertyBoxUID:

        case kAudioBoxPropertyTransportType:

        case kAudioBoxPropertyHasAudio:

        case kAudioBoxPropertyHasVideo:

        case kAudioBoxPropertyHasMIDI:

        case kAudioBoxPropertyIsProtected:

        case kAudioBoxPropertyAcquisitionFailed:

        case kAudioBoxPropertyDeviceList:

            *outIsSettable = false;

            break;

        case kAudioObjectPropertyName:

        case kAudioObjectPropertyIdentify:

        case kAudioBoxPropertyAcquired:

            *outIsSettable = true;

            break;

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_GetBoxPropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize)

{

    //  This method returns the byte size of the property's data.

    #pragma unused(inClientProcessID, inQualifierDataSize, inQualifierData)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetBoxPropertyDataSize: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetBoxPropertyDataSize: no address");

    FailWithAction(outDataSize == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetBoxPropertyDataSize: no place to put the return value");

    FailWithAction(inObjectID != kObjectID_Box, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetBoxPropertyDataSize: not the plug-in object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetBoxPropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyClass:

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyOwner:

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioObjectPropertyName:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyModelName:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyManufacturer:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyOwnedObjects:

            *outDataSize = 0;

            break;

        case kAudioObjectPropertyIdentify:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioObjectPropertySerialNumber:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyFirmwareVersion:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioBoxPropertyBoxUID:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioBoxPropertyTransportType:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyHasAudio:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyHasVideo:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyHasMIDI:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyIsProtected:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyAcquired:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyAcquisitionFailed:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyDeviceList:

            {

                pthread_mutex_lock(&gPlugIn_StateMutex);

                *outDataSize = gBox_Acquired ? sizeof(AudioObjectID) : 0;

                pthread_mutex_unlock(&gPlugIn_StateMutex);

            }

            break;

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_GetBoxPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, UInt32* outDataSize, void* outData)

{

    #pragma unused(inClientProcessID, inQualifierDataSize, inQualifierData)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetBoxPropertyData: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetBoxPropertyData: no address");

    FailWithAction(outDataSize == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetBoxPropertyData: no place to put the return value size");

    FailWithAction(outData == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetBoxPropertyData: no place to put the return value");

    FailWithAction(inObjectID != kObjectID_Box, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetBoxPropertyData: not the plug-in object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required.

    //

    //  Also, since most of the data that will get returned is static, there are few instances where

    //  it is necessary to lock the state mutex.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

            //  The base class for kAudioBoxClassID is kAudioObjectClassID

            FailWithAction(inDataSize < sizeof(AudioClassID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyBaseClass for the box");

            *((AudioClassID*)outData) = kAudioObjectClassID;

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyClass:

            //  The class is always kAudioBoxClassID for regular drivers

            FailWithAction(inDataSize < sizeof(AudioClassID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyClass for the box");

            *((AudioClassID*)outData) = kAudioBoxClassID;

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyOwner:

            //  The owner is the plug-in object

            FailWithAction(inDataSize < sizeof(AudioObjectID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyOwner for the box");

            *((AudioObjectID*)outData) = kObjectID_PlugIn;

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioObjectPropertyName:

            //  This is the human readable name of the maker of the box.

            FailWithAction(inDataSize < sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyManufacturer for the box");

            pthread_mutex_lock(&gPlugIn_StateMutex);

            *((CFStringRef*)outData) = gBox_Name;

            pthread_mutex_unlock(&gPlugIn_StateMutex);

            if(*((CFStringRef*)outData) != NULL)

            {

                CFRetain(*((CFStringRef*)outData));

            }

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyModelName:

            //  This is the human readable name of the maker of the box.

            FailWithAction(inDataSize < sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyManufacturer for the box");

            *((CFStringRef*)outData) = CFSTR("Null Model");

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyManufacturer:

            //  This is the human readable name of the maker of the box.

            FailWithAction(inDataSize < sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyManufacturer for the box");

            *((CFStringRef*)outData) = CFSTR("Apple Inc.");

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyOwnedObjects:

            //  This returns the objects directly owned by the object. Boxes don't own anything.

            *outDataSize = 0;

            break;

        case kAudioObjectPropertyIdentify:

            //  This is used to highling the device in the UI, but it's value has no meaning

            FailWithAction(inDataSize < sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyIdentify for the box");

            *((UInt32*)outData) = 0;

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioObjectPropertySerialNumber:

            //  This is the human readable serial number of the box.

            FailWithAction(inDataSize < sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertySerialNumber for the box");

            *((CFStringRef*)outData) = CFSTR("00000001");

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyFirmwareVersion:

            //  This is the human readable firmware version of the box.

            FailWithAction(inDataSize < sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyFirmwareVersion for the box");

            *((CFStringRef*)outData) = CFSTR("1.0");

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioBoxPropertyBoxUID:

            //  Boxes have UIDs the same as devices

            FailWithAction(inDataSize < sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioObjectPropertyManufacturer for the box");

            *((CFStringRef*)outData) = CFSTR(kBox_UID);

            break;

        case kAudioBoxPropertyTransportType:

            //  This value represents how the device is attached to the system. This can be

            //  any 32 bit integer, but common values for this property are defined in

            //  <CoreAudio/AudioHardwareBase.h>

            FailWithAction(inDataSize < sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioDevicePropertyTransportType for the box");

            *((UInt32*)outData) = kAudioDeviceTransportTypeVirtual;

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyHasAudio:

            //  Indicates whether or not the box has audio capabilities

            FailWithAction(inDataSize < sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioBoxPropertyHasAudio for the box");

            *((UInt32*)outData) = 1;

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyHasVideo:

            //  Indicates whether or not the box has video capabilities

            FailWithAction(inDataSize < sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioBoxPropertyHasVideo for the box");

            *((UInt32*)outData) = 0;

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyHasMIDI:

            //  Indicates whether or not the box has MIDI capabilities

            FailWithAction(inDataSize < sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioBoxPropertyHasMIDI for the box");

            *((UInt32*)outData) = 0;

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyIsProtected:

            //  Indicates whether or not the box has requires authentication to use

            FailWithAction(inDataSize < sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioBoxPropertyIsProtected for the box");

            *((UInt32*)outData) = 0;

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyAcquired:

            //  When set to a non-zero value, the device is acquired for use by the local machine

            FailWithAction(inDataSize < sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioBoxPropertyAcquired for the box");

            pthread_mutex_lock(&gPlugIn_StateMutex);

            *((UInt32*)outData) = gBox_Acquired ? 1 : 0;

            pthread_mutex_unlock(&gPlugIn_StateMutex);

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyAcquisitionFailed:

            //  This is used for notifications to say when an attempt to acquire a device has failed.

            FailWithAction(inDataSize < sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioBoxPropertyAcquisitionFailed for the box");

            *((UInt32*)outData) = 0;

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioBoxPropertyDeviceList:

            //  This is used to indicate which devices came from this box

            pthread_mutex_lock(&gPlugIn_StateMutex);

            if(gBox_Acquired)

            {

                FailWithAction(inDataSize < sizeof(AudioObjectID), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_GetBoxPropertyData: not enough space for the return value of kAudioBoxPropertyDeviceList for the box");

                *((AudioObjectID*)outData) = kObjectID_Device;

                *outDataSize = sizeof(AudioObjectID);

            }

            else

            {

                *outDataSize = 0;

            }

            pthread_mutex_unlock(&gPlugIn_StateMutex);

            break;

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_SetBoxPropertyData(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData, UInt32* outNumberPropertiesChanged, AudioObjectPropertyAddress outChangedAddresses[2])

{

    #pragma unused(inClientProcessID, inQualifierDataSize, inQualifierData, inDataSize, inData)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_SetBoxPropertyData: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_SetBoxPropertyData: no address");

    FailWithAction(outNumberPropertiesChanged == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_SetBoxPropertyData: no place to return the number of properties that changed");

    FailWithAction(outChangedAddresses == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_SetBoxPropertyData: no place to return the properties that changed");

    FailWithAction(inObjectID != kObjectID_Box, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_SetBoxPropertyData: not the box object");

    //  initialize the returned number of changed properties

    *outNumberPropertiesChanged = 0;

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetPlugInPropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyName:

            //  Boxes should allow their name to be editable

            {

                FailWithAction(inDataSize != sizeof(CFStringRef), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_SetBoxPropertyData: wrong size for the data for kAudioObjectPropertyName");

                CFStringRef* theNewName = (CFStringRef*)inData;

                pthread_mutex_lock(&gPlugIn_StateMutex);

                if((theNewName != NULL) && (*theNewName != NULL))

                {

                    CFRetain(*theNewName);

                }

                if(gBox_Name != NULL)

                {

                    CFRelease(gBox_Name);

                }

                gBox_Name = *theNewName;

                pthread_mutex_unlock(&gPlugIn_StateMutex);

                *outNumberPropertiesChanged = 1;

                outChangedAddresses[0].mSelector = kAudioObjectPropertyName;

                outChangedAddresses[0].mScope = kAudioObjectPropertyScopeGlobal;

                outChangedAddresses[0].mElement = kAudioObjectPropertyElementMaster;

            }

            break;

        case kAudioObjectPropertyIdentify:

            //  since we don't have any actual hardware to flash, we will schedule a notificaiton for

            //  this property off into the future as a testing thing. Note that a real implementation

            //  of this property should only send the notificaiton if the hardware wants the app to

            //  flash it's UI for the device.

            {

                syslog(LOG_NOTICE, "The identify property has been set on the Box implemented by the NullAudio driver.");

                FailWithAction(inDataSize != sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_SetBoxPropertyData: wrong size for the data for kAudioObjectPropertyIdentify");

                dispatch_after(dispatch_time(0, 2ULL * 1000ULL * 1000ULL * 1000ULL), dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^()

                                                                                                                                        {

                                                                                                                                            AudioObjectPropertyAddress theAddress = { kAudioObjectPropertyIdentify, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };

                                                                                                                                            gPlugIn_Host->PropertiesChanged(gPlugIn_Host, kObjectID_Box, 1, &theAddress);

                                                                                                                                        });

            }

            break;

        case kAudioBoxPropertyAcquired:

            //  When the box is acquired, it means the contents, namely the device, are available to the system

            {

                FailWithAction(inDataSize != sizeof(UInt32), theAnswer = kAudioHardwareBadPropertySizeError, Done, "NullAudio_SetBoxPropertyData: wrong size for the data for kAudioBoxPropertyAcquired");

                pthread_mutex_lock(&gPlugIn_StateMutex);

                if(gBox_Acquired != (*((UInt32*)inData) != 0))

                {

                    //  the new value is different from the old value, so save it

                    gBox_Acquired = *((UInt32*)inData) != 0;

                    gPlugIn_Host->WriteToStorage(gPlugIn_Host, CFSTR("box acquired"), gBox_Acquired ? kCFBooleanTrue : kCFBooleanFalse);

                    //  and it means that this property and the device list property have changed

                    *outNumberPropertiesChanged = 2;

                    outChangedAddresses[0].mSelector = kAudioBoxPropertyAcquired;

                    outChangedAddresses[0].mScope = kAudioObjectPropertyScopeGlobal;

                    outChangedAddresses[0].mElement = kAudioObjectPropertyElementMaster;

                    outChangedAddresses[1].mSelector = kAudioBoxPropertyDeviceList;

                    outChangedAddresses[1].mScope = kAudioObjectPropertyScopeGlobal;

                    outChangedAddresses[1].mElement = kAudioObjectPropertyElementMaster;

                    //  but it also means that the device list has changed for the plug-in too

                    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),   ^()

                                                                                                    {

                                                                                                        AudioObjectPropertyAddress theAddress = { kAudioPlugInPropertyDeviceList, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };

                                                                                                        gPlugIn_Host->PropertiesChanged(gPlugIn_Host, kObjectID_PlugIn, 1, &theAddress);

                                                                                                    });

                }

                pthread_mutex_unlock(&gPlugIn_StateMutex);

            }

            break;

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

#pragma mark Device Property Operations

static Boolean  NullAudio_HasDeviceProperty(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress)

{

    //  This method returns whether or not the given object has the given property.

    #pragma unused(inClientProcessID)

    //  declare the local variables

    Boolean theAnswer = false;

    //  check the arguments

    FailIf(inDriver != gAudioServerPlugInDriverRef, Done, "NullAudio_HasDeviceProperty: bad driver reference");

    FailIf(inAddress == NULL, Done, "NullAudio_HasDeviceProperty: no address");

    FailIf(inObjectID != kObjectID_Device, Done, "NullAudio_HasDeviceProperty: not the device object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetDevicePropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

        case kAudioObjectPropertyClass:

        case kAudioObjectPropertyOwner:

        case kAudioObjectPropertyName:

        case kAudioObjectPropertyManufacturer:

        case kAudioObjectPropertyOwnedObjects:

        case kAudioDevicePropertyDeviceUID:

        case kAudioDevicePropertyModelUID:

        case kAudioDevicePropertyTransportType:

        case kAudioDevicePropertyRelatedDevices:

        case kAudioDevicePropertyClockDomain:

        case kAudioDevicePropertyDeviceIsAlive:

        case kAudioDevicePropertyDeviceIsRunning:

        case kAudioObjectPropertyControlList:

        case kAudioDevicePropertyNominalSampleRate:

        case kAudioDevicePropertyAvailableNominalSampleRates:

        case kAudioDevicePropertyIsHidden:

        case kAudioDevicePropertyZeroTimeStampPeriod:

        case kAudioDevicePropertyIcon:

        case kAudioDevicePropertyStreams:

            theAnswer = true;

            break;

        case kAudioDevicePropertyDeviceCanBeDefaultDevice:

        case kAudioDevicePropertyDeviceCanBeDefaultSystemDevice:

        case kAudioDevicePropertyLatency:

        case kAudioDevicePropertySafetyOffset:

        case kAudioDevicePropertyPreferredChannelsForStereo:

        case kAudioDevicePropertyPreferredChannelLayout:

            theAnswer = (inAddress->mScope == kAudioObjectPropertyScopeInput) || (inAddress->mScope == kAudioObjectPropertyScopeOutput);

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_IsDevicePropertySettable(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, Boolean* outIsSettable)

{

    //  This method returns whether or not the given property on the object can have its value

    //  changed.

    #pragma unused(inClientProcessID)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_IsDevicePropertySettable: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_IsDevicePropertySettable: no address");

    FailWithAction(outIsSettable == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_IsDevicePropertySettable: no place to put the return value");

    FailWithAction(inObjectID != kObjectID_Device, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_IsDevicePropertySettable: not the device object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetDevicePropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

        case kAudioObjectPropertyClass:

        case kAudioObjectPropertyOwner:

        case kAudioObjectPropertyName:

        case kAudioObjectPropertyManufacturer:

        case kAudioObjectPropertyOwnedObjects:

        case kAudioDevicePropertyDeviceUID:

        case kAudioDevicePropertyModelUID:

        case kAudioDevicePropertyTransportType:

        case kAudioDevicePropertyRelatedDevices:

        case kAudioDevicePropertyClockDomain:

        case kAudioDevicePropertyDeviceIsAlive:

        case kAudioDevicePropertyDeviceIsRunning:

        case kAudioDevicePropertyDeviceCanBeDefaultDevice:

        case kAudioDevicePropertyDeviceCanBeDefaultSystemDevice:

        case kAudioDevicePropertyLatency:

        case kAudioDevicePropertyStreams:

        case kAudioObjectPropertyControlList:

        case kAudioDevicePropertySafetyOffset:

        case kAudioDevicePropertyAvailableNominalSampleRates:

        case kAudioDevicePropertyIsHidden:

        case kAudioDevicePropertyPreferredChannelsForStereo:

        case kAudioDevicePropertyPreferredChannelLayout:

        case kAudioDevicePropertyZeroTimeStampPeriod:

        case kAudioDevicePropertyIcon:

            *outIsSettable = false;

            break;

        case kAudioDevicePropertyNominalSampleRate:

            *outIsSettable = true;

            break;

        default:

            theAnswer = kAudioHardwareUnknownPropertyError;

            break;

    };

Done:

    return theAnswer;

}

static OSStatus NullAudio_GetDevicePropertyDataSize(AudioServerPlugInDriverRef inDriver, AudioObjectID inObjectID, pid_t inClientProcessID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize)

{

    //  This method returns the byte size of the property's data.

    #pragma unused(inClientProcessID, inQualifierDataSize, inQualifierData)

    //  declare the local variables

    OSStatus theAnswer = 0;

    //  check the arguments

    FailWithAction(inDriver != gAudioServerPlugInDriverRef, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetDevicePropertyDataSize: bad driver reference");

    FailWithAction(inAddress == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetDevicePropertyDataSize: no address");

    FailWithAction(outDataSize == NULL, theAnswer = kAudioHardwareIllegalOperationError, Done, "NullAudio_GetDevicePropertyDataSize: no place to put the return value");

    FailWithAction(inObjectID != kObjectID_Device, theAnswer = kAudioHardwareBadObjectError, Done, "NullAudio_GetDevicePropertyDataSize: not the device object");

    //  Note that for each object, this driver implements all the required properties plus a few

    //  extras that are useful but not required. There is more detailed commentary about each

    //  property in the NullAudio_GetDevicePropertyData() method.

    switch(inAddress->mSelector)

    {

        case kAudioObjectPropertyBaseClass:

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyClass:

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioObjectPropertyOwner:

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioObjectPropertyName:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyManufacturer:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioObjectPropertyOwnedObjects:

            switch(inAddress->mScope)

            {

                case kAudioObjectPropertyScopeGlobal:

                    *outDataSize = 8 * sizeof(AudioObjectID);

                    break;

                case kAudioObjectPropertyScopeInput:

                    *outDataSize = 4 * sizeof(AudioObjectID);

                    break;

                case kAudioObjectPropertyScopeOutput:

                    *outDataSize = 4 * sizeof(AudioObjectID);

                    break;

            };

            break;

        case kAudioDevicePropertyDeviceUID:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioDevicePropertyModelUID:

            *outDataSize = sizeof(CFStringRef);

            break;

        case kAudioDevicePropertyTransportType:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioDevicePropertyRelatedDevices:

            *outDataSize = sizeof(AudioObjectID);

            break;

        case kAudioDevicePropertyClockDomain:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioDevicePropertyDeviceIsAlive:

            *outDataSize = sizeof(AudioClassID);

            break;

        case kAudioDevicePropertyDeviceIsRunning:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioDevicePropertyDeviceCanBeDefaultDevice:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioDevicePropertyDeviceCanBeDefaultSystemDevice:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioDevicePropertyLatency:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioDevicePropertyStreams:

            switch(inAddress->mScope)

            {

                case kAudioObjectPropertyScopeGlobal:

                    *outDataSize = 2 * sizeof(AudioObjectID);

                    break;

                case kAudioObjectPropertyScopeInput:

                    *outDataSize = 1 * sizeof(AudioObjectID);

                    break;

                case kAudioObjectPropertyScopeOutput:

                    *outDataSize = 1 * sizeof(AudioObjectID);

                    break;

            };

            break;

        case kAudioObjectPropertyControlList:

            *outDataSize = 6 * sizeof(AudioObjectID);

            break;

        case kAudioDevicePropertySafetyOffset:

            *outDataSize = sizeof(UInt32);

            break;

        case kAudioDevicePropertyNominalSampleRate:

            *outDataSize = sizeof(Float64);