aboutsummaryrefslogtreecommitdiff
path: root/pd/portaudio/pa_mac_sm
diff options
context:
space:
mode:
authorMiller Puckette <millerpuckette@users.sourceforge.net>2004-09-06 20:44:42 +0000
committerMiller Puckette <millerpuckette@users.sourceforge.net>2004-09-06 20:44:42 +0000
commitcfc2f7d280ae57ef563dd69bad27c61a148d6ded (patch)
tree92c4c645399fcad23f4a6ba15dff91c0e6fccb29 /pd/portaudio/pa_mac_sm
parented932acb5860bf8b9296169676499562a55d139e (diff)
... more changes to try to upload 0.38 test 5 to CVS
svn path=/trunk/; revision=2011
Diffstat (limited to 'pd/portaudio/pa_mac_sm')
-rw-r--r--pd/portaudio/pa_mac_sm/pa_mac_sm.c1656
1 files changed, 1656 insertions, 0 deletions
diff --git a/pd/portaudio/pa_mac_sm/pa_mac_sm.c b/pd/portaudio/pa_mac_sm/pa_mac_sm.c
new file mode 100644
index 00000000..59457ded
--- /dev/null
+++ b/pd/portaudio/pa_mac_sm/pa_mac_sm.c
@@ -0,0 +1,1656 @@
+/*
+ * $Id: pa_mac_sm.c,v 1.1.2.1 2002/06/07 21:20:48 rossb Exp $
+ * Portable Audio I/O Library for Macintosh
+ *
+ * Based on the Open Source API proposed by Ross Bencina
+ * Copyright (c) 1999-2000 Phil Burk
+ *
+ * Special thanks to Chris Rolfe for his many helpful suggestions, bug fixes,
+ * and code contributions.
+ * Thanks also to Tue Haste Andersen, Alberto Ricci, Nico Wald,
+ * Roelf Toxopeus and Tom Erbe for testing the code and making
+ * numerous suggestions.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+/* Modification History
+ PLB20010415 - ScanInputDevices was setting sDefaultOutputDeviceID instead of sDefaultInputDeviceID
+ PLB20010415 - Device Scan was crashing for anything other than siBadSoundInDevice, but some Macs may return other errors!
+ PLB20010420 - Fix TIMEOUT in record mode.
+ PLB20010420 - Change CARBON_COMPATIBLE to TARGET_API_MAC_CARBON
+ PLB20010907 - Pass unused event to WaitNextEvent to prevent Mac OSX crash. Thanks Dominic Mazzoni.
+ PLB20010908 - Use requested number of input channels. Thanks Dominic Mazzoni.
+ PLB20011009 - Use NewSndCallBackUPP() for CARBON
+ PLB20020417 - I used to call Pa_GetMinNumBuffers() which doesn't take into account the
+ variable minFramesPerHostBuffer. Now I call PaMac_GetMinNumBuffers() which will
+ give lower latency when virtual memory is turned off.
+ Thanks Kristoffer Jensen and Georgios Marentakis for spotting this bug.
+ PLB20020423 - Use new method to calculate CPU load similar to other ports. Based on num frames calculated.
+ Fixed Pa_StreamTime(). Now estimates how many frames have played based on MicroSecond timer.
+ Added PA_MAX_USAGE_ALLOWED to prevent Mac form hanging when CPU load approaches 100%.
+ PLB20020424 - Fixed return value in Pa_StreamTime
+*/
+
+/*
+COMPATIBILITY
+This Macintosh implementation is designed for use with Mac OS 7, 8 and
+9 on PowerMacs, and OS X if compiled with CARBON
+
+OUTPUT
+A circular array of CmpSoundHeaders is used as a queue. For low latency situations
+there will only be two small buffers used. For higher latency, more and larger buffers
+may be used.
+To play the sound we use SndDoCommand() with bufferCmd. Each buffer is followed
+by a callbackCmd which informs us when the buffer has been processsed.
+
+INPUT
+The SndInput Manager SPBRecord call is used for sound input. If only
+input is used, then the PA user callback is called from the Input completion proc.
+For full-duplex, or output only operation, the PA callback is called from the
+HostBuffer output completion proc. In that case, input sound is passed to the
+callback by a simple FIFO.
+
+TODO:
+O- Add support for native sample data formats other than int16.
+O- Review buffer sizing. Should it be based on result of siDeviceBufferInfo query?
+O- Determine default devices somehow.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <memory.h>
+#include <math.h>
+
+/* Mac specific includes */
+#include "OSUtils.h"
+#include <MacTypes.h>
+#include <Math64.h>
+#include <Errors.h>
+#include <Sound.h>
+#include <SoundInput.h>
+#include <SoundComponents.h>
+#include <Devices.h>
+#include <DateTimeUtils.h>
+#include <Timer.h>
+#include <Gestalt.h>
+
+#include "portaudio.h"
+#include "pa_host.h"
+#include "pa_trace.h"
+
+#ifndef FALSE
+ #define FALSE (0)
+ #define TRUE (!FALSE)
+#endif
+
+/* #define TARGET_API_MAC_CARBON (1) */
+
+/*
+ * Define maximum CPU load that will be allowed. User callback will
+ * be skipped if load exceeds this limit. This is to prevent the Mac
+ * from hanging when the CPU is hogged by the sound thread.
+ * On my PowerBook G3, the mac hung when I used 94% of CPU ( usage = 0.94 ).
+ */
+#define PA_MAX_USAGE_ALLOWED (0.92)
+
+/* Debugging output macros. */
+#define PRINT(x) { printf x; fflush(stdout); }
+#define ERR_RPT(x) PRINT(x)
+#define DBUG(x) /* PRINT(x) /**/
+#define DBUGX(x) /* PRINT(x) /**/
+
+#define MAC_PHYSICAL_FRAMES_PER_BUFFER (512) /* Minimum number of stereo frames per SoundManager double buffer. */
+#define MAC_VIRTUAL_FRAMES_PER_BUFFER (4096) /* Need this many when using Virtual Memory for recording. */
+#define PA_MIN_NUM_HOST_BUFFERS (2)
+#define PA_MAX_NUM_HOST_BUFFERS (16) /* Do not exceed!! */
+#define PA_MAX_DEVICE_INFO (32)
+
+/* Conversions for 16.16 fixed point code. */
+#define DoubleToUnsignedFixed(x) ((UnsignedFixed) ((x) * 65536.0))
+#define UnsignedFixedToDouble(fx) (((double)(fx)) * (1.0/(1<<16)))
+
+/************************************************************************************/
+/****************** Structures ******************************************************/
+/************************************************************************************/
+/* Use for passing buffers from input callback to output callback for processing. */
+typedef struct MultiBuffer
+{
+ char *buffers[PA_MAX_NUM_HOST_BUFFERS];
+ int numBuffers;
+ int nextWrite;
+ int nextRead;
+}
+MultiBuffer;
+
+/* Define structure to contain all Macintosh specific data. */
+typedef struct PaHostSoundControl
+{
+ UInt64 pahsc_EntryCount;
+ double pahsc_InverseMicrosPerHostBuffer; /* 1/Microseconds of real-time audio per user buffer. */
+
+ /* Use char instead of Boolean for atomic operation. */
+ volatile char pahsc_IsRecording; /* Recording in progress. Set by foreground. Cleared by background. */
+ volatile char pahsc_StopRecording; /* Signal sent to background. */
+ volatile char pahsc_IfInsideCallback;
+ /* Input */
+ SPB pahsc_InputParams;
+ SICompletionUPP pahsc_InputCompletionProc;
+ MultiBuffer pahsc_InputMultiBuffer;
+ int32 pahsc_BytesPerInputHostBuffer;
+ int32 pahsc_InputRefNum;
+ /* Output */
+ CmpSoundHeader pahsc_SoundHeaders[PA_MAX_NUM_HOST_BUFFERS];
+ int32 pahsc_BytesPerOutputHostBuffer;
+ SndChannelPtr pahsc_Channel;
+ SndCallBackUPP pahsc_OutputCompletionProc;
+ int32 pahsc_NumOutsQueued;
+ int32 pahsc_NumOutsPlayed;
+ PaTimestamp pahsc_NumFramesDone;
+ UInt64 pahsc_WhenFramesDoneIncremented;
+ /* Init Time -------------- */
+ int32 pahsc_NumHostBuffers;
+ int32 pahsc_FramesPerHostBuffer;
+ int32 pahsc_UserBuffersPerHostBuffer;
+ int32 pahsc_MinFramesPerHostBuffer; /* Can vary depending on virtual memory usage. */
+}
+PaHostSoundControl;
+
+/* Mac specific device information. */
+typedef struct internalPortAudioDevice
+{
+ long pad_DeviceRefNum;
+ long pad_DeviceBufferSize;
+ Component pad_Identifier;
+ PaDeviceInfo pad_Info;
+}
+internalPortAudioDevice;
+
+/************************************************************************************/
+/****************** Data ************************************************************/
+/************************************************************************************/
+static int sNumDevices = 0;
+static internalPortAudioDevice sDevices[PA_MAX_DEVICE_INFO] = { 0 };
+static int32 sPaHostError = 0;
+static int sDefaultOutputDeviceID;
+static int sDefaultInputDeviceID;
+
+/************************************************************************************/
+/****************** Prototypes ******************************************************/
+/************************************************************************************/
+static PaError PaMac_TimeSlice( internalPortAudioStream *past, int16 *macOutputBufPtr );
+static PaError PaMac_CallUserLoop( internalPortAudioStream *past, int16 *outPtr );
+static PaError PaMac_RecordNext( internalPortAudioStream *past );
+static void PaMac_StartLoadCalculation( internalPortAudioStream *past );
+static int PaMac_GetMinNumBuffers( int minFramesPerHostBuffer, int framesPerBuffer, double sampleRate );
+static double *PaMac_GetSampleRatesFromHandle ( int numRates, Handle h );
+static PaError PaMac_ScanInputDevices( void );
+static PaError PaMac_ScanOutputDevices( void );
+static PaError PaMac_QueryOutputDeviceInfo( Component identifier, internalPortAudioDevice *ipad );
+static PaError PaMac_QueryInputDeviceInfo( Str255 deviceName, internalPortAudioDevice *ipad );
+static void PaMac_InitSoundHeader( internalPortAudioStream *past, CmpSoundHeader *sndHeader );
+static void PaMac_EndLoadCalculation( internalPortAudioStream *past );
+static void PaMac_PlayNext ( internalPortAudioStream *past, int index );
+static long PaMac_FillNextOutputBuffer( internalPortAudioStream *past, int index );
+static pascal void PaMac_InputCompletionProc(SPBPtr recParams);
+static pascal void PaMac_OutputCompletionProc (SndChannelPtr theChannel, SndCommand * theCmd);
+static PaError PaMac_BackgroundManager( internalPortAudioStream *past, int index );
+long PaHost_GetTotalBufferFrames( internalPortAudioStream *past );
+static int Mac_IsVirtualMemoryOn( void );
+static void PToCString(unsigned char* inString, char* outString);
+char *MultiBuffer_GetNextWriteBuffer( MultiBuffer *mbuf );
+char *MultiBuffer_GetNextReadBuffer( MultiBuffer *mbuf );
+int MultiBuffer_GetNextReadIndex( MultiBuffer *mbuf );
+int MultiBuffer_GetNextWriteIndex( MultiBuffer *mbuf );
+int MultiBuffer_IsWriteable( MultiBuffer *mbuf );
+int MultiBuffer_IsReadable( MultiBuffer *mbuf );
+void MultiBuffer_AdvanceReadIndex( MultiBuffer *mbuf );
+void MultiBuffer_AdvanceWriteIndex( MultiBuffer *mbuf );
+
+/*************************************************************************
+** Simple FIFO index control for multiple buffers.
+** Read and Write indices range from 0 to 2N-1.
+** This allows us to distinguish between full and empty.
+*/
+char *MultiBuffer_GetNextWriteBuffer( MultiBuffer *mbuf )
+{
+ return mbuf->buffers[mbuf->nextWrite % mbuf->numBuffers];
+}
+char *MultiBuffer_GetNextReadBuffer( MultiBuffer *mbuf )
+{
+ return mbuf->buffers[mbuf->nextRead % mbuf->numBuffers];
+}
+int MultiBuffer_GetNextReadIndex( MultiBuffer *mbuf )
+{
+ return mbuf->nextRead % mbuf->numBuffers;
+}
+int MultiBuffer_GetNextWriteIndex( MultiBuffer *mbuf )
+{
+ return mbuf->nextWrite % mbuf->numBuffers;
+}
+
+int MultiBuffer_IsWriteable( MultiBuffer *mbuf )
+{
+ int bufsFull = mbuf->nextWrite - mbuf->nextRead;
+ if( bufsFull < 0 ) bufsFull += (2 * mbuf->numBuffers);
+ return (bufsFull < mbuf->numBuffers);
+}
+int MultiBuffer_IsReadable( MultiBuffer *mbuf )
+{
+ int bufsFull = mbuf->nextWrite - mbuf->nextRead;
+ if( bufsFull < 0 ) bufsFull += (2 * mbuf->numBuffers);
+ return (bufsFull > 0);
+}
+void MultiBuffer_AdvanceReadIndex( MultiBuffer *mbuf )
+{
+ int temp = mbuf->nextRead + 1;
+ mbuf->nextRead = (temp >= (2 * mbuf->numBuffers)) ? 0 : temp;
+}
+void MultiBuffer_AdvanceWriteIndex( MultiBuffer *mbuf )
+{
+ int temp = mbuf->nextWrite + 1;
+ mbuf->nextWrite = (temp >= (2 * mbuf->numBuffers)) ? 0 : temp;
+}
+
+/*************************************************************************
+** String Utility by Chris Rolfe
+*/
+static void PToCString(unsigned char* inString, char* outString)
+{
+ long i;
+ for(i=0; i<inString[0]; i++) /* convert Pascal to C string */
+ outString[i] = inString[i+1];
+ outString[i]=0;
+}
+
+/*************************************************************************/
+PaError PaHost_Term( void )
+{
+ int i;
+ PaDeviceInfo *dev;
+ double *rates;
+ /* Free any allocated sample rate arrays. */
+ for( i=0; i<sNumDevices; i++ )
+ {
+ dev = &sDevices[i].pad_Info;
+ rates = (double *) dev->sampleRates;
+ if( (rates != NULL) ) free( rates ); /* MEM_011 */
+ dev->sampleRates = NULL;
+ if( dev->name != NULL ) free( (void *) dev->name ); /* MEM_010 */
+ dev->name = NULL;
+ }
+ sNumDevices = 0;
+ return paNoError;
+}
+
+/*************************************************************************
+ PaHost_Init() is the library initialization function - call this before
+ using the library.
+*/
+PaError PaHost_Init( void )
+{
+ PaError err;
+ NumVersionVariant version;
+
+ version.parts = SndSoundManagerVersion();
+ DBUG(("SndSoundManagerVersion = 0x%x\n", version.whole));
+
+ /* Have we already initialized the device info? */
+ err = (PaError) Pa_CountDevices();
+ if( err < 0 ) return err;
+ else return paNoError;
+}
+
+/*************************************************************************
+ PaMac_ScanOutputDevices() queries the properties of all output devices.
+*/
+static PaError PaMac_ScanOutputDevices( void )
+{
+ PaError err;
+ Component identifier=0;
+ ComponentDescription criteria = { kSoundOutputDeviceType, 0, 0, 0, 0 };
+ long numComponents, i;
+
+ /* Search the system linked list for output components */
+ numComponents = CountComponents (&criteria);
+ identifier = 0;
+ sDefaultOutputDeviceID = sNumDevices; /* FIXME - query somehow */
+ for (i = 0; i < numComponents; i++)
+ {
+ /* passing nil returns first matching component. */
+ identifier = FindNextComponent( identifier, &criteria);
+ sDevices[sNumDevices].pad_Identifier = identifier;
+
+ /* Set up for default OUTPUT devices. */
+ err = PaMac_QueryOutputDeviceInfo( identifier, &sDevices[sNumDevices] );
+ if( err < 0 ) return err;
+ else sNumDevices++;
+
+ }
+
+ return paNoError;
+}
+
+/*************************************************************************
+ PaMac_ScanInputDevices() queries the properties of all input devices.
+*/
+static PaError PaMac_ScanInputDevices( void )
+{
+ Str255 deviceName;
+ int count;
+ Handle iconHandle;
+ PaError err;
+ OSErr oserr;
+ count = 1;
+ sDefaultInputDeviceID = sNumDevices; /* FIXME - query somehow */ /* PLB20010415 - was setting sDefaultOutputDeviceID */
+ while(true)
+ {
+ /* Thanks Chris Rolfe and Alberto Ricci for this trick. */
+ oserr = SPBGetIndexedDevice(count++, deviceName, &iconHandle);
+ DBUG(("PaMac_ScanInputDevices: SPBGetIndexedDevice returned %d\n", oserr ));
+#if 1
+ /* PLB20010415 - was giving error for anything other than siBadSoundInDevice, but some Macs may return other errors! */
+ if(oserr != noErr) break; /* Some type of error is expected when count > devices */
+#else
+ if(oserr == siBadSoundInDevice)
+ { /* it's expected when count > devices */
+ oserr = noErr;
+ break;
+ }
+ if(oserr != noErr)
+ {
+ ERR_RPT(("ERROR: SPBGetIndexedDevice(%d,,) returned %d\n", count-1, oserr ));
+ sPaHostError = oserr;
+ return paHostError;
+ }
+#endif
+ DisposeHandle(iconHandle); /* Don't need the icon */
+
+ err = PaMac_QueryInputDeviceInfo( deviceName, &sDevices[sNumDevices] );
+ DBUG(("PaMac_ScanInputDevices: PaMac_QueryInputDeviceInfo returned %d\n", err ));
+ if( err < 0 ) return err;
+ else if( err == 1 ) sNumDevices++;
+ }
+
+ return paNoError;
+}
+
+/* Sample rate info returned by using siSampleRateAvailable selector in SPBGetDeviceInfo() */
+/* Thanks to Chris Rolfe for help with this query. */
+#pragma options align=mac68k
+typedef struct
+{
+ int16 numRates;
+ UnsignedFixed (**rates)[]; /* Handle created by SPBGetDeviceInfo */
+}
+SRateInfo;
+#pragma options align=reset
+
+/*************************************************************************
+** PaMac_QueryOutputDeviceInfo()
+** Query information about a named output device.
+** Clears contents of ipad and writes info based on queries.
+** Return one if OK,
+** zero if device cannot be used,
+** or negative error.
+*/
+static PaError PaMac_QueryOutputDeviceInfo( Component identifier, internalPortAudioDevice *ipad )
+{
+ int len;
+ OSErr err;
+ PaDeviceInfo *dev = &ipad->pad_Info;
+ SRateInfo srinfo = {0};
+ int numRates;
+ ComponentDescription tempD;
+ Handle nameH=nil, infoH=nil, iconH=nil;
+
+ memset( ipad, 0, sizeof(internalPortAudioDevice) );
+
+ dev->structVersion = 1;
+ dev->maxInputChannels = 0;
+ dev->maxOutputChannels = 2;
+ dev->nativeSampleFormats = paInt16; /* FIXME - query to see if 24 or 32 bit data can be handled. */
+
+ /* Get sample rates supported. */
+ err = GetSoundOutputInfo(identifier, siSampleRateAvailable, (Ptr) &srinfo);
+ if(err != noErr)
+ {
+ ERR_RPT(("Error in PaMac_QueryOutputDeviceInfo: GetSoundOutputInfo siSampleRateAvailable returned %d\n", err ));
+ goto error;
+ }
+ numRates = srinfo.numRates;
+ DBUG(("PaMac_QueryOutputDeviceInfo: srinfo.numRates = 0x%x\n", srinfo.numRates ));
+ if( numRates == 0 )
+ {
+ dev->numSampleRates = -1;
+ numRates = 2;
+ }
+ else
+ {
+ dev->numSampleRates = numRates;
+ }
+ dev->sampleRates = PaMac_GetSampleRatesFromHandle( numRates, (Handle) srinfo.rates );
+ /* SPBGetDeviceInfo created the handle, but it's OUR job to release it. */
+ DisposeHandle((Handle) srinfo.rates);
+
+ /* Device name */
+ /* we pass an existing handle for the component name;
+ we don't care about the info (type, subtype, etc.) or icon, so set them to nil */
+ infoH = nil;
+ iconH = nil;
+ nameH = NewHandle(0);
+ if(nameH == nil) return paInsufficientMemory;
+ err = GetComponentInfo(identifier, &tempD, nameH, infoH, iconH);
+ if (err)
+ {
+ ERR_RPT(("Error in PaMac_QueryOutputDeviceInfo: GetComponentInfo returned %d\n", err ));
+ goto error;
+ }
+ len = (*nameH)[0] + 1;
+ dev->name = (char *) malloc(len); /* MEM_010 */
+ if( dev->name == NULL )
+ {
+ DisposeHandle(nameH);
+ return paInsufficientMemory;
+ }
+ else
+ {
+ PToCString((unsigned char *)(*nameH), (char *) dev->name);
+ DisposeHandle(nameH);
+ }
+
+ DBUG(("PaMac_QueryOutputDeviceInfo: dev->name = %s\n", dev->name ));
+ return paNoError;
+
+error:
+ sPaHostError = err;
+ return paHostError;
+
+}
+
+/*************************************************************************
+** PaMac_QueryInputDeviceInfo()
+** Query information about a named input device.
+** Clears contents of ipad and writes info based on queries.
+** Return one if OK,
+** zero if device cannot be used,
+** or negative error.
+*/
+static PaError PaMac_QueryInputDeviceInfo( Str255 deviceName, internalPortAudioDevice *ipad )
+{
+ PaError result = paNoError;
+ int len;
+ OSErr err;
+ long mRefNum = 0;
+ long tempL;
+ int16 tempS;
+ Fixed tempF;
+ PaDeviceInfo *dev = &ipad->pad_Info;
+ SRateInfo srinfo = {0};
+ int numRates;
+
+ memset( ipad, 0, sizeof(internalPortAudioDevice) );
+ dev->maxOutputChannels = 0;
+
+ /* Open device based on name. If device is in use, it may not be able to open in write mode. */
+ err = SPBOpenDevice( deviceName, siWritePermission, &mRefNum);
+ if (err)
+ {
+ /* If device is in use, it may not be able to open in write mode so try read mode. */
+ err = SPBOpenDevice( deviceName, siReadPermission, &mRefNum);
+ if (err)
+ {
+ ERR_RPT(("Error in PaMac_QueryInputDeviceInfo: SPBOpenDevice returned %d\n", err ));
+ sPaHostError = err;
+ return paHostError;
+ }
+ }
+
+ /* Define macros for printing out device info. */
+#define PrintDeviceInfo(selector,var) \
+ err = SPBGetDeviceInfo(mRefNum, selector, (Ptr) &var); \
+ if (err) { \
+ DBUG(("query %s failed\n", #selector )); \
+ }\
+ else { \
+ DBUG(("query %s = 0x%x\n", #selector, var )); \
+ }
+
+ PrintDeviceInfo( siContinuous, tempS );
+ PrintDeviceInfo( siAsync, tempS );
+ PrintDeviceInfo( siNumberChannels, tempS );
+ PrintDeviceInfo( siSampleSize, tempS );
+ PrintDeviceInfo( siSampleRate, tempF );
+ PrintDeviceInfo( siChannelAvailable, tempS );
+ PrintDeviceInfo( siActiveChannels, tempL );
+ PrintDeviceInfo( siDeviceBufferInfo, tempL );
+
+ err = SPBGetDeviceInfo(mRefNum, siActiveChannels, (Ptr) &tempL);
+ if (err == 0) DBUG(("%s = 0x%x\n", "siActiveChannels", tempL ));
+ /* Can we use this device? */
+ err = SPBGetDeviceInfo(mRefNum, siAsync, (Ptr) &tempS);
+ if (err)
+ {
+ ERR_RPT(("Error in PaMac_QueryInputDeviceInfo: SPBGetDeviceInfo siAsync returned %d\n", err ));
+ goto error;
+ }
+ if( tempS == 0 ) goto useless; /* Does not support async recording so forget about it. */
+
+ err = SPBGetDeviceInfo(mRefNum, siChannelAvailable, (Ptr) &tempS);
+ if (err)
+ {
+ ERR_RPT(("Error in PaMac_QueryInputDeviceInfo: SPBGetDeviceInfo siChannelAvailable returned %d\n", err ));
+ goto error;
+ }
+ dev->maxInputChannels = tempS;
+
+ /* Get sample rates supported. */
+ err = SPBGetDeviceInfo(mRefNum, siSampleRateAvailable, (Ptr) &srinfo);
+ if (err)
+ {
+ ERR_RPT(("Error in PaMac_QueryInputDeviceInfo: SPBGetDeviceInfo siSampleRateAvailable returned %d\n", err ));
+ goto error;
+ }
+
+ numRates = srinfo.numRates;
+ DBUG(("numRates = 0x%x\n", numRates ));
+ if( numRates == 0 )
+ {
+ dev->numSampleRates = -1;
+ numRates = 2;
+ }
+ else
+ {
+ dev->numSampleRates = numRates;
+ }
+ dev->sampleRates = PaMac_GetSampleRatesFromHandle( numRates, (Handle) srinfo.rates );
+ /* SPBGetDeviceInfo created the handle, but it's OUR job to release it. */
+ DisposeHandle((Handle) srinfo.rates);
+
+ /* Get size of device buffer. */
+ err = SPBGetDeviceInfo(mRefNum, siDeviceBufferInfo, (Ptr) &tempL);
+ if (err)
+ {
+ ERR_RPT(("Error in PaMac_QueryInputDeviceInfo: SPBGetDeviceInfo siDeviceBufferInfo returned %d\n", err ));
+ goto error;
+ }
+ ipad->pad_DeviceBufferSize = tempL;
+ DBUG(("siDeviceBufferInfo = %d\n", tempL ));
+
+ /* Set format based on sample size. */
+ err = SPBGetDeviceInfo(mRefNum, siSampleSize, (Ptr) &tempS);
+ if (err)
+ {
+ ERR_RPT(("Error in PaMac_QueryInputDeviceInfo: SPBGetDeviceInfo siSampleSize returned %d\n", err ));
+ goto error;
+ }
+ switch( tempS )
+ {
+ case 0x0020:
+ dev->nativeSampleFormats = paInt32; /* FIXME - warning, code probably won't support this! */
+ break;
+ case 0x0010:
+ default: /* FIXME - What about other formats? */
+ dev->nativeSampleFormats = paInt16;
+ break;
+ }
+ DBUG(("nativeSampleFormats = %d\n", dev->nativeSampleFormats ));
+
+ /* Device name */
+ len = deviceName[0] + 1; /* Get length of Pascal string */
+ dev->name = (char *) malloc(len); /* MEM_010 */
+ if( dev->name == NULL )
+ {
+ result = paInsufficientMemory;
+ goto cleanup;
+ }
+ PToCString(deviceName, (char *) dev->name);
+ DBUG(("deviceName = %s\n", dev->name ));
+ result = (PaError) 1;
+ /* All done so close up device. */
+cleanup:
+ if( mRefNum ) SPBCloseDevice(mRefNum);
+ return result;
+
+error:
+ if( mRefNum ) SPBCloseDevice(mRefNum);
+ sPaHostError = err;
+ return paHostError;
+
+useless:
+ if( mRefNum ) SPBCloseDevice(mRefNum);
+ return (PaError) 0;
+}
+
+/*************************************************************************
+** Allocate a double array and fill it with listed sample rates.
+*/
+static double * PaMac_GetSampleRatesFromHandle ( int numRates, Handle h )
+{
+ OSErr err = noErr;
+ SInt8 hState;
+ int i;
+ UnsignedFixed *fixedRates;
+ double *rates = (double *) malloc( numRates * sizeof(double) ); /* MEM_011 */
+ if( rates == NULL ) return NULL;
+ /* Save and restore handle state as suggested by TechNote at:
+ http://developer.apple.com/technotes/tn/tn1122.html
+ */
+ hState = HGetState (h);
+ if (!(err = MemError ()))
+ {
+ HLock (h);
+ if (!(err = MemError ( )))
+ {
+ fixedRates = (UInt32 *) *h;
+ for( i=0; i<numRates; i++ )
+ {
+ rates[i] = UnsignedFixedToDouble(fixedRates[i]);
+ }
+
+ HSetState (h,hState);
+ err = MemError ( );
+ }
+ }
+ if( err )
+ {
+ free( rates );
+ ERR_RPT(("Error in PaMac_GetSampleRatesFromHandle = %d\n", err ));
+ }
+ return rates;
+}
+
+/*************************************************************************/
+int Pa_CountDevices()
+{
+ PaError err;
+ DBUG(("Pa_CountDevices()\n"));
+ /* If no devices, go find some. */
+ if( sNumDevices <= 0 )
+ {
+ err = PaMac_ScanOutputDevices();
+ if( err != paNoError ) goto error;
+ err = PaMac_ScanInputDevices();
+ if( err != paNoError ) goto error;
+ }
+ return sNumDevices;
+
+error:
+ PaHost_Term();
+ DBUG(("Pa_CountDevices: returns %d\n", err ));
+ return err;
+
+}
+
+/*************************************************************************/
+const PaDeviceInfo* Pa_GetDeviceInfo( PaDeviceID id )
+{
+ if( (id < 0) || ( id >= Pa_CountDevices()) ) return NULL;
+ return &sDevices[id].pad_Info;
+}
+/*************************************************************************/
+PaDeviceID Pa_GetDefaultInputDeviceID( void )
+{
+ return sDefaultInputDeviceID;
+}
+
+/*************************************************************************/
+PaDeviceID Pa_GetDefaultOutputDeviceID( void )
+{
+ return sDefaultOutputDeviceID;
+}
+
+/********************************* BEGIN CPU UTILIZATION MEASUREMENT ****/
+static void PaMac_StartLoadCalculation( internalPortAudioStream *past )
+{
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ UnsignedWide widePad;
+ if( pahsc == NULL ) return;
+ /* Query system timer for usage analysis and to prevent overuse of CPU. */
+ Microseconds( &widePad );
+ pahsc->pahsc_EntryCount = UnsignedWideToUInt64( widePad );
+}
+
+/******************************************************************************
+** Measure fractional CPU load based on real-time it took to calculate
+** buffers worth of output.
+*/
+/**************************************************************************/
+static void PaMac_EndLoadCalculation( internalPortAudioStream *past )
+{
+ UnsignedWide widePad;
+ UInt64 currentCount;
+ long usecsElapsed;
+ double newUsage;
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ if( pahsc == NULL ) return;
+
+ /* Measure CPU utilization during this callback. Note that this calculation
+ ** assumes that we had the processor the whole time.
+ */
+#define LOWPASS_COEFFICIENT_0 (0.95)
+#define LOWPASS_COEFFICIENT_1 (0.99999 - LOWPASS_COEFFICIENT_0)
+ Microseconds( &widePad );
+ currentCount = UnsignedWideToUInt64( widePad );
+
+ usecsElapsed = (long) U64Subtract(currentCount, pahsc->pahsc_EntryCount);
+
+ /* Use inverse because it is faster than the divide. */
+ newUsage = usecsElapsed * pahsc->pahsc_InverseMicrosPerHostBuffer;
+
+ past->past_Usage = (LOWPASS_COEFFICIENT_0 * past->past_Usage) +
+ (LOWPASS_COEFFICIENT_1 * newUsage);
+
+}
+
+/***********************************************************************
+** Called by Pa_StartStream()
+*/
+PaError PaHost_StartInput( internalPortAudioStream *past )
+{
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ pahsc->pahsc_IsRecording = 0;
+ pahsc->pahsc_StopRecording = 0;
+ pahsc->pahsc_InputMultiBuffer.nextWrite = 0;
+ pahsc->pahsc_InputMultiBuffer.nextRead = 0;
+ return PaMac_RecordNext( past );
+}
+
+/***********************************************************************
+** Called by Pa_StopStream().
+** May be called during error recovery or cleanup code
+** so protect against NULL pointers.
+*/
+PaError PaHost_StopInput( internalPortAudioStream *past, int abort )
+{
+ int32 timeOutMsec;
+ PaError result = paNoError;
+ OSErr err = 0;
+ long mRefNum;
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ if( pahsc == NULL ) return paNoError;
+
+ (void) abort;
+
+ mRefNum = pahsc->pahsc_InputRefNum;
+
+ DBUG(("PaHost_StopInput: mRefNum = %d\n", mRefNum ));
+ if( mRefNum )
+ {
+ DBUG(("PaHost_StopInput: pahsc_IsRecording = %d\n", pahsc->pahsc_IsRecording ));
+ if( pahsc->pahsc_IsRecording )
+ {
+ /* PLB20010420 - Fix TIMEOUT in record mode. */
+ pahsc->pahsc_StopRecording = 1; /* Request that we stop recording. */
+ err = SPBStopRecording(mRefNum);
+ DBUG(("PaHost_StopInput: then pahsc_IsRecording = %d\n", pahsc->pahsc_IsRecording ));
+
+ /* Calculate timeOut longer than longest time it could take to play one buffer. */
+ timeOutMsec = (int32) ((1500.0 * pahsc->pahsc_FramesPerHostBuffer) / past->past_SampleRate);
+ /* Keep querying sound channel until it is no longer busy playing. */
+ while( !err && pahsc->pahsc_IsRecording && (timeOutMsec > 0))
+ {
+ Pa_Sleep(20);
+ timeOutMsec -= 20;
+ }
+ if( timeOutMsec <= 0 )
+ {
+ ERR_RPT(("PaHost_StopInput: timed out!\n"));
+ return paTimedOut;
+ }
+ }
+ }
+ if( err )
+ {
+ sPaHostError = err;
+ result = paHostError;
+ }
+
+ DBUG(("PaHost_StopInput: finished.\n", mRefNum ));
+ return result;
+}
+
+/***********************************************************************/
+static void PaMac_InitSoundHeader( internalPortAudioStream *past, CmpSoundHeader *sndHeader )
+{
+ sndHeader->numChannels = past->past_NumOutputChannels;
+ sndHeader->sampleRate = DoubleToUnsignedFixed(past->past_SampleRate);
+ sndHeader->loopStart = 0;
+ sndHeader->loopEnd = 0;
+ sndHeader->encode = cmpSH;
+ sndHeader->baseFrequency = kMiddleC;
+ sndHeader->markerChunk = nil;
+ sndHeader->futureUse2 = nil;
+ sndHeader->stateVars = nil;
+ sndHeader->leftOverSamples = nil;
+ sndHeader->compressionID = 0;
+ sndHeader->packetSize = 0;
+ sndHeader->snthID = 0;
+ sndHeader->sampleSize = 8 * sizeof(int16); // FIXME - might be 24 or 32 bits some day;
+ sndHeader->sampleArea[0] = 0;
+ sndHeader->format = kSoundNotCompressed;
+}
+
+static void SetFramesDone( PaHostSoundControl *pahsc, PaTimestamp framesDone )
+{
+ UnsignedWide now;
+ Microseconds( &now );
+ pahsc->pahsc_NumFramesDone = framesDone;
+ pahsc->pahsc_WhenFramesDoneIncremented = UnsignedWideToUInt64( now );
+}
+
+/***********************************************************************/
+PaError PaHost_StartOutput( internalPortAudioStream *past )
+{
+ SndCommand pauseCommand;
+ SndCommand resumeCommand;
+ int i;
+ OSErr error;
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ if( pahsc == NULL ) return paInternalError;
+ if( pahsc->pahsc_Channel == NULL ) return paInternalError;
+
+ past->past_StopSoon = 0;
+ past->past_IsActive = 1;
+ pahsc->pahsc_NumOutsQueued = 0;
+ pahsc->pahsc_NumOutsPlayed = 0;
+
+ SetFramesDone( pahsc, 0.0 );
+
+ /* Pause channel so it does not do back ground processing while we are still filling the queue. */
+ pauseCommand.cmd = pauseCmd;
+ pauseCommand.param1 = pauseCommand.param2 = 0;
+ error = SndDoCommand (pahsc->pahsc_Channel, &pauseCommand, true);
+ if (noErr != error) goto exit;
+
+ /* Queue all of the buffers so we start off full. */
+ for (i = 0; i<pahsc->pahsc_NumHostBuffers; i++)
+ {
+ PaMac_PlayNext( past, i );
+ }
+
+ /* Resume channel now that the queue is full. */
+ resumeCommand.cmd = resumeCmd;
+ resumeCommand.param1 = resumeCommand.param2 = 0;
+ error = SndDoImmediate( pahsc->pahsc_Channel, &resumeCommand );
+ if (noErr != error) goto exit;
+
+ return paNoError;
+exit:
+ past->past_IsActive = 0;
+ sPaHostError = error;
+ ERR_RPT(("Error in PaHost_StartOutput: SndDoCommand returned %d\n", error ));
+ return paHostError;
+}
+
+/*******************************************************************/
+long PaHost_GetTotalBufferFrames( internalPortAudioStream *past )
+{
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ return (long) (pahsc->pahsc_NumHostBuffers * pahsc->pahsc_FramesPerHostBuffer);
+}
+
+/***********************************************************************
+** Called by Pa_StopStream().
+** May be called during error recovery or cleanup code
+** so protect against NULL pointers.
+*/
+PaError PaHost_StopOutput( internalPortAudioStream *past, int abort )
+{
+ int32 timeOutMsec;
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ if( pahsc == NULL ) return paNoError;
+ if( pahsc->pahsc_Channel == NULL ) return paNoError;
+
+ DBUG(("PaHost_StopOutput()\n"));
+ if( past->past_IsActive == 0 ) return paNoError;
+
+ /* Set flags for callback function to see. */
+ if( abort ) past->past_StopNow = 1;
+ past->past_StopSoon = 1;
+ /* Calculate timeOut longer than longest time it could take to play all buffers. */
+ timeOutMsec = (int32) ((1500.0 * PaHost_GetTotalBufferFrames( past )) / past->past_SampleRate);
+ /* Keep querying sound channel until it is no longer busy playing. */
+ while( past->past_IsActive && (timeOutMsec > 0))
+ {
+ Pa_Sleep(20);
+ timeOutMsec -= 20;
+ }
+ if( timeOutMsec <= 0 )
+ {
+ ERR_RPT(("PaHost_StopOutput: timed out!\n"));
+ return paTimedOut;
+ }
+ else return paNoError;
+}
+
+/***********************************************************************/
+PaError PaHost_StartEngine( internalPortAudioStream *past )
+{
+ (void) past; /* Prevent unused variable warnings. */
+ return paNoError;
+}
+
+/***********************************************************************/
+PaError PaHost_StopEngine( internalPortAudioStream *past, int abort )
+{
+ (void) past; /* Prevent unused variable warnings. */
+ (void) abort; /* Prevent unused variable warnings. */
+ return paNoError;
+}
+/***********************************************************************/
+PaError PaHost_StreamActive( internalPortAudioStream *past )
+{
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ return (PaError) ( past->past_IsActive + pahsc->pahsc_IsRecording );
+}
+int Mac_IsVirtualMemoryOn( void )
+{
+ long attr;
+ OSErr result = Gestalt( gestaltVMAttr, &attr );
+ DBUG(("gestaltVMAttr : 0x%x\n", attr ));
+ return ((attr >> gestaltVMHasPagingControl ) & 1);
+}
+
+/*******************************************************************
+* Determine number of host Buffers
+* and how many User Buffers we can put into each host buffer.
+*/
+static void PaHost_CalcNumHostBuffers( internalPortAudioStream *past )
+{
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ int32 minNumBuffers;
+ int32 minFramesPerHostBuffer;
+ int32 minTotalFrames;
+ int32 userBuffersPerHostBuffer;
+ int32 framesPerHostBuffer;
+ int32 numHostBuffers;
+
+ minFramesPerHostBuffer = pahsc->pahsc_MinFramesPerHostBuffer;
+ minFramesPerHostBuffer = (minFramesPerHostBuffer + 7) & ~7;
+ DBUG(("PaHost_CalcNumHostBuffers: minFramesPerHostBuffer = %d\n", minFramesPerHostBuffer ));
+
+ /* Determine number of user buffers based on minimum latency. */
+ /* PLB20020417 I used to call Pa_GetMinNumBuffers() which doesn't take into account the
+ ** variable minFramesPerHostBuffer. Now I call PaMac_GetMinNumBuffers() which will
+ ** gove lower latency when virtual memory is turned off. */
+ /* minNumBuffers = Pa_GetMinNumBuffers( past->past_FramesPerUserBuffer, past->past_SampleRate ); WRONG */
+ minNumBuffers = PaMac_GetMinNumBuffers( minFramesPerHostBuffer, past->past_FramesPerUserBuffer, past->past_SampleRate );
+
+ past->past_NumUserBuffers = ( minNumBuffers > past->past_NumUserBuffers ) ? minNumBuffers : past->past_NumUserBuffers;
+ DBUG(("PaHost_CalcNumHostBuffers: min past_NumUserBuffers = %d\n", past->past_NumUserBuffers ));
+ minTotalFrames = past->past_NumUserBuffers * past->past_FramesPerUserBuffer;
+
+ /* We cannot make the buffers too small because they may not get serviced quickly enough. */
+ if( (int32) past->past_FramesPerUserBuffer < minFramesPerHostBuffer )
+ {
+ userBuffersPerHostBuffer =
+ (minFramesPerHostBuffer + past->past_FramesPerUserBuffer - 1) /
+ past->past_FramesPerUserBuffer;
+ }
+ else
+ {
+ userBuffersPerHostBuffer = 1;
+ }
+ framesPerHostBuffer = past->past_FramesPerUserBuffer * userBuffersPerHostBuffer;
+
+ /* Calculate number of host buffers needed. Round up to cover minTotalFrames. */
+ numHostBuffers = (minTotalFrames + framesPerHostBuffer - 1) / framesPerHostBuffer;
+ /* Make sure we have enough host buffers. */
+ if( numHostBuffers < PA_MIN_NUM_HOST_BUFFERS)
+ {
+ numHostBuffers = PA_MIN_NUM_HOST_BUFFERS;
+ }
+ else
+ {
+ /* If we have too many host buffers, try to put more user buffers in a host buffer. */
+ while(numHostBuffers > PA_MAX_NUM_HOST_BUFFERS)
+ {
+ userBuffersPerHostBuffer += 1;
+ framesPerHostBuffer = past->past_FramesPerUserBuffer * userBuffersPerHostBuffer;
+ numHostBuffers = (minTotalFrames + framesPerHostBuffer - 1) / framesPerHostBuffer;
+ }
+ }
+
+ pahsc->pahsc_UserBuffersPerHostBuffer = userBuffersPerHostBuffer;
+ pahsc->pahsc_FramesPerHostBuffer = framesPerHostBuffer;
+ pahsc->pahsc_NumHostBuffers = numHostBuffers;
+ DBUG(("PaHost_CalcNumHostBuffers: pahsc_UserBuffersPerHostBuffer = %d\n", pahsc->pahsc_UserBuffersPerHostBuffer ));
+ DBUG(("PaHost_CalcNumHostBuffers: pahsc_NumHostBuffers = %d\n", pahsc->pahsc_NumHostBuffers ));
+ DBUG(("PaHost_CalcNumHostBuffers: pahsc_FramesPerHostBuffer = %d\n", pahsc->pahsc_FramesPerHostBuffer ));
+ DBUG(("PaHost_CalcNumHostBuffers: past_NumUserBuffers = %d\n", past->past_NumUserBuffers ));
+}
+
+/*******************************************************************/
+PaError PaHost_OpenStream( internalPortAudioStream *past )
+{
+ OSErr err;
+ PaError result = paHostError;
+ PaHostSoundControl *pahsc;
+ int i;
+ /* Allocate and initialize host data. */
+ pahsc = (PaHostSoundControl *) PaHost_AllocateFastMemory(sizeof(PaHostSoundControl));
+ if( pahsc == NULL )
+ {
+ return paInsufficientMemory;
+ }
+ past->past_DeviceData = (void *) pahsc;
+
+ /* If recording, and virtual memory is turned on, then use bigger buffers to prevent glitches. */
+ if( (past->past_NumInputChannels > 0) && Mac_IsVirtualMemoryOn() )
+ {
+ pahsc->pahsc_MinFramesPerHostBuffer = MAC_VIRTUAL_FRAMES_PER_BUFFER;
+ }
+ else
+ {
+ pahsc->pahsc_MinFramesPerHostBuffer = MAC_PHYSICAL_FRAMES_PER_BUFFER;
+ }
+
+ PaHost_CalcNumHostBuffers( past );
+
+ /* Setup constants for CPU load measurement. */
+ pahsc->pahsc_InverseMicrosPerHostBuffer = past->past_SampleRate / (1000000.0 * pahsc->pahsc_FramesPerHostBuffer);
+
+ /* ------------------ OUTPUT */
+ if( past->past_NumOutputChannels > 0 )
+ {
+ /* Create sound channel to which we can send commands. */
+ pahsc->pahsc_Channel = 0L;
+ err = SndNewChannel(&pahsc->pahsc_Channel, sampledSynth, 0, nil); /* FIXME - use kUseOptionalOutputDevice if not default. */
+ if(err != 0)
+ {
+ ERR_RPT(("Error in PaHost_OpenStream: SndNewChannel returned 0x%x\n", err ));
+ goto error;
+ }
+
+ /* Install our callback function pointer straight into the sound channel structure */
+ /* Use new CARBON name for callback procedure. */
+#if TARGET_API_MAC_CARBON
+ pahsc->pahsc_OutputCompletionProc = NewSndCallBackUPP(PaMac_OutputCompletionProc);
+#else
+ pahsc->pahsc_OutputCompletionProc = NewSndCallBackProc(PaMac_OutputCompletionProc);
+#endif
+
+ pahsc->pahsc_Channel->callBack = pahsc->pahsc_OutputCompletionProc;
+
+ pahsc->pahsc_BytesPerOutputHostBuffer = pahsc->pahsc_FramesPerHostBuffer * past->past_NumOutputChannels * sizeof(int16);
+ for (i = 0; i<pahsc->pahsc_NumHostBuffers; i++)
+ {
+ char *buf = (char *)PaHost_AllocateFastMemory(pahsc->pahsc_BytesPerOutputHostBuffer);
+ if (buf == NULL)
+ {
+ ERR_RPT(("Error in PaHost_OpenStream: could not allocate output buffer. Size = \n", pahsc->pahsc_BytesPerOutputHostBuffer ));
+ goto memerror;
+ }
+
+ PaMac_InitSoundHeader( past, &pahsc->pahsc_SoundHeaders[i] );
+ pahsc->pahsc_SoundHeaders[i].samplePtr = buf;
+ pahsc->pahsc_SoundHeaders[i].numFrames = (unsigned long) pahsc->pahsc_FramesPerHostBuffer;
+
+ }
+ }
+#ifdef SUPPORT_AUDIO_CAPTURE
+ /* ------------------ INPUT */
+ /* Use double buffer scheme that matches output. */
+ if( past->past_NumInputChannels > 0 )
+ {
+ int16 tempS;
+ long tempL;
+ Fixed tempF;
+ long mRefNum;
+ unsigned char noname = 0; /* FIXME - use real device names. */
+#if TARGET_API_MAC_CARBON
+ pahsc->pahsc_InputCompletionProc = NewSICompletionUPP((SICompletionProcPtr)PaMac_InputCompletionProc);
+#else
+ pahsc->pahsc_InputCompletionProc = NewSICompletionProc((ProcPtr)PaMac_InputCompletionProc);
+#endif
+ pahsc->pahsc_BytesPerInputHostBuffer = pahsc->pahsc_FramesPerHostBuffer * past->past_NumInputChannels * sizeof(int16);
+ for (i = 0; i<pahsc->pahsc_NumHostBuffers; i++)
+ {
+ char *buf = (char *) PaHost_AllocateFastMemory(pahsc->pahsc_BytesPerInputHostBuffer);
+ if ( buf == NULL )
+ {
+ ERR_RPT(("PaHost_OpenStream: could not allocate input buffer. Size = \n", pahsc->pahsc_BytesPerInputHostBuffer ));
+ goto memerror;
+ }
+ pahsc->pahsc_InputMultiBuffer.buffers[i] = buf;
+ }
+ pahsc->pahsc_InputMultiBuffer.numBuffers = pahsc->pahsc_NumHostBuffers;
+
+ err = SPBOpenDevice( (const unsigned char *) &noname, siWritePermission, &mRefNum); /* FIXME - use name so we get selected device */
+ // FIXME err = SPBOpenDevice( (const unsigned char *) sDevices[past->past_InputDeviceID].pad_Info.name, siWritePermission, &mRefNum);
+ if (err) goto error;
+ pahsc->pahsc_InputRefNum = mRefNum;
+ DBUG(("PaHost_OpenStream: mRefNum = %d\n", mRefNum ));
+
+ /* Set input device characteristics. */
+ tempS = 1;
+ err = SPBSetDeviceInfo(mRefNum, siContinuous, (Ptr) &tempS);
+ if (err)
+ {
+ ERR_RPT(("Error in PaHost_OpenStream: SPBSetDeviceInfo siContinuous returned %d\n", err ));
+ goto error;
+ }
+
+ tempL = 0x03;
+ err = SPBSetDeviceInfo(mRefNum, siActiveChannels, (Ptr) &tempL);
+ if (err)
+ {
+ DBUG(("PaHost_OpenStream: setting siActiveChannels returned 0x%x. Error ignored.\n", err ));
+ }
+
+ /* PLB20010908 - Use requested number of input channels. Thanks Dominic Mazzoni. */
+ tempS = past->past_NumInputChannels;
+ err = SPBSetDeviceInfo(mRefNum, siNumberChannels, (Ptr) &tempS);
+ if (err)
+ {
+ ERR_RPT(("Error in PaHost_OpenStream: SPBSetDeviceInfo siNumberChannels returned %d\n", err ));
+ goto error;
+ }
+
+ tempF = ((unsigned long)past->past_SampleRate) << 16;
+ err = SPBSetDeviceInfo(mRefNum, siSampleRate, (Ptr) &tempF);
+ if (err)
+ {
+ ERR_RPT(("Error in PaHost_OpenStream: SPBSetDeviceInfo siSampleRate returned %d\n", err ));
+ goto error;
+ }
+
+ /* Setup record-parameter block */
+ pahsc->pahsc_InputParams.inRefNum = mRefNum;
+ pahsc->pahsc_InputParams.milliseconds = 0; // not used
+ pahsc->pahsc_InputParams.completionRoutine = pahsc->pahsc_InputCompletionProc;
+ pahsc->pahsc_InputParams.interruptRoutine = 0;
+ pahsc->pahsc_InputParams.userLong = (long) past;
+ pahsc->pahsc_InputParams.unused1 = 0;
+ }
+#endif /* SUPPORT_AUDIO_CAPTURE */
+ DBUG(("PaHost_OpenStream: complete.\n"));
+ return paNoError;
+
+error:
+ PaHost_CloseStream( past );
+ ERR_RPT(("PaHost_OpenStream: sPaHostError = 0x%x.\n", err ));
+ sPaHostError = err;
+ return paHostError;
+
+memerror:
+ PaHost_CloseStream( past );
+ return paInsufficientMemory;
+}
+
+/***********************************************************************
+** Called by Pa_CloseStream().
+** May be called during error recovery or cleanup code
+** so protect against NULL pointers.
+*/
+PaError PaHost_CloseStream( internalPortAudioStream *past )
+{
+ PaError result = paNoError;
+ OSErr err = 0;
+ int i;
+ PaHostSoundControl *pahsc;
+
+ DBUG(("PaHost_CloseStream( 0x%x )\n", past ));
+
+ if( past == NULL ) return paBadStreamPtr;
+
+ pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ if( pahsc == NULL ) return paNoError;
+
+ if( past->past_NumOutputChannels > 0 )
+ {
+ /* TRUE means flush now instead of waiting for quietCmd to be processed. */
+ if( pahsc->pahsc_Channel != NULL ) SndDisposeChannel(pahsc->pahsc_Channel, TRUE);
+ {
+ for (i = 0; i<pahsc->pahsc_NumHostBuffers; i++)
+ {
+ Ptr p = (Ptr) pahsc->pahsc_SoundHeaders[i].samplePtr;
+ if( p != NULL ) PaHost_FreeFastMemory( p, pahsc->pahsc_BytesPerOutputHostBuffer );
+ }
+ }
+ }
+
+ if( past->past_NumInputChannels > 0 )
+ {
+ if( pahsc->pahsc_InputRefNum )
+ {
+ err = SPBCloseDevice(pahsc->pahsc_InputRefNum);
+ pahsc->pahsc_InputRefNum = 0;
+ if( err )
+ {
+ sPaHostError = err;
+ result = paHostError;
+ }
+ }
+ {
+ for (i = 0; i<pahsc->pahsc_InputMultiBuffer.numBuffers; i++)
+ {
+ Ptr p = (Ptr) pahsc->pahsc_InputMultiBuffer.buffers[i];
+ if( p != NULL ) PaHost_FreeFastMemory( p, pahsc->pahsc_BytesPerInputHostBuffer );
+ }
+ }
+ }
+
+ past->past_DeviceData = NULL;
+ PaHost_FreeFastMemory( pahsc, sizeof(PaHostSoundControl) );
+
+ DBUG(("PaHost_CloseStream: complete.\n", past ));
+ return result;
+}
+/*************************************************************************/
+int Pa_GetMinNumBuffers( int framesPerUserBuffer, double sampleRate )
+{
+/* We use the MAC_VIRTUAL_FRAMES_PER_BUFFER because we might be recording.
+** This routine doesn't have enough information to determine the best value
+** and is being depracated. */
+ return PaMac_GetMinNumBuffers( MAC_VIRTUAL_FRAMES_PER_BUFFER, framesPerUserBuffer, sampleRate );
+}
+/*************************************************************************/
+static int PaMac_GetMinNumBuffers( int minFramesPerHostBuffer, int framesPerUserBuffer, double sampleRate )
+{
+ int minUserPerHost = ( minFramesPerHostBuffer + framesPerUserBuffer - 1) / framesPerUserBuffer;
+ int numBufs = PA_MIN_NUM_HOST_BUFFERS * minUserPerHost;
+ if( numBufs < PA_MIN_NUM_HOST_BUFFERS ) numBufs = PA_MIN_NUM_HOST_BUFFERS;
+ (void) sampleRate;
+ return numBufs;
+}
+
+/*************************************************************************/
+void Pa_Sleep( int32 msec )
+{
+ EventRecord event;
+ int32 sleepTime, endTime;
+ /* Convert to ticks. Round up so we sleep a MINIMUM of msec time. */
+ sleepTime = ((msec * 60) + 999) / 1000;
+ if( sleepTime < 1 ) sleepTime = 1;
+ endTime = TickCount() + sleepTime;
+ do
+ {
+ DBUGX(("Sleep for %d ticks.\n", sleepTime ));
+ /* Use WaitNextEvent() to sleep without getting events. */
+ /* PLB20010907 - Pass unused event to WaitNextEvent instead of NULL to prevent
+ * Mac OSX crash. Thanks Dominic Mazzoni. */
+ WaitNextEvent( 0, &event, sleepTime, NULL );
+ sleepTime = endTime - TickCount();
+ }
+ while( sleepTime > 0 );
+}
+/*************************************************************************/
+int32 Pa_GetHostError( void )
+{
+ int32 err = sPaHostError;
+ sPaHostError = 0;
+ return err;
+}
+
+/*************************************************************************
+ * Allocate memory that can be accessed in real-time.
+ * This may need to be held in physical memory so that it is not
+ * paged to virtual memory.
+ * This call MUST be balanced with a call to PaHost_FreeFastMemory().
+ */
+void *PaHost_AllocateFastMemory( long numBytes )
+{
+ void *addr = NewPtrClear( numBytes );
+ if( (addr == NULL) || (MemError () != 0) ) return NULL;
+
+#if (TARGET_API_MAC_CARBON == 0)
+ if( HoldMemory( addr, numBytes ) != noErr )
+ {
+ DisposePtr( (Ptr) addr );
+ return NULL;
+ }
+#endif
+ return addr;
+}
+
+/*************************************************************************
+ * Free memory that could be accessed in real-time.
+ * This call MUST be balanced with a call to PaHost_AllocateFastMemory().
+ */
+void PaHost_FreeFastMemory( void *addr, long numBytes )
+{
+ if( addr == NULL ) return;
+#if TARGET_API_MAC_CARBON
+ (void) numBytes;
+#else
+ UnholdMemory( addr, numBytes );
+#endif
+ DisposePtr( (Ptr) addr );
+}
+
+/*************************************************************************/
+PaTimestamp Pa_StreamTime( PortAudioStream *stream )
+{
+ PaTimestamp framesDone1;
+ PaTimestamp framesDone2;
+ UInt64 whenIncremented;
+ UnsignedWide now;
+ UInt64 now64;
+ long microsElapsed;
+ long framesElapsed;
+
+ PaHostSoundControl *pahsc;
+ internalPortAudioStream *past = (internalPortAudioStream *) stream;
+ if( past == NULL ) return paBadStreamPtr;
+ pahsc = (PaHostSoundControl *) past->past_DeviceData;
+
+/* Capture information from audio thread.
+ * We have to be careful that we don't get interrupted in the middle.
+ * So we grab the pahsc_NumFramesDone twice and make sure it didn't change.
+ */
+ do
+ {
+ framesDone1 = pahsc->pahsc_NumFramesDone;
+ whenIncremented = pahsc->pahsc_WhenFramesDoneIncremented;
+ framesDone2 = pahsc->pahsc_NumFramesDone;
+ } while( framesDone1 != framesDone2 );
+
+ /* Calculate how many microseconds have elapsed and convert to frames. */
+ Microseconds( &now );
+ now64 = UnsignedWideToUInt64( now );
+ microsElapsed = U64Subtract( now64, whenIncremented );
+ framesElapsed = microsElapsed * past->past_SampleRate * 0.000001;
+
+ return framesDone1 + framesElapsed;
+}
+
+/**************************************************************************
+** Callback for Input, SPBRecord()
+*/
+int gRecordCounter = 0;
+int gPlayCounter = 0;
+pascal void PaMac_InputCompletionProc(SPBPtr recParams)
+{
+ PaError result = paNoError;
+ int finished = 1;
+ internalPortAudioStream *past;
+ PaHostSoundControl *pahsc;
+
+ gRecordCounter += 1; /* debug hack to see if engine running */
+
+ /* Get our PA data from Mac structure. */
+ past = (internalPortAudioStream *) recParams->userLong;
+ if( past == NULL ) return;
+
+ if( past->past_Magic != PA_MAGIC )
+ {
+ AddTraceMessage("PaMac_InputCompletionProc: bad MAGIC, past", (long) past );
+ AddTraceMessage("PaMac_InputCompletionProc: bad MAGIC, magic", (long) past->past_Magic );
+ goto error;
+ }
+ pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ past->past_NumCallbacks += 1;
+
+ /* Have we been asked to stop recording? */
+ if( (recParams->error == abortErr) || pahsc->pahsc_StopRecording ) goto error;
+
+ /* If there are no output channels, then we need to call the user callback function from here.
+ * Otherwise we will call the user code during the output completion routine.
+ */
+ if(past->past_NumOutputChannels == 0)
+ {
+ SetFramesDone( pahsc,
+ pahsc->pahsc_NumFramesDone + pahsc->pahsc_FramesPerHostBuffer );
+ result = PaMac_CallUserLoop( past, NULL );
+ }
+
+ /* Did user code ask us to stop? If not, issue another recording request. */
+ if( (result == paNoError) && (pahsc->pahsc_StopRecording == 0) )
+ {
+ result = PaMac_RecordNext( past );
+ if( result != paNoError ) pahsc->pahsc_IsRecording = 0;
+ }
+ else goto error;
+
+ return;
+
+error:
+ pahsc->pahsc_IsRecording = 0;
+ pahsc->pahsc_StopRecording = 0;
+ return;
+}
+
+/***********************************************************************
+** Called by either input or output completion proc.
+** Grabs input data if any present, and calls PA conversion code,
+** that in turn calls user code.
+*/
+static PaError PaMac_CallUserLoop( internalPortAudioStream *past, int16 *outPtr )
+{
+ PaError result = paNoError;
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ int16 *inPtr = NULL;
+ int i;
+
+
+ /* Advance read index for sound input FIFO here, independantly of record/write process. */
+ if(past->past_NumInputChannels > 0)
+ {
+ if( MultiBuffer_IsReadable( &pahsc->pahsc_InputMultiBuffer ) )
+ {
+ inPtr = (int16 *) MultiBuffer_GetNextReadBuffer( &pahsc->pahsc_InputMultiBuffer );
+ MultiBuffer_AdvanceReadIndex( &pahsc->pahsc_InputMultiBuffer );
+ }
+ }
+
+ /* Call user code enough times to fill buffer. */
+ if( (inPtr != NULL) || (outPtr != NULL) )
+ {
+ PaMac_StartLoadCalculation( past ); /* CPU usage */
+
+#ifdef PA_MAX_USAGE_ALLOWED
+ /* If CPU usage exceeds limit, skip user callback to prevent hanging CPU. */
+ if( past->past_Usage > PA_MAX_USAGE_ALLOWED )
+ {
+ past->past_FrameCount += (PaTimestamp) pahsc->pahsc_FramesPerHostBuffer;
+ }
+ else
+#endif
+ {
+
+ for( i=0; i<pahsc->pahsc_UserBuffersPerHostBuffer; i++ )
+ {
+ result = (PaError) Pa_CallConvertInt16( past, inPtr, outPtr );
+ if( result != 0)
+ {
+ /* Recording might be in another process, so tell it to stop with a flag. */
+ pahsc->pahsc_StopRecording = pahsc->pahsc_IsRecording;
+ break;
+ }
+ /* Advance sample pointers. */
+ if(inPtr != NULL) inPtr += past->past_FramesPerUserBuffer * past->past_NumInputChannels;
+ if(outPtr != NULL) outPtr += past->past_FramesPerUserBuffer * past->past_NumOutputChannels;
+ }
+ }
+
+ PaMac_EndLoadCalculation( past );
+ }
+ return result;
+}
+
+/***********************************************************************
+** Setup next recording buffer in FIFO and issue recording request to Snd Input Manager.
+*/
+static PaError PaMac_RecordNext( internalPortAudioStream *past )
+{
+ PaError result = paNoError;
+ OSErr err;
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ /* Get pointer to next buffer to record into. */
+ pahsc->pahsc_InputParams.bufferPtr = MultiBuffer_GetNextWriteBuffer( &pahsc->pahsc_InputMultiBuffer );
+
+ /* Advance write index if there is room. Otherwise keep writing same buffer. */
+ if( MultiBuffer_IsWriteable( &pahsc->pahsc_InputMultiBuffer ) )
+ {
+ MultiBuffer_AdvanceWriteIndex( &pahsc->pahsc_InputMultiBuffer );
+ }
+
+ AddTraceMessage("PaMac_RecordNext: bufferPtr", (long) pahsc->pahsc_InputParams.bufferPtr );
+ AddTraceMessage("PaMac_RecordNext: nextWrite", pahsc->pahsc_InputMultiBuffer.nextWrite );
+
+ /* Setup parameters and issue an asynchronous recording request. */
+ pahsc->pahsc_InputParams.bufferLength = pahsc->pahsc_BytesPerInputHostBuffer;
+ pahsc->pahsc_InputParams.count = pahsc->pahsc_BytesPerInputHostBuffer;
+ err = SPBRecord(&pahsc->pahsc_InputParams, true);
+ if( err )
+ {
+ AddTraceMessage("PaMac_RecordNext: SPBRecord error ", err );
+ sPaHostError = err;
+ result = paHostError;
+ }
+ else
+ {
+ pahsc->pahsc_IsRecording = 1;
+ }
+ return result;
+}
+
+/**************************************************************************
+** Callback for Output Playback()
+** Return negative error, 0 to continue, 1 to stop.
+*/
+long PaMac_FillNextOutputBuffer( internalPortAudioStream *past, int index )
+{
+ PaHostSoundControl *pahsc;
+ long result = 0;
+ int finished = 1;
+ char *outPtr;
+
+ gPlayCounter += 1; /* debug hack */
+
+ past->past_NumCallbacks += 1;
+ pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ if( pahsc == NULL ) return -1;
+ /* Are we nested?! */
+ if( pahsc->pahsc_IfInsideCallback ) return 0;
+ pahsc->pahsc_IfInsideCallback = 1;
+ /* Get pointer to buffer to fill. */
+ outPtr = pahsc->pahsc_SoundHeaders[index].samplePtr;
+ /* Combine with any sound input, and call user callback. */
+ result = PaMac_CallUserLoop( past, (int16 *) outPtr );
+
+ pahsc->pahsc_IfInsideCallback = 0;
+ return result;
+}
+
+/*************************************************************************************
+** Called by SoundManager when ready for another buffer.
+*/
+static pascal void PaMac_OutputCompletionProc (SndChannelPtr theChannel, SndCommand * theCallBackCmd)
+{
+ internalPortAudioStream *past;
+ PaHostSoundControl *pahsc;
+ (void) theChannel;
+ (void) theCallBackCmd;
+
+ /* Get our data from Mac structure. */
+ past = (internalPortAudioStream *) theCallBackCmd->param2;
+ if( past == NULL ) return;
+
+ pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ pahsc->pahsc_NumOutsPlayed += 1;
+
+ SetFramesDone( pahsc,
+ pahsc->pahsc_NumFramesDone + pahsc->pahsc_FramesPerHostBuffer );
+
+ PaMac_BackgroundManager( past, theCallBackCmd->param1 );
+}
+
+/*******************************************************************/
+static PaError PaMac_BackgroundManager( internalPortAudioStream *past, int index )
+{
+ PaError result = paNoError;
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+ /* Has someone asked us to abort by calling Pa_AbortStream()? */
+ if( past->past_StopNow )
+ {
+ SndCommand command;
+ /* Clear the queue of any pending commands. */
+ command.cmd = flushCmd;
+ command.param1 = command.param2 = 0;
+ SndDoImmediate( pahsc->pahsc_Channel, &command );
+ /* Then stop currently playing buffer, if any. */
+ command.cmd = quietCmd;
+ SndDoImmediate( pahsc->pahsc_Channel, &command );
+ past->past_IsActive = 0;
+ }
+ /* Has someone asked us to stop by calling Pa_StopStream()
+ * OR has a user callback returned '1' to indicate finished.
+ */
+ else if( past->past_StopSoon )
+ {
+ if( (pahsc->pahsc_NumOutsQueued - pahsc->pahsc_NumOutsPlayed) <= 0 )
+ {
+ past->past_IsActive = 0; /* We're finally done. */
+ }
+ }
+ else
+ {
+ PaMac_PlayNext( past, index );
+ }
+ return result;
+}
+
+/*************************************************************************************
+** Fill next buffer with sound and queue it for playback.
+*/
+static void PaMac_PlayNext ( internalPortAudioStream *past, int index )
+{
+ OSErr error;
+ long result;
+ SndCommand playCmd;
+ SndCommand callbackCmd;
+ PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
+
+ /* If this was the last buffer, or abort requested, then just be done. */
+ if ( past->past_StopSoon ) goto done;
+
+ /* Load buffer with sound. */
+ result = PaMac_FillNextOutputBuffer ( past, index );
+ if( result > 0 ) past->past_StopSoon = 1; /* Stop generating audio but wait until buffers play. */
+ else if( result < 0 ) goto done;
+
+ /* Play the next buffer. */
+ playCmd.cmd = bufferCmd;
+ playCmd.param1 = 0;
+ playCmd.param2 = (long) &pahsc->pahsc_SoundHeaders[ index ];
+ error = SndDoCommand (pahsc->pahsc_Channel, &playCmd, true );
+ if( error != noErr ) goto gotError;
+
+ /* Ask for a callback when it is done. */
+ callbackCmd.cmd = callBackCmd;
+ callbackCmd.param1 = index;
+ callbackCmd.param2 = (long)past;
+ error = SndDoCommand (pahsc->pahsc_Channel, &callbackCmd, true );
+ if( error != noErr ) goto gotError;
+ pahsc->pahsc_NumOutsQueued += 1;
+
+ return;
+
+gotError:
+ sPaHostError = error;
+done:
+ return;
+}