SV platform dependency builds

/*

 * Implementation of the PortAudio API for Apple AUHAL

 *

 * PortAudio Portable Real-Time Audio Library

 * Latest Version at: http://www.portaudio.com

 *

 * Written by Bjorn Roche of XO Audio LLC, from PA skeleton code.

 * Portions copied from code by Dominic Mazzoni (who wrote a HAL implementation)

 *

 * Dominic's code was based on code by Phil Burk, Darren Gibbs,

 * Gord Peters, Stephane Letz, and Greg Pfiel.

 *

 * The following people also deserve acknowledgements:

 *

 * Olivier Tristan for feedback and testing

 * Glenn Zelniker and Z-Systems engineering for sponsoring the Blocking I/O

 * interface.

 * 

 *

 * Based on the Open Source API proposed by Ross Bencina

 * Copyright (c) 1999-2002 Ross Bencina, Phil Burk

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files

 * (the "Software"), to deal in the Software without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Software,

 * and to permit persons to whom the Software is furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR

 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

/*

 * The text above constitutes the entire PortAudio license; however, 

 * the PortAudio community also makes the following non-binding requests:

 *

 * Any person wishing to distribute modifications to the Software is

 * requested to send the modifications to the original developer so that

 * they can be incorporated into the canonical version. It is also 

 * requested that these non-binding requests be included along with the 

 * license above.

 */

/**

 @file pa_mac_core

 @ingroup hostapi_src

 @author Bjorn Roche

 @brief AUHAL implementation of PortAudio

*/

/* FIXME: not all error conditions call PaUtil_SetLastHostErrorInfo()

 * PaMacCore_SetError() will do this.

 */

#include "pa_mac_core_internal.h"

#include <string.h> /* strlen(), memcmp() etc. */

#include <libkern/OSAtomic.h>

#include "pa_mac_core.h"

#include "pa_mac_core_utilities.h"

#include "pa_mac_core_blocking.h"

#ifdef __cplusplus

extern "C"

{

#endif /* __cplusplus */

/* This is a reasonable size for a small buffer based on experience. */

#define PA_MAC_SMALL_BUFFER_SIZE    (64)

/* prototypes for functions declared in this file */

PaError PaMacCore_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index );

/*

 * Function declared in pa_mac_core.h. Sets up a PaMacCoreStreamInfoStruct

 * with the requested flags and initializes channel map.

 */

void PaMacCore_SetupStreamInfo(  PaMacCoreStreamInfo *data, const unsigned long flags )

{

   bzero( data, sizeof( PaMacCoreStreamInfo ) );

   data->size = sizeof( PaMacCoreStreamInfo );

   data->hostApiType = paCoreAudio;

   data->version = 0x01;

   data->flags = flags;

   data->channelMap = NULL;

   data->channelMapSize = 0;

}

/*

 * Function declared in pa_mac_core.h. Adds channel mapping to a PaMacCoreStreamInfoStruct

 */

void PaMacCore_SetupChannelMap( PaMacCoreStreamInfo *data, const SInt32 * const channelMap, const unsigned long channelMapSize )

{

   data->channelMap = channelMap;

   data->channelMapSize = channelMapSize;

}

static char *channelName = NULL;

static int channelNameSize = 0;

static bool ensureChannelNameSize( int size )

{

   if( size >= channelNameSize ) {

      free( channelName );

      channelName = (char *) malloc( ( channelNameSize = size ) + 1 );

      if( !channelName ) {

         channelNameSize = 0;

         return false;

      }

   }

   return true;

}

/*

 * Function declared in pa_mac_core.h. retrives channel names.

 */

const char *PaMacCore_GetChannelName( int device, int channelIndex, bool input )

{

        struct PaUtilHostApiRepresentation *hostApi;

        PaError err;

        OSStatus error;

        err = PaUtil_GetHostApiRepresentation( &hostApi, paCoreAudio );

        assert(err == paNoError);

        if( err != paNoError )

                return NULL;

        PaMacAUHAL *macCoreHostApi = (PaMacAUHAL*)hostApi;

        AudioDeviceID hostApiDevice = macCoreHostApi->devIds[device];

        CFStringRef nameRef;

        /* First try with CFString */

        UInt32 size = sizeof(nameRef);

        error = AudioDeviceGetProperty( hostApiDevice,

                                                                   channelIndex + 1,

                                                                   input,

                                                                   kAudioDevicePropertyChannelNameCFString,

                                                                   &size,

                                                                   &nameRef );

        if( error )

        {

                /* try the C String */

                size = 0;

                error = AudioDeviceGetPropertyInfo( hostApiDevice,

                                                                                   channelIndex + 1,

                                                                                   input,

                                                                                   kAudioDevicePropertyChannelName,

                                                                                   &size,

                                                                                   NULL);

                if( !error )

                {

                        if( !ensureChannelNameSize( size ) )

                                return NULL;

                        error = AudioDeviceGetProperty( hostApiDevice,

                                                                                   channelIndex + 1,

                                                                                   input,

                                                                                   kAudioDevicePropertyChannelName,

                                                                                   &size,

                                                                                   channelName );

                        if( !error )

                                return channelName;

                }

                /* as a last-ditch effort, we use the device name and append the channel number. */

                nameRef = CFStringCreateWithFormat( NULL, NULL, CFSTR( "%s: %d"), hostApi->deviceInfos[device]->name, channelIndex + 1 );

                size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(nameRef), kCFStringEncodingUTF8);;

                if( !ensureChannelNameSize( size ) )

                {

                        CFRelease( nameRef );

                        return NULL;

                }

                CFStringGetCString( nameRef, channelName, size+1, kCFStringEncodingUTF8 );

                CFRelease( nameRef );

        }

        else

        {

                size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(nameRef), kCFStringEncodingUTF8);;

                if( !ensureChannelNameSize( size ) )

                {

                        CFRelease( nameRef );

                        return NULL;

                }

                CFStringGetCString( nameRef, channelName, size+1, kCFStringEncodingUTF8 );

                CFRelease( nameRef );

        }

        return channelName;

}

PaError PaMacCore_GetBufferSizeRange( PaDeviceIndex device,

                                      long *minBufferSizeFrames, long *maxBufferSizeFrames )

{

    PaError result;

    PaUtilHostApiRepresentation *hostApi;

    result = PaUtil_GetHostApiRepresentation( &hostApi, paCoreAudio );

    if( result == paNoError )

    {

        PaDeviceIndex hostApiDeviceIndex;

        result = PaUtil_DeviceIndexToHostApiDeviceIndex( &hostApiDeviceIndex, device, hostApi );

        if( result == paNoError )

        {

            PaMacAUHAL *macCoreHostApi = (PaMacAUHAL*)hostApi;

            AudioDeviceID macCoreDeviceId = macCoreHostApi->devIds[hostApiDeviceIndex];

            AudioValueRange audioRange;

            UInt32 propSize = sizeof( audioRange );

            // return the size range for the output scope unless we only have inputs

            Boolean isInput = 0;

            if( macCoreHostApi->inheritedHostApiRep.deviceInfos[hostApiDeviceIndex]->maxOutputChannels == 0 )

                isInput = 1;

            result = WARNING(AudioDeviceGetProperty( macCoreDeviceId, 0, isInput, kAudioDevicePropertyBufferFrameSizeRange, &propSize, &audioRange ) );

            *minBufferSizeFrames = audioRange.mMinimum;

            *maxBufferSizeFrames = audioRange.mMaximum;

        }

    }

    return result;

}

