/****************************************** END CPU UTILIZATION *******/
static PaError Pa_QueryDevices( void )
{
int numBytes;
sDefaultInputDeviceID = paNoDevice;
sDefaultOutputDeviceID = paNoDevice;
/* Enumerate once just to count devices. */
sNumDevices = 0; // for default device
DirectSoundEnumerate( (LPDSENUMCALLBACK)Pa_CountDevProc, NULL );
#if SUPPORT_AUDIO_CAPTURE
DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK)Pa_CountDevProc, NULL );
#endif /* SUPPORT_AUDIO_CAPTURE */
/* Allocate structures to hold device info. */
numBytes = sNumDevices * sizeof(internalPortAudioDevice);
sDevices = (internalPortAudioDevice *)PaHost_AllocateFastMemory( numBytes ); /* MEM */
if( sDevices == NULL ) return paInsufficientMemory;
/* Enumerate again to fill in structures. */
sDeviceIndex = 0;
sEnumerationError = 0;
DirectSoundEnumerate( (LPDSENUMCALLBACK)Pa_EnumProc, (void *)0 );
#if SUPPORT_AUDIO_CAPTURE
if( sEnumerationError != paNoError ) return sEnumerationError;
sEnumerationError = 0;
DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK)Pa_EnumProc, (void *)1 );
#endif /* SUPPORT_AUDIO_CAPTURE */
return sEnumerationError;
}
/* Build linked a list with all the available audio devices on this SGI machine (only 1 for now). */
PaError PaHost_Init(void) /* Called by Pa_Initialize() from pa_lib.c. */
{
internalPortAudioDevice* pad;
PaError r = paNoError;
int audioLibFileID; /* To test for the presence of audio. */
if (sDeviceList) /* Allow re-init, only warn, no error. */
{
ERR_RPT(("Warning: PaHost_Init() did not really re-init PA.\n"));
return r;
}
/*------------- ADD THE SGI DEFAULT DEVICE TO THE LIST: ---------------------------------------*/
audioLibFileID = open("/dev/hdsp/hdsp0master", O_RDONLY); /* Try to open Indigo style audio */
if (audioLibFileID < 0) /* IO port. On failure, machine */
{ /* has no audio ability. */
ERR_RPT(("PaHost_Init(): This machine has no (Indigo-style) audio abilities.\n"));
return paHostError;
}
close(audioLibFileID); /* Allocate fast mem to hold device info. */
pad = PaHost_AllocateFastMemory(sizeof(internalPortAudioDevice));
if (pad == NULL)
return paInsufficientMemory;
memset(pad, 0, sizeof(internalPortAudioDevice)); /* "pad->pad_Next = NULL" is more elegant. */
r = Pa_sgiQueryDevice(AL_DEFAULT_DEVICE, /* Set AL device num (AL_DEFAULT_DEVICE). */
Pa_GetDefaultOutputDeviceID(),/* Set PA device num (or InputDeviceID()). */
"AL default", /* A suitable name. */
pad); /* Write args and queried info into pad. */
if (r != paNoError)
{
ERR_RPT(("Pa_QueryDevice for '%s' returned: %d\n", pad->pad_DeviceName, r));
PaHost_FreeFastMemory(pad, sizeof(internalPortAudioDevice)); /* sDeviceList still NULL ! */
}
else
sDeviceList = pad; /* First element in linked list. pad->pad_Next already NULL. */
/*------------- QUERY AND ADD MORE POSSIBLE SGI DEVICES TO THE LINKED LIST: -------------------*/
/*---------------------------------------------------------------------------------------------*/
return r;
}
/*********************************************************************
* Determines the number of available devices by trying to open
* each "/dev/dsp#" or "/dsp/audio#" in order until it fails.
* Add each working device to a singly linked list of devices.
*/
PaError Pa_QueryDevices( void )
{
internalPortAudioDevice *pad, *lastPad;
int go = 1;
int numDevices = 0;
PaError testResult;
PaError result = paNoError;
char *envdev;
sDefaultInputDeviceID = paNoDevice;
sDefaultOutputDeviceID = paNoDevice;
lastPad = NULL;
while( go )
{
/* Allocate structure to hold device info. */
pad = (internalPortAudioDevice *)
PaHost_AllocateFastMemory( sizeof(internalPortAudioDevice) );
if( pad == NULL ) return paInsufficientMemory;
memset( pad, 0, sizeof(internalPortAudioDevice) );
/* Build name for device. */
if( numDevices == 0 )
{
sprintf( pad->pad_DeviceName, DEVICE_NAME_BASE);
}
else
{
sprintf( pad->pad_DeviceName, DEVICE_NAME_BASE "%d", numDevices );
}
DBUG(("Try device %s\n", pad->pad_DeviceName ));
testResult = Pa_QueryDevice( pad->pad_DeviceName, pad );
DBUG(("Pa_QueryDevice returned %d\n", testResult ));
if( testResult != paNoError )
{
if( lastPad == NULL )
{
result = testResult; /* No good devices! */
}
go = 0;
PaHost_FreeFastMemory( pad, sizeof(internalPortAudioDevice) );
}
else
{
numDevices += 1;
/* Add to linked list of devices. */
if( lastPad )
{
lastPad->pad_Next = pad;
}
else
{
sDeviceList = pad; /* First element in linked list. */
}
lastPad = pad;
}
}
/* I'm sitting at a SunRay1 and I neither have /dev/audio# nor /dev/dsp#.
Instead, the correct audio device is stored in the environment variable
AUDIODEV and/or UTAUDIODEV, so check these devices as well if we haven't
checked them yet above - MR */
DBUG(("Checking for AUDIODEV and UTAUDIODEV\n"));
envdev = getenv("AUDIODEV");
if (envdev != NULL && !strstr(envdev, DEVICE_NAME_BASE)) {
result = paNoError;
/* Allocate structure to hold device info. */
pad = (internalPortAudioDevice *)
PaHost_AllocateFastMemory( sizeof(internalPortAudioDevice) );
if( pad == NULL ) return paInsufficientMemory;
memset( pad, 0, sizeof(internalPortAudioDevice) );
/* Build name for device. */
strcpy(pad->pad_DeviceName, envdev);
DBUG(("Try device %s\n", pad->pad_DeviceName ));
testResult = Pa_QueryDevice( pad->pad_DeviceName, pad );
DBUG(("Pa_QueryDevice returned %d\n", testResult ));
if( testResult != paNoError )
{
if( lastPad == NULL )
{
result = testResult; /* No good devices! */
}
PaHost_FreeFastMemory( pad, sizeof(internalPortAudioDevice) );
}
else
{
numDevices += 1;
/* Add to linked list of devices. */
if( lastPad )
{
lastPad->pad_Next = pad;
}
else
{
sDeviceList = pad; /* First element in linked list. */
}
lastPad = pad;
}
}
envdev = getenv("UTAUDIODEV");
if (envdev != NULL && !strstr(envdev, DEVICE_NAME_BASE) && getenv("AUDIODEV") != NULL && strcmp(envdev, getenv("AUDIODEV"))) {
result = paNoError;
/* Allocate structure to hold device info. */
pad = (internalPortAudioDevice *)
PaHost_AllocateFastMemory( sizeof(internalPortAudioDevice) );
if( pad == NULL ) return paInsufficientMemory;
memset( pad, 0, sizeof(internalPortAudioDevice) );
/* Build name for device. */
strcpy(pad->pad_DeviceName, envdev);
DBUG(("Try device %s\n", pad->pad_DeviceName ));
testResult = Pa_QueryDevice( pad->pad_DeviceName, pad );
DBUG(("Pa_QueryDevice returned %d\n", testResult ));
if( testResult != paNoError )
{
if( lastPad == NULL )
{
result = testResult; /* No good devices! */
}
PaHost_FreeFastMemory( pad, sizeof(internalPortAudioDevice) );
}
else
{
numDevices += 1;
/* Add to linked list of devices. */
if( lastPad )
{
lastPad->pad_Next = pad;
}
else
{
sDeviceList = pad; /* First element in linked list. */
}
lastPad = pad;
}
}
return result;
}
PaError PaHost_OpenStream( internalPortAudioStream *past )
{
HRESULT hr;
PaError result = paNoError;
PaHostSoundControl *pahsc;
int numBytes, maxChannels;
unsigned int minNumBuffers;
internalPortAudioDevice *pad;
DSoundWrapper *dsw;
/* Allocate and initialize host data. */
pahsc = (PaHostSoundControl *) PaHost_AllocateFastMemory(sizeof(PaHostSoundControl)); /* MEM */
if( pahsc == NULL )
{
result = paInsufficientMemory;
goto error;
}
memset( pahsc, 0, sizeof(PaHostSoundControl) );
past->past_DeviceData = (void *) pahsc;
pahsc->pahsc_TimerID = 0;
dsw = &pahsc->pahsc_DSoundWrapper;
DSW_Init( dsw );
/* Allocate native buffer. */
maxChannels = ( past->past_NumOutputChannels > past->past_NumInputChannels ) ?
past->past_NumOutputChannels : past->past_NumInputChannels;
pahsc->pahsc_BytesPerBuffer = past->past_FramesPerUserBuffer * maxChannels * sizeof(short);
if( maxChannels > 0 )
{
pahsc->pahsc_NativeBuffer = (short *) PaHost_AllocateFastMemory(pahsc->pahsc_BytesPerBuffer); /* MEM */
if( pahsc->pahsc_NativeBuffer == NULL )
{
result = paInsufficientMemory;
goto error;
}
}
else
{
result = paInvalidChannelCount;
goto error;
}
DBUG(("PaHost_OpenStream: pahsc_MinFramesPerHostBuffer = %d\n", pahsc->pahsc_MinFramesPerHostBuffer ));
minNumBuffers = Pa_GetMinNumBuffers( past->past_FramesPerUserBuffer, past->past_SampleRate );
past->past_NumUserBuffers = ( minNumBuffers > past->past_NumUserBuffers ) ? minNumBuffers : past->past_NumUserBuffers;
numBytes = pahsc->pahsc_BytesPerBuffer * past->past_NumUserBuffers;
if( numBytes < DSBSIZE_MIN )
{
result = paBufferTooSmall;
goto error;
}
if( numBytes > DSBSIZE_MAX )
{
result = paBufferTooBig;
goto error;
}
pahsc->pahsc_FramesPerDSBuffer = past->past_FramesPerUserBuffer * past->past_NumUserBuffers;
{
int msecLatency = (int) ((pahsc->pahsc_FramesPerDSBuffer * 1000) / past->past_SampleRate);
PRINT(("PortAudio on DirectSound - Latency = %d frames, %d msec\n", pahsc->pahsc_FramesPerDSBuffer, msecLatency ));
}
/* ------------------ OUTPUT */
if( (past->past_OutputDeviceID >= 0) && (past->past_NumOutputChannels > 0) )
{
DBUG(("PaHost_OpenStream: deviceID = 0x%x\n", past->past_OutputDeviceID));
pad = Pa_GetInternalDevice( past->past_OutputDeviceID );
hr = DirectSoundCreate( pad->pad_lpGUID, &dsw->dsw_pDirectSound, NULL );
/* If this fails, then try each output device until we find one that works. */
if( hr != DS_OK )
{
int i;
ERR_RPT(("Creation of requested Audio Output device '%s' failed.\n",
((pad->pad_lpGUID == NULL) ? "Default" : pad->pad_Info.name) ));
for( i=0; i<Pa_CountDevices(); i++ )
{
pad = Pa_GetInternalDevice( i );
if( pad->pad_Info.maxOutputChannels >= past->past_NumOutputChannels )
{
DBUG(("Try device '%s' instead.\n", pad->pad_Info.name ));
hr = DirectSoundCreate( pad->pad_lpGUID, &dsw->dsw_pDirectSound, NULL );
if( hr == DS_OK )
{
ERR_RPT(("Using device '%s' instead.\n", pad->pad_Info.name ));
break;
}
}
}
}
if( hr != DS_OK )
{
ERR_RPT(("PortAudio: DirectSoundCreate() failed!\n"));
result = paHostError;
sPaHostError = hr;
goto error;
}
hr = DSW_InitOutputBuffer( dsw,
(unsigned long) (past->past_SampleRate + 0.5),
past->past_NumOutputChannels, numBytes );
DBUG(("DSW_InitOutputBuffer() returns %x\n", hr));
if( hr != DS_OK )
{
result = paHostError;
sPaHostError = hr;
goto error;
}
past->past_FrameCount = pahsc->pahsc_DSoundWrapper.dsw_FramesWritten;
}
#if SUPPORT_AUDIO_CAPTURE
/* ------------------ INPUT */
if( (past->past_InputDeviceID >= 0) && (past->past_NumInputChannels > 0) )
{
pad = Pa_GetInternalDevice( past->past_InputDeviceID );
hr = DirectSoundCaptureCreate( pad->pad_lpGUID, &dsw->dsw_pDirectSoundCapture, NULL );
/* If this fails, then try each input device until we find one that works. */
if( hr != DS_OK )
{
int i;
ERR_RPT(("Creation of requested Audio Capture device '%s' failed.\n",
((pad->pad_lpGUID == NULL) ? "Default" : pad->pad_Info.name) ));
for( i=0; i<Pa_CountDevices(); i++ )
{
pad = Pa_GetInternalDevice( i );
if( pad->pad_Info.maxInputChannels >= past->past_NumInputChannels )
{
PRINT(("Try device '%s' instead.\n", pad->pad_Info.name ));
hr = DirectSoundCaptureCreate( pad->pad_lpGUID, &dsw->dsw_pDirectSoundCapture, NULL );
if( hr == DS_OK ) break;
}
}
}
if( hr != DS_OK )
{
ERR_RPT(("PortAudio: DirectSoundCaptureCreate() failed!\n"));
result = paHostError;
sPaHostError = hr;
goto error;
}
hr = DSW_InitInputBuffer( dsw,
(unsigned long) (past->past_SampleRate + 0.5),
past->past_NumInputChannels, numBytes );
DBUG(("DSW_InitInputBuffer() returns %x\n", hr));
if( hr != DS_OK )
{
ERR_RPT(("PortAudio: DSW_InitInputBuffer() returns %x\n", hr));
result = paHostError;
sPaHostError = hr;
goto error;
}
}
#endif /* SUPPORT_AUDIO_CAPTURE */
/* Calculate scalar used in CPULoad calculation. */
{
LARGE_INTEGER frequency;
if( QueryPerformanceFrequency( &frequency ) == 0 )
{
pahsc->pahsc_InverseTicksPerUserBuffer = 0.0;
}
else
{
pahsc->pahsc_InverseTicksPerUserBuffer = past->past_SampleRate /
( (double)frequency.QuadPart * past->past_FramesPerUserBuffer );
DBUG(("pahsc_InverseTicksPerUserBuffer = %g\n", pahsc->pahsc_InverseTicksPerUserBuffer ));
}
}
return result;
error:
PaHost_CloseStream( past );
return result;
}
/*********************************************************************
* Try to open the named device.
* If it opens, try to set various rates and formats and fill in
* the device info structure.
*/
PaError Pa_QueryDevice( const char *deviceName, internalPortAudioDevice *pad )
{
int result = paHostError;
int tempDevHandle;
int numChannels, maxNumChannels;
int numSampleRates;
int sampleRate;
int numRatesToTry;
int ratesToTry[9] = {96000, 48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000};
int i;
audio_info_t solaris_info;
audio_device_t device_info;
/* douglas:
we have to do this querying in a slightly different order. apparently
some sound cards will give you different info based on their settins.
e.g. a card might give you stereo at 22kHz but only mono at 44kHz.
the correct order for OSS is: format, channels, sample rate
*/
/*
to check a device for it's capabilities, it's probably better to use the
equivalent "-ctl"-descriptor - MR
*/
char devname[strlen(deviceName) + 4];
snprintf(devname,(strlen(deviceName) + 4),"%sctl",deviceName);
if ((tempDevHandle = open(devname, O_WRONLY|O_NONBLOCK)) == -1 )
{
DBUG(("Pa_QueryDevice: could not open %s\n", deviceName ));
return paHostError;
}
/* Ask OSS what formats are supported by the hardware. */
pad->pad_Info.nativeSampleFormats = 0;
AUDIO_INITINFO(&solaris_info);
/* SAM 12/31/01: Sparc native does mulaw, alaw and PCM.
I think PCM is signed. */
for (i = 8; i <= 32; i += 8) {
solaris_info.play.precision = i;
solaris_info.play.encoding = AUDIO_ENCODING_LINEAR;
/* If there are no errors, add the format. */
if (ioctl(tempDevHandle, AUDIO_SETINFO, &solaris_info) > -1) {
switch (i) {
case 8:
pad->pad_Info.nativeSampleFormats |= paInt8;
break;
case 16:
pad->pad_Info.nativeSampleFormats |= paInt16;
break;
case 24:
pad->pad_Info.nativeSampleFormats |= paInt24;
break;
case 32:
pad->pad_Info.nativeSampleFormats |= paInt32;
break;
}
}
}
maxNumChannels = 0;
for( numChannels = 1; numChannels <= 16; numChannels++ )
{
int temp = numChannels;
DBUG(("Pa_QueryDevice: use SNDCTL_DSP_CHANNELS, numChannels = %d\n", numChannels ))
AUDIO_INITINFO(&solaris_info);
solaris_info.play.channels = temp;
if (ioctl(tempDevHandle, AUDIO_SETINFO, &solaris_info) < 0)
{
/* ioctl() failed so bail out if we already have stereo */
if( numChannels > 2 ) break;
}
else
{
/* ioctl() worked but bail out if it does not support numChannels.
* We don't want to leave gaps in the numChannels supported.
*/
if( (numChannels > 2) && (temp != numChannels) ) break;
DBUG(("Pa_QueryDevice: temp = %d\n", temp ))
if( temp > maxNumChannels ) maxNumChannels = temp; /* Save maximum. */
}
}
pad->pad_Info.maxOutputChannels = maxNumChannels;
DBUG(("Pa_QueryDevice: maxNumChannels = %d\n", maxNumChannels))
/* FIXME - for now, assume maxInputChannels = maxOutputChannels.
* Eventually do separate queries for O_WRONLY and O_RDONLY
*/
pad->pad_Info.maxInputChannels = pad->pad_Info.maxOutputChannels;
DBUG(("Pa_QueryDevice: maxInputChannels = %d\n",
pad->pad_Info.maxInputChannels))
/* Determine available sample rates by trying each one and seeing result.
*/
numSampleRates = 0;
AUDIO_INITINFO(&solaris_info);
numRatesToTry = sizeof(ratesToTry)/sizeof(int);
for (i = 0; i < numRatesToTry; i++)
{
sampleRate = ratesToTry[i];
solaris_info.play.sample_rate = sampleRate; /* AS: We opened for Write, so set play */
if (ioctl(tempDevHandle, AUDIO_SETINFO, &solaris_info) >= 0 ) /* PLB20010817 */
{
if (sampleRate == ratesToTry[i])
{
DBUG(("Pa_QueryDevice: got sample rate: %d\n", sampleRate))
pad->pad_SampleRates[numSampleRates] = (float)ratesToTry[i];
numSampleRates++;
}
}
}
DBUG(("Pa_QueryDevice: final numSampleRates = %d\n", numSampleRates))
if (numSampleRates==0) /* HP20010922 */
{
ERR_RPT(("Pa_QueryDevice: no supported sample rate (or SNDCTL_DSP_SPEED ioctl call failed).\n" ));
goto error;
}
pad->pad_Info.numSampleRates = numSampleRates;
pad->pad_Info.sampleRates = pad->pad_SampleRates;
/* query for the device name instead of using the filesystem-device - MR */
if (ioctl(tempDevHandle, AUDIO_GETDEV, &device_info) == -1) {
pad->pad_Info.name = deviceName;
} else {
char *pt = (char *)PaHost_AllocateFastMemory(strlen(device_info.name));
strcpy(pt, device_info.name);
pad->pad_Info.name = pt;
}
result = paNoError;
error:
/* We MUST close the handle here or we won't be able to reopen it later!!! */
close(tempDevHandle);
return result;
}
/*--------------------------------------------------------------------------------------*/
PaError PaHost_OpenStream(internalPortAudioStream *past)
{
PaError result = paNoError;
PaHostSoundControl *pahsc;
unsigned int minNumBuffers;
internalPortAudioDevice *padIN, *padOUT; /* For looking up native AL-numbers. */
ALconfig sgiALconfig = NULL; /* IRIX-datatype. */
long pvbuf[8]; /* To get/set hardware configs. */
long sr, ALqsize;
DBUG(("PaHost_OpenStream() called.\n")); /* Alloc FASTMEM and init host data. */
if (!past)
{
ERR_RPT(("Streampointer NULL!\n"));
result = paBadStreamPtr; goto done;
}
pahsc = (PaHostSoundControl*)PaHost_AllocateFastMemory(sizeof(PaHostSoundControl));
if (pahsc == NULL)
{
ERR_RPT(("FAST Memory allocation failed.\n")); /* Pass trough some ERR_RPT-exit- */
result = paInsufficientMemory; goto done; /* code (nothing will be freed). */
}
memset(pahsc, 0, sizeof(PaHostSoundControl));
/* pahsc->pahsc_threadPID = -1; Should pahsc_threadPID be inited to */
past->past_DeviceData = (void*)pahsc; /* -1 instead of 0 ?? */
/*--------------------------------------------------- Allocate native buffers: --------*/
pahsc->pahsc_SamplesPerInputBuffer = past->past_FramesPerUserBuffer * /* Needed by the */
past->past_NumInputChannels; /* audio-thread. */
pahsc->pahsc_BytesPerInputBuffer = pahsc->pahsc_SamplesPerInputBuffer * sizeof(short);
if (past->past_NumInputChannels > 0) /* Assumes short = 16 bits! */
{
pahsc->pahsc_NativeInputBuffer = (short*)PaHost_AllocateFastMemory(pahsc->pahsc_BytesPerInputBuffer);
if( pahsc->pahsc_NativeInputBuffer == NULL )
{
ERR_RPT(("Fast memory allocation for input-buffer failed.\n"));
result = paInsufficientMemory; goto done;
}
}
pahsc->pahsc_SamplesPerOutputBuffer = past->past_FramesPerUserBuffer * /* Needed by the */
past->past_NumOutputChannels; /* audio-thread. */
pahsc->pahsc_BytesPerOutputBuffer = pahsc->pahsc_SamplesPerOutputBuffer * sizeof(short);
if (past->past_NumOutputChannels > 0) /* Assumes short = 16 bits! */
{
pahsc->pahsc_NativeOutputBuffer = (short*)PaHost_AllocateFastMemory(pahsc->pahsc_BytesPerOutputBuffer);
if (pahsc->pahsc_NativeOutputBuffer == NULL)
{
ERR_RPT(("Fast memory allocation for output-buffer failed.\n"));
result = paInsufficientMemory; goto done;
}
}
/*------------------------------------------ Manipulate hardware if necessary and allowed: --*/
ALseterrorhandler(0); /* 0 = turn off the default error handler. */
pvbuf[0] = AL_INPUT_RATE;
pvbuf[2] = AL_INPUT_COUNT;
pvbuf[4] = AL_OUTPUT_RATE; /* TO FIX: rates may be logically, not always in Hz! */
pvbuf[6] = AL_OUTPUT_COUNT;
sr = (long)(past->past_SampleRate + 0.5); /* Common for input and output :-) */
if (past->past_NumInputChannels > 0) /* We need to lookup the corre- */
{ /* sponding native AL-number(s). */
padIN = Pa_GetInternalDevice(past->past_InputDeviceID);
if (!padIN)
{
ERR_RPT(("Pa_GetInternalDevice() for input failed.\n"));
result = paHostError; goto done;
}
if (ALgetparams(padIN->pad_ALdevice, &pvbuf[0], 4)) /* Although input and output will both be on */
goto sgiError; /* the same AL-device, the AL-library might */
if (pvbuf[1] != sr) /* contain more than AL_DEFAULT_DEVICE in */
{ /* Rate different from current harware-rate? the future. Therefore 2 seperate queries. */
if (pvbuf[3] > 0) /* Means, there's other clients using AL-input-ports */
{
ERR_RPT(("Sorry, not allowed to switch input-hardware to %ld Hz because \
another process is currently using input at %ld kHz.\n", sr, pvbuf[1]));
result = paHostError; goto done;
}
pvbuf[1] = sr; /* Then set input-rate. */
if (ALsetparams(padIN->pad_ALdevice, &pvbuf[0], 2))
goto sgiError; /* WHETHER THIS SAMPLERATE WAS REALLY PRESENT IN OUR ARRAY OF RATES, */
} /* IS NOT CHECKED, AT LEAST NOT BY ME, WITHIN THIS FILE! Does PA do? */