AudioDeviceID PaMacCore_GetStreamInputDevice( PaStream* s )

{

    PaMacCoreStream *stream = (PaMacCoreStream*)s;

    VVDBUG(("PaMacCore_GetStreamInputHandle()\n"));

    return ( stream->inputDevice );

}

AudioDeviceID PaMacCore_GetStreamOutputDevice( PaStream* s )

{

    PaMacCoreStream *stream = (PaMacCoreStream*)s;

    VVDBUG(("PaMacCore_GetStreamOutputHandle()\n"));

    return ( stream->outputDevice );

}

#ifdef __cplusplus

}

#endif /* __cplusplus */

#define RING_BUFFER_ADVANCE_DENOMINATOR (4)

static void Terminate( struct PaUtilHostApiRepresentation *hostApi );

static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,

                                  const PaStreamParameters *inputParameters,

                                  const PaStreamParameters *outputParameters,

                                  double sampleRate );

static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

                           PaStream** s,

                           const PaStreamParameters *inputParameters,

                           const PaStreamParameters *outputParameters,

                           double sampleRate,

                           unsigned long framesPerBuffer,

                           PaStreamFlags streamFlags,

                           PaStreamCallback *streamCallback,

                           void *userData );

static PaError CloseStream( PaStream* stream );

static PaError StartStream( PaStream *stream );

static PaError StopStream( PaStream *stream );

static PaError AbortStream( PaStream *stream );

static PaError IsStreamStopped( PaStream *s );

static PaError IsStreamActive( PaStream *stream );

static PaTime GetStreamTime( PaStream *stream );

static OSStatus AudioIOProc( void *inRefCon,

                               AudioUnitRenderActionFlags *ioActionFlags,

                               const AudioTimeStamp *inTimeStamp,

                               UInt32 inBusNumber,

                               UInt32 inNumberFrames,

                               AudioBufferList *ioData );

static double GetStreamCpuLoad( PaStream* stream );

static PaError GetChannelInfo( PaMacAUHAL *auhalHostApi,

                               PaDeviceInfo *deviceInfo,

                               AudioDeviceID macCoreDeviceId,

                               int isInput);

static PaError OpenAndSetupOneAudioUnit(

                                   const PaMacCoreStream *stream,

                                   const PaStreamParameters *inStreamParams,

                                   const PaStreamParameters *outStreamParams,

                                   const UInt32 requestedFramesPerBuffer,

                                   UInt32 *actualInputFramesPerBuffer,

                                   UInt32 *actualOutputFramesPerBuffer,

                                   const PaMacAUHAL *auhalHostApi,

#ifndef AUDIO_COMPONENT_FIX

                                   AudioUnit *audioUnit,

#else

                                   AudioComponentInstance *audioUnit,

#endif

                                   AudioConverterRef *srConverter,

                                   AudioDeviceID *audioDevice,

                                   const double sampleRate,

                                   void *refCon );

/* for setting errors. */

#define PA_AUHAL_SET_LAST_HOST_ERROR( errorCode, errorText ) \

    PaUtil_SetLastHostErrorInfo( paCoreAudio, errorCode, errorText )

/*

 * Callback called when starting or stopping a stream.

 */

static void startStopCallback(

   void *               inRefCon,

#ifndef AUDIO_COMPONENT_FIX

   AudioUnit            ci,

#else

   AudioComponentInstance            ci,

#endif

   AudioUnitPropertyID  inID,

   AudioUnitScope       inScope,

   AudioUnitElement     inElement )

{

   PaMacCoreStream *stream = (PaMacCoreStream *) inRefCon;

   UInt32 isRunning;

   UInt32 size = sizeof( isRunning );

   OSStatus err;

   err = AudioUnitGetProperty( ci, kAudioOutputUnitProperty_IsRunning, inScope, inElement, &isRunning, &size );

   assert( !err );

   if( err )

      isRunning = false; //it's very unclear what to do in case of error here. There's no real way to notify the user, and crashing seems unreasonable.

   if( isRunning )

      return; //We are only interested in when we are stopping

   // -- if we are using 2 I/O units, we only need one notification!

   if( stream->inputUnit && stream->outputUnit && stream->inputUnit != stream->outputUnit && ci == stream->inputUnit )

      return;

   PaStreamFinishedCallback *sfc = stream->streamRepresentation.streamFinishedCallback;

   if( stream->state == STOPPING )

      stream->state = STOPPED ;

   if( sfc )

      sfc( stream->streamRepresentation.userData );

}

/*currently, this is only used in initialization, but it might be modified

  to be used when the list of devices changes.*/

static PaError gatherDeviceInfo(PaMacAUHAL *auhalHostApi)

{

    UInt32 size;

    UInt32 propsize;

    VVDBUG(("gatherDeviceInfo()\n"));

    /* -- free any previous allocations -- */

    if( auhalHostApi->devIds )

        PaUtil_GroupFreeMemory(auhalHostApi->allocations, auhalHostApi->devIds);

    auhalHostApi->devIds = NULL;

    /* -- figure out how many devices there are -- */

    AudioHardwareGetPropertyInfo( kAudioHardwarePropertyDevices,

                                  &propsize,

                                  NULL );

    auhalHostApi->devCount = propsize / sizeof( AudioDeviceID );

    VDBUG( ( "Found %ld device(s).\n", auhalHostApi->devCount ) );

    /* -- copy the device IDs -- */

    auhalHostApi->devIds = (AudioDeviceID *)PaUtil_GroupAllocateMemory(

                             auhalHostApi->allocations,

                             propsize );

    if( !auhalHostApi->devIds )

        return paInsufficientMemory;

    AudioHardwareGetProperty( kAudioHardwarePropertyDevices,

                                  &propsize,

                                  auhalHostApi->devIds );

#ifdef MAC_CORE_VERBOSE_DEBUG

    {

       int i;

       for( i=0; i<auhalHostApi->devCount; ++i )

          printf( "Device %d\t: %ld\n", i, auhalHostApi->devIds[i] );

    }

#endif

    size = sizeof(AudioDeviceID);

    auhalHostApi->defaultIn  = kAudioDeviceUnknown;

    auhalHostApi->defaultOut = kAudioDeviceUnknown;

    /* determine the default device. */

    /* I am not sure how these calls to AudioHardwareGetProperty()

       could fail, but in case they do, we use the first available

       device as the default. */

    if( 0 != AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,

                     &size,

                     &auhalHostApi->defaultIn) ) {

       int i;

       auhalHostApi->defaultIn  = kAudioDeviceUnknown;

       VDBUG(("Failed to get default input device from OS."));

       VDBUG((" I will substitute the first available input Device."));

       for( i=0; i<auhalHostApi->devCount; ++i ) {

          PaDeviceInfo devInfo;

          if( 0 != GetChannelInfo( auhalHostApi, &devInfo,

                                   auhalHostApi->devIds[i], TRUE ) )

             if( devInfo.maxInputChannels ) {

                auhalHostApi->defaultIn = auhalHostApi->devIds[i];

                break;

             }

       }

    }   

    if( 0 != AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,

                     &size,

                     &auhalHostApi->defaultOut) ) {

       int i;

       auhalHostApi->defaultIn  = kAudioDeviceUnknown;

       VDBUG(("Failed to get default output device from OS."));

       VDBUG((" I will substitute the first available output Device."));

       for( i=0; i<auhalHostApi->devCount; ++i ) {

          PaDeviceInfo devInfo;

          if( 0 != GetChannelInfo( auhalHostApi, &devInfo,

                                   auhalHostApi->devIds[i], FALSE ) )

             if( devInfo.maxOutputChannels ) {

                auhalHostApi->defaultOut = auhalHostApi->devIds[i];

                break;

             }

       }

    }   

    VDBUG( ( "Default in : %ld\n", auhalHostApi->defaultIn  ) );

    VDBUG( ( "Default out: %ld\n", auhalHostApi->defaultOut ) );

    return paNoError;

}

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

/**

 * @internal

 * @brief Clip the desired size against the allowed IO buffer size range for the device.

 */

static PaError ClipToDeviceBufferSize( AudioDeviceID macCoreDeviceId,

                                                                        int isInput, UInt32 desiredSize, UInt32 *allowedSize )

{

        UInt32 resultSize = desiredSize;

        AudioValueRange audioRange;

        UInt32 propSize = sizeof( audioRange );

        PaError err = WARNING(AudioDeviceGetProperty( macCoreDeviceId, 0, isInput, kAudioDevicePropertyBufferFrameSizeRange, &propSize, &audioRange ) );

        resultSize = MAX( resultSize, audioRange.mMinimum );

        resultSize = MIN( resultSize, audioRange.mMaximum );

        *allowedSize = resultSize;

        return err;

}

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

#if 0

static void DumpDeviceProperties( AudioDeviceID macCoreDeviceId,

                          int isInput )

{

    PaError err;

    int i;

    UInt32 propSize;

    UInt32 deviceLatency;

    UInt32 streamLatency;

    UInt32 bufferFrames;

    UInt32 safetyOffset;

    AudioStreamID streamIDs[128];

    printf("\n======= latency query : macCoreDeviceId = %d, isInput %d =======\n", (int)macCoreDeviceId, isInput );    

    propSize = sizeof(UInt32);

    err = WARNING(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyBufferFrameSize, &propSize, &bufferFrames));

    printf("kAudioDevicePropertyBufferFrameSize: err = %d, propSize = %d, value = %d\n", err, propSize, bufferFrames );

    propSize = sizeof(UInt32);

    err = WARNING(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertySafetyOffset, &propSize, &safetyOffset));

    printf("kAudioDevicePropertySafetyOffset: err = %d, propSize = %d, value = %d\n", err, propSize, safetyOffset );

    propSize = sizeof(UInt32);

    err = WARNING(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyLatency, &propSize, &deviceLatency));

    printf("kAudioDevicePropertyLatency: err = %d, propSize = %d, value = %d\n", err, propSize, deviceLatency );

    AudioValueRange audioRange;

    propSize = sizeof( audioRange );

    err = WARNING(AudioDeviceGetProperty( macCoreDeviceId, 0, isInput, kAudioDevicePropertyBufferFrameSizeRange, &propSize, &audioRange ) );

    printf("kAudioDevicePropertyBufferFrameSizeRange: err = %d, propSize = %u, minimum = %g\n", err, propSize, audioRange.mMinimum);

    printf("kAudioDevicePropertyBufferFrameSizeRange: err = %d, propSize = %u, maximum = %g\n", err, propSize, audioRange.mMaximum );

    /* Get the streams from the device and query their latency. */

    propSize = sizeof(streamIDs);

    err  = WARNING(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyStreams, &propSize, &streamIDs[0]));

    int numStreams = propSize / sizeof(AudioStreamID);

    for( i=0; i<numStreams; i++ )

    {

        printf("Stream #%d = %d---------------------- \n", i, streamIDs[i] );

        propSize = sizeof(UInt32);

        err  = WARNING(AudioStreamGetProperty(streamIDs[i], 0, kAudioStreamPropertyLatency, &propSize, &streamLatency));

        printf("  kAudioStreamPropertyLatency: err = %d, propSize = %d, value = %d\n", err, propSize, streamLatency );

    }

}

#endif

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

/**

 * @internal

 * Calculate the fixed latency from the system and the device.

 * Sum of kAudioStreamPropertyLatency +

 *        kAudioDevicePropertySafetyOffset +

 *        kAudioDevicePropertyLatency

 *

 * Some useful info from Jeff Moore on latency.

 * http://osdir.com/ml/coreaudio-api/2010-01/msg00046.html

 * http://osdir.com/ml/coreaudio-api/2009-07/msg00140.html

 */

static PaError CalculateFixedDeviceLatency( AudioDeviceID macCoreDeviceId, int isInput, UInt32 *fixedLatencyPtr )

{

    PaError err;

    UInt32 propSize;

    UInt32 deviceLatency;

    UInt32 streamLatency;

    UInt32 safetyOffset;

    AudioStreamID streamIDs[1];

    // To get stream latency we have to get a streamID from the device.

    // We are only going to look at the first stream so only fetch one stream.

    propSize = sizeof(streamIDs);

    err  = WARNING(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyStreams, &propSize, &streamIDs[0]));

    if( err != paNoError ) goto error;

    if( propSize == sizeof(AudioStreamID) )

    {        

        propSize = sizeof(UInt32);

        err  = WARNING(AudioStreamGetProperty(streamIDs[0], 0, kAudioStreamPropertyLatency, &propSize, &streamLatency));

    }

    propSize = sizeof(UInt32);

    err = WARNING(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertySafetyOffset, &propSize, &safetyOffset));

    if( err != paNoError ) goto error;

    propSize = sizeof(UInt32);

    err = WARNING(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyLatency, &propSize, &deviceLatency));

    if( err != paNoError ) goto error;

    *fixedLatencyPtr = deviceLatency + streamLatency + safetyOffset;

    return err;

error:

    return err;

}

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

static PaError CalculateDefaultDeviceLatencies( AudioDeviceID macCoreDeviceId,

                                               int isInput, UInt32 *lowLatencyFramesPtr,

                                               UInt32 *highLatencyFramesPtr )

{

    UInt32 propSize;

    UInt32 bufferFrames = 0;

    UInt32 fixedLatency = 0;

    UInt32 clippedMinBufferSize = 0;

    //DumpDeviceProperties( macCoreDeviceId, isInput );

    PaError err = CalculateFixedDeviceLatency( macCoreDeviceId, isInput, &fixedLatency );

    if( err != paNoError ) goto error;

    // For low latency use a small fixed size buffer clipped to the device range.

    err = ClipToDeviceBufferSize( macCoreDeviceId, isInput, PA_MAC_SMALL_BUFFER_SIZE, &clippedMinBufferSize );

    if( err != paNoError ) goto error;

    // For high latency use the default device buffer size.

    propSize = sizeof(UInt32);

    err = WARNING(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyBufferFrameSize, &propSize, &bufferFrames));

    if( err != paNoError ) goto error;

    *lowLatencyFramesPtr = fixedLatency + clippedMinBufferSize;

    *highLatencyFramesPtr = fixedLatency + bufferFrames;

    return err;

error:

    return err;

}

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

static PaError GetChannelInfo( PaMacAUHAL *auhalHostApi,

                               PaDeviceInfo *deviceInfo,

                               AudioDeviceID macCoreDeviceId,

                               int isInput)

{

    UInt32 propSize;

    PaError err = paNoError;

    UInt32 i;

    int numChannels = 0;

    AudioBufferList *buflist = NULL;

    VVDBUG(("GetChannelInfo()\n"));

    /* Get the number of channels from the stream configuration.

       Fail if we can't get this. */

    err = ERR(AudioDeviceGetPropertyInfo(macCoreDeviceId, 0, isInput, kAudioDevicePropertyStreamConfiguration, &propSize, NULL));

    if (err)

        return err;

    buflist = PaUtil_AllocateMemory(propSize);

    if( !buflist )

       return paInsufficientMemory;

    err = ERR(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyStreamConfiguration, &propSize, buflist));

    if (err)

        goto error;

    for (i = 0; i < buflist->mNumberBuffers; ++i)

        numChannels += buflist->mBuffers[i].mNumberChannels;

    if (isInput)

        deviceInfo->maxInputChannels = numChannels;

    else

        deviceInfo->maxOutputChannels = numChannels;

    if (numChannels > 0) /* do not try to retrieve the latency if there are no channels. */

    {

        /* Get the latency.  Don't fail if we can't get this. */

        /* default to something reasonable */

        deviceInfo->defaultLowInputLatency = .01;

        deviceInfo->defaultHighInputLatency = .10;

        deviceInfo->defaultLowOutputLatency = .01;

        deviceInfo->defaultHighOutputLatency = .10;        

        UInt32 lowLatencyFrames = 0;

        UInt32 highLatencyFrames = 0;

        err = CalculateDefaultDeviceLatencies( macCoreDeviceId, isInput, &lowLatencyFrames, &highLatencyFrames );

        if( err == 0 )

        {

            double lowLatencySeconds = lowLatencyFrames / deviceInfo->defaultSampleRate;

            double highLatencySeconds = highLatencyFrames / deviceInfo->defaultSampleRate;

            if (isInput)

            {

                deviceInfo->defaultLowInputLatency = lowLatencySeconds;

                deviceInfo->defaultHighInputLatency = highLatencySeconds;

            }

            else

            {

                deviceInfo->defaultLowOutputLatency = lowLatencySeconds;

                deviceInfo->defaultHighOutputLatency = highLatencySeconds;

            }

        }

    }

    PaUtil_FreeMemory( buflist );

    return paNoError;

 error:

    PaUtil_FreeMemory( buflist );

    return err;

}

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

static PaError InitializeDeviceInfo( PaMacAUHAL *auhalHostApi,

                                     PaDeviceInfo *deviceInfo,

                                     AudioDeviceID macCoreDeviceId,

                                     PaHostApiIndex hostApiIndex )

{

    Float64 sampleRate;

    char *name;

    PaError err = paNoError;

        CFStringRef nameRef;

    UInt32 propSize;

    VVDBUG(("InitializeDeviceInfo(): macCoreDeviceId=%ld\n", macCoreDeviceId));

    memset(deviceInfo, 0, sizeof(PaDeviceInfo));

    deviceInfo->structVersion = 2;

    deviceInfo->hostApi = hostApiIndex;

    /* Get the device name using CFString */

        propSize = sizeof(nameRef);

    err = ERR(AudioDeviceGetProperty(macCoreDeviceId, 0, 0, kAudioDevicePropertyDeviceNameCFString, &propSize, &nameRef));

    if (err)

    {

                /* Get the device name using c string.  Fail if we can't get it. */

                err = ERR(AudioDeviceGetPropertyInfo(macCoreDeviceId, 0, 0, kAudioDevicePropertyDeviceName, &propSize, NULL));

                if (err)

                        return err;

                name = PaUtil_GroupAllocateMemory(auhalHostApi->allocations,propSize+1);

                if ( !name )

                        return paInsufficientMemory;

                err = ERR(AudioDeviceGetProperty(macCoreDeviceId, 0, 0, kAudioDevicePropertyDeviceName, &propSize, name));

                if (err)

                        return err;

        }

        else

        {

                /* valid CFString so we just allocate a c string big enough to contain the data */

                propSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(nameRef), kCFStringEncodingUTF8);

                name = PaUtil_GroupAllocateMemory(auhalHostApi->allocations, propSize+1);

                if ( !name )

                {

                        CFRelease(nameRef);

                        return paInsufficientMemory;

                }

                CFStringGetCString(nameRef, name, propSize+1, kCFStringEncodingUTF8);

                CFRelease(nameRef);

        }

    deviceInfo->name = name;

    /* Try to get the default sample rate.  Don't fail if we can't get this. */

    propSize = sizeof(Float64);

    err = ERR(AudioDeviceGetProperty(macCoreDeviceId, 0, 0, kAudioDevicePropertyNominalSampleRate, &propSize, &sampleRate));

    if (err)

        deviceInfo->defaultSampleRate = 0.0;

    else

        deviceInfo->defaultSampleRate = sampleRate;

    /* Get the maximum number of input and output channels.  Fail if we can't get this. */

    err = GetChannelInfo(auhalHostApi, deviceInfo, macCoreDeviceId, 1);

    if (err)

        return err;

    err = GetChannelInfo(auhalHostApi, deviceInfo, macCoreDeviceId, 0);

    if (err)

        return err;

    return paNoError;

}

PaError PaMacCore_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex )

{

    PaError result = paNoError;

    int i;

    PaMacAUHAL *auhalHostApi = NULL;

    PaDeviceInfo *deviceInfoArray;

    int unixErr;

    VVDBUG(("PaMacCore_Initialize(): hostApiIndex=%d\n", hostApiIndex));

        SInt32 major;

        SInt32 minor;

        Gestalt(gestaltSystemVersionMajor, &major);

        Gestalt(gestaltSystemVersionMinor, &minor);

        // Starting with 10.6 systems, the HAL notification thread is created internally

        if (major == 10 && minor >= 6) {

                CFRunLoopRef theRunLoop = NULL;

                AudioObjectPropertyAddress theAddress = { kAudioHardwarePropertyRunLoop, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };

                OSStatus osErr = AudioObjectSetPropertyData (kAudioObjectSystemObject, &theAddress, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);

                if (osErr != noErr) {

                        goto error;

                }

        }

    unixErr = initializeXRunListenerList();

    if( 0 != unixErr ) {

       return UNIX_ERR(unixErr);

    }

    auhalHostApi = (PaMacAUHAL*)PaUtil_AllocateMemory( sizeof(PaMacAUHAL) );

    if( !auhalHostApi )

    {

        result = paInsufficientMemory;

        goto error;

    }

    auhalHostApi->allocations = PaUtil_CreateAllocationGroup();

    if( !auhalHostApi->allocations )

    {

        result = paInsufficientMemory;

        goto error;

    }

    auhalHostApi->devIds = NULL;

    auhalHostApi->devCount = 0;

    /* get the info we need about the devices */

    result = gatherDeviceInfo( auhalHostApi );

    if( result != paNoError )

       goto error;

    *hostApi = &auhalHostApi->inheritedHostApiRep;

    (*hostApi)->info.structVersion = 1;

    (*hostApi)->info.type = paCoreAudio;

    (*hostApi)->info.name = "Core Audio";

    (*hostApi)->info.defaultInputDevice = paNoDevice;

    (*hostApi)->info.defaultOutputDevice = paNoDevice;

    (*hostApi)->info.deviceCount = 0;  

    if( auhalHostApi->devCount > 0 )

    {

        (*hostApi)->deviceInfos = (PaDeviceInfo**)PaUtil_GroupAllocateMemory(

                auhalHostApi->allocations, sizeof(PaDeviceInfo*) * auhalHostApi->devCount);

        if( !(*hostApi)->deviceInfos )

        {

            result = paInsufficientMemory;

            goto error;

        }

        /* allocate all device info structs in a contiguous block */

        deviceInfoArray = (PaDeviceInfo*)PaUtil_GroupAllocateMemory(

                auhalHostApi->allocations, sizeof(PaDeviceInfo) * auhalHostApi->devCount );

        if( !deviceInfoArray )

        {

            result = paInsufficientMemory;

            goto error;

        }

        for( i=0; i < auhalHostApi->devCount; ++i )

        {

            int err;

            err = InitializeDeviceInfo( auhalHostApi, &deviceInfoArray[i],

                                      auhalHostApi->devIds[i],

                                      hostApiIndex );

            if (err == paNoError)

            { /* copy some info and set the defaults */

                (*hostApi)->deviceInfos[(*hostApi)->info.deviceCount] = &deviceInfoArray[i];

                if (auhalHostApi->devIds[i] == auhalHostApi->defaultIn)

                    (*hostApi)->info.defaultInputDevice = (*hostApi)->info.deviceCount;

                if (auhalHostApi->devIds[i] == auhalHostApi->defaultOut)

                    (*hostApi)->info.defaultOutputDevice = (*hostApi)->info.deviceCount;

                (*hostApi)->info.deviceCount++;

            }

            else

            { /* there was an error. we need to shift the devices down, so we ignore this one */

                int j;

                auhalHostApi->devCount--;

                for( j=i; j<auhalHostApi->devCount; ++j )

                   auhalHostApi->devIds[j] = auhalHostApi->devIds[j+1];

                i--;

            }

        }

    }

    (*hostApi)->Terminate = Terminate;

    (*hostApi)->OpenStream = OpenStream;

    (*hostApi)->IsFormatSupported = IsFormatSupported;

    PaUtil_InitializeStreamInterface( &auhalHostApi->callbackStreamInterface,

                                      CloseStream, StartStream,

                                      StopStream, AbortStream, IsStreamStopped,

                                      IsStreamActive,

                                      GetStreamTime, GetStreamCpuLoad,

                                      PaUtil_DummyRead, PaUtil_DummyWrite,

                                      PaUtil_DummyGetReadAvailable,

                                      PaUtil_DummyGetWriteAvailable );

    PaUtil_InitializeStreamInterface( &auhalHostApi->blockingStreamInterface,

                                      CloseStream, StartStream,

                                      StopStream, AbortStream, IsStreamStopped,

                                      IsStreamActive,

                                      GetStreamTime, PaUtil_DummyGetCpuLoad,

                                      ReadStream, WriteStream,

                                      GetStreamReadAvailable,

                                      GetStreamWriteAvailable );

    return result;

error:

    if( auhalHostApi )

    {

        if( auhalHostApi->allocations )

        {

            PaUtil_FreeAllAllocations( auhalHostApi->allocations );

            PaUtil_DestroyAllocationGroup( auhalHostApi->allocations );

        }

        PaUtil_FreeMemory( auhalHostApi );

    }

    return result;

}

static void Terminate( struct PaUtilHostApiRepresentation *hostApi )

{

    int unixErr;

    PaMacAUHAL *auhalHostApi = (PaMacAUHAL*)hostApi;

    VVDBUG(("Terminate()\n"));

    unixErr = destroyXRunListenerList();

    if( 0 != unixErr )

       UNIX_ERR(unixErr);

    /*

        IMPLEMENT ME:

            - clean up any resources not handled by the allocation group

        TODO: Double check that everything is handled by alloc group

    */

    if( auhalHostApi->allocations )

    {

        PaUtil_FreeAllAllocations( auhalHostApi->allocations );

        PaUtil_DestroyAllocationGroup( auhalHostApi->allocations );

    }

    PaUtil_FreeMemory( auhalHostApi );

}

static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,

                                  const PaStreamParameters *inputParameters,

                                  const PaStreamParameters *outputParameters,

                                  double sampleRate )

{

    int inputChannelCount, outputChannelCount;

    PaSampleFormat inputSampleFormat, outputSampleFormat;

    VVDBUG(("IsFormatSupported(): in chan=%d, in fmt=%ld, out chan=%d, out fmt=%ld sampleRate=%g\n",

                inputParameters  ? inputParameters->channelCount  : -1,

                inputParameters  ? inputParameters->sampleFormat  : -1,

                outputParameters ? outputParameters->channelCount : -1,

                outputParameters ? outputParameters->sampleFormat : -1,

                (float) sampleRate ));

    /** These first checks are standard PA checks. We do some fancier checks

        later. */

    if( inputParameters )

    {

        inputChannelCount = inputParameters->channelCount;

        inputSampleFormat = inputParameters->sampleFormat;

        /* all standard sample formats are supported by the buffer adapter,

            this implementation doesn't support any custom sample formats */

        if( inputSampleFormat & paCustomFormat )

            return paSampleFormatNotSupported;

        /* unless alternate device specification is supported, reject the use of

            paUseHostApiSpecificDeviceSpecification */

        if( inputParameters->device == paUseHostApiSpecificDeviceSpecification )

            return paInvalidDevice;

        /* check that input device can support inputChannelCount */

        if( inputChannelCount > hostApi->deviceInfos[ inputParameters->device ]->maxInputChannels )

            return paInvalidChannelCount;

    }

    else

    {

        inputChannelCount = 0;

    }

    if( outputParameters )

    {

        outputChannelCount = outputParameters->channelCount;

        outputSampleFormat = outputParameters->sampleFormat;

        /* all standard sample formats are supported by the buffer adapter,

            this implementation doesn't support any custom sample formats */

        if( outputSampleFormat & paCustomFormat )

            return paSampleFormatNotSupported;

        /* unless alternate device specification is supported, reject the use of

            paUseHostApiSpecificDeviceSpecification */

        if( outputParameters->device == paUseHostApiSpecificDeviceSpecification )

            return paInvalidDevice;

        /* check that output device can support outputChannelCount */

        if( outputChannelCount > hostApi->deviceInfos[ outputParameters->device ]->maxOutputChannels )

            return paInvalidChannelCount;

    }

    else

    {

        outputChannelCount = 0;

    }

    /* FEEDBACK */

    /*        I think the only way to check a given format SR combo is     */

    /*        to try opening it. This could be disruptive, is that Okay?   */

    /*        The alternative is to just read off available sample rates,  */

    /*        but this will not work %100 of the time (eg, a device that   */

    /*        supports N output at one rate but only N/2 at a higher rate.)*/

    /* The following code opens the device with the requested parameters to

       see if it works. */

    {

       PaError err;

       PaStream *s;

       err = OpenStream( hostApi, &s, inputParameters, outputParameters,

                           sampleRate, 1024, 0, (PaStreamCallback *)1, NULL );

       if( err != paNoError && err != paInvalidSampleRate )

          DBUG( ( "OpenStream @ %g returned: %d: %s\n",

                  (float) sampleRate, err, Pa_GetErrorText( err ) ) );

       if( err ) 

          return err;

       err = CloseStream( s );

       if( err ) {

          /* FEEDBACK: is this more serious? should we assert? */

          DBUG( ( "WARNING: could not close Stream. %d: %s\n",

                  err, Pa_GetErrorText( err ) ) );

       }

    }

    return paFormatIsSupported;

}

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

static void InitializeDeviceProperties( PaMacCoreDeviceProperties *deviceProperties )

{

    memset( deviceProperties, 0, sizeof(PaMacCoreDeviceProperties) );

    deviceProperties->sampleRate = 1.0; // Better than random. Overwritten by actual values later on.

    deviceProperties->samplePeriod = 1.0 / deviceProperties->sampleRate;

}

static Float64 CalculateSoftwareLatencyFromProperties( PaMacCoreStream *stream, PaMacCoreDeviceProperties *deviceProperties )

{

    UInt32 latencyFrames = deviceProperties->bufferFrameSize + deviceProperties->deviceLatency + deviceProperties->safetyOffset;

    return latencyFrames * deviceProperties->samplePeriod; // same as dividing by sampleRate but faster

}

static Float64 CalculateHardwareLatencyFromProperties( PaMacCoreStream *stream, PaMacCoreDeviceProperties *deviceProperties )

{

    return deviceProperties->deviceLatency * deviceProperties->samplePeriod; // same as dividing by sampleRate but faster

}

/* Calculate values used to convert Apple timestamps into PA timestamps

 * from the device properties. The final results of this calculation

 * will be used in the audio callback function.

 */

static void UpdateTimeStampOffsets( PaMacCoreStream *stream )

{

    Float64 inputSoftwareLatency = 0.0;

    Float64 inputHardwareLatency = 0.0;

    Float64 outputSoftwareLatency = 0.0;

    Float64 outputHardwareLatency = 0.0;

    if( stream->inputUnit != NULL )

    {

        inputSoftwareLatency = CalculateSoftwareLatencyFromProperties( stream, &stream->inputProperties );

        inputHardwareLatency = CalculateHardwareLatencyFromProperties( stream, &stream->inputProperties );

    }    

    if( stream->outputUnit != NULL )

    {

        outputSoftwareLatency = CalculateSoftwareLatencyFromProperties( stream, &stream->outputProperties );

        outputHardwareLatency = CalculateHardwareLatencyFromProperties( stream, &stream->outputProperties );

    }    

    /* We only need a mutex around setting these variables as a group. */

        pthread_mutex_lock( &stream->timingInformationMutex );

    stream->timestampOffsetCombined = inputSoftwareLatency + outputSoftwareLatency;

    stream->timestampOffsetInputDevice = inputHardwareLatency;

    stream->timestampOffsetOutputDevice = outputHardwareLatency;

        pthread_mutex_unlock( &stream->timingInformationMutex );

}

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

/* can be used to update from nominal or actual sample rate */

static OSStatus UpdateSampleRateFromDeviceProperty( PaMacCoreStream *stream, AudioDeviceID deviceID, Boolean isInput, AudioDevicePropertyID sampleRatePropertyID )

{

    PaMacCoreDeviceProperties * deviceProperties = isInput ? &stream->inputProperties : &stream->outputProperties;

        Float64 sampleRate = 0.0;

        UInt32 propSize = sizeof(Float64);

    OSStatus osErr = AudioDeviceGetProperty( deviceID, 0, isInput, sampleRatePropertyID, &propSize, &sampleRate);

        if( (osErr == noErr) && (sampleRate > 1000.0) ) /* avoid divide by zero if there's an error */

        {

        deviceProperties->sampleRate = sampleRate;

        deviceProperties->samplePeriod = 1.0 / sampleRate;

    }

    return osErr;

}

static OSStatus AudioDevicePropertyActualSampleRateListenerProc( AudioDeviceID inDevice, UInt32 inChannel, Boolean isInput, AudioDevicePropertyID inPropertyID, void *inClientData )

{

        PaMacCoreStream *stream = (PaMacCoreStream*)inClientData;

    // Make sure the callback is operating on a stream that is still valid!

    assert( stream->streamRepresentation.magic == PA_STREAM_MAGIC );

        OSStatus osErr = UpdateSampleRateFromDeviceProperty( stream, inDevice, isInput, kAudioDevicePropertyActualSampleRate );

    if( osErr == noErr )

    {

        UpdateTimeStampOffsets( stream );

    }

    return osErr;

}

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

static OSStatus QueryUInt32DeviceProperty( AudioDeviceID deviceID, Boolean isInput, AudioDevicePropertyID propertyID, UInt32 *outValue )

{

        UInt32 propertyValue = 0;

        UInt32 propertySize = sizeof(UInt32);

        OSStatus osErr = AudioDeviceGetProperty( deviceID, 0, isInput, propertyID, &propertySize, &propertyValue);

        if( osErr == noErr )

        {

        *outValue = propertyValue;

        }

    return osErr;

}

static OSStatus AudioDevicePropertyGenericListenerProc( AudioDeviceID inDevice, UInt32 inChannel, Boolean isInput, AudioDevicePropertyID inPropertyID, void *inClientData )

{

    OSStatus osErr = noErr;

        PaMacCoreStream *stream = (PaMacCoreStream*)inClientData;

    // Make sure the callback is operating on a stream that is still valid!

    assert( stream->streamRepresentation.magic == PA_STREAM_MAGIC );

    PaMacCoreDeviceProperties *deviceProperties = isInput ? &stream->inputProperties : &stream->outputProperties;

    UInt32 *valuePtr = NULL;

    switch( inPropertyID )

    {

        case kAudioDevicePropertySafetyOffset:

            valuePtr = &deviceProperties->safetyOffset;

            break;

        case kAudioDevicePropertyLatency:

            valuePtr = &deviceProperties->deviceLatency;

            break;

        case kAudioDevicePropertyBufferFrameSize:

            valuePtr = &deviceProperties->bufferFrameSize;

            break;            

    }

    if( valuePtr != NULL )

    {

        osErr = QueryUInt32DeviceProperty( inDevice, isInput, inPropertyID, valuePtr );

        if( osErr == noErr )

        {

            UpdateTimeStampOffsets( stream );

        }

    }

    return osErr;

}

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

/*

 * Setup listeners in case device properties change during the run. */

static OSStatus SetupDevicePropertyListeners( PaMacCoreStream *stream, AudioDeviceID deviceID, Boolean isInput )

{

    OSStatus osErr = noErr;

    PaMacCoreDeviceProperties *deviceProperties = isInput ? &stream->inputProperties : &stream->outputProperties;

    if( (osErr = QueryUInt32DeviceProperty( deviceID, isInput,

                                           kAudioDevicePropertyLatency, &deviceProperties->deviceLatency )) != noErr ) return osErr;

    if( (osErr = QueryUInt32DeviceProperty( deviceID, isInput,

                                           kAudioDevicePropertyBufferFrameSize, &deviceProperties->bufferFrameSize )) != noErr ) return osErr;

    if( (osErr = QueryUInt32DeviceProperty( deviceID, isInput,

                                           kAudioDevicePropertySafetyOffset, &deviceProperties->safetyOffset )) != noErr ) return osErr;

    AudioDeviceAddPropertyListener( deviceID, 0, isInput, kAudioDevicePropertyActualSampleRate, 

                                   AudioDevicePropertyActualSampleRateListenerProc, stream );

    AudioDeviceAddPropertyListener( deviceID, 0, isInput, kAudioStreamPropertyLatency, 

                                   AudioDevicePropertyGenericListenerProc, stream );

    AudioDeviceAddPropertyListener( deviceID, 0, isInput, kAudioDevicePropertyBufferFrameSize, 

                                   AudioDevicePropertyGenericListenerProc, stream );

    AudioDeviceAddPropertyListener( deviceID, 0, isInput, kAudioDevicePropertySafetyOffset, 

                                   AudioDevicePropertyGenericListenerProc, stream );

    return osErr;

}

static void CleanupDevicePropertyListeners( PaMacCoreStream *stream, AudioDeviceID deviceID, Boolean isInput )

{    

    AudioDeviceRemovePropertyListener( deviceID, 0, isInput, kAudioDevicePropertyActualSampleRate, 

                                   AudioDevicePropertyActualSampleRateListenerProc );

    AudioDeviceRemovePropertyListener( deviceID, 0, isInput, kAudioDevicePropertyLatency, 

                                   AudioDevicePropertyGenericListenerProc );        

    AudioDeviceRemovePropertyListener( deviceID, 0, isInput, kAudioDevicePropertyBufferFrameSize, 

                                   AudioDevicePropertyGenericListenerProc );

    AudioDeviceRemovePropertyListener( deviceID, 0, isInput, kAudioDevicePropertySafetyOffset, 

                                   AudioDevicePropertyGenericListenerProc );

}

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

static PaError OpenAndSetupOneAudioUnit(

                                   const PaMacCoreStream *stream,

                                   const PaStreamParameters *inStreamParams,

                                   const PaStreamParameters *outStreamParams,

                                   const UInt32 requestedFramesPerBuffer,

                                   UInt32 *actualInputFramesPerBuffer,

                                   UInt32 *actualOutputFramesPerBuffer,

                                   const PaMacAUHAL *auhalHostApi,

#ifndef AUDIO_COMPONENT_FIX

                                   AudioUnit *audioUnit,

#else

                                   AudioComponentInstance *audioUnit,

#endif

                                   AudioConverterRef *srConverter,

                                   AudioDeviceID *audioDevice,

                                   const double sampleRate,

                                   void *refCon )

{

#ifndef AUDIO_COMPONENT_FIX

    ComponentDescription desc;

    Component comp;

#else

    AudioComponentDescription desc;

    AudioComponent comp;

#endif

    /*An Apple TN suggests using CAStreamBasicDescription, but that is C++*/

    AudioStreamBasicDescription desiredFormat;

    OSStatus result = noErr;

    PaError paResult = paNoError;

    int line = 0;

    UInt32 callbackKey;

    AURenderCallbackStruct rcbs;

    unsigned long macInputStreamFlags  = paMacCorePlayNice;

    unsigned long macOutputStreamFlags = paMacCorePlayNice;

    SInt32 const *inChannelMap = NULL;

    SInt32 const *outChannelMap = NULL;

    unsigned long inChannelMapSize = 0;

    unsigned long outChannelMapSize = 0;

    VVDBUG(("OpenAndSetupOneAudioUnit(): in chan=%d, in fmt=%ld, out chan=%d, out fmt=%ld, requestedFramesPerBuffer=%ld\n",

                inStreamParams  ? inStreamParams->channelCount  : -1,

                inStreamParams  ? inStreamParams->sampleFormat  : -1,

                outStreamParams ? outStreamParams->channelCount : -1,

                outStreamParams ? outStreamParams->sampleFormat : -1,

                requestedFramesPerBuffer ));

    /* -- handle the degenerate case  -- */

    if( !inStreamParams && !outStreamParams ) {

       *audioUnit = NULL;

       *audioDevice = kAudioDeviceUnknown;

       return paNoError;

    }

    /* -- get the user's api specific info, if they set any -- */

    if( inStreamParams && inStreamParams->hostApiSpecificStreamInfo )

    {

       macInputStreamFlags=

            ((PaMacCoreStreamInfo*)inStreamParams->hostApiSpecificStreamInfo)

                  ->flags;

       inChannelMap = ((PaMacCoreStreamInfo*)inStreamParams->hostApiSpecificStreamInfo)

                  ->channelMap;

       inChannelMapSize = ((PaMacCoreStreamInfo*)inStreamParams->hostApiSpecificStreamInfo)

                  ->channelMapSize;

    }

    if( outStreamParams && outStreamParams->hostApiSpecificStreamInfo )

    {

       macOutputStreamFlags=

            ((PaMacCoreStreamInfo*)outStreamParams->hostApiSpecificStreamInfo)

                  ->flags;

       outChannelMap = ((PaMacCoreStreamInfo*)outStreamParams->hostApiSpecificStreamInfo)

                  ->channelMap;

       outChannelMapSize = ((PaMacCoreStreamInfo*)outStreamParams->hostApiSpecificStreamInfo)

                  ->channelMapSize; 

    }

    /* Override user's flags here, if desired for testing. */

    /*

     * The HAL AU is a Mac OS style "component".

     * the first few steps deal with that.

     * Later steps work on a combination of Mac OS

     * components and the slightly lower level

     * HAL.

     */

    /* -- describe the output type AudioUnit -- */

    /*  Note: for the default AudioUnit, we could use the

     *  componentSubType value kAudioUnitSubType_DefaultOutput;

     *  but I don't think that's relevant here.

     */

    desc.componentType         = kAudioUnitType_Output;

    desc.componentSubType      = kAudioUnitSubType_HALOutput;

    desc.componentManufacturer = kAudioUnitManufacturer_Apple;

    desc.componentFlags        = 0;

    desc.componentFlagsMask    = 0;

    /* -- find the component -- */

#ifndef AUDIO_COMPONENT_FIX

    comp = FindNextComponent( NULL, &desc );

#else

    comp = AudioComponentFindNext( NULL, &desc );

#endif

    if( !comp )

    {

       DBUG( ( "AUHAL component not found." ) );

       *audioUnit = NULL;

       *audioDevice = kAudioDeviceUnknown;

       return paUnanticipatedHostError;

    }

    /* -- open it -- */

#ifndef AUDIO_COMPONENT_FIX

                result = OpenAComponent(comp, audioUnit);

#else

                result = AudioComponentInstanceNew(comp, audioUnit);

#endif

    if( result )

    {

       DBUG( ( "Failed to open AUHAL component." ) );

       *audioUnit = NULL;

       *audioDevice = kAudioDeviceUnknown;

       return ERR( result );

    }

    /* -- prepare a little error handling logic / hackery -- */

#define ERR_WRAP(mac_err) do { result = mac_err ; line = __LINE__ ; if ( result != noErr ) goto error ; } while(0)

    /* -- if there is input, we have to explicitly enable input -- */

    if( inStreamParams )

    {

       UInt32 enableIO = 1;

       ERR_WRAP( AudioUnitSetProperty( *audioUnit,

                 kAudioOutputUnitProperty_EnableIO,

                 kAudioUnitScope_Input,

                 INPUT_ELEMENT,

                 &enableIO,

                 sizeof(enableIO) ) );

    }

    /* -- if there is no output, we must explicitly disable output -- */

    if( !outStreamParams )

    {

       UInt32 enableIO = 0;

       ERR_WRAP( AudioUnitSetProperty( *audioUnit,

                 kAudioOutputUnitProperty_EnableIO,

                 kAudioUnitScope_Output,

                 OUTPUT_ELEMENT,

                 &enableIO,

                 sizeof(enableIO) ) );

    }

    /* -- set the devices -- */

    /* make sure input and output are the same device if we are doing input and

       output. */

    if( inStreamParams && outStreamParams )

    {

       assert( outStreamParams->device == inStreamParams->device );

    }

    if( inStreamParams )

    {

       *audioDevice = auhalHostApi->devIds[inStreamParams->device] ;

       ERR_WRAP( AudioUnitSetProperty( *audioUnit,

                    kAudioOutputUnitProperty_CurrentDevice,

                    kAudioUnitScope_Global,

                    INPUT_ELEMENT,

                    audioDevice,

                    sizeof(AudioDeviceID) ) );

    }

    if( outStreamParams && outStreamParams != inStreamParams )

    {

       *audioDevice = auhalHostApi->devIds[outStreamParams->device] ;

       ERR_WRAP( AudioUnitSetProperty( *audioUnit,

                    kAudioOutputUnitProperty_CurrentDevice,

                    kAudioUnitScope_Global,

                    OUTPUT_ELEMENT,

                    audioDevice,

                    sizeof(AudioDeviceID) ) );

    }

    /* -- add listener for dropouts -- */

    result = AudioDeviceAddPropertyListener( *audioDevice,

                                             0,

                                             outStreamParams ? false : true,

                                             kAudioDeviceProcessorOverload,

                                             xrunCallback,

                                             addToXRunListenerList( (void *)stream ) ) ;

    if( result == kAudioHardwareIllegalOperationError ) {

       // -- already registered, we're good

    } else {

       // -- not already registered, just check for errors

       ERR_WRAP( result );

    }

    /* -- listen for stream start and stop -- */

    ERR_WRAP( AudioUnitAddPropertyListener( *audioUnit,

                                            kAudioOutputUnitProperty_IsRunning,

                                            startStopCallback,

                                            (void *)stream ) );

    /* -- set format -- */

    bzero( &desiredFormat, sizeof(desiredFormat) );

    desiredFormat.mFormatID         = kAudioFormatLinearPCM ;

    desiredFormat.mFormatFlags      = kAudioFormatFlagsNativeFloatPacked;

    desiredFormat.mFramesPerPacket  = 1;

    desiredFormat.mBitsPerChannel   = sizeof( float ) * 8;

    result = 0;

    /*  set device format first, but only touch the device if the user asked */

    if( inStreamParams ) {

       /*The callback never calls back if we don't set the FPB */

       /*This seems wierd, because I would think setting anything on the device

         would be disruptive.*/

       paResult = setBestFramesPerBuffer( *audioDevice, FALSE,

                                          requestedFramesPerBuffer,

                                          actualInputFramesPerBuffer );

       if( paResult ) goto error;

       if( macInputStreamFlags & paMacCoreChangeDeviceParameters ) {

          bool requireExact;

          requireExact=macInputStreamFlags & paMacCoreFailIfConversionRequired;

          paResult = setBestSampleRateForDevice( *audioDevice, FALSE,

                                                 requireExact, sampleRate );

          if( paResult ) goto error;

       }

       if( actualInputFramesPerBuffer && actualOutputFramesPerBuffer )

          *actualOutputFramesPerBuffer = *actualInputFramesPerBuffer ;

    }

    if( outStreamParams && !inStreamParams ) {