From b0080e69d64ce69e21c8ce1b22b1bb7f888f1e58 Mon Sep 17 00:00:00 2001 From: Gary Scavone Date: Tue, 7 Aug 2007 14:52:05 +0000 Subject: Check in of new version 4.0.0 distribution (GS). --- RtAudio.cpp | 12615 +++++++++++++++++++++++++--------------------------------- 1 file changed, 5515 insertions(+), 7100 deletions(-) (limited to 'RtAudio.cpp') diff --git a/RtAudio.cpp b/RtAudio.cpp index f7c918d..71be207 100644 --- a/RtAudio.cpp +++ b/RtAudio.cpp @@ -4,13 +4,13 @@ RtAudio provides a common API (Application Programming Interface) for realtime audio input/output across Linux (native ALSA, Jack, - and OSS), SGI, Macintosh OS X (CoreAudio), and Windows + and OSS), SGI, Macintosh OS X (CoreAudio and Jack), and Windows (DirectSound and ASIO) operating systems. - RtAudio WWW site: http://music.mcgill.ca/~gary/rtaudio/ + RtAudio WWW site: http://www.music.mcgill.ca/~gary/rtaudio/ RtAudio: realtime audio i/o C++ classes - Copyright (c) 2001-2005 Gary P. Scavone + Copyright (c) 2001-2007 Gary P. Scavone Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files @@ -24,8 +24,9 @@ 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. + asked to send the modifications to the original developer so that + they can be incorporated into the canonical version. This is, + however, not a binding provision of this license. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF @@ -37,11 +38,10 @@ */ /************************************************************************/ -// RtAudio: Version 3.0.3 (18 November 2005) +// RtAudio: Version 4.0 #include "RtAudio.h" #include -#include // Static variable definitions. const unsigned int RtApi::MAX_SAMPLE_RATES = 14; @@ -52,101 +52,59 @@ const unsigned int RtApi::SAMPLE_RATES[] = { #if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) #define MUTEX_INITIALIZE(A) InitializeCriticalSection(A) - #define MUTEX_DESTROY(A) DeleteCriticalSection(A); - #define MUTEX_LOCK(A) EnterCriticalSection(A) + #define MUTEX_DESTROY(A) DeleteCriticalSection(A) + #define MUTEX_LOCK(A) EnterCriticalSection(A) #define MUTEX_UNLOCK(A) LeaveCriticalSection(A) -#else // pthread API +#elif defined(__LINUX_ALSA__) || defined(__UNIX_JACK__) || defined(__LINUX_OSS__) || defined(__MACOSX_CORE__) + // pthread API #define MUTEX_INITIALIZE(A) pthread_mutex_init(A, NULL) - #define MUTEX_DESTROY(A) pthread_mutex_destroy(A); + #define MUTEX_DESTROY(A) pthread_mutex_destroy(A) #define MUTEX_LOCK(A) pthread_mutex_lock(A) #define MUTEX_UNLOCK(A) pthread_mutex_unlock(A) +#else + #define MUTEX_INITIALIZE(A) abs(*A) // dummy definitions + #define MUTEX_DESTROY(A) abs(*A) // dummy definitions #endif // *************************************************** // // -// Public common (OS-independent) methods. +// RtAudio definitions. // // *************************************************** // -RtAudio :: RtAudio( RtAudioApi api ) -{ - initialize( api ); -} - -RtAudio :: RtAudio( int outputDevice, int outputChannels, - int inputDevice, int inputChannels, - RtAudioFormat format, int sampleRate, - int *bufferSize, int numberOfBuffers, RtAudioApi api ) -{ - initialize( api ); - - try { - rtapi_->openStream( outputDevice, outputChannels, - inputDevice, inputChannels, - format, sampleRate, - bufferSize, numberOfBuffers ); - } - catch (RtError &exception) { - // Deallocate the RtApi instance. - delete rtapi_; - throw exception; - } -} - -RtAudio :: RtAudio( int outputDevice, int outputChannels, - int inputDevice, int inputChannels, - RtAudioFormat format, int sampleRate, - int *bufferSize, int *numberOfBuffers, RtAudioApi api ) -{ - initialize( api ); - - try { - rtapi_->openStream( outputDevice, outputChannels, - inputDevice, inputChannels, - format, sampleRate, - bufferSize, numberOfBuffers ); - } - catch (RtError &exception) { - // Deallocate the RtApi instance. - delete rtapi_; - throw exception; - } -} - -RtAudio :: ~RtAudio() -{ - delete rtapi_; -} - -void RtAudio :: openStream( int outputDevice, int outputChannels, - int inputDevice, int inputChannels, - RtAudioFormat format, int sampleRate, - int *bufferSize, int numberOfBuffers ) +void RtAudio :: getCompiledApi( std::vector &apis ) throw() { - rtapi_->openStream( outputDevice, outputChannels, inputDevice, - inputChannels, format, sampleRate, - bufferSize, numberOfBuffers ); -} + apis.clear(); -void RtAudio :: openStream( int outputDevice, int outputChannels, - int inputDevice, int inputChannels, - RtAudioFormat format, int sampleRate, - int *bufferSize, int *numberOfBuffers ) -{ - rtapi_->openStream( outputDevice, outputChannels, inputDevice, - inputChannels, format, sampleRate, - bufferSize, *numberOfBuffers ); + // The order here will control the order of RtAudio's API search in + // the constructor. +#if defined(__UNIX_JACK__) + apis.push_back( UNIX_JACK ); +#endif +#if defined(__LINUX_ALSA__) + apis.push_back( LINUX_ALSA ); +#endif +#if defined(__LINUX_OSS__) + apis.push_back( LINUX_OSS ); +#endif +#if defined(__WINDOWS_ASIO__) + apis.push_back( WINDOWS_ASIO ); +#endif +#if defined(__WINDOWS_DS__) + apis.push_back( WINDOWS_DS ); +#endif +#if defined(__MACOSX_CORE__) + apis.push_back( MACOSX_CORE ); +#endif +#if defined(__RTAUDIO_DUMMY__) + apis.push_back( RTAUDIO_DUMMY ); +#endif } -void RtAudio::initialize( RtAudioApi api ) +void RtAudio :: openRtApi( RtAudio::Api api ) { - rtapi_ = 0; - - // First look for a compiled match to a specified API value. If one - // of these constructors throws an error, it will be passed up the - // inheritance chain. -#if defined(__LINUX_JACK__) - if ( api == LINUX_JACK ) +#if defined(__UNIX_JACK__) + if ( api == UNIX_JACK ) rtapi_ = new RtApiJack(); #endif #if defined(__LINUX_ALSA__) @@ -165,314 +123,240 @@ void RtAudio::initialize( RtAudioApi api ) if ( api == WINDOWS_DS ) rtapi_ = new RtApiDs(); #endif -#if defined(__IRIX_AL__) - if ( api == IRIX_AL ) - rtapi_ = new RtApiAl(); -#endif #if defined(__MACOSX_CORE__) if ( api == MACOSX_CORE ) rtapi_ = new RtApiCore(); #endif +#if defined(__RTAUDIO_DUMMY__) + if ( api == RTAUDIO_DUMMY ) + rtapi_ = new RtApiDummy(); +#endif +} - if ( rtapi_ ) return; - if ( api > 0 ) { - // No compiled support for specified API value. - throw RtError( "RtAudio: no compiled support for specified API argument!", RtError::INVALID_PARAMETER ); - } +RtAudio :: RtAudio( RtAudio::Api api ) throw() +{ + rtapi_ = 0; - // No specified API ... search for "best" option. - try { -#if defined(__LINUX_JACK__) - rtapi_ = new RtApiJack(); -#elif defined(__WINDOWS_ASIO__) - rtapi_ = new RtApiAsio(); -#elif defined(__IRIX_AL__) - rtapi_ = new RtApiAl(); -#elif defined(__MACOSX_CORE__) - rtapi_ = new RtApiCore(); -#else - ; -#endif - } - catch (RtError &) { -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\nRtAudio: no devices found for first api option (JACK, ASIO, Al, or CoreAudio).\n\n"); -#endif - rtapi_ = 0; - } + if ( api != UNSPECIFIED ) { + // Attempt to open the specified API. + openRtApi( api ); + if ( rtapi_ ) return; - if ( rtapi_ ) return; + // No compiled support for specified API value. Issue a debug + // warning and continue as if no API was specified. + std::cerr << "\nRtAudio: no compiled support for specified API argument!\n" << std::endl; + } -// Try second API support - if ( rtapi_ == 0 ) { - try { -#if defined(__LINUX_ALSA__) - rtapi_ = new RtApiAlsa(); -#elif defined(__WINDOWS_DS__) - rtapi_ = new RtApiDs(); -#else - ; -#endif - } - catch (RtError &) { -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\nRtAudio: no devices found for second api option (Alsa or DirectSound).\n\n"); -#endif - rtapi_ = 0; - } + // Iterate through the compiled APIs and return as soon as we find + // one with at least one device or we reach the end of the list. + std::vector< RtAudio::Api > apis; + getCompiledApi( apis ); + for ( unsigned int i=0; igetDeviceCount() ) break; } if ( rtapi_ ) return; - // Try third API support - if ( rtapi_ == 0 ) { -#if defined(__LINUX_OSS__) - try { - rtapi_ = new RtApiOss(); - } - catch (RtError &error) { - rtapi_ = 0; - } -#else - ; -#endif - } + // It should not be possible to get here because the preprocessor + // definition __RTAUDIO_DUMMY__ is automatically defined if no + // API-specific definitions are passed to the compiler. But just in + // case something weird happens, we'll print out an error message. + std::cerr << "\nRtAudio: no compiled API support found ... critical error!!\n\n"; +} - if ( rtapi_ == 0 ) { - // No devices found. - throw RtError( "RtAudio: no devices found for compiled audio APIs!", RtError::NO_DEVICES_FOUND ); - } +RtAudio :: ~RtAudio() throw() +{ + delete rtapi_; } +void RtAudio :: openStream( RtAudio::StreamParameters *outputParameters, + RtAudio::StreamParameters *inputParameters, + RtAudioFormat format, unsigned int sampleRate, + unsigned int *bufferFrames, + RtAudioCallback callback, void *userData, + RtAudio::StreamOptions *options ) +{ + return rtapi_->openStream( outputParameters, inputParameters, format, + sampleRate, bufferFrames, callback, + userData, options ); +} + +// *************************************************** // +// +// Public RtApi definitions (see end of file for +// private or protected utility functions). +// +// *************************************************** // + RtApi :: RtApi() { + stream_.state = STREAM_CLOSED; stream_.mode = UNINITIALIZED; - stream_.state = STREAM_STOPPED; stream_.apiHandle = 0; - MUTEX_INITIALIZE(&stream_.mutex); + stream_.userBuffer[0] = 0; + stream_.userBuffer[1] = 0; + MUTEX_INITIALIZE( &stream_.mutex ); + showWarnings_ = true; } RtApi :: ~RtApi() { - MUTEX_DESTROY(&stream_.mutex); + MUTEX_DESTROY( &stream_.mutex ); } -void RtApi :: openStream( int outputDevice, int outputChannels, - int inputDevice, int inputChannels, - RtAudioFormat format, int sampleRate, - int *bufferSize, int *numberOfBuffers ) +void RtApi :: openStream( RtAudio::StreamParameters *oParams, + RtAudio::StreamParameters *iParams, + RtAudioFormat format, unsigned int sampleRate, + unsigned int *bufferFrames, + RtAudioCallback callback, void *userData, + RtAudio::StreamOptions *options ) { - this->openStream( outputDevice, outputChannels, inputDevice, - inputChannels, format, sampleRate, - bufferSize, *numberOfBuffers ); - *numberOfBuffers = stream_.nBuffers; -} + if ( stream_.state != STREAM_CLOSED ) { + errorText_ = "RtApi::openStream: a stream is already open!"; + error( INVALID_CALL ); + } -void RtApi :: openStream( int outputDevice, int outputChannels, - int inputDevice, int inputChannels, - RtAudioFormat format, int sampleRate, - int *bufferSize, int numberOfBuffers ) -{ - if ( stream_.mode != UNINITIALIZED ) { - sprintf(message_, "RtApi: only one open stream allowed per class instance."); - error(RtError::INVALID_STREAM); + if ( oParams && oParams->nChannels < 1 ) { + errorText_ = "RtApi::openStream: a non-NULL output StreamParameters structure cannot have an nChannels value less than one."; + error( INVALID_CALL ); } - if (outputChannels < 1 && inputChannels < 1) { - sprintf(message_,"RtApi: one or both 'channel' parameters must be greater than zero."); - error(RtError::INVALID_PARAMETER); + if ( iParams && iParams->nChannels < 1 ) { + errorText_ = "RtApi::openStream: a non-NULL input StreamParameters structure cannot have an nChannels value less than one."; + error( INVALID_CALL ); + } + + if ( oParams == NULL && iParams == NULL ) { + errorText_ = "RtApi::openStream: input and output StreamParameters structures are both NULL!"; + error( INVALID_CALL ); } if ( formatBytes(format) == 0 ) { - sprintf(message_,"RtApi: 'format' parameter value is undefined."); - error(RtError::INVALID_PARAMETER); + errorText_ = "RtApi::openStream: 'format' parameter value is undefined."; + error( INVALID_CALL ); } - if ( outputChannels > 0 ) { - if (outputDevice > nDevices_ || outputDevice < 0) { - sprintf(message_,"RtApi: 'outputDevice' parameter value (%d) is invalid.", outputDevice); - error(RtError::INVALID_PARAMETER); + unsigned int nDevices = getDeviceCount(); + unsigned int oChannels = 0; + if ( oParams ) { + oChannels = oParams->nChannels; + if ( oParams->deviceId >= nDevices ) { + errorText_ = "RtApi::openStream: output device parameter value is invalid."; + error( INVALID_CALL ); } } - if ( inputChannels > 0 ) { - if (inputDevice > nDevices_ || inputDevice < 0) { - sprintf(message_,"RtApi: 'inputDevice' parameter value (%d) is invalid.", inputDevice); - error(RtError::INVALID_PARAMETER); + unsigned int iChannels = 0; + if ( iParams ) { + iChannels = iParams->nChannels; + if ( iParams->deviceId >= nDevices ) { + errorText_ = "RtApi::openStream: input device parameter value is invalid."; + error( INVALID_CALL ); } } - std::string errorMessages; clearStreamInfo(); - bool result = FAILURE; - int device, defaultDevice = 0; - StreamMode mode; - int channels; - if ( outputChannels > 0 ) { - - mode = OUTPUT; - channels = outputChannels; + bool result; - if ( outputDevice == 0 ) { // Try default device first. - defaultDevice = getDefaultOutputDevice(); - device = defaultDevice; - } - else - device = outputDevice - 1; + if ( oChannels > 0 ) { - for ( int i=-1; i= 0 ) { - if ( i == defaultDevice ) continue; - device = i; - } - if ( devices_[device].probed == false ) { - // If the device wasn't successfully probed before, try it - // (again) now. - clearDeviceInfo(&devices_[device]); - probeDeviceInfo(&devices_[device]); - } - if ( devices_[device].probed ) - result = probeDeviceOpen(device, mode, channels, sampleRate, - format, bufferSize, numberOfBuffers); - if ( result == SUCCESS ) break; - errorMessages.append( " " ); - errorMessages.append( message_ ); - errorMessages.append( "\n" ); - if ( outputDevice > 0 ) break; - clearStreamInfo(); - } + result = probeDeviceOpen( oParams->deviceId, OUTPUT, oChannels, oParams->firstChannel, + sampleRate, format, bufferFrames, options ); + if ( result == false ) error( SYSTEM ); } - if ( inputChannels > 0 && ( result == SUCCESS || outputChannels <= 0 ) ) { - - mode = INPUT; - channels = inputChannels; - - if ( inputDevice == 0 ) { // Try default device first. - defaultDevice = getDefaultInputDevice(); - device = defaultDevice; - } - else - device = inputDevice - 1; + if ( iChannels > 0 ) { - for ( int i=-1; i= 0 ) { - if ( i == defaultDevice ) continue; - device = i; - } - if ( devices_[device].probed == false ) { - // If the device wasn't successfully probed before, try it - // (again) now. - clearDeviceInfo(&devices_[device]); - probeDeviceInfo(&devices_[device]); - } - if ( devices_[device].probed ) - result = probeDeviceOpen( device, mode, channels, sampleRate, - format, bufferSize, numberOfBuffers ); - if ( result == SUCCESS ) break; - errorMessages.append( " " ); - errorMessages.append( message_ ); - errorMessages.append( "\n" ); - if ( inputDevice > 0 ) break; + result = probeDeviceOpen( iParams->deviceId, INPUT, iChannels, iParams->firstChannel, + sampleRate, format, bufferFrames, options ); + if ( result == false ) { + if ( oChannels > 0 ) closeStream(); + error( SYSTEM ); } } - if ( result == SUCCESS ) - return; - - // If we get here, all attempted probes failed. Close any opened - // devices and clear the stream structure. - if ( stream_.mode != UNINITIALIZED ) closeStream(); - clearStreamInfo(); - if ( ( outputDevice == 0 && outputChannels > 0 ) - || ( inputDevice == 0 && inputChannels > 0 ) ) - sprintf(message_,"RtApi: no devices found for given stream parameters: \n%s", - errorMessages.c_str()); - else - sprintf(message_,"RtApi: unable to open specified device(s) with given stream parameters: \n%s", - errorMessages.c_str()); - error(RtError::INVALID_PARAMETER); + stream_.callbackInfo.callback = (void *) callback; + stream_.callbackInfo.userData = userData; - return; + if ( options ) options->numberOfBuffers = stream_.nBuffers; + stream_.state = STREAM_STOPPED; } -int RtApi :: getDeviceCount(void) +unsigned int RtApi :: getDefaultInputDevice( void ) { - return devices_.size(); + // Should be implemented in subclasses if possible. + return 0; } -RtApi::StreamState RtApi :: getStreamState( void ) const +unsigned int RtApi :: getDefaultOutputDevice( void ) { - return stream_.state; + // Should be implemented in subclasses if possible. + return 0; } -RtAudioDeviceInfo RtApi :: getDeviceInfo( int device ) +void RtApi :: closeStream( void ) { - if (device > (int) devices_.size() || device < 1) { - sprintf(message_, "RtApi: invalid device specifier (%d)!", device); - error(RtError::INVALID_DEVICE); - } + // MUST be implemented in subclasses! + return; +} - RtAudioDeviceInfo info; - int deviceIndex = device - 1; +bool RtApi :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, + unsigned int firstChannel, unsigned int sampleRate, + RtAudioFormat format, unsigned int *bufferSize, + RtAudio::StreamOptions *options ) +{ + // MUST be implemented in subclasses! + return FAILURE; +} - // If the device wasn't successfully probed before, try it now (or again). - if (devices_[deviceIndex].probed == false) { - clearDeviceInfo(&devices_[deviceIndex]); - probeDeviceInfo(&devices_[deviceIndex]); - } +void RtApi :: tickStreamTime( void ) +{ + // Subclasses that do not provide their own implementation of + // getStreamTime should call this function once per buffer I/O to + // provide basic stream time support. - info.name.append( devices_[deviceIndex].name ); - info.probed = devices_[deviceIndex].probed; - if ( info.probed == true ) { - info.outputChannels = devices_[deviceIndex].maxOutputChannels; - info.inputChannels = devices_[deviceIndex].maxInputChannels; - info.duplexChannels = devices_[deviceIndex].maxDuplexChannels; - for (unsigned int i=0; i -#include -#include -#include -#include -#include -#include -#include -#include +// The OS X CoreAudio API is designed to use a separate callback +// procedure for each of its audio devices. A single RtAudio duplex +// stream using two different devices is supported here, though it +// cannot be guaranteed to always behave correctly because we cannot +// synchronize these two callbacks. +// +// A property listener is installed for over/underrun information. +// However, no functionality is currently provided to allow property +// listeners to trigger user handlers because it is unclear what could +// be done if a critical stream parameter (buffer size, sample rate, +// device disconnect) notification arrived. The listeners entail +// quite a bit of extra code and most likely, a user program wouldn't +// be prepared for the result anyway. However, we do provide a flag +// to the client callback function to inform of an over/underrun. +// +// The mechanism for querying and setting system parameters was +// updated (and perhaps simplified) in OS-X version 10.4. However, +// since 10.4 support is not necessarily available to all users, I've +// decided not to update the respective code at this time. Perhaps +// this will happen when Apple makes 10.4 free for everyone. :-) -#define DAC_NAME "/dev/dsp" -#define MAX_DEVICES 16 -#define MAX_CHANNELS 16 +// A structure to hold various information related to the CoreAudio API +// implementation. +struct CoreHandle { + AudioDeviceID id[2]; // device ids + UInt32 iStream[2]; // device stream index (first for mono mode) + bool xrun[2]; + char *deviceBuffer; + pthread_cond_t condition; + int drainCounter; // Tracks callback counts when draining + bool internalDrain; // Indicates if stop is initiated from callback or not. -extern "C" void *ossCallbackHandler(void * ptr); + CoreHandle() + :deviceBuffer(0), drainCounter(0), internalDrain(false) { id[0] = 0; id[1] = 0; xrun[0] = false; xrun[1] = false; } +}; -RtApiOss :: RtApiOss() +RtApiCore :: RtApiCore() { - this->initialize(); - - if (nDevices_ <= 0) { - sprintf(message_, "RtApiOss: no Linux OSS audio devices found!"); - error(RtError::NO_DEVICES_FOUND); - } + // Nothing to do here. } -RtApiOss :: ~RtApiOss() +RtApiCore :: ~RtApiCore() { - if ( stream_.mode != UNINITIALIZED ) - closeStream(); + // The subclass destructor gets called before the base class + // destructor, so close an existing stream before deallocating + // apiDeviceId memory. + if ( stream_.state != STREAM_CLOSED ) closeStream(); } -void RtApiOss :: initialize(void) +unsigned int RtApiCore :: getDeviceCount( void ) { - // Count cards and devices - nDevices_ = 0; - - // We check /dev/dsp before probing devices. /dev/dsp is supposed to - // be a link to the "default" audio device, of the form /dev/dsp0, - // /dev/dsp1, etc... However, I've seen many cases where /dev/dsp was a - // real device, so we need to check for that. Also, sometimes the - // link is to /dev/dspx and other times just dspx. I'm not sure how - // the latter works, but it does. - char device_name[16]; - struct stat dspstat; - int dsplink = -1; - int i = 0; - if (lstat(DAC_NAME, &dspstat) == 0) { - if (S_ISLNK(dspstat.st_mode)) { - i = readlink(DAC_NAME, device_name, sizeof(device_name)); - if (i > 0) { - device_name[i] = '\0'; - if (i > 8) { // check for "/dev/dspx" - if (!strncmp(DAC_NAME, device_name, 8)) - dsplink = atoi(&device_name[8]); - } - else if (i > 3) { // check for "dspx" - if (!strncmp("dsp", device_name, 3)) - dsplink = atoi(&device_name[3]); - } - } - else { - sprintf(message_, "RtApiOss: cannot read value of symbolic link %s.", DAC_NAME); - error(RtError::SYSTEM_ERROR); - } - } + // Find out how many audio devices there are, if any. + UInt32 dataSize; + OSStatus result = AudioHardwareGetPropertyInfo( kAudioHardwarePropertyDevices, &dataSize, NULL ); + if ( result != noErr ) { + errorText_ = "RtApiCore::getDeviceCount: OS-X error getting device info!"; + error( WARNING ); + return 0; } - else { - sprintf(message_, "RtApiOss: cannot stat %s.", DAC_NAME); - error(RtError::SYSTEM_ERROR); - } - - // The OSS API doesn't provide a routine for determining the number - // of devices. Thus, we'll just pursue a brute force method. The - // idea is to start with /dev/dsp(0) and continue with higher device - // numbers until we reach MAX_DSP_DEVICES. This should tell us how - // many devices we have ... it is not a fullproof scheme, but hopefully - // it will work most of the time. - int fd = 0; - RtApiDevice device; - for (i=-1; i= 0) close(fd); - device.name.erase(); - device.name.append( (const char *)device_name, strlen(device_name)+1); - devices_.push_back(device); - nDevices_++; - } + return dataSize / sizeof( AudioDeviceID ); } -void RtApiOss :: probeDeviceInfo(RtApiDevice *info) +unsigned int RtApiCore :: getDefaultInputDevice( void ) { - int i, fd, channels, mask; + unsigned int nDevices = getDeviceCount(); + if ( nDevices <= 1 ) return 0; - // The OSS API doesn't provide a means for probing the capabilities - // of devices. Thus, we'll just pursue a brute force method. + AudioDeviceID id; + UInt32 dataSize = sizeof( AudioDeviceID ); + OSStatus result = AudioHardwareGetProperty( kAudioHardwarePropertyDefaultInputDevice, + &dataSize, &id ); - // First try for playback - fd = open(info->name.c_str(), O_WRONLY | O_NONBLOCK); - if (fd == -1) { - // Open device failed ... either busy or doesn't exist - if (errno == EBUSY || errno == EAGAIN) - sprintf(message_, "RtApiOss: OSS playback device (%s) is busy and cannot be probed.", - info->name.c_str()); - else - sprintf(message_, "RtApiOss: OSS playback device (%s) open error.", info->name.c_str()); - error(RtError::DEBUG_WARNING); - goto capture_probe; - } - - // We have an open device ... see how many channels it can handle - for (i=MAX_CHANNELS; i>0; i--) { - channels = i; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) == -1) { - // This would normally indicate some sort of hardware error, but under ALSA's - // OSS emulation, it sometimes indicates an invalid channel value. Further, - // the returned channel value is not changed. So, we'll ignore the possible - // hardware error. - continue; // try next channel number - } - // Check to see whether the device supports the requested number of channels - if (channels != i ) continue; // try next channel number - // If here, we found the largest working channel value - break; + if ( result != noErr ) { + errorText_ = "RtApiCore::getDefaultInputDevice: OS-X system error getting device."; + error( WARNING ); + return 0; } - info->maxOutputChannels = i; - // Now find the minimum number of channels it can handle - for (i=1; i<=info->maxOutputChannels; i++) { - channels = i; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) == -1 || channels != i) - continue; // try next channel number - // If here, we found the smallest working channel value - break; + dataSize *= nDevices; + AudioDeviceID deviceList[ nDevices ]; + result = AudioHardwareGetProperty( kAudioHardwarePropertyDevices, &dataSize, (void *) &deviceList ); + if ( result != noErr ) { + errorText_ = "RtApiCore::getDefaultInputDevice: OS-X system error getting device IDs."; + error( WARNING ); + return 0; } - info->minOutputChannels = i; - close(fd); - capture_probe: - // Now try for capture - fd = open(info->name.c_str(), O_RDONLY | O_NONBLOCK); - if (fd == -1) { - // Open device for capture failed ... either busy or doesn't exist - if (errno == EBUSY || errno == EAGAIN) - sprintf(message_, "RtApiOss: OSS capture device (%s) is busy and cannot be probed.", - info->name.c_str()); - else - sprintf(message_, "RtApiOss: OSS capture device (%s) open error.", info->name.c_str()); - error(RtError::DEBUG_WARNING); - if (info->maxOutputChannels == 0) - // didn't open for playback either ... device invalid - return; - goto probe_parameters; - } + for ( unsigned int i=0; i0; i--) { - channels = i; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) == -1 || channels != i) { - continue; // as above - } - // If here, we found a working channel value - break; - } - info->maxInputChannels = i; + errorText_ = "RtApiCore::getDefaultInputDevice: No default device found!"; + error( WARNING ); + return 0; +} - // Now find the minimum number of channels it can handle - for (i=1; i<=info->maxInputChannels; i++) { - channels = i; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) == -1 || channels != i) - continue; // try next channel number - // If here, we found the smallest working channel value - break; +unsigned int RtApiCore :: getDefaultOutputDevice( void ) +{ + unsigned int nDevices = getDeviceCount(); + if ( nDevices <= 1 ) return 0; + + AudioDeviceID id; + UInt32 dataSize = sizeof( AudioDeviceID ); + OSStatus result = AudioHardwareGetProperty( kAudioHardwarePropertyDefaultOutputDevice, + &dataSize, &id ); + + if ( result != noErr ) { + errorText_ = "RtApiCore::getDefaultOutputDevice: OS-X system error getting device."; + error( WARNING ); + return 0; } - info->minInputChannels = i; - close(fd); - if (info->maxOutputChannels == 0 && info->maxInputChannels == 0) { - sprintf(message_, "RtApiOss: device (%s) reports zero channels for input and output.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; + dataSize *= nDevices; + AudioDeviceID deviceList[ nDevices ]; + result = AudioHardwareGetProperty( kAudioHardwarePropertyDevices, &dataSize, (void *) &deviceList ); + if ( result != noErr ) { + errorText_ = "RtApiCore::getDefaultOutputDevice: OS-X system error getting device IDs."; + error( WARNING ); + return 0; } - // If device opens for both playback and capture, we determine the channels. - if (info->maxOutputChannels == 0 || info->maxInputChannels == 0) - goto probe_parameters; - - fd = open(info->name.c_str(), O_RDWR | O_NONBLOCK); - if (fd == -1) - goto probe_parameters; - - ioctl(fd, SNDCTL_DSP_SETDUPLEX, 0); - ioctl(fd, SNDCTL_DSP_GETCAPS, &mask); - if (mask & DSP_CAP_DUPLEX) { - info->hasDuplexSupport = true; - // We have the device open for duplex ... see how many channels it can handle - for (i=MAX_CHANNELS; i>0; i--) { - channels = i; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) == -1 || channels != i) - continue; // as above - // If here, we found a working channel value - break; - } - info->maxDuplexChannels = i; + for ( unsigned int i=0; imaxDuplexChannels; i++) { - channels = i; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) == -1 || channels != i) - continue; // try next channel number - // If here, we found the smallest working channel value - break; - } - info->minDuplexChannels = i; - } - close(fd); + errorText_ = "RtApiCore::getDefaultOutputDevice: No default device found!"; + error( WARNING ); + return 0; +} - probe_parameters: - // At this point, we need to figure out the supported data formats - // and sample rates. We'll proceed by openning the device in the - // direction with the maximum number of channels, or playback if - // they are equal. This might limit our sample rate options, but so - // be it. +RtAudio::DeviceInfo RtApiCore :: getDeviceInfo( unsigned int device ) +{ + RtAudio::DeviceInfo info; + info.probed = false; - if (info->maxOutputChannels >= info->maxInputChannels) { - fd = open(info->name.c_str(), O_WRONLY | O_NONBLOCK); - channels = info->maxOutputChannels; - } - else { - fd = open(info->name.c_str(), O_RDONLY | O_NONBLOCK); - channels = info->maxInputChannels; + // Get device ID + unsigned int nDevices = getDeviceCount(); + if ( nDevices == 0 ) { + errorText_ = "RtApiCore::getDeviceInfo: no devices found!"; + error( INVALID_CALL ); } - if (fd == -1) { - // We've got some sort of conflict ... abort - sprintf(message_, "RtApiOss: device (%s) won't reopen during probe.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; + if ( device >= nDevices ) { + errorText_ = "RtApiCore::getDeviceInfo: device ID is invalid!"; + error( INVALID_CALL ); } - // We have an open device ... set to maximum channels. - i = channels; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) == -1 || channels != i) { - // We've got some sort of conflict ... abort - close(fd); - sprintf(message_, "RtApiOss: device (%s) won't revert to previous channel setting.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; + AudioDeviceID deviceList[ nDevices ]; + UInt32 dataSize = sizeof( AudioDeviceID ) * nDevices; + OSStatus result = AudioHardwareGetProperty( kAudioHardwarePropertyDevices, &dataSize, (void *) &deviceList ); + if ( result != noErr ) { + errorText_ = "RtApiCore::getDeviceInfo: OS-X system error getting device IDs."; + error( WARNING ); + return info; } - if (ioctl(fd, SNDCTL_DSP_GETFMTS, &mask) == -1) { - close(fd); - sprintf(message_, "RtApiOss: device (%s) can't get supported audio formats.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } + AudioDeviceID id = deviceList[ device ]; + + // Get the device name. + info.name.erase(); + char name[256]; + dataSize = 256; + result = AudioDeviceGetProperty( id, 0, false, + kAudioDevicePropertyDeviceManufacturer, + &dataSize, name ); - // Probe the supported data formats ... we don't care about endian-ness just yet. - int format; - info->nativeFormats = 0; -#if defined (AFMT_S32_BE) - // This format does not seem to be in the 2.4 kernel version of OSS soundcard.h - if (mask & AFMT_S32_BE) { - format = AFMT_S32_BE; - info->nativeFormats |= RTAUDIO_SINT32; + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceInfo: system error (" << getErrorCode( result ) << ") getting device manufacturer."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } -#endif -#if defined (AFMT_S32_LE) - /* This format is not in the 2.4.4 kernel version of OSS soundcard.h */ - if (mask & AFMT_S32_LE) { - format = AFMT_S32_LE; - info->nativeFormats |= RTAUDIO_SINT32; + info.name.append( (const char *)name, strlen(name) + 1 ); + info.name.append( ": " ); + + dataSize = 256; + result = AudioDeviceGetProperty( id, 0, false, + kAudioDevicePropertyDeviceName, + &dataSize, name ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceInfo: system error (" << getErrorCode( result ) << ") getting device name."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; + } + info.name.append( (const char *)name, strlen(name) + 1 ); + + // Get the output stream "configuration". + AudioBufferList *bufferList = nil; + result = AudioDeviceGetPropertyInfo( id, 0, false, + kAudioDevicePropertyStreamConfiguration, + &dataSize, NULL ); + if (result != noErr || dataSize == 0) { + errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting output stream configuration info for device (" << device << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; + } + + // Allocate the AudioBufferList. + bufferList = (AudioBufferList *) malloc( dataSize ); + if ( bufferList == NULL ) { + errorText_ = "RtApiCore::getDeviceInfo: memory error allocating output AudioBufferList."; + error( WARNING ); + return info; + } + + result = AudioDeviceGetProperty( id, 0, false, + kAudioDevicePropertyStreamConfiguration, + &dataSize, bufferList ); + if ( result != noErr ) { + free( bufferList ); + errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting output stream configuration for device (" << device << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } -#endif - if (mask & AFMT_S8) { - format = AFMT_S8; - info->nativeFormats |= RTAUDIO_SINT8; + + // Get output channel information. + unsigned int i, nStreams = bufferList->mNumberBuffers; + for ( i=0; imBuffers[i].mNumberChannels; + free( bufferList ); + + // Get the input stream "configuration". + result = AudioDeviceGetPropertyInfo( id, 0, true, + kAudioDevicePropertyStreamConfiguration, + &dataSize, NULL ); + if (result != noErr || dataSize == 0) { + errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting input stream configuration info for device (" << device << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; + } + + // Allocate the AudioBufferList. + bufferList = (AudioBufferList *) malloc( dataSize ); + if ( bufferList == NULL ) { + errorText_ = "RtApiCore::getDeviceInfo: memory error allocating input AudioBufferList."; + error( WARNING ); + return info; + } + + result = AudioDeviceGetProperty( id, 0, true, + kAudioDevicePropertyStreamConfiguration, + &dataSize, bufferList ); + if ( result != noErr ) { + free( bufferList ); + errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting input stream configuration for device (" << device << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - if (mask & AFMT_S16_BE) { - format = AFMT_S16_BE; - info->nativeFormats |= RTAUDIO_SINT16; + + // Get input channel information. + nStreams = bufferList->mNumberBuffers; + for ( i=0; imBuffers[i].mNumberChannels; + free( bufferList ); + + // If device opens for both playback and capture, we determine the channels. + if ( info.outputChannels > 0 && info.inputChannels > 0 ) + info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels; + + // Probe the device sample rates. + bool isInput = false; + if ( info.outputChannels == 0 ) isInput = true; + + // Determine the supported sample rates. + result = AudioDeviceGetPropertyInfo( id, 0, isInput, + kAudioDevicePropertyAvailableNominalSampleRates, + &dataSize, NULL ); + + if ( result != kAudioHardwareNoError || dataSize == 0 ) { + errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting sample rate info."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - if (mask & AFMT_S16_LE) { - format = AFMT_S16_LE; - info->nativeFormats |= RTAUDIO_SINT16; + + UInt32 nRanges = dataSize / sizeof( AudioValueRange ); + AudioValueRange rangeList[ nRanges ]; + result = AudioDeviceGetProperty( id, 0, isInput, + kAudioDevicePropertyAvailableNominalSampleRates, + &dataSize, &rangeList ); + + if ( result != kAudioHardwareNoError ) { + errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting sample rates."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - // Check that we have at least one supported format - if (info->nativeFormats == 0) { - close(fd); - sprintf(message_, "RtApiOss: device (%s) data format not supported by RtAudio.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; + Float64 minimumRate = 100000000.0, maximumRate = 0.0; + for ( UInt32 i=0; i maximumRate ) maximumRate = rangeList[i].mMaximum; } - // Set the format - i = format; - if (ioctl(fd, SNDCTL_DSP_SETFMT, &format) == -1 || format != i) { - close(fd); - sprintf(message_, "RtApiOss: device (%s) error setting data format.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; + info.sampleRates.clear(); + for ( unsigned int k=0; k= (unsigned int) minimumRate && SAMPLE_RATES[k] <= (unsigned int) maximumRate ) + info.sampleRates.push_back( SAMPLE_RATES[k] ); } - // Probe the supported sample rates. - info->sampleRates.clear(); - for (unsigned int k=0; ksampleRates.push_back(speed); - } - - if (info->sampleRates.size() == 0) { - close(fd); - sprintf(message_, "RtApiOss: no supported sample rates found for device (%s).", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; + if ( info.sampleRates.size() == 0 ) { + errorStream_ << "RtApiCore::probeDeviceInfo: No supported sample rates found for device (" << device << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - // That's all ... close the device and return - close(fd); - info->probed = true; - return; + // CoreAudio always uses 32-bit floating point data for PCM streams. + // Thus, any other "physical" formats supported by the device are of + // no interest to the client. + info.nativeFormats = RTAUDIO_FLOAT32; + + if ( getDefaultOutputDevice() == device ) + info.isDefaultOutput = true; + if ( getDefaultInputDevice() == device ) + info.isDefaultInput = true; + + info.probed = true; + return info; } -bool RtApiOss :: probeDeviceOpen(int device, StreamMode mode, int channels, - int sampleRate, RtAudioFormat format, - int *bufferSize, int numberOfBuffers) +OSStatus callbackHandler( AudioDeviceID inDevice, + const AudioTimeStamp* inNow, + const AudioBufferList* inInputData, + const AudioTimeStamp* inInputTime, + AudioBufferList* outOutputData, + const AudioTimeStamp* inOutputTime, + void* infoPointer ) { - int buffers, buffer_bytes, device_channels, device_format; - int srate, temp, fd; - int *handle = (int *) stream_.apiHandle; + CallbackInfo *info = (CallbackInfo *) infoPointer; - const char *name = devices_[device].name.c_str(); + RtApiCore *object = (RtApiCore *) info->object; + if ( object->callbackEvent( inDevice, inInputData, outOutputData ) == false ) + return kAudioHardwareUnspecifiedError; + else + return kAudioHardwareNoError; +} - if (mode == OUTPUT) - fd = open(name, O_WRONLY | O_NONBLOCK); - else { // mode == INPUT - if (stream_.mode == OUTPUT && stream_.device[0] == device) { - // We just set the same device for playback ... close and reopen for duplex (OSS only). - close(handle[0]); - handle[0] = 0; - // First check that the number previously set channels is the same. - if (stream_.nUserChannels[0] != channels) { - sprintf(message_, "RtApiOss: input/output channels must be equal for OSS duplex device (%s).", name); - goto error; - } - fd = open(name, O_RDWR | O_NONBLOCK); - } +OSStatus deviceListener( AudioDeviceID inDevice, + UInt32 channel, + Boolean isInput, + AudioDevicePropertyID propertyID, + void* handlePointer ) +{ + CoreHandle *handle = (CoreHandle *) handlePointer; + if ( propertyID == kAudioDeviceProcessorOverload ) { + if ( isInput ) + handle->xrun[1] = true; else - fd = open(name, O_RDONLY | O_NONBLOCK); + handle->xrun[0] = true; } - if (fd == -1) { - if (errno == EBUSY || errno == EAGAIN) - sprintf(message_, "RtApiOss: device (%s) is busy and cannot be opened.", - name); - else - sprintf(message_, "RtApiOss: device (%s) cannot be opened.", name); - goto error; - } + return kAudioHardwareNoError; +} - // Now reopen in blocking mode. - close(fd); - if (mode == OUTPUT) - fd = open(name, O_WRONLY | O_SYNC); - else { // mode == INPUT - if (stream_.mode == OUTPUT && stream_.device[0] == device) - fd = open(name, O_RDWR | O_SYNC); - else - fd = open(name, O_RDONLY | O_SYNC); - } +static bool hasProperty( AudioDeviceID id, UInt32 channel, bool isInput, AudioDevicePropertyID property ) +{ + OSStatus result = AudioDeviceGetPropertyInfo( id, channel, isInput, property, NULL, NULL ); + return result == 0; +} - if (fd == -1) { - sprintf(message_, "RtApiOss: device (%s) cannot be opened.", name); - goto error; +bool RtApiCore :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, + unsigned int firstChannel, unsigned int sampleRate, + RtAudioFormat format, unsigned int *bufferSize, + RtAudio::StreamOptions *options ) +{ + // Get device ID + unsigned int nDevices = getDeviceCount(); + if ( nDevices == 0 ) { + // This should not happen because a check is made before this function is called. + errorText_ = "RtApiCore::probeDeviceOpen: no devices found!"; + return FAILURE; } - // Get the sample format mask - int mask; - if (ioctl(fd, SNDCTL_DSP_GETFMTS, &mask) == -1) { - close(fd); - sprintf(message_, "RtApiOss: device (%s) can't get supported audio formats.", - name); - goto error; + if ( device >= nDevices ) { + // This should not happen because a check is made before this function is called. + errorText_ = "RtApiCore::probeDeviceOpen: device ID is invalid!"; + return FAILURE; } - // Determine how to set the device format. - stream_.userFormat = format; - device_format = -1; - stream_.doByteSwap[mode] = false; - if (format == RTAUDIO_SINT8) { - if (mask & AFMT_S8) { - device_format = AFMT_S8; - stream_.deviceFormat[mode] = RTAUDIO_SINT8; - } - } - else if (format == RTAUDIO_SINT16) { - if (mask & AFMT_S16_NE) { - device_format = AFMT_S16_NE; - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - } -#if BYTE_ORDER == LITTLE_ENDIAN - else if (mask & AFMT_S16_BE) { - device_format = AFMT_S16_BE; - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - stream_.doByteSwap[mode] = true; - } -#else - else if (mask & AFMT_S16_LE) { - device_format = AFMT_S16_LE; - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - stream_.doByteSwap[mode] = true; - } -#endif + AudioDeviceID deviceList[ nDevices ]; + UInt32 dataSize = sizeof( AudioDeviceID ) * nDevices; + OSStatus result = AudioHardwareGetProperty( kAudioHardwarePropertyDevices, &dataSize, (void *) &deviceList ); + if ( result != noErr ) { + errorText_ = "RtApiCore::probeDeviceOpen: OS-X system error getting device IDs."; + return FAILURE; } -#if defined (AFMT_S32_NE) && defined (AFMT_S32_LE) && defined (AFMT_S32_BE) - else if (format == RTAUDIO_SINT32) { - if (mask & AFMT_S32_NE) { - device_format = AFMT_S32_NE; - stream_.deviceFormat[mode] = RTAUDIO_SINT32; - } -#if BYTE_ORDER == LITTLE_ENDIAN - else if (mask & AFMT_S32_BE) { - device_format = AFMT_S32_BE; - stream_.deviceFormat[mode] = RTAUDIO_SINT32; - stream_.doByteSwap[mode] = true; - } -#else - else if (mask & AFMT_S32_LE) { - device_format = AFMT_S32_LE; - stream_.deviceFormat[mode] = RTAUDIO_SINT32; - stream_.doByteSwap[mode] = true; - } -#endif + + AudioDeviceID id = deviceList[ device ]; + + // Setup for stream mode. + bool isInput = false; + if ( mode == INPUT ) isInput = true; + + // Set or disable "hog" mode. + dataSize = sizeof( UInt32 ); + UInt32 doHog = 0; + if ( options && options->flags & RTAUDIO_HOG_DEVICE ) doHog = 1; + result = AudioHardwareSetProperty( kAudioHardwarePropertyHogModeIsAllowed, dataSize, &doHog ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting 'hog' state!"; + errorText_ = errorStream_.str(); + return FAILURE; } -#endif - if (device_format == -1) { - // The user requested format is not natively supported by the device. - if (mask & AFMT_S16_NE) { - device_format = AFMT_S16_NE; - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - } -#if BYTE_ORDER == LITTLE_ENDIAN - else if (mask & AFMT_S16_BE) { - device_format = AFMT_S16_BE; - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - stream_.doByteSwap[mode] = true; - } -#else - else if (mask & AFMT_S16_LE) { - device_format = AFMT_S16_LE; - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - stream_.doByteSwap[mode] = true; - } -#endif -#if defined (AFMT_S32_NE) && defined (AFMT_S32_LE) && defined (AFMT_S32_BE) - else if (mask & AFMT_S32_NE) { - device_format = AFMT_S32_NE; - stream_.deviceFormat[mode] = RTAUDIO_SINT32; - } -#if BYTE_ORDER == LITTLE_ENDIAN - else if (mask & AFMT_S32_BE) { - device_format = AFMT_S32_BE; - stream_.deviceFormat[mode] = RTAUDIO_SINT32; - stream_.doByteSwap[mode] = true; - } -#else - else if (mask & AFMT_S32_LE) { - device_format = AFMT_S32_LE; - stream_.deviceFormat[mode] = RTAUDIO_SINT32; - stream_.doByteSwap[mode] = true; - } -#endif -#endif - else if (mask & AFMT_S8) { - device_format = AFMT_S8; - stream_.deviceFormat[mode] = RTAUDIO_SINT8; - } + // Get the stream "configuration". + AudioBufferList *bufferList; + result = AudioDeviceGetPropertyInfo( id, 0, isInput, + kAudioDevicePropertyStreamConfiguration, + &dataSize, NULL ); + if (result != noErr || dataSize == 0) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream configuration info for device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; } - if (stream_.deviceFormat[mode] == 0) { - // This really shouldn't happen ... - close(fd); - sprintf(message_, "RtApiOss: device (%s) data format not supported by RtAudio.", - name); - goto error; + // Allocate the AudioBufferList. + bufferList = (AudioBufferList *) malloc( dataSize ); + if ( bufferList == NULL ) { + errorText_ = "RtApiCore::probeDeviceOpen: memory error allocating AudioBufferList."; + return FAILURE; } - // Determine the number of channels for this device. Note that the - // channel value requested by the user might be < min_X_Channels. - stream_.nUserChannels[mode] = channels; - device_channels = channels; - if (mode == OUTPUT) { - if (channels < devices_[device].minOutputChannels) - device_channels = devices_[device].minOutputChannels; + result = AudioDeviceGetProperty( id, 0, isInput, + kAudioDevicePropertyStreamConfiguration, + &dataSize, bufferList ); + if ( result != noErr ) { + free( bufferList ); + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream configuration for device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; } - else { // mode == INPUT - if (stream_.mode == OUTPUT && stream_.device[0] == device) { - // We're doing duplex setup here. - if (channels < devices_[device].minDuplexChannels) - device_channels = devices_[device].minDuplexChannels; + + // Search for a stream that contains the desired number of + // channels. CoreAudio devices can have an arbitrary number of + // streams and each stream can have an arbitrary number of channels. + // For each stream, a single buffer of interleaved samples is + // provided. RtAudio currently only supports the use of one stream + // of interleaved data or multiple consecutive single-channel + // streams. Thus, our search below is limited to these two + // contexts. + unsigned int streamChannels = 0, nStreams = 0; + UInt32 iChannel = 0, iStream = 0; + unsigned int offsetCounter = firstChannel; + stream_.deviceInterleaved[mode] = true; + nStreams = bufferList->mNumberBuffers; + bool foundStream = false; + + for ( iStream=0; iStreammBuffers[iStream].mNumberChannels; + if ( streamChannels >= channels + offsetCounter ) { + iChannel += offsetCounter; + foundStream = true; + break; } - else { - if (channels < devices_[device].minInputChannels) - device_channels = devices_[device].minInputChannels; + if ( streamChannels > offsetCounter ) break; + offsetCounter -= streamChannels; + iChannel += streamChannels; + } + + // If we didn't find a single stream above, see if we can meet + // the channel specification in mono mode (i.e. using separate + // non-interleaved buffers). This can only work if there are N + // consecutive one-channel streams, where N is the number of + // desired channels (+ channel offset). + if ( foundStream == false ) { + unsigned int counter = 0; + offsetCounter = firstChannel; + iChannel = 0; + for ( iStream=0; iStreammBuffers[iStream].mNumberChannels; + if ( offsetCounter ) { + if ( streamChannels > offsetCounter ) break; + offsetCounter -= streamChannels; + } + else if ( streamChannels == 1 ) + counter++; + else + counter = 0; + if ( counter == channels ) { + iStream -= channels - 1; + iChannel -= channels - 1; + stream_.deviceInterleaved[mode] = false; + foundStream = true; + break; + } + iChannel += streamChannels; } } - stream_.nDeviceChannels[mode] = device_channels; + free( bufferList ); - // Attempt to set the buffer size. According to OSS, the minimum - // number of buffers is two. The supposed minimum buffer size is 16 - // bytes, so that will be our lower bound. The argument to this - // call is in the form 0xMMMMSSSS (hex), where the buffer size (in - // bytes) is given as 2^SSSS and the number of buffers as 2^MMMM. - // We'll check the actual value used near the end of the setup - // procedure. - buffer_bytes = *bufferSize * formatBytes(stream_.deviceFormat[mode]) * device_channels; - if (buffer_bytes < 16) buffer_bytes = 16; - buffers = numberOfBuffers; - if (buffers < 2) buffers = 2; - temp = ((int) buffers << 16) + (int)(log10((double)buffer_bytes)/log10(2.0)); - if (ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &temp)) { - close(fd); - sprintf(message_, "RtApiOss: error setting fragment size for device (%s).", - name); - goto error; + if ( foundStream == false ) { + errorStream_ << "RtApiCore::probeDeviceOpen: unable to find OS-X stream on device (" << device << ") for requested channels."; + errorText_ = errorStream_.str(); + return FAILURE; } - stream_.nBuffers = buffers; - // Set the data format. - temp = device_format; - if (ioctl(fd, SNDCTL_DSP_SETFMT, &device_format) == -1 || device_format != temp) { - close(fd); - sprintf(message_, "RtApiOss: error setting data format for device (%s).", - name); - goto error; + // Determine the buffer size. + AudioValueRange bufferRange; + dataSize = sizeof( AudioValueRange ); + result = AudioDeviceGetProperty( id, 0, isInput, + kAudioDevicePropertyBufferFrameSizeRange, + &dataSize, &bufferRange ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting buffer size range for device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; } - // Set the number of channels. - temp = device_channels; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &device_channels) == -1 || device_channels != temp) { - close(fd); - sprintf(message_, "RtApiOss: error setting %d channels on device (%s).", - temp, name); - goto error; - } + if ( bufferRange.mMinimum > *bufferSize ) *bufferSize = (unsigned long) bufferRange.mMinimum; + else if ( bufferRange.mMaximum < *bufferSize ) *bufferSize = (unsigned long) bufferRange.mMaximum; + if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) *bufferSize = (unsigned long) bufferRange.mMinimum; - // Set the sample rate. - srate = sampleRate; - temp = srate; - if (ioctl(fd, SNDCTL_DSP_SPEED, &srate) == -1) { - close(fd); - sprintf(message_, "RtApiOss: error setting sample rate = %d on device (%s).", - temp, name); - goto error; + // Set the buffer size. For mono mode, I'm assuming we only need to + // make this setting for the master channel. + UInt32 theSize = (UInt32) *bufferSize; + dataSize = sizeof( UInt32 ); + result = AudioDeviceSetProperty( id, NULL, 0, isInput, + kAudioDevicePropertyBufferFrameSize, + dataSize, &theSize ); + + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting the buffer size for device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; } - // Verify the sample rate setup worked. - if (abs(srate - temp) > 100) { - close(fd); - sprintf(message_, "RtApiOss: error ... audio device (%s) doesn't support sample rate of %d.", - name, temp); - goto error; + // If attempting to setup a duplex stream, the bufferSize parameter + // MUST be the same in both directions! + *bufferSize = theSize; + if ( stream_.mode == OUTPUT && mode == INPUT && *bufferSize != stream_.bufferSize ) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error setting buffer size for duplex stream on device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; } - stream_.sampleRate = sampleRate; - if (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &buffer_bytes) == -1) { - close(fd); - sprintf(message_, "RtApiOss: error getting buffer size for device (%s).", - name); - goto error; + stream_.bufferSize = *bufferSize; + stream_.nBuffers = 1; + + // Get the stream ID(s) so we can set the stream format. In mono + // mode, we'll have to do this for each stream (channel). + AudioStreamID streamIDs[ nStreams ]; + dataSize = nStreams * sizeof( AudioStreamID ); + result = AudioDeviceGetProperty( id, 0, isInput, + kAudioDevicePropertyStreams, + &dataSize, &streamIDs ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream ID(s) for device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; } - // Save buffer size (in sample frames). - *bufferSize = buffer_bytes / (formatBytes(stream_.deviceFormat[mode]) * device_channels); - stream_.bufferSize = *bufferSize; + // Now set the stream format. Also, check the physical format of the + // device and change that if necessary. + AudioStreamBasicDescription description; + dataSize = sizeof( AudioStreamBasicDescription ); + if ( stream_.deviceInterleaved[mode] ) nStreams = 1; + else nStreams = channels; - if (mode == INPUT && stream_.mode == OUTPUT && - stream_.device[0] == device) { - // We're doing duplex setup here. - stream_.deviceFormat[0] = stream_.deviceFormat[1]; - stream_.nDeviceChannels[0] = device_channels; + bool updateFormat; + for ( unsigned int i=0; i 1.0 ) { + description.mSampleRate = (double) sampleRate; + updateFormat = true; + } + + if ( description.mFormatID != kAudioFormatLinearPCM ) { + description.mFormatID = kAudioFormatLinearPCM; + updateFormat = true; + } + + if ( updateFormat ) { + result = AudioStreamSetProperty( streamIDs[iStream+i], NULL, 0, + kAudioStreamPropertyVirtualFormat, + dataSize, &description ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting sample rate or data format for device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + } + + // Now check the physical format. + result = AudioStreamGetProperty( streamIDs[iStream+i], 0, + kAudioStreamPropertyPhysicalFormat, + &dataSize, &description ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream physical format for device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + + if ( description.mFormatID != kAudioFormatLinearPCM || description.mBitsPerChannel < 24 ) { + description.mFormatID = kAudioFormatLinearPCM; + AudioStreamBasicDescription testDescription = description; + unsigned long formatFlags; + + // We'll try higher bit rates first and then work our way down. + testDescription.mBitsPerChannel = 32; + formatFlags = description.mFormatFlags | kLinearPCMFormatFlagIsFloat & ~kLinearPCMFormatFlagIsSignedInteger; + testDescription.mFormatFlags = formatFlags; + result = AudioStreamSetProperty( streamIDs[iStream+i], NULL, 0, kAudioStreamPropertyPhysicalFormat, dataSize, &testDescription ); + if ( result == noErr ) continue; + + testDescription = description; + testDescription.mBitsPerChannel = 32; + formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsSignedInteger) & ~kLinearPCMFormatFlagIsFloat; + testDescription.mFormatFlags = formatFlags; + result = AudioStreamSetProperty( streamIDs[iStream+i], NULL, 0, kAudioStreamPropertyPhysicalFormat, dataSize, &testDescription ); + if ( result == noErr ) continue; + + testDescription = description; + testDescription.mBitsPerChannel = 24; + testDescription.mFormatFlags = formatFlags; + result = AudioStreamSetProperty( streamIDs[iStream+i], NULL, 0, kAudioStreamPropertyPhysicalFormat, dataSize, &testDescription ); + if ( result == noErr ) continue; + + testDescription = description; + testDescription.mBitsPerChannel = 16; + testDescription.mFormatFlags = formatFlags; + result = AudioStreamSetProperty( streamIDs[iStream+i], NULL, 0, kAudioStreamPropertyPhysicalFormat, dataSize, &testDescription ); + if ( result == noErr ) continue; + + testDescription = description; + testDescription.mBitsPerChannel = 8; + testDescription.mFormatFlags = formatFlags; + result = AudioStreamSetProperty( streamIDs[iStream+i], NULL, 0, kAudioStreamPropertyPhysicalFormat, dataSize, &testDescription ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting physical data format for device (" << device << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + } } - // Allocate the stream handles if necessary and then save. - if ( stream_.apiHandle == 0 ) { - handle = (int *) calloc(2, sizeof(int)); - stream_.apiHandle = (void *) handle; - handle[0] = 0; - handle[1] = 0; + // Get the stream latency. There can be latency in both the device + // and the stream. First, attempt to get the device latency on the + // master channel or the first open channel. Errors that might + // occur here are not deemed critical. + UInt32 latency, channel = 0; + dataSize = sizeof( UInt32 ); + AudioDevicePropertyID property = kAudioDevicePropertyLatency; + for ( int i=0; i<2; i++ ) { + if ( hasProperty( id, channel, isInput, property ) == true ) break; + channel = iChannel + 1 + i; + } + if ( channel <= iChannel + 1 ) { + result = AudioDeviceGetProperty( id, channel, isInput, property, &dataSize, &latency ); + if ( result == kAudioHardwareNoError ) stream_.latency[ mode ] = latency; + else { + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting device latency for device (" << device << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + } } + + // Now try to get the stream latency. For "mono" mode, I assume the + // latency is equal for all single-channel streams. + result = AudioStreamGetProperty( streamIDs[iStream], 0, property, &dataSize, &latency ); + if ( result == kAudioHardwareNoError ) stream_.latency[ mode ] += latency; else { - handle = (int *) stream_.apiHandle; + errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream latency for device (" << device << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); } - handle[mode] = fd; - // Set flags for buffer conversion + // Byte-swapping: According to AudioHardware.h, the stream data will + // always be presented in native-endian format, so we should never + // need to byte swap. + stream_.doByteSwap[mode] = false; + + // From the CoreAudio documentation, PCM data must be supplied as + // 32-bit floats. + stream_.userFormat = format; + stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; + + if ( stream_.deviceInterleaved[mode] ) + stream_.nDeviceChannels[mode] = description.mChannelsPerFrame; + else // mono mode + stream_.nDeviceChannels[mode] = channels; + stream_.nUserChannels[mode] = channels; + stream_.channelOffset[mode] = iChannel; // offset within a CoreAudio stream + if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false; + else stream_.userInterleaved = true; + + // Set flags for buffer conversion. stream_.doConvertBuffer[mode] = false; - if (stream_.userFormat != stream_.deviceFormat[mode]) + if ( stream_.userFormat != stream_.deviceFormat[mode] ) stream_.doConvertBuffer[mode] = true; - if (stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode]) + if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] ) + stream_.doConvertBuffer[mode] = true; + if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] && + stream_.nUserChannels[mode] > 1 ) stream_.doConvertBuffer[mode] = true; - // Allocate necessary internal buffers - if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { + // Allocate our CoreHandle structure for the stream. + CoreHandle *handle = 0; + if ( stream_.apiHandle == 0 ) { + try { + handle = new CoreHandle; + } + catch ( std::bad_alloc& ) { + errorText_ = "RtApiCore::probeDeviceOpen: error allocating CoreHandle memory."; + goto error; + } - long buffer_bytes; - if (stream_.nUserChannels[0] >= stream_.nUserChannels[1]) - buffer_bytes = stream_.nUserChannels[0]; - else - buffer_bytes = stream_.nUserChannels[1]; - - buffer_bytes *= *bufferSize * formatBytes(stream_.userFormat); - if (stream_.userBuffer) free(stream_.userBuffer); - stream_.userBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.userBuffer == NULL) { - close(fd); - sprintf(message_, "RtApiOss: error allocating user buffer memory (%s).", - name); + if ( pthread_cond_init( &handle->condition, NULL ) ) { + errorText_ = "RtApiCore::probeDeviceOpen: error initializing pthread condition variable."; goto error; } + stream_.apiHandle = (void *) handle; } + else + handle = (CoreHandle *) stream_.apiHandle; + handle->iStream[mode] = iStream; + handle->id[mode] = id; - if ( stream_.doConvertBuffer[mode] ) { + // Allocate necessary internal buffers. + unsigned long bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat ); + stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 ); + if ( stream_.userBuffer[mode] == NULL ) { + errorText_ = "RtApiCore::probeDeviceOpen: error allocating user buffer memory."; + goto error; + } + + // If possible, we will make use of the CoreAudio stream buffers as + // "device buffers". However, we can't do this if the device + // buffers are non-interleaved ("mono" mode). + if ( !stream_.deviceInterleaved[mode] && stream_.doConvertBuffer[mode] ) { - long buffer_bytes; bool makeBuffer = true; - if ( mode == OUTPUT ) - buffer_bytes = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - else { // mode == INPUT - buffer_bytes = stream_.nDeviceChannels[1] * formatBytes(stream_.deviceFormat[1]); + bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] ); + if ( mode == INPUT ) { if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { - long bytes_out = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - if ( buffer_bytes < bytes_out ) makeBuffer = false; + unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] ); + if ( bufferBytes <= bytesOut ) makeBuffer = false; } } if ( makeBuffer ) { - buffer_bytes *= *bufferSize; - if (stream_.deviceBuffer) free(stream_.deviceBuffer); - stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.deviceBuffer == NULL) { - close(fd); - sprintf(message_, "RtApiOss: error allocating device buffer memory (%s).", - name); + bufferBytes *= *bufferSize; + if ( stream_.deviceBuffer ) free( stream_.deviceBuffer ); + stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 ); + if ( stream_.deviceBuffer == NULL ) { + errorText_ = "RtApiCore::probeDeviceOpen: error allocating device buffer memory."; goto error; } + + // Save a pointer to our own device buffer in the CoreHandle + // structure because we may need to use the stream_.deviceBuffer + // variable to point to the CoreAudio buffer before buffer + // conversion (if we have a duplex stream with two different + // conversion schemes). + handle->deviceBuffer = stream_.deviceBuffer; } } + stream_.sampleRate = sampleRate; stream_.device[mode] = device; stream_.state = STREAM_STOPPED; + stream_.callbackInfo.object = (void *) this; - if ( stream_.mode == OUTPUT && mode == INPUT ) { - stream_.mode = DUPLEX; - if (stream_.device[0] == device) - handle[0] = fd; - } - else - stream_.mode = mode; - - // Setup the buffer conversion information structure. + // Setup the buffer conversion information structure. We override + // the channel offset value and perform our own setting for that + // here. if ( stream_.doConvertBuffer[mode] ) { - if (mode == INPUT) { // convert device to user buffer - stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1]; - stream_.convertInfo[mode].outJump = stream_.nUserChannels[1]; - stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1]; - stream_.convertInfo[mode].outFormat = stream_.userFormat; - } - else { // convert user to device buffer - stream_.convertInfo[mode].inJump = stream_.nUserChannels[0]; - stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0]; - stream_.convertInfo[mode].inFormat = stream_.userFormat; - stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0]; - } + setConvertInfo( mode, 0 ); - if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump ) - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump; - else - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump; - - // Set up the interleave/deinterleave offsets. - if ( mode == INPUT && stream_.deInterleave[1] ) { - for (int k=0; k 0 && stream_.deviceInterleaved[mode] ) { + if ( mode == OUTPUT ) { + for ( int k=0; kcondition ); + delete handle; stream_.apiHandle = 0; } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } + } + + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; } - error(RtError::DEBUG_WARNING); return FAILURE; } -void RtApiOss :: closeStream() +void RtApiCore :: closeStream( void ) { - // We don't want an exception to be thrown here because this - // function is called by our class destructor. So, do our own - // stream check. - if ( stream_.mode == UNINITIALIZED ) { - sprintf(message_, "RtApiOss::closeStream(): no open stream to close!"); - error(RtError::WARNING); + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiCore::closeStream(): no open stream to close!"; + error( WARNING ); return; } - int *handle = (int *) stream_.apiHandle; - if (stream_.state == STREAM_RUNNING) { - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) - ioctl(handle[0], SNDCTL_DSP_RESET, 0); - else - ioctl(handle[1], SNDCTL_DSP_RESET, 0); - stream_.state = STREAM_STOPPED; - } - - if (stream_.callbackInfo.usingCallback) { - stream_.callbackInfo.usingCallback = false; - pthread_join(stream_.callbackInfo.thread, NULL); + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + if ( stream_.state == STREAM_RUNNING ) + AudioDeviceStop( handle->id[0], callbackHandler ); + AudioDeviceRemoveIOProc( handle->id[0], callbackHandler ); } - if (handle) { - if (handle[0]) close(handle[0]); - if (handle[1]) close(handle[1]); - free(handle); - stream_.apiHandle = 0; + if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) { + if ( stream_.state == STREAM_RUNNING ) + AudioDeviceStop( handle->id[1], callbackHandler ); + AudioDeviceRemoveIOProc( handle->id[1], callbackHandler ); } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } } - if (stream_.deviceBuffer) { - free(stream_.deviceBuffer); + if ( handle->deviceBuffer ) { + free( handle->deviceBuffer ); stream_.deviceBuffer = 0; } + // Destroy pthread condition variable. + pthread_cond_destroy( &handle->condition ); + delete handle; + stream_.apiHandle = 0; + stream_.mode = UNINITIALIZED; + stream_.state = STREAM_CLOSED; } -void RtApiOss :: startStream() +void RtApiCore :: startStream( void ) { verifyStream(); - if (stream_.state == STREAM_RUNNING) return; + if ( stream_.state == STREAM_RUNNING ) { + errorText_ = "RtApiCore::startStream(): the stream is already running!"; + error( WARNING ); + return; + } - MUTEX_LOCK(&stream_.mutex); + MUTEX_LOCK( &stream_.mutex ); + OSStatus result = noErr; + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + + result = AudioDeviceStart( handle->id[0], callbackHandler ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::startStream: system error (" << getErrorCode( result ) << ") starting callback procedure on device (" << stream_.device[0] << ")."; + errorText_ = errorStream_.str(); + goto unlock; + } + } + + if ( stream_.mode == INPUT || + ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) { + + result = AudioDeviceStart( handle->id[1], callbackHandler ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::startStream: system error starting input callback procedure on device (" << stream_.device[1] << ")."; + errorText_ = errorStream_.str(); + goto unlock; + } + } + + handle->drainCounter = 0; + handle->internalDrain = false; stream_.state = STREAM_RUNNING; - // No need to do anything else here ... OSS automatically starts - // when fed samples. + unlock: + MUTEX_UNLOCK( &stream_.mutex ); - MUTEX_UNLOCK(&stream_.mutex); + if ( result == noErr ) return; + error( SYSTEM ); } -void RtApiOss :: stopStream() +void RtApiCore :: stopStream( void ) { verifyStream(); - if (stream_.state == STREAM_STOPPED) return; + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiCore::stopStream(): the stream is already stopped!"; + error( WARNING ); + return; + } - // Change the state before the lock to improve shutdown response - // when using a callback. - stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); + MUTEX_LOCK( &stream_.mutex ); + + OSStatus result = noErr; + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + + if ( handle->drainCounter == 0 ) { + handle->drainCounter = 1; + pthread_cond_wait( &handle->condition, &stream_.mutex ); // block until signaled + } - int err; - int *handle = (int *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - err = ioctl(handle[0], SNDCTL_DSP_POST, 0); - //err = ioctl(handle[0], SNDCTL_DSP_SYNC, 0); - if (err < -1) { - sprintf(message_, "RtApiOss: error stopping device (%s).", - devices_[stream_.device[0]].name.c_str()); - error(RtError::DRIVER_ERROR); + result = AudioDeviceStop( handle->id[0], callbackHandler ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::stopStream: system error (" << getErrorCode( result ) << ") stopping callback procedure on device (" << stream_.device[0] << ")."; + errorText_ = errorStream_.str(); + goto unlock; } } - else { - err = ioctl(handle[1], SNDCTL_DSP_POST, 0); - //err = ioctl(handle[1], SNDCTL_DSP_SYNC, 0); - if (err < -1) { - sprintf(message_, "RtApiOss: error stopping device (%s).", - devices_[stream_.device[1]].name.c_str()); - error(RtError::DRIVER_ERROR); + + if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) { + + result = AudioDeviceStop( handle->id[1], callbackHandler ); + if ( result != noErr ) { + errorStream_ << "RtApiCore::stopStream: system error (" << getErrorCode( result ) << ") stopping input callback procedure on device (" << stream_.device[1] << ")."; + errorText_ = errorStream_.str(); + goto unlock; } } - MUTEX_UNLOCK(&stream_.mutex); + unlock: + MUTEX_UNLOCK( &stream_.mutex ); + + stream_.state = STREAM_STOPPED; + if ( result == noErr ) return; + error( SYSTEM ); } -void RtApiOss :: abortStream() +void RtApiCore :: abortStream( void ) { + verifyStream(); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiCore::abortStream(): the stream is already stopped!"; + error( WARNING ); + return; + } + + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; + handle->drainCounter = 1; + stopStream(); } -int RtApiOss :: streamWillBlock() +bool RtApiCore :: callbackEvent( AudioDeviceID deviceId, + const AudioBufferList *inBufferList, + const AudioBufferList *outBufferList ) { - verifyStream(); - if (stream_.state == STREAM_STOPPED) return 0; + if ( stream_.state == STREAM_STOPPED ) return SUCCESS; + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiCore::callbackEvent(): the stream is closed ... this shouldn't happen!"; + error( WARNING ); + return FAILURE; + } - MUTEX_LOCK(&stream_.mutex); + CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; - int bytes = 0, channels = 0, frames = 0; - audio_buf_info info; - int *handle = (int *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - ioctl(handle[0], SNDCTL_DSP_GETOSPACE, &info); - bytes = info.bytes; - channels = stream_.nDeviceChannels[0]; + // Check if we were draining the stream and signal is finished. + if ( handle->drainCounter > 3 ) { + if ( handle->internalDrain == false ) + pthread_cond_signal( &handle->condition ); + else + stopStream(); + return SUCCESS; } - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - ioctl(handle[1], SNDCTL_DSP_GETISPACE, &info); - if (stream_.mode == DUPLEX ) { - bytes = (bytes < info.bytes) ? bytes : info.bytes; - channels = stream_.nDeviceChannels[0]; + MUTEX_LOCK( &stream_.mutex ); + + AudioDeviceID outputDevice = handle->id[0]; + + // Invoke user callback to get fresh output data UNLESS we are + // draining stream or duplex mode AND the input/output devices are + // different AND this function is called for the input device. + if ( handle->drainCounter == 0 && ( stream_.mode != DUPLEX || deviceId == outputDevice ) ) { + RtAudioCallback callback = (RtAudioCallback) info->callback; + double streamTime = getStreamTime(); + RtAudioStreamStatus status = 0; + if ( stream_.mode != INPUT && handle->xrun[0] == true ) { + status |= RTAUDIO_OUTPUT_UNDERFLOW; + handle->xrun[0] = false; } - else { - bytes = info.bytes; - channels = stream_.nDeviceChannels[1]; + if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) { + status |= RTAUDIO_INPUT_OVERFLOW; + handle->xrun[1] = false; } + handle->drainCounter = callback( stream_.userBuffer[0], stream_.userBuffer[1], + stream_.bufferSize, streamTime, status, info->userData ); + if ( handle->drainCounter == 2 ) { + MUTEX_UNLOCK( &stream_.mutex ); + abortStream(); + return SUCCESS; + } + else if ( handle->drainCounter == 1 ) + handle->internalDrain = true; } - frames = (int) (bytes / (channels * formatBytes(stream_.deviceFormat[0]))); - frames -= stream_.bufferSize; - if (frames < 0) frames = 0; - - MUTEX_UNLOCK(&stream_.mutex); - return frames; -} + if ( stream_.mode == OUTPUT || ( stream_.mode == DUPLEX && deviceId == outputDevice ) ) { -void RtApiOss :: tickStream() -{ - verifyStream(); + if ( handle->drainCounter > 1 ) { // write zeros to the output stream - int stopStream = 0; - if (stream_.state == STREAM_STOPPED) { - if (stream_.callbackInfo.usingCallback) usleep(50000); // sleep 50 milliseconds - return; - } - else if (stream_.callbackInfo.usingCallback) { - RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; - stopStream = callback(stream_.userBuffer, stream_.bufferSize, stream_.callbackInfo.userData); - } + if ( stream_.deviceInterleaved[0] ) { + memset( outBufferList->mBuffers[handle->iStream[0]].mData, + 0, + outBufferList->mBuffers[handle->iStream[0]].mDataByteSize ); + } + else { + for ( unsigned int i=0; imBuffers[handle->iStream[0]+i].mData, + 0, + outBufferList->mBuffers[handle->iStream[0]+i].mDataByteSize ); + } + } + } + else if ( stream_.doConvertBuffer[0] ) { - MUTEX_LOCK(&stream_.mutex); + if ( stream_.deviceInterleaved[0] ) + stream_.deviceBuffer = (char *) outBufferList->mBuffers[handle->iStream[0]].mData; + else + stream_.deviceBuffer = handle->deviceBuffer; - // The state might change while waiting on a mutex. - if (stream_.state == STREAM_STOPPED) - goto unlock; + convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] ); - int result, *handle; - char *buffer; - int samples; - RtAudioFormat format; - handle = (int *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { + if ( !stream_.deviceInterleaved[0] ) { + UInt32 bufferBytes = outBufferList->mBuffers[handle->iStream[0]].mDataByteSize; + for ( unsigned int i=0; imBuffers[handle->iStream[0]+i].mData, + &stream_.deviceBuffer[i*bufferBytes], bufferBytes ); + } + } - // Setup parameters and do buffer conversion if necessary. - if (stream_.doConvertBuffer[0]) { - buffer = stream_.deviceBuffer; - convertBuffer( buffer, stream_.userBuffer, stream_.convertInfo[0] ); - samples = stream_.bufferSize * stream_.nDeviceChannels[0]; - format = stream_.deviceFormat[0]; } else { - buffer = stream_.userBuffer; - samples = stream_.bufferSize * stream_.nUserChannels[0]; - format = stream_.userFormat; + if ( stream_.deviceInterleaved[0] ) { + memcpy( outBufferList->mBuffers[handle->iStream[0]].mData, + stream_.userBuffer[0], + outBufferList->mBuffers[handle->iStream[0]].mDataByteSize ); + } + else { + UInt32 bufferBytes = outBufferList->mBuffers[handle->iStream[0]].mDataByteSize; + for ( unsigned int i=0; imBuffers[handle->iStream[0]+i].mData, + &stream_.userBuffer[0][i*bufferBytes], bufferBytes ); + } + } } - // Do byte swapping if necessary. - if (stream_.doByteSwap[0]) - byteSwapBuffer(buffer, samples, format); - - // Write samples to device. - result = write(handle[0], buffer, samples * formatBytes(format)); - - if (result == -1) { - // This could be an underrun, but the basic OSS API doesn't provide a means for determining that. - sprintf(message_, "RtApiOss: audio write error for device (%s).", - devices_[stream_.device[0]].name.c_str()); - error(RtError::DRIVER_ERROR); + if ( handle->drainCounter ) { + handle->drainCounter++; + goto unlock; } } - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - - // Setup parameters. - if (stream_.doConvertBuffer[1]) { - buffer = stream_.deviceBuffer; - samples = stream_.bufferSize * stream_.nDeviceChannels[1]; - format = stream_.deviceFormat[1]; - } - else { - buffer = stream_.userBuffer; - samples = stream_.bufferSize * stream_.nUserChannels[1]; - format = stream_.userFormat; - } + AudioDeviceID inputDevice = handle->id[1]; + if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && deviceId == inputDevice ) ) { - // Read samples from device. - result = read(handle[1], buffer, samples * formatBytes(format)); + if ( stream_.doConvertBuffer[1] ) { - if (result == -1) { - // This could be an overrun, but the basic OSS API doesn't provide a means for determining that. - sprintf(message_, "RtApiOss: audio read error for device (%s).", - devices_[stream_.device[1]].name.c_str()); - error(RtError::DRIVER_ERROR); - } + if ( stream_.deviceInterleaved[1] ) + stream_.deviceBuffer = (char *) inBufferList->mBuffers[handle->iStream[1]].mData; + else { + stream_.deviceBuffer = (char *) handle->deviceBuffer; + UInt32 bufferBytes = inBufferList->mBuffers[handle->iStream[1]].mDataByteSize; + for ( unsigned int i=0; imBuffers[handle->iStream[1]+i].mData, bufferBytes ); + } + } - // Do byte swapping if necessary. - if (stream_.doByteSwap[1]) - byteSwapBuffer(buffer, samples, format); + convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] ); - // Do buffer conversion if necessary. - if (stream_.doConvertBuffer[1]) - convertBuffer( stream_.userBuffer, stream_.deviceBuffer, stream_.convertInfo[1] ); + } + else { + memcpy( stream_.userBuffer[1], + inBufferList->mBuffers[handle->iStream[1]].mData, + inBufferList->mBuffers[handle->iStream[1]].mDataByteSize ); + } } unlock: - MUTEX_UNLOCK(&stream_.mutex); + MUTEX_UNLOCK( &stream_.mutex ); - if (stream_.callbackInfo.usingCallback && stopStream) - this->stopStream(); + RtApi::tickStreamTime(); + return SUCCESS; } -void RtApiOss :: setStreamCallback(RtAudioCallback callback, void *userData) +const char* RtApiCore :: getErrorCode( OSStatus code ) { - verifyStream(); - - CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; - if ( info->usingCallback ) { - sprintf(message_, "RtApiOss: A callback is already set for this stream!"); - error(RtError::WARNING); - return; - } + switch( code ) { - info->callback = (void *) callback; - info->userData = userData; - info->usingCallback = true; - info->object = (void *) this; + case kAudioHardwareNotRunningError: + return "kAudioHardwareNotRunningError"; - // Set the thread attributes for joinable and realtime scheduling - // priority. The higher priority will only take affect if the - // program is run as root or suid. - pthread_attr_t attr; - pthread_attr_init(&attr); - pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); - pthread_attr_setschedpolicy(&attr, SCHED_RR); + case kAudioHardwareUnspecifiedError: + return "kAudioHardwareUnspecifiedError"; - int err = pthread_create(&(info->thread), &attr, ossCallbackHandler, &stream_.callbackInfo); - pthread_attr_destroy(&attr); - if (err) { - info->usingCallback = false; - sprintf(message_, "RtApiOss: error starting callback thread!"); - error(RtError::THREAD_ERROR); - } -} + case kAudioHardwareUnknownPropertyError: + return "kAudioHardwareUnknownPropertyError"; -void RtApiOss :: cancelStreamCallback() -{ - verifyStream(); + case kAudioHardwareBadPropertySizeError: + return "kAudioHardwareBadPropertySizeError"; - if (stream_.callbackInfo.usingCallback) { + case kAudioHardwareIllegalOperationError: + return "kAudioHardwareIllegalOperationError"; - if (stream_.state == STREAM_RUNNING) - stopStream(); + case kAudioHardwareBadObjectError: + return "kAudioHardwareBadObjectError"; - MUTEX_LOCK(&stream_.mutex); + case kAudioHardwareBadDeviceError: + return "kAudioHardwareBadDeviceError"; - stream_.callbackInfo.usingCallback = false; - pthread_join(stream_.callbackInfo.thread, NULL); - stream_.callbackInfo.thread = 0; - stream_.callbackInfo.callback = NULL; - stream_.callbackInfo.userData = NULL; + case kAudioHardwareBadStreamError: + return "kAudioHardwareBadStreamError"; - MUTEX_UNLOCK(&stream_.mutex); - } -} + case kAudioHardwareUnsupportedOperationError: + return "kAudioHardwareUnsupportedOperationError"; -extern "C" void *ossCallbackHandler(void *ptr) -{ - CallbackInfo *info = (CallbackInfo *) ptr; - RtApiOss *object = (RtApiOss *) info->object; - bool *usingCallback = &info->usingCallback; + case kAudioDeviceUnsupportedFormatError: + return "kAudioDeviceUnsupportedFormatError"; - while ( *usingCallback ) { - pthread_testcancel(); - try { - object->tickStream(); - } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiOss: callback thread error (%s) ... closing thread.\n\n", - exception.getMessageString()); - break; - } - } + case kAudioDevicePermissionsError: + return "kAudioDevicePermissionsError"; - return 0; + default: + return "CoreAudio unknown error"; + } } -//******************** End of __LINUX_OSS__ *********************// +//******************** End of __MACOSX_CORE__ *********************// #endif -#if defined(__MACOSX_CORE__) - +#if defined(__UNIX_JACK__) -// The OS X CoreAudio API is designed to use a separate callback -// procedure for each of its audio devices. A single RtAudio duplex -// stream using two different devices is supported here, though it -// cannot be guaranteed to always behave correctly because we cannot -// synchronize these two callbacks. This same functionality can be -// achieved with better synchrony by opening two separate streams for -// the devices and using RtAudio blocking calls (i.e. tickStream()). +// JACK is a low-latency audio server, originally written for the +// GNU/Linux operating system and now also ported to OS-X. It can +// connect a number of different applications to an audio device, as +// well as allowing them to share audio between themselves. // -// A property listener is installed for over/underrun information. -// However, no functionality is currently provided to allow property -// listeners to trigger user handlers because it is unclear what could -// be done if a critical stream parameter (buffer size, sample rate, -// device disconnect) notification arrived. The listeners entail -// quite a bit of extra code and most likely, a user program wouldn't -// be prepared for the result anyway. +// When using JACK with RtAudio, "devices" refer to JACK clients that +// have ports connected to the server. The JACK server is typically +// started in a terminal as follows: +// +// .jackd -d alsa -d hw:0 +// +// or through an interface program such as qjackctl. Many of the +// parameters normally set for a stream are fixed by the JACK server +// and can be specified when the JACK server is started. In +// particular, +// +// .jackd -d alsa -d hw:0 -r 44100 -p 512 -n 4 +// +// specifies a sample rate of 44100 Hz, a buffer size of 512 sample +// frames, and number of buffers = 4. Once the server is running, it +// is not possible to override these values. If the values are not +// specified in the command-line, the JACK server uses default values. +// +// The JACK server does not have to be running when an instance of +// RtApiJack is created, though the function getDeviceCount() will +// report 0 devices found until JACK has been started. When no +// devices are available (i.e., the JACK server is not running), a +// stream cannot be opened. -// A structure to hold various information related to the CoreAudio API +#include +#include + +// A structure to hold various information related to the Jack API // implementation. -struct CoreHandle { - UInt32 index[2]; - bool stopStream; - bool xrun; - char *deviceBuffer; +struct JackHandle { + jack_client_t *client; + jack_port_t **ports[2]; + std::string deviceName[2]; + bool xrun[2]; pthread_cond_t condition; + int drainCounter; // Tracks callback counts when draining + bool internalDrain; // Indicates if stop is initiated from callback or not. - CoreHandle() - :stopStream(false), xrun(false), deviceBuffer(0) {} + JackHandle() + :client(0), drainCounter(0), internalDrain(false) { ports[0] = 0; ports[1] = 0; xrun[0] = false; xrun[1] = false; } }; -RtApiCore :: RtApiCore() +RtApiJack :: RtApiJack() { - this->initialize(); - - if (nDevices_ <= 0) { - sprintf(message_, "RtApiCore: no Macintosh OS-X Core Audio devices found!"); - error(RtError::NO_DEVICES_FOUND); - } + // Nothing to do here. } -RtApiCore :: ~RtApiCore() +RtApiJack :: ~RtApiJack() { - // The subclass destructor gets called before the base class - // destructor, so close an existing stream before deallocating - // apiDeviceId memory. - if ( stream_.mode != UNINITIALIZED ) closeStream(); - - // Free our allocated apiDeviceId memory. - AudioDeviceID *id; - for ( unsigned int i=0; iapiDeviceId; - err = AudioDeviceGetProperty( *id, 0, false, - kAudioDevicePropertyDeviceManufacturer, - &dataSize, name ); - if (err != noErr) { - sprintf( message_, "RtApiCore: OS-X error getting device manufacturer." ); - error(RtError::DEBUG_WARNING); - return; - } - strncpy(fullname, name, 256); - strcat(fullname, ": " ); - - dataSize = 256; - err = AudioDeviceGetProperty( *id, 0, false, - kAudioDevicePropertyDeviceName, - &dataSize, name ); - if (err != noErr) { - sprintf( message_, "RtApiCore: OS-X error getting device name." ); - error(RtError::DEBUG_WARNING); - return; - } - strncat(fullname, name, 254); - info->name.erase(); - info->name.append( (const char *)fullname, strlen(fullname)+1); - - // Get output channel information. - unsigned int i, minChannels = 0, maxChannels = 0, nStreams = 0; - AudioBufferList *bufferList = nil; - err = AudioDeviceGetPropertyInfo( *id, 0, false, - kAudioDevicePropertyStreamConfiguration, - &dataSize, NULL ); - if (err == noErr && dataSize > 0) { - bufferList = (AudioBufferList *) malloc( dataSize ); - if (bufferList == NULL) { - sprintf(message_, "RtApiCore: memory allocation error!"); - error(RtError::DEBUG_WARNING); - return; - } - - err = AudioDeviceGetProperty( *id, 0, false, - kAudioDevicePropertyStreamConfiguration, - &dataSize, bufferList ); - if (err == noErr) { - maxChannels = 0; - minChannels = 1000; - nStreams = bufferList->mNumberBuffers; - for ( i=0; imBuffers[i].mNumberChannels; - if ( bufferList->mBuffers[i].mNumberChannels < minChannels ) - minChannels = bufferList->mBuffers[i].mNumberChannels; + const char **ports; + std::string port, previousPort; + unsigned int nPorts = 0, nDevices = 0; + ports = jack_get_ports( client, NULL, NULL, 0 ); + if ( ports ) { + // Parse the port names up to the first colon (:). + unsigned int iColon = 0; + do { + port = (char *) ports[ nPorts ]; + iColon = port.find(":"); + if ( iColon != std::string::npos ) { + port = port.substr( 0, iColon ); + if ( port != previousPort ) { + if ( nDevices == device ) info.name = port; + nDevices++; + previousPort = port; + } } - } + } while ( ports[++nPorts] ); + free( ports ); } - free (bufferList); - if (err != noErr || dataSize <= 0) { - sprintf( message_, "RtApiCore: OS-X error getting output channels for device (%s).", - info->name.c_str() ); - error(RtError::DEBUG_WARNING); - return; + if ( device >= nDevices ) { + errorText_ = "RtApiJack::getDeviceInfo: device ID is invalid!"; + error( INVALID_CALL ); } - if ( nStreams ) { - if ( maxChannels > 0 ) - info->maxOutputChannels = maxChannels; - if ( minChannels > 0 ) - info->minOutputChannels = minChannels; - } + // Get the current jack server sample rate. + info.sampleRates.clear(); + info.sampleRates.push_back( jack_get_sample_rate( client ) ); - // Get input channel information. - bufferList = nil; - err = AudioDeviceGetPropertyInfo( *id, 0, true, - kAudioDevicePropertyStreamConfiguration, - &dataSize, NULL ); - if (err == noErr && dataSize > 0) { - bufferList = (AudioBufferList *) malloc( dataSize ); - if (bufferList == NULL) { - sprintf(message_, "RtApiCore: memory allocation error!"); - error(RtError::DEBUG_WARNING); - return; - } - err = AudioDeviceGetProperty( *id, 0, true, - kAudioDevicePropertyStreamConfiguration, - &dataSize, bufferList ); - if (err == noErr) { - maxChannels = 0; - minChannels = 1000; - nStreams = bufferList->mNumberBuffers; - for ( i=0; imBuffers[i].mNumberChannels < minChannels ) - minChannels = bufferList->mBuffers[i].mNumberChannels; - maxChannels += bufferList->mBuffers[i].mNumberChannels; - } - } + // Count the available ports containing the client name as device + // channels. Jack "input ports" equal RtAudio output channels. + unsigned int nChannels = 0; + ports = jack_get_ports( client, info.name.c_str(), NULL, JackPortIsInput ); + if ( ports ) { + while ( ports[ nChannels ] ) nChannels++; + free( ports ); + info.outputChannels = nChannels; } - free (bufferList); - if (err != noErr || dataSize <= 0) { - sprintf( message_, "RtApiCore: OS-X error getting input channels for device (%s).", - info->name.c_str() ); - error(RtError::DEBUG_WARNING); - return; + // Jack "output ports" equal RtAudio input channels. + nChannels = 0; + ports = jack_get_ports( client, info.name.c_str(), NULL, JackPortIsOutput ); + if ( ports ) { + while ( ports[ nChannels ] ) nChannels++; + free( ports ); + info.inputChannels = nChannels; } - if ( nStreams ) { - if ( maxChannels > 0 ) - info->maxInputChannels = maxChannels; - if ( minChannels > 0 ) - info->minInputChannels = minChannels; + if ( info.outputChannels == 0 && info.inputChannels == 0 ) { + jack_client_close(client); + errorText_ = "RtApiJack::getDeviceInfo: error determining Jack input/output channels!"; + error( WARNING ); + return info; } // If device opens for both playback and capture, we determine the channels. - if (info->maxOutputChannels > 0 && info->maxInputChannels > 0) { - info->hasDuplexSupport = true; - info->maxDuplexChannels = (info->maxOutputChannels > info->maxInputChannels) ? - info->maxInputChannels : info->maxOutputChannels; - info->minDuplexChannels = (info->minOutputChannels > info->minInputChannels) ? - info->minInputChannels : info->minOutputChannels; - } - - // Probe the device sample rate and data format parameters. The - // core audio query mechanism is performed on a "stream" - // description, which can have a variable number of channels and - // apply to input or output only. - - // Create a stream description structure. - AudioStreamBasicDescription description; - dataSize = sizeof( AudioStreamBasicDescription ); - memset(&description, 0, sizeof(AudioStreamBasicDescription)); - bool isInput = false; - if ( info->maxOutputChannels == 0 ) isInput = true; - bool isDuplex = false; - if ( info->maxDuplexChannels > 0 ) isDuplex = true; - - // Determine the supported sample rates. - info->sampleRates.clear(); - for (unsigned int k=0; ksampleRates.push_back( SAMPLE_RATES[k] ); - } - - if (info->sampleRates.size() == 0) { - sprintf( message_, "RtApiCore: No supported sample rates found for OS-X device (%s).", - info->name.c_str() ); - error(RtError::DEBUG_WARNING); - return; - } - - // Determine the supported data formats. - info->nativeFormats = 0; - description.mFormatID = kAudioFormatLinearPCM; - description.mBitsPerChannel = 8; - description.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_SINT8; - else { - description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_SINT8; - } + if ( info.outputChannels > 0 && info.inputChannels > 0 ) + info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels; - description.mBitsPerChannel = 16; - description.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_SINT16; - else { - description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_SINT16; - } - - description.mBitsPerChannel = 32; - description.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_SINT32; - else { - description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_SINT32; - } + // Jack always uses 32-bit floats. + info.nativeFormats = RTAUDIO_FLOAT32; - description.mBitsPerChannel = 24; - description.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsAlignedHigh | kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_SINT24; - else { - description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_SINT24; - } + // Jack doesn't provide default devices so we'll use the first available one. + if ( device == 0 && info.outputChannels > 0 ) + info.isDefaultOutput = true; + if ( device == 0 && info.inputChannels > 0 ) + info.isDefaultInput = true; - description.mBitsPerChannel = 32; - description.mFormatFlags = kLinearPCMFormatFlagIsFloat | kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_FLOAT32; - else { - description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_FLOAT32; - } + jack_client_close(client); + info.probed = true; + return info; +} - description.mBitsPerChannel = 64; - description.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_FLOAT64; - else { - description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) - info->nativeFormats |= RTAUDIO_FLOAT64; - } +int jackCallbackHandler( jack_nframes_t nframes, void *infoPointer ) +{ + CallbackInfo *info = (CallbackInfo *) infoPointer; - // Check that we have at least one supported format. - if (info->nativeFormats == 0) { - sprintf(message_, "RtApiCore: OS-X device (%s) data format not supported by RtAudio.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } + RtApiJack *object = (RtApiJack *) info->object; + if ( object->callbackEvent( (unsigned long) nframes ) == false ) return 1; - info->probed = true; + return 0; } -OSStatus callbackHandler( AudioDeviceID inDevice, - const AudioTimeStamp* inNow, - const AudioBufferList* inInputData, - const AudioTimeStamp* inInputTime, - AudioBufferList* outOutputData, - const AudioTimeStamp* inOutputTime, - void* infoPointer ) +void jackShutdown( void *infoPointer ) { CallbackInfo *info = (CallbackInfo *) infoPointer; + RtApiJack *object = (RtApiJack *) info->object; - RtApiCore *object = (RtApiCore *) info->object; - try { - object->callbackEvent( inDevice, (void *)inInputData, (void *)outOutputData ); - } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiCore: callback handler error (%s)!\n\n", exception.getMessageString()); - return kAudioHardwareUnspecifiedError; - } + // Check current stream state. If stopped, then we'll assume this + // was called as a result of a call to RtApiJack::stopStream (the + // deactivation of a client handle causes this function to be called). + // If not, we'll assume the Jack server is shutting down or some + // other problem occurred and we should close the stream. + if ( object->isStreamRunning() == false ) return; - return kAudioHardwareNoError; + object->closeStream(); + std::cerr << "\nRtApiJack: the Jack server is shutting down this client ... stream stopped and closed!!\n" << std::endl; } -OSStatus deviceListener( AudioDeviceID inDevice, - UInt32 channel, - Boolean isInput, - AudioDevicePropertyID propertyID, - void* handlePointer ) +int jackXrun( void *infoPointer ) { - CoreHandle *handle = (CoreHandle *) handlePointer; - if ( propertyID == kAudioDeviceProcessorOverload ) { - if ( isInput ) - fprintf(stderr, "\nRtApiCore: OS-X audio input overrun detected!\n"); - else - fprintf(stderr, "\nRtApiCore: OS-X audio output underrun detected!\n"); - handle->xrun = true; - } + JackHandle *handle = (JackHandle *) infoPointer; - return kAudioHardwareNoError; + if ( handle->ports[0] ) handle->xrun[0] = true; + if ( handle->ports[1] ) handle->xrun[1] = true; + + return 0; } -bool RtApiCore :: probeDeviceOpen( int device, StreamMode mode, int channels, - int sampleRate, RtAudioFormat format, - int *bufferSize, int numberOfBuffers ) +bool RtApiJack :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, + unsigned int firstChannel, unsigned int sampleRate, + RtAudioFormat format, unsigned int *bufferSize, + RtAudio::StreamOptions *options ) { - // Setup for stream mode. - bool isInput = false; - AudioDeviceID id = *((AudioDeviceID *) devices_[device].apiDeviceId); - if ( mode == INPUT ) isInput = true; + JackHandle *handle = (JackHandle *) stream_.apiHandle; - // Search for a stream which contains the desired number of channels. - OSStatus err = noErr; - UInt32 dataSize; - unsigned int deviceChannels, nStreams = 0; - UInt32 iChannel = 0, iStream = 0; - AudioBufferList *bufferList = nil; - err = AudioDeviceGetPropertyInfo( id, 0, isInput, - kAudioDevicePropertyStreamConfiguration, - &dataSize, NULL ); - - if (err == noErr && dataSize > 0) { - bufferList = (AudioBufferList *) malloc( dataSize ); - if (bufferList == NULL) { - sprintf(message_, "RtApiCore: memory allocation error in probeDeviceOpen()!"); - error(RtError::DEBUG_WARNING); + // Look for jack server and try to become a client (only do once per stream). + jack_client_t *client = 0; + if ( mode == OUTPUT || ( mode == INPUT && stream_.mode != OUTPUT ) ) { + if ( options && !options->streamName.empty() ) + client = jack_client_new( options->streamName.c_str() ); + else + client = jack_client_new( "RtApiJack" ); + if ( client == 0 ) { + errorText_ = "RtApiJack::probeDeviceOpen: Jack server not found or connection error!"; + error( WARNING ); return FAILURE; } - err = AudioDeviceGetProperty( id, 0, isInput, - kAudioDevicePropertyStreamConfiguration, - &dataSize, bufferList ); + } + else { + // The handle must have been created on an earlier pass. + client = handle->client; + } - if (err == noErr) { - stream_.deInterleave[mode] = false; - nStreams = bufferList->mNumberBuffers; - for ( iStream=0; iStreammBuffers[iStream].mNumberChannels >= (unsigned int) channels ) break; - iChannel += bufferList->mBuffers[iStream].mNumberChannels; - } - // If we didn't find a single stream above, see if we can meet - // the channel specification in mono mode (i.e. using separate - // non-interleaved buffers). This can only work if there are N - // consecutive one-channel streams, where N is the number of - // desired channels. - iChannel = 0; - if ( iStream >= nStreams && nStreams >= (unsigned int) channels ) { - int counter = 0; - for ( iStream=0; iStreammBuffers[iStream].mNumberChannels == 1 ) - counter++; - else - counter = 0; - if ( counter == channels ) { - iStream -= channels - 1; - iChannel -= channels - 1; - stream_.deInterleave[mode] = true; - break; - } - iChannel += bufferList->mBuffers[iStream].mNumberChannels; + const char **ports; + std::string port, previousPort, deviceName; + unsigned int nPorts = 0, nDevices = 0; + ports = jack_get_ports( client, NULL, NULL, 0 ); + if ( ports ) { + // Parse the port names up to the first colon (:). + unsigned int iColon = 0; + do { + port = (char *) ports[ nPorts ]; + iColon = port.find(":"); + if ( iColon != std::string::npos ) { + port = port.substr( 0, iColon ); + if ( port != previousPort ) { + if ( nDevices == device ) deviceName = port; + nDevices++; + previousPort = port; } } - } - } - if (err != noErr || dataSize <= 0) { - if ( bufferList ) free( bufferList ); - sprintf( message_, "RtApiCore: OS-X error getting channels for device (%s).", - devices_[device].name.c_str() ); - error(RtError::DEBUG_WARNING); - return FAILURE; + } while ( ports[++nPorts] ); + free( ports ); } - if (iStream >= nStreams) { - free (bufferList); - sprintf( message_, "RtApiCore: unable to find OS-X audio stream on device (%s) for requested channels (%d).", - devices_[device].name.c_str(), channels ); - error(RtError::DEBUG_WARNING); + if ( device >= nDevices ) { + errorText_ = "RtApiJack::probeDeviceOpen: device ID is invalid!"; return FAILURE; } - // This is ok even for mono mode ... it gets updated later. - deviceChannels = bufferList->mBuffers[iStream].mNumberChannels; - free (bufferList); - - // Determine the buffer size. - AudioValueRange bufferRange; - dataSize = sizeof(AudioValueRange); - err = AudioDeviceGetProperty( id, 0, isInput, - kAudioDevicePropertyBufferSizeRange, - &dataSize, &bufferRange); - if (err != noErr) { - sprintf( message_, "RtApiCore: OS-X error getting buffer size range for device (%s).", - devices_[device].name.c_str() ); - error(RtError::DEBUG_WARNING); - return FAILURE; + // Count the available ports containing the client name as device + // channels. Jack "input ports" equal RtAudio output channels. + unsigned int nChannels = 0; + unsigned long flag = JackPortIsOutput; + if ( mode == INPUT ) flag = JackPortIsInput; + ports = jack_get_ports( client, deviceName.c_str(), NULL, flag ); + if ( ports ) { + while ( ports[ nChannels ] ) nChannels++; + free( ports ); } - long bufferBytes = *bufferSize * deviceChannels * formatBytes(RTAUDIO_FLOAT32); - if (bufferRange.mMinimum > bufferBytes) bufferBytes = (int) bufferRange.mMinimum; - else if (bufferRange.mMaximum < bufferBytes) bufferBytes = (int) bufferRange.mMaximum; - - // Set the buffer size. For mono mode, I'm assuming we only need to - // make this setting for the first channel. - UInt32 theSize = (UInt32) bufferBytes; - dataSize = sizeof( UInt32); - err = AudioDeviceSetProperty(id, NULL, 0, isInput, - kAudioDevicePropertyBufferSize, - dataSize, &theSize); - if (err != noErr) { - sprintf( message_, "RtApiCore: OS-X error setting the buffer size for device (%s).", - devices_[device].name.c_str() ); - error(RtError::DEBUG_WARNING); + // Compare the jack ports for specified client to the requested number of channels. + if ( nChannels < (channels + firstChannel) ) { + errorStream_ << "RtApiJack::probeDeviceOpen: requested number of channels (" << channels << ") + offset (" << firstChannel << ") not found for specified device (" << device << ":" << deviceName << ")."; + errorText_ = errorStream_.str(); return FAILURE; } - // If attempting to setup a duplex stream, the bufferSize parameter - // MUST be the same in both directions! - *bufferSize = bufferBytes / ( deviceChannels * formatBytes(RTAUDIO_FLOAT32) ); - if ( stream_.mode == OUTPUT && mode == INPUT && *bufferSize != stream_.bufferSize ) { - sprintf( message_, "RtApiCore: OS-X error setting buffer size for duplex stream on device (%s).", - devices_[device].name.c_str() ); - error(RtError::DEBUG_WARNING); + // Check the jack server sample rate. + unsigned int jackRate = jack_get_sample_rate( client ); + if ( sampleRate != jackRate ) { + jack_client_close( client ); + errorStream_ << "RtApiJack::probeDeviceOpen: the requested sample rate (" << sampleRate << ") is different than the JACK server rate (" << jackRate << ")."; + errorText_ = errorStream_.str(); return FAILURE; } + stream_.sampleRate = jackRate; - stream_.bufferSize = *bufferSize; - stream_.nBuffers = 1; + // Get the latency of the JACK port. + ports = jack_get_ports( client, deviceName.c_str(), NULL, flag ); + if ( ports[ firstChannel ] ) + stream_.latency[mode] = jack_port_get_latency( jack_port_by_name( client, ports[ firstChannel ] ) ); + free( ports ); - // Set the stream format description. Do for each channel in mono mode. - AudioStreamBasicDescription description; - dataSize = sizeof( AudioStreamBasicDescription ); - if ( stream_.deInterleave[mode] ) nStreams = channels; - else nStreams = 1; - for ( unsigned int i=0; iflags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false; + else stream_.userInterleaved = true; - // Check whether we need byte-swapping (assuming OS-X host is big-endian). - iChannel -= nStreams; - err = AudioDeviceGetProperty( id, iChannel, isInput, - kAudioDevicePropertyStreamFormat, - &dataSize, &description ); - if (err != noErr) { - sprintf( message_, "RtApiCore: OS-X error getting stream format for device (%s).", devices_[device].name.c_str() ); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + // Jack always uses non-interleaved buffers. + stream_.deviceInterleaved[mode] = false; + // Jack always provides host byte-ordered data. stream_.doByteSwap[mode] = false; - if ( !description.mFormatFlags & kLinearPCMFormatFlagIsBigEndian ) - stream_.doByteSwap[mode] = true; - // From the CoreAudio documentation, PCM data must be supplied as - // 32-bit floats. - stream_.userFormat = format; - stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; + // Get the buffer size. The buffer size and number of buffers + // (periods) is set when the jack server is started. + stream_.bufferSize = (int) jack_get_buffer_size( client ); + *bufferSize = stream_.bufferSize; - if ( stream_.deInterleave[mode] ) // mono mode - stream_.nDeviceChannels[mode] = channels; - else - stream_.nDeviceChannels[mode] = description.mChannelsPerFrame; + stream_.nDeviceChannels[mode] = channels; stream_.nUserChannels[mode] = channels; // Set flags for buffer conversion. stream_.doConvertBuffer[mode] = false; - if (stream_.userFormat != stream_.deviceFormat[mode]) + if ( stream_.userFormat != stream_.deviceFormat[mode] ) stream_.doConvertBuffer[mode] = true; - if (stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode]) - stream_.doConvertBuffer[mode] = true; - if (stream_.nUserChannels[mode] > 1 && stream_.deInterleave[mode]) + if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] && + stream_.nUserChannels[mode] > 1 ) stream_.doConvertBuffer[mode] = true; - // Allocate our CoreHandle structure for the stream. - CoreHandle *handle; - if ( stream_.apiHandle == 0 ) { - handle = (CoreHandle *) calloc(1, sizeof(CoreHandle)); - if ( handle == NULL ) { - sprintf(message_, "RtApiCore: OS-X error allocating coreHandle memory (%s).", - devices_[device].name.c_str()); + // Allocate our JackHandle structure for the stream. + if ( handle == 0 ) { + try { + handle = new JackHandle; + } + catch ( std::bad_alloc& ) { + errorText_ = "RtApiJack::probeDeviceOpen: error allocating JackHandle memory."; goto error; } - handle->index[0] = 0; - handle->index[1] = 0; + if ( pthread_cond_init(&handle->condition, NULL) ) { - sprintf(message_, "RtApiCore: error initializing pthread condition variable (%s).", - devices_[device].name.c_str()); + errorText_ = "RtApiJack::probeDeviceOpen: error initializing pthread condition variable."; goto error; } stream_.apiHandle = (void *) handle; + handle->client = client; } - else - handle = (CoreHandle *) stream_.apiHandle; - handle->index[mode] = iStream; + handle->deviceName[mode] = deviceName; // Allocate necessary internal buffers. - if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { - - long buffer_bytes; - if (stream_.nUserChannels[0] >= stream_.nUserChannels[1]) - buffer_bytes = stream_.nUserChannels[0]; - else - buffer_bytes = stream_.nUserChannels[1]; - - buffer_bytes *= *bufferSize * formatBytes(stream_.userFormat); - if (stream_.userBuffer) free(stream_.userBuffer); - stream_.userBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.userBuffer == NULL) { - sprintf(message_, "RtApiCore: OS-X error allocating user buffer memory (%s).", - devices_[device].name.c_str()); - goto error; - } + unsigned long bufferBytes; + bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat ); + stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 ); + if ( stream_.userBuffer[mode] == NULL ) { + errorText_ = "RtApiJack::probeDeviceOpen: error allocating user buffer memory."; + goto error; } - if ( stream_.deInterleave[mode] ) { + if ( stream_.doConvertBuffer[mode] ) { - long buffer_bytes; bool makeBuffer = true; if ( mode == OUTPUT ) - buffer_bytes = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); + bufferBytes = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] ); else { // mode == INPUT - buffer_bytes = stream_.nDeviceChannels[1] * formatBytes(stream_.deviceFormat[1]); + bufferBytes = stream_.nDeviceChannels[1] * formatBytes( stream_.deviceFormat[1] ); if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { - long bytes_out = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - if ( buffer_bytes < bytes_out ) makeBuffer = false; + unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); + if ( bufferBytes < bytesOut ) makeBuffer = false; } } if ( makeBuffer ) { - buffer_bytes *= *bufferSize; - if (stream_.deviceBuffer) free(stream_.deviceBuffer); - stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.deviceBuffer == NULL) { - sprintf(message_, "RtApiCore: error allocating device buffer memory (%s).", - devices_[device].name.c_str()); + bufferBytes *= *bufferSize; + if ( stream_.deviceBuffer ) free( stream_.deviceBuffer ); + stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 ); + if ( stream_.deviceBuffer == NULL ) { + errorText_ = "RtApiJack::probeDeviceOpen: error allocating device buffer memory."; goto error; } - - // If not de-interleaving, we point stream_.deviceBuffer to the - // OS X supplied device buffer before doing any necessary data - // conversions. This presents a problem if we have a duplex - // stream using one device which needs de-interleaving and - // another device which doesn't. So, save a pointer to our own - // device buffer in the CallbackInfo structure. - handle->deviceBuffer = stream_.deviceBuffer; } } - stream_.sampleRate = sampleRate; + // Allocate memory for the Jack ports (channels) identifiers. + handle->ports[mode] = (jack_port_t **) malloc ( sizeof (jack_port_t *) * channels ); + if ( handle->ports[mode] == NULL ) { + errorText_ = "RtApiJack::probeDeviceOpen: error allocating port memory."; + goto error; + } + stream_.device[mode] = device; + stream_.channelOffset[mode] = firstChannel; stream_.state = STREAM_STOPPED; stream_.callbackInfo.object = (void *) this; - // Setup the buffer conversion information structure. - if ( stream_.doConvertBuffer[mode] ) { - if (mode == INPUT) { // convert device to user buffer - stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1]; - stream_.convertInfo[mode].outJump = stream_.nUserChannels[1]; - stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1]; - stream_.convertInfo[mode].outFormat = stream_.userFormat; + if ( stream_.mode == OUTPUT && mode == INPUT ) + // We had already set up the stream for output. + stream_.mode = DUPLEX; + else { + stream_.mode = mode; + jack_set_process_callback( handle->client, jackCallbackHandler, (void *) &stream_.callbackInfo ); + jack_set_xrun_callback( handle->client, jackXrun, (void *) &handle ); + jack_on_shutdown( handle->client, jackShutdown, (void *) &stream_.callbackInfo ); + } + + // Register our ports. + char label[64]; + if ( mode == OUTPUT ) { + for ( unsigned int i=0; iports[0][i] = jack_port_register( handle->client, (const char *)label, + JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ); } - else { // convert user to device buffer - stream_.convertInfo[mode].inJump = stream_.nUserChannels[0]; - stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0]; - stream_.convertInfo[mode].inFormat = stream_.userFormat; - stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0]; + } + else { + for ( unsigned int i=0; iports[1][i] = jack_port_register( handle->client, (const char *)label, + JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 ); } + } - if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump ) - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump; - else - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump; - - // Set up the interleave/deinterleave offsets. - if ( mode == INPUT && stream_.deInterleave[1] ) { - for (int k=0; kcondition); - free(handle); + pthread_cond_destroy( &handle->condition ); + jack_client_close( handle->client ); + + if ( handle->ports[0] ) free( handle->ports[0] ); + if ( handle->ports[1] ) free( handle->ports[1] ); + + delete handle; stream_.apiHandle = 0; } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } + } + + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; } - error(RtError::DEBUG_WARNING); return FAILURE; } -void RtApiCore :: closeStream() +void RtApiJack :: closeStream( void ) { - // We don't want an exception to be thrown here because this - // function is called by our class destructor. So, do our own - // stream check. - if ( stream_.mode == UNINITIALIZED ) { - sprintf(message_, "RtApiCore::closeStream(): no open stream to close!"); - error(RtError::WARNING); + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiJack::closeStream(): no open stream to close!"; + error( WARNING ); return; } - AudioDeviceID id = *( (AudioDeviceID *) devices_[stream_.device[0]].apiDeviceId ); - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - if (stream_.state == STREAM_RUNNING) - AudioDeviceStop( id, callbackHandler ); - AudioDeviceRemoveIOProc( id, callbackHandler ); - } + JackHandle *handle = (JackHandle *) stream_.apiHandle; + if ( handle ) { - id = *( (AudioDeviceID *) devices_[stream_.device[1]].apiDeviceId ); - if (stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1]) ) { - if (stream_.state == STREAM_RUNNING) - AudioDeviceStop( id, callbackHandler ); - AudioDeviceRemoveIOProc( id, callbackHandler ); - } + if ( stream_.state == STREAM_RUNNING ) + jack_deactivate( handle->client ); - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + jack_client_close( handle->client ); } - if ( stream_.deInterleave[0] || stream_.deInterleave[1] ) { - free(stream_.deviceBuffer); - stream_.deviceBuffer = 0; + if ( handle ) { + if ( handle->ports[0] ) free( handle->ports[0] ); + if ( handle->ports[1] ) free( handle->ports[1] ); + pthread_cond_destroy( &handle->condition ); + delete handle; + stream_.apiHandle = 0; } - CoreHandle *handle = (CoreHandle *) stream_.apiHandle; + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } + } - // Destroy pthread condition variable and free the CoreHandle structure. - if ( handle ) { - pthread_cond_destroy(&handle->condition); - free( handle ); - stream_.apiHandle = 0; + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; } stream_.mode = UNINITIALIZED; + stream_.state = STREAM_CLOSED; } -void RtApiCore :: startStream() +void RtApiJack :: startStream( void ) { verifyStream(); - if (stream_.state == STREAM_RUNNING) return; + if ( stream_.state == STREAM_RUNNING ) { + errorText_ = "RtApiJack::startStream(): the stream is already running!"; + error( WARNING ); + return; + } MUTEX_LOCK(&stream_.mutex); - OSStatus err; - AudioDeviceID id; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { + JackHandle *handle = (JackHandle *) stream_.apiHandle; + int result = jack_activate( handle->client ); + if ( result ) { + errorText_ = "RtApiJack::startStream(): unable to activate JACK client!"; + goto unlock; + } + + const char **ports; + + // Get the list of available ports. + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + result = 1; + ports = jack_get_ports( handle->client, handle->deviceName[0].c_str(), NULL, JackPortIsInput); + if ( ports == NULL) { + errorText_ = "RtApiJack::startStream(): error determining available JACK input ports!"; + goto unlock; + } - id = *( (AudioDeviceID *) devices_[stream_.device[0]].apiDeviceId ); - err = AudioDeviceStart(id, callbackHandler); - if (err != noErr) { - sprintf(message_, "RtApiCore: OS-X error starting callback procedure on device (%s).", - devices_[stream_.device[0]].name.c_str()); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + // Now make the port connections. Since RtAudio wasn't designed to + // allow the user to select particular channels of a device, we'll + // just open the first "nChannels" ports with offset. + for ( unsigned int i=0; iclient, jack_port_name( handle->ports[0][i] ), ports[ stream_.channelOffset[0] + i ] ); + if ( result ) { + free( ports ); + errorText_ = "RtApiJack::startStream(): error connecting output ports!"; + goto unlock; + } } + free(ports); } - if (stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1]) ) { + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { + result = 1; + ports = jack_get_ports( handle->client, handle->deviceName[1].c_str(), NULL, JackPortIsOutput ); + if ( ports == NULL) { + errorText_ = "RtApiJack::startStream(): error determining available JACK output ports!"; + goto unlock; + } - id = *( (AudioDeviceID *) devices_[stream_.device[1]].apiDeviceId ); - err = AudioDeviceStart(id, callbackHandler); - if (err != noErr) { - sprintf(message_, "RtApiCore: OS-X error starting input callback procedure on device (%s).", - devices_[stream_.device[0]].name.c_str()); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + // Now make the port connections. See note above. + for ( unsigned int i=0; iclient, ports[ stream_.channelOffset[1] + i ], jack_port_name( handle->ports[1][i] ) ); + if ( result ) { + free( ports ); + errorText_ = "RtApiJack::startStream(): error connecting input ports!"; + goto unlock; + } } + free(ports); } - CoreHandle *handle = (CoreHandle *) stream_.apiHandle; - handle->stopStream = false; + handle->drainCounter = 0; + handle->internalDrain = false; stream_.state = STREAM_RUNNING; + unlock: MUTEX_UNLOCK(&stream_.mutex); + + if ( result == 0 ) return; + error( SYSTEM ); } -void RtApiCore :: stopStream() +void RtApiJack :: stopStream( void ) { verifyStream(); - if (stream_.state == STREAM_STOPPED) return; - - // Change the state before the lock to improve shutdown response - // when using a callback. - stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); - - OSStatus err; - AudioDeviceID id; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - - id = *( (AudioDeviceID *) devices_[stream_.device[0]].apiDeviceId ); - err = AudioDeviceStop(id, callbackHandler); - if (err != noErr) { - sprintf(message_, "RtApiCore: OS-X error stopping callback procedure on device (%s).", - devices_[stream_.device[0]].name.c_str()); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiJack::stopStream(): the stream is already stopped!"; + error( WARNING ); + return; } - if (stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1]) ) { + MUTEX_LOCK( &stream_.mutex ); + + JackHandle *handle = (JackHandle *) stream_.apiHandle; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - id = *( (AudioDeviceID *) devices_[stream_.device[1]].apiDeviceId ); - err = AudioDeviceStop(id, callbackHandler); - if (err != noErr) { - sprintf(message_, "RtApiCore: OS-X error stopping input callback procedure on device (%s).", - devices_[stream_.device[0]].name.c_str()); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + if ( handle->drainCounter == 0 ) { + handle->drainCounter = 1; + pthread_cond_wait( &handle->condition, &stream_.mutex ); // block until signaled } } - MUTEX_UNLOCK(&stream_.mutex); -} + jack_deactivate( handle->client ); + stream_.state = STREAM_STOPPED; -void RtApiCore :: abortStream() -{ - stopStream(); + MUTEX_UNLOCK( &stream_.mutex ); } -void RtApiCore :: tickStream() +void RtApiJack :: abortStream( void ) { verifyStream(); - - if (stream_.state == STREAM_STOPPED) return; - - if (stream_.callbackInfo.usingCallback) { - sprintf(message_, "RtApiCore: tickStream() should not be used when a callback function is set!"); - error(RtError::WARNING); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiJack::abortStream(): the stream is already stopped!"; + error( WARNING ); return; } - CoreHandle *handle = (CoreHandle *) stream_.apiHandle; - - MUTEX_LOCK(&stream_.mutex); - - pthread_cond_wait(&handle->condition, &stream_.mutex); + JackHandle *handle = (JackHandle *) stream_.apiHandle; + handle->drainCounter = 1; - MUTEX_UNLOCK(&stream_.mutex); + stopStream(); } -void RtApiCore :: callbackEvent( AudioDeviceID deviceId, void *inData, void *outData ) +bool RtApiJack :: callbackEvent( unsigned long nframes ) { - verifyStream(); - - if (stream_.state == STREAM_STOPPED) return; + if ( stream_.state == STREAM_STOPPED ) return SUCCESS; + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiCore::callbackEvent(): the stream is closed ... this shouldn't happen!"; + error( WARNING ); + return FAILURE; + } + if ( stream_.bufferSize != nframes ) { + errorText_ = "RtApiCore::callbackEvent(): the JACK buffer size has changed ... cannot process!"; + error( WARNING ); + return FAILURE; + } CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; - CoreHandle *handle = (CoreHandle *) stream_.apiHandle; - AudioBufferList *inBufferList = (AudioBufferList *) inData; - AudioBufferList *outBufferList = (AudioBufferList *) outData; - - if ( info->usingCallback && handle->stopStream ) { - // Check if the stream should be stopped (via the previous user - // callback return value). We stop the stream here, rather than - // after the function call, so that output data can first be - // processed. - this->stopStream(); - return; + JackHandle *handle = (JackHandle *) stream_.apiHandle; + + // Check if we were draining the stream and signal is finished. + if ( handle->drainCounter > 3 ) { + if ( handle->internalDrain == false ) + pthread_cond_signal( &handle->condition ); + else + stopStream(); + return SUCCESS; } - MUTEX_LOCK(&stream_.mutex); + MUTEX_LOCK( &stream_.mutex ); - // Invoke user callback first, to get fresh output data. Don't - // invoke the user callback if duplex mode AND the input/output devices - // are different AND this function is called for the input device. - AudioDeviceID id = *( (AudioDeviceID *) devices_[stream_.device[0]].apiDeviceId ); - if ( info->usingCallback && (stream_.mode != DUPLEX || deviceId == id ) ) { + // Invoke user callback first, to get fresh output data. + if ( handle->drainCounter == 0 ) { RtAudioCallback callback = (RtAudioCallback) info->callback; - handle->stopStream = callback(stream_.userBuffer, stream_.bufferSize, info->userData); - if ( handle->xrun == true ) { - handle->xrun = false; - MUTEX_UNLOCK(&stream_.mutex); - return; + double streamTime = getStreamTime(); + RtAudioStreamStatus status = 0; + if ( stream_.mode != INPUT && handle->xrun[0] == true ) { + status |= RTAUDIO_OUTPUT_UNDERFLOW; + handle->xrun[0] = false; + } + if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) { + status |= RTAUDIO_INPUT_OVERFLOW; + handle->xrun[1] = false; } + handle->drainCounter = callback( stream_.userBuffer[0], stream_.userBuffer[1], + stream_.bufferSize, streamTime, status, info->userData ); + if ( handle->drainCounter == 2 ) { + MUTEX_UNLOCK( &stream_.mutex ); + abortStream(); + return SUCCESS; + } + else if ( handle->drainCounter == 1 ) + handle->internalDrain = true; } - if ( stream_.mode == OUTPUT || ( stream_.mode == DUPLEX && deviceId == id ) ) { - - if (stream_.doConvertBuffer[0]) { + jack_default_audio_sample_t *jackbuffer; + unsigned long bufferBytes = nframes * sizeof( jack_default_audio_sample_t ); + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - if ( !stream_.deInterleave[0] ) - stream_.deviceBuffer = (char *) outBufferList->mBuffers[handle->index[0]].mData; - else - stream_.deviceBuffer = handle->deviceBuffer; + if ( handle->drainCounter > 0 ) { // write zeros to the output stream - convertBuffer( stream_.deviceBuffer, stream_.userBuffer, stream_.convertInfo[0] ); - if ( stream_.doByteSwap[0] ) - byteSwapBuffer(stream_.deviceBuffer, - stream_.bufferSize * stream_.nDeviceChannels[0], - stream_.deviceFormat[0]); - - if ( stream_.deInterleave[0] ) { - int bufferBytes = outBufferList->mBuffers[handle->index[0]].mDataByteSize; - for ( int i=0; imBuffers[handle->index[0]+i].mData, - &stream_.deviceBuffer[i*bufferBytes], bufferBytes ); - } + for ( unsigned int i=0; iports[0][i], (jack_nframes_t) nframes ); + memset( jackbuffer, 0, bufferBytes ); } } - else { - if (stream_.doByteSwap[0]) - byteSwapBuffer(stream_.userBuffer, - stream_.bufferSize * stream_.nUserChannels[0], - stream_.userFormat); - - memcpy(outBufferList->mBuffers[handle->index[0]].mData, - stream_.userBuffer, - outBufferList->mBuffers[handle->index[0]].mDataByteSize ); - } - } + else if ( stream_.doConvertBuffer[0] ) { - id = *( (AudioDeviceID *) devices_[stream_.device[1]].apiDeviceId ); - if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && deviceId == id ) ) { + convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] ); - if (stream_.doConvertBuffer[1]) { - - if ( stream_.deInterleave[1] ) { - stream_.deviceBuffer = (char *) handle->deviceBuffer; - int bufferBytes = inBufferList->mBuffers[handle->index[1]].mDataByteSize; - for ( int i=0; imBuffers[handle->index[1]+i].mData, bufferBytes ); - } + for ( unsigned int i=0; iports[0][i], (jack_nframes_t) nframes ); + memcpy( jackbuffer, &stream_.deviceBuffer[i*bufferBytes], bufferBytes ); + } + } + else { // no buffer conversion + for ( unsigned int i=0; iports[0][i], (jack_nframes_t) nframes ); + memcpy( jackbuffer, &stream_.userBuffer[0][i*bufferBytes], bufferBytes ); } - else - stream_.deviceBuffer = (char *) inBufferList->mBuffers[handle->index[1]].mData; - - if ( stream_.doByteSwap[1] ) - byteSwapBuffer(stream_.deviceBuffer, - stream_.bufferSize * stream_.nDeviceChannels[1], - stream_.deviceFormat[1]); - convertBuffer( stream_.userBuffer, stream_.deviceBuffer, stream_.convertInfo[1] ); - } - else { - memcpy(stream_.userBuffer, - inBufferList->mBuffers[handle->index[1]].mData, - inBufferList->mBuffers[handle->index[1]].mDataByteSize ); - if (stream_.doByteSwap[1]) - byteSwapBuffer(stream_.userBuffer, - stream_.bufferSize * stream_.nUserChannels[1], - stream_.userFormat); + if ( handle->drainCounter ) { + handle->drainCounter++; + goto unlock; } } - if ( !info->usingCallback && (stream_.mode != DUPLEX || deviceId == id ) ) - pthread_cond_signal(&handle->condition); - - MUTEX_UNLOCK(&stream_.mutex); -} - -void RtApiCore :: setStreamCallback(RtAudioCallback callback, void *userData) -{ - verifyStream(); + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { - if ( stream_.callbackInfo.usingCallback ) { - sprintf(message_, "RtApiCore: A callback is already set for this stream!"); - error(RtError::WARNING); - return; + if ( stream_.doConvertBuffer[1] ) { + for ( unsigned int i=0; iports[1][i], (jack_nframes_t) nframes ); + memcpy( &stream_.deviceBuffer[i*bufferBytes], jackbuffer, bufferBytes ); + } + convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] ); + } + else { // no buffer conversion + for ( unsigned int i=0; iports[1][i], (jack_nframes_t) nframes ); + memcpy( &stream_.userBuffer[1][i*bufferBytes], jackbuffer, bufferBytes ); + } + } } - stream_.callbackInfo.callback = (void *) callback; - stream_.callbackInfo.userData = userData; - stream_.callbackInfo.usingCallback = true; -} - -void RtApiCore :: cancelStreamCallback() -{ - verifyStream(); - - if (stream_.callbackInfo.usingCallback) { - - if (stream_.state == STREAM_RUNNING) - stopStream(); - - MUTEX_LOCK(&stream_.mutex); - - stream_.callbackInfo.usingCallback = false; - stream_.callbackInfo.userData = NULL; - stream_.state = STREAM_STOPPED; - stream_.callbackInfo.callback = NULL; + unlock: + MUTEX_UNLOCK(&stream_.mutex); - MUTEX_UNLOCK(&stream_.mutex); - } + RtApi::tickStreamTime(); + return SUCCESS; } - - -//******************** End of __MACOSX_CORE__ *********************// +//******************** End of __UNIX_JACK__ *********************// #endif -#if defined(__LINUX_JACK__) +#if defined(__WINDOWS_ASIO__) // ASIO API on Windows -// JACK is a low-latency audio server, written primarily for the -// GNU/Linux operating system. It can connect a number of different -// applications to an audio device, as well as allowing them to share -// audio between themselves. -// -// The JACK server must be running before RtApiJack can be instantiated. -// RtAudio will report just a single "device", which is the JACK audio -// server. The JACK server is typically started in a terminal as follows: -// -// .jackd -d alsa -d hw:0 -// -// or through an interface program such as qjackctl. Many of the -// parameters normally set for a stream are fixed by the JACK server -// and can be specified when the JACK server is started. In -// particular, +// The ASIO API is designed around a callback scheme, so this +// implementation is similar to that used for OS-X CoreAudio and Linux +// Jack. The primary constraint with ASIO is that it only allows +// access to a single driver at a time. Thus, it is not possible to +// have more than one simultaneous RtAudio stream. // -// .jackd -d alsa -d hw:0 -r 44100 -p 512 -n 4 +// This implementation also requires a number of external ASIO files +// and a few global variables. The ASIO callback scheme does not +// allow for the passing of user data, so we must create a global +// pointer to our callbackInfo structure. // -// specifies a sample rate of 44100 Hz, a buffer size of 512 sample -// frames, and number of buffers = 4. Once the server is running, it -// is not possible to override these values. If the values are not -// specified in the command-line, the JACK server uses default values. +// On unix systems, we make use of a pthread condition variable. +// Since there is no equivalent in Windows, I hacked something based +// on information found in +// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html. -#include -#include +#include "asio/asiosys.h" +#include "asio/asio.h" +#include "asio/iasiothiscallresolver.h" +#include "asio/asiodrivers.h" +#include -// A structure to hold various information related to the Jack API -// implementation. -struct JackHandle { - jack_client_t *client; - jack_port_t **ports[2]; - bool clientOpen; - bool stopStream; - pthread_cond_t condition; +AsioDrivers drivers; +ASIOCallbacks asioCallbacks; +ASIODriverInfo driverInfo; +CallbackInfo *asioCallbackInfo; +bool asioXRun; - JackHandle() - :client(0), clientOpen(false), stopStream(false) {} +struct AsioHandle { + int drainCounter; // Tracks callback counts when draining + bool internalDrain; // Indicates if stop is initiated from callback or not. + ASIOBufferInfo *bufferInfos; + HANDLE condition; + + AsioHandle() + :drainCounter(0), internalDrain(false), bufferInfos(0) {} }; -std::string jackmsg; +// Function declarations (definitions at end of section) +static const char* getAsioErrorString( ASIOError result ); +void sampleRateChanged( ASIOSampleRate sRate ); +long asioMessages( long selector, long value, void* message, double* opt ); -static void jackerror (const char *desc) +RtApiAsio :: RtApiAsio() { - jackmsg.erase(); - jackmsg.append( desc, strlen(desc)+1 ); + // ASIO cannot run on a multi-threaded appartment. You can call + // CoInitialize beforehand, but it must be for appartment threading + // (in which case, CoInitilialize will return S_FALSE here). + coInitialized_ = false; + HRESULT hr = CoInitialize( NULL ); + if ( FAILED(hr) ) { + errorText_ = "RtApiAsio::ASIO requires a single-threaded appartment. Call CoInitializeEx(0,COINIT_APARTMENTTHREADED)"; + error( WARNING ); + } + coInitialized_ = true; + + drivers.removeCurrentDriver(); + driverInfo.asioVersion = 2; + + // See note in DirectSound implementation about GetDesktopWindow(). + driverInfo.sysRef = GetForegroundWindow(); } -RtApiJack :: RtApiJack() +RtApiAsio :: ~RtApiAsio() { - this->initialize(); - - if (nDevices_ <= 0) { - sprintf(message_, "RtApiJack: no Linux Jack server found or connection error (jack: %s)!", - jackmsg.c_str()); - error(RtError::NO_DEVICES_FOUND); - } + if ( stream_.state != STREAM_CLOSED ) closeStream(); + if ( coInitialized_ ) CoUninitialize(); } -RtApiJack :: ~RtApiJack() +unsigned int RtApiAsio :: getDeviceCount( void ) { - if ( stream_.mode != UNINITIALIZED ) closeStream(); + return (unsigned int) drivers.asioGetNumDev(); } -void RtApiJack :: initialize(void) +RtAudio::DeviceInfo RtApiAsio :: getDeviceInfo( unsigned int device ) { - nDevices_ = 0; + RtAudio::DeviceInfo info; + info.probed = false; - // Tell the jack server to call jackerror() when it experiences an - // error. This function saves the error message for subsequent - // reporting via the normal RtAudio error function. - jack_set_error_function( jackerror ); + // Get device ID + unsigned int nDevices = getDeviceCount(); + if ( nDevices == 0 ) { + errorText_ = "RtApiAsio::getDeviceInfo: no devices found!"; + error( INVALID_CALL ); + } - // Look for jack server and try to become a client. - jack_client_t *client; - if ( (client = jack_client_new( "RtApiJack" )) == 0) - return; + if ( device >= nDevices ) { + errorText_ = "RtApiAsio::getDeviceInfo: device ID is invalid!"; + error( INVALID_CALL ); + } - /* - RtApiDevice device; - // Determine the name of the device. - device.name = "Jack Server"; - devices_.push_back(device); - nDevices_++; - */ - const char **ports; - std::string port, prevPort; - unsigned int nChannels = 0; - ports = jack_get_ports( client, NULL, NULL, 0 ); - if ( ports ) { - port = (char *) ports[ nChannels ]; - unsigned int colonPos = 0; - do { - port = (char *) ports[ nChannels ]; - if ( (colonPos = port.find(":")) != std::string::npos ) { - port = port.substr( 0, colonPos+1 ); - if ( port != prevPort ) { - RtApiDevice device; - device.name = port; - devices_.push_back( device ); - nDevices_++; - prevPort = port; - } - } - } while ( ports[++nChannels] ); - free( ports ); + // Don't probe if a stream is already open. + if ( stream_.state != STREAM_CLOSED ) { + errorText_ = "RtApiAsio::getDeviceInfo: unable to probe driver while a stream is open."; + error( WARNING ); + return info; } - jack_client_close(client); -} - -void RtApiJack :: probeDeviceInfo(RtApiDevice *info) -{ - // Look for jack server and try to become a client. - jack_client_t *client; - if ( (client = jack_client_new( "RtApiJack_Probe" )) == 0) { - sprintf(message_, "RtApiJack: error connecting to Linux Jack server in probeDeviceInfo() (jack: %s)!", - jackmsg.c_str()); - error(RtError::WARNING); - return; + char driverName[32]; + ASIOError result = drivers.asioGetDriverName( (int) device, driverName, 32 ); + if ( result != ASE_OK ) { + errorStream_ << "RtApiAsio::getDeviceInfo: unable to get driver name (" << getAsioErrorString( result ) << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - // Get the current jack server sample rate. - info->sampleRates.clear(); - info->sampleRates.push_back( jack_get_sample_rate(client) ); + info.name = driverName; - // Count the available ports as device channels. Jack "input ports" - // equal RtAudio output channels. - const char **ports; - char *port; - unsigned int nChannels = 0; - ports = jack_get_ports( client, info->name.c_str(), NULL, JackPortIsInput ); - if ( ports ) { - port = (char *) ports[nChannels]; - while ( port ) - port = (char *) ports[++nChannels]; - free( ports ); - info->maxOutputChannels = nChannels; - info->minOutputChannels = 1; + if ( !drivers.loadDriver( driverName ) ) { + errorStream_ << "RtApiAsio::getDeviceInfo: unable to load driver (" << driverName << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - // Jack "output ports" equal RtAudio input channels. - nChannels = 0; - ports = jack_get_ports( client, info->name.c_str(), NULL, JackPortIsOutput ); - if ( ports ) { - port = (char *) ports[nChannels]; - while ( port ) - port = (char *) ports[++nChannels]; - free( ports ); - info->maxInputChannels = nChannels; - info->minInputChannels = 1; + result = ASIOInit( &driverInfo ); + if ( result != ASE_OK ) { + errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") initializing driver (" << driverName << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - if (info->maxOutputChannels == 0 && info->maxInputChannels == 0) { - jack_client_close(client); - sprintf(message_, "RtApiJack: error determining jack input/output channels!"); - error(RtError::DEBUG_WARNING); - return; + // Determine the device channel information. + long inputChannels, outputChannels; + result = ASIOGetChannels( &inputChannels, &outputChannels ); + if ( result != ASE_OK ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") getting channel count (" << driverName << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - if (info->maxOutputChannels > 0 && info->maxInputChannels > 0) { - info->hasDuplexSupport = true; - info->maxDuplexChannels = (info->maxOutputChannels > info->maxInputChannels) ? - info->maxInputChannels : info->maxOutputChannels; - info->minDuplexChannels = (info->minOutputChannels > info->minInputChannels) ? - info->minInputChannels : info->minOutputChannels; - } + info.outputChannels = outputChannels; + info.inputChannels = inputChannels; + if ( info.outputChannels > 0 && info.inputChannels > 0 ) + info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels; - // Get the jack data format type. There isn't much documentation - // regarding supported data formats in jack. I'm assuming here that - // the default type will always be a floating-point type, of length - // equal to either 4 or 8 bytes. - int sample_size = sizeof( jack_default_audio_sample_t ); - if ( sample_size == 4 ) - info->nativeFormats = RTAUDIO_FLOAT32; - else if ( sample_size == 8 ) - info->nativeFormats = RTAUDIO_FLOAT64; + // Determine the supported sample rates. + info.sampleRates.clear(); + for ( unsigned int i=0; inativeFormats == 0) { - jack_client_close(client); - sprintf(message_, "RtApiJack: error determining jack server data format!"); - error(RtError::DEBUG_WARNING); - return; + // Determine supported data types ... just check first channel and assume rest are the same. + ASIOChannelInfo channelInfo; + channelInfo.channel = 0; + channelInfo.isInput = true; + if ( info.inputChannels <= 0 ) channelInfo.isInput = false; + result = ASIOGetChannelInfo( &channelInfo ); + if ( result != ASE_OK ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") getting driver channel info (" << driverName << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - jack_client_close(client); - info->probed = true; + info.nativeFormats = 0; + if ( channelInfo.type == ASIOSTInt16MSB || channelInfo.type == ASIOSTInt16LSB ) + info.nativeFormats |= RTAUDIO_SINT16; + else if ( channelInfo.type == ASIOSTInt32MSB || channelInfo.type == ASIOSTInt32LSB ) + info.nativeFormats |= RTAUDIO_SINT32; + else if ( channelInfo.type == ASIOSTFloat32MSB || channelInfo.type == ASIOSTFloat32LSB ) + info.nativeFormats |= RTAUDIO_FLOAT32; + else if ( channelInfo.type == ASIOSTFloat64MSB || channelInfo.type == ASIOSTFloat64LSB ) + info.nativeFormats |= RTAUDIO_FLOAT64; + + if ( getDefaultOutputDevice() == device ) + info.isDefaultOutput = true; + if ( getDefaultInputDevice() == device ) + info.isDefaultInput = true; + + info.probed = true; + drivers.removeCurrentDriver(); + return info; } -int jackCallbackHandler(jack_nframes_t nframes, void *infoPointer) +void bufferSwitch( long index, ASIOBool processNow ) { - CallbackInfo *info = (CallbackInfo *) infoPointer; - RtApiJack *object = (RtApiJack *) info->object; - try { - object->callbackEvent( (unsigned long) nframes ); - } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiJack: callback handler error (%s)!\n\n", exception.getMessageString()); - return 0; - } - - return 0; + RtApiAsio *object = (RtApiAsio *) asioCallbackInfo->object; + object->callbackEvent( index ); } -void jackShutdown(void *infoPointer) +bool RtApiAsio :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, + unsigned int firstChannel, unsigned int sampleRate, + RtAudioFormat format, unsigned int *bufferSize, + RtAudio::StreamOptions *options ) { - CallbackInfo *info = (CallbackInfo *) infoPointer; - JackHandle *handle = (JackHandle *) info->apiInfo; - handle->clientOpen = false; - RtApiJack *object = (RtApiJack *) info->object; + // For ASIO, a duplex stream MUST use the same driver. + if ( mode == INPUT && stream_.mode == OUTPUT && stream_.device[0] != device ) { + errorText_ = "RtApiAsio::probeDeviceOpen: an ASIO duplex stream must use the same device for input and output!"; + return FAILURE; + } - // Check current stream state. If stopped, then we'll assume this - // was called as a result of a call to RtApiJack::stopStream (the - // deactivation of a client handle causes this function to be called). - // If not, we'll assume the Jack server is shutting down or some - // other problem occurred and we should close the stream. - if ( object->getStreamState() == RtApi::STREAM_STOPPED ) return; + char driverName[32]; + ASIOError result = drivers.asioGetDriverName( (int) device, driverName, 32 ); + if ( result != ASE_OK ) { + errorStream_ << "RtApiAsio::probeDeviceOpen: unable to get driver name (" << getAsioErrorString( result ) << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } - try { - object->closeStream(); + // Only load the driver once for duplex stream. + if ( mode != INPUT || stream_.mode != OUTPUT ) { + if ( !drivers.loadDriver( driverName ) ) { + errorStream_ << "RtApiAsio::probeDeviceOpen: unable to load driver (" << driverName << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + + result = ASIOInit( &driverInfo ); + if ( result != ASE_OK ) { + errorStream_ << "RtApiAsio::probeDeviceOpen: error (" << getAsioErrorString( result ) << ") initializing driver (" << driverName << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiJack: jackShutdown error (%s)!\n\n", exception.getMessageString()); - return; + + // Check the device channel count. + long inputChannels, outputChannels; + result = ASIOGetChannels( &inputChannels, &outputChannels ); + if ( result != ASE_OK ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::probeDeviceOpen: error (" << getAsioErrorString( result ) << ") getting channel count (" << driverName << ")."; + errorText_ = errorStream_.str(); + return FAILURE; } - fprintf(stderr, "\nRtApiJack: the Jack server is shutting down this client ... stream stopped and closed!!!\n\n"); -} + if ( ( mode == OUTPUT && (channels+firstChannel) > (unsigned int) outputChannels) || + ( mode == INPUT && (channels+firstChannel) > (unsigned int) inputChannels) ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") does not support requested channel count (" << channels << ") + offset (" << firstChannel << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + stream_.nDeviceChannels[mode] = channels; + stream_.nUserChannels[mode] = channels; + stream_.channelOffset[mode] = firstChannel; -int jackXrun( void * ) -{ - fprintf(stderr, "\nRtApiJack: audio overrun/underrun reported!\n"); - return 0; -} + // Verify the sample rate is supported. + result = ASIOCanSampleRate( (ASIOSampleRate) sampleRate ); + if ( result != ASE_OK ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") does not support requested sample rate (" << sampleRate << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } -bool RtApiJack :: probeDeviceOpen(int device, StreamMode mode, int channels, - int sampleRate, RtAudioFormat format, - int *bufferSize, int numberOfBuffers) -{ - // Compare the jack server channels to the requested number of channels. - if ( (mode == OUTPUT && devices_[device].maxOutputChannels < channels ) || - (mode == INPUT && devices_[device].maxInputChannels < channels ) ) { - sprintf(message_, "RtApiJack: the Jack server does not support requested channels!"); - error(RtError::DEBUG_WARNING); + // Set the sample rate. + result = ASIOSetSampleRate( (ASIOSampleRate) sampleRate ); + if ( result != ASE_OK ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error setting sample rate (" << sampleRate << ")."; + errorText_ = errorStream_.str(); return FAILURE; } - JackHandle *handle = (JackHandle *) stream_.apiHandle; + // Determine the driver data type. + ASIOChannelInfo channelInfo; + channelInfo.channel = 0; + if ( mode == OUTPUT ) channelInfo.isInput = false; + else channelInfo.isInput = true; + result = ASIOGetChannelInfo( &channelInfo ); + if ( result != ASE_OK ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") getting data format."; + errorText_ = errorStream_.str(); + return FAILURE; + } - // Look for jack server and try to become a client (only do once per stream). - char label[32]; - jack_client_t *client = 0; - if ( mode == OUTPUT || (mode == INPUT && stream_.mode != OUTPUT) ) { - snprintf(label, 32, "RtApiJack"); - if ( (client = jack_client_new( (const char *) label )) == 0) { - sprintf(message_, "RtApiJack: cannot connect to Linux Jack server in probeDeviceOpen() (jack: %s)!", - jackmsg.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + // Assuming WINDOWS host is always little-endian. + stream_.doByteSwap[mode] = false; + stream_.userFormat = format; + stream_.deviceFormat[mode] = 0; + if ( channelInfo.type == ASIOSTInt16MSB || channelInfo.type == ASIOSTInt16LSB ) { + stream_.deviceFormat[mode] = RTAUDIO_SINT16; + if ( channelInfo.type == ASIOSTInt16MSB ) stream_.doByteSwap[mode] = true; } - else { - // The handle must have been created on an earlier pass. - client = handle->client; + else if ( channelInfo.type == ASIOSTInt32MSB || channelInfo.type == ASIOSTInt32LSB ) { + stream_.deviceFormat[mode] = RTAUDIO_SINT32; + if ( channelInfo.type == ASIOSTInt32MSB ) stream_.doByteSwap[mode] = true; + } + else if ( channelInfo.type == ASIOSTFloat32MSB || channelInfo.type == ASIOSTFloat32LSB ) { + stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; + if ( channelInfo.type == ASIOSTFloat32MSB ) stream_.doByteSwap[mode] = true; + } + else if ( channelInfo.type == ASIOSTFloat64MSB || channelInfo.type == ASIOSTFloat64LSB ) { + stream_.deviceFormat[mode] = RTAUDIO_FLOAT64; + if ( channelInfo.type == ASIOSTFloat64MSB ) stream_.doByteSwap[mode] = true; } - // First, check the jack server sample rate. - int jack_rate; - jack_rate = (int) jack_get_sample_rate(client); - if ( sampleRate != jack_rate ) { - jack_client_close(client); - sprintf( message_, "RtApiJack: the requested sample rate (%d) is different than the JACK server rate (%d).", - sampleRate, jack_rate ); - error(RtError::DEBUG_WARNING); + if ( stream_.deviceFormat[mode] == 0 ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") data format not supported by RtAudio."; + errorText_ = errorStream_.str(); return FAILURE; } - stream_.sampleRate = jack_rate; - // The jack server seems to support just a single floating-point - // data type. Since we already checked it before, just use what we - // found then. - stream_.deviceFormat[mode] = devices_[device].nativeFormats; - stream_.userFormat = format; + // Set the buffer size. For a duplex stream, this will end up + // setting the buffer size based on the input constraints, which + // should be ok. + long minSize, maxSize, preferSize, granularity; + result = ASIOGetBufferSize( &minSize, &maxSize, &preferSize, &granularity ); + if ( result != ASE_OK ) { + drivers.removeCurrentDriver(); + errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") getting buffer size."; + errorText_ = errorStream_.str(); + return FAILURE; + } - // Jack always uses non-interleaved buffers. We'll need to - // de-interleave if we have more than one channel. - stream_.deInterleave[mode] = false; - if ( channels > 1 ) - stream_.deInterleave[mode] = true; + if ( *bufferSize < (unsigned int) minSize ) *bufferSize = (unsigned int) minSize; + else if ( *bufferSize > (unsigned int) maxSize ) *bufferSize = (unsigned int) maxSize; + else if ( granularity == -1 ) { + // Make sure bufferSize is a power of two. + double power = std::log10( (double) *bufferSize ) / log10( 2.0 ); + *bufferSize = (int) pow( 2.0, floor(power+0.5) ); + if ( *bufferSize < (unsigned int) minSize ) *bufferSize = (unsigned int) minSize; + else if ( *bufferSize > (unsigned int) maxSize ) *bufferSize = (unsigned int) maxSize; + else *bufferSize = preferSize; + } + else if ( granularity != 0 ) { + // Set to an even multiple of granularity, rounding up. + *bufferSize = (*bufferSize + granularity-1) / granularity * granularity; + } - // Jack always provides host byte-ordered data. - stream_.doByteSwap[mode] = false; + if ( mode == INPUT && stream_.mode == OUTPUT && stream_.bufferSize != *bufferSize ) { + drivers.removeCurrentDriver(); + errorText_ = "RtApiAsio::probeDeviceOpen: input/output buffersize discrepancy!"; + return FAILURE; + } - // Get the buffer size. The buffer size and number of buffers - // (periods) is set when the jack server is started. - stream_.bufferSize = (int) jack_get_buffer_size(client); - *bufferSize = stream_.bufferSize; + stream_.bufferSize = *bufferSize; + stream_.nBuffers = 2; - stream_.nDeviceChannels[mode] = channels; - stream_.nUserChannels[mode] = channels; + if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false; + else stream_.userInterleaved = true; - stream_.doConvertBuffer[mode] = false; - if (stream_.userFormat != stream_.deviceFormat[mode]) - stream_.doConvertBuffer[mode] = true; - if (stream_.deInterleave[mode]) - stream_.doConvertBuffer[mode] = true; + // ASIO always uses non-interleaved buffers. + stream_.deviceInterleaved[mode] = false; - // Allocate our JackHandle structure for the stream. + // Allocate, if necessary, our AsioHandle structure for the stream. + AsioHandle *handle = (AsioHandle *) stream_.apiHandle; if ( handle == 0 ) { - handle = (JackHandle *) calloc(1, sizeof(JackHandle)); - if ( handle == NULL ) { - sprintf(message_, "RtApiJack: error allocating JackHandle memory (%s).", - devices_[device].name.c_str()); - goto error; + try { + handle = new AsioHandle; } - handle->ports[0] = 0; - handle->ports[1] = 0; - if ( pthread_cond_init(&handle->condition, NULL) ) { - sprintf(message_, "RtApiJack: error initializing pthread condition variable!"); - goto error; + catch ( std::bad_alloc& ) { + //if ( handle == NULL ) { + drivers.removeCurrentDriver(); + errorText_ = "RtApiAsio::probeDeviceOpen: error allocating AsioHandle memory."; + return FAILURE; } + handle->bufferInfos = 0; + + // Create a manual-reset event. + handle->condition = CreateEvent( NULL, // no security + TRUE, // manual-reset + FALSE, // non-signaled initially + NULL ); // unnamed stream_.apiHandle = (void *) handle; - handle->client = client; - handle->clientOpen = true; } - // Allocate necessary internal buffers. - if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { + // Create the ASIO internal buffers. Since RtAudio sets up input + // and output separately, we'll have to dispose of previously + // created output buffers for a duplex stream. + long inputLatency, outputLatency; + if ( mode == INPUT && stream_.mode == OUTPUT ) { + ASIODisposeBuffers(); + if ( handle->bufferInfos ) free( handle->bufferInfos ); + } - long buffer_bytes; - if (stream_.nUserChannels[0] >= stream_.nUserChannels[1]) - buffer_bytes = stream_.nUserChannels[0]; - else - buffer_bytes = stream_.nUserChannels[1]; - - buffer_bytes *= *bufferSize * formatBytes(stream_.userFormat); - if (stream_.userBuffer) free(stream_.userBuffer); - stream_.userBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.userBuffer == NULL) { - sprintf(message_, "RtApiJack: error allocating user buffer memory (%s).", - devices_[device].name.c_str()); - goto error; - } + // Allocate, initialize, and save the bufferInfos in our stream callbackInfo structure. + bool buffersAllocated = false; + unsigned int i, nChannels = stream_.nDeviceChannels[0] + stream_.nDeviceChannels[1]; + handle->bufferInfos = (ASIOBufferInfo *) malloc( nChannels * sizeof(ASIOBufferInfo) ); + if ( handle->bufferInfos == NULL ) { + errorStream_ << "RtApiAsio::probeDeviceOpen: error allocating bufferInfo memory for driver (" << driverName << ")."; + errorText_ = errorStream_.str(); + goto error; + } + + ASIOBufferInfo *infos; + infos = handle->bufferInfos; + for ( i=0; iisInput = ASIOFalse; + infos->channelNum = i + stream_.channelOffset[0]; + infos->buffers[0] = infos->buffers[1] = 0; + } + for ( i=0; iisInput = ASIOTrue; + infos->channelNum = i + stream_.channelOffset[1]; + infos->buffers[0] = infos->buffers[1] = 0; + } + + // Set up the ASIO callback structure and create the ASIO data buffers. + asioCallbacks.bufferSwitch = &bufferSwitch; + asioCallbacks.sampleRateDidChange = &sampleRateChanged; + asioCallbacks.asioMessage = &asioMessages; + asioCallbacks.bufferSwitchTimeInfo = NULL; + result = ASIOCreateBuffers( handle->bufferInfos, nChannels, stream_.bufferSize, &asioCallbacks ); + if ( result != ASE_OK ) { + errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") creating buffers."; + errorText_ = errorStream_.str(); + goto error; + } + buffersAllocated = true; + + // Set flags for buffer conversion. + stream_.doConvertBuffer[mode] = false; + if ( stream_.userFormat != stream_.deviceFormat[mode] ) + stream_.doConvertBuffer[mode] = true; + if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] && + stream_.nUserChannels[mode] > 1 ) + stream_.doConvertBuffer[mode] = true; + + // Allocate necessary internal buffers + unsigned long bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat ); + stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 ); + if ( stream_.userBuffer[mode] == NULL ) { + errorText_ = "RtApiAsio::probeDeviceOpen: error allocating user buffer memory."; + goto error; } if ( stream_.doConvertBuffer[mode] ) { - long buffer_bytes; bool makeBuffer = true; - if ( mode == OUTPUT ) - buffer_bytes = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - else { // mode == INPUT - buffer_bytes = stream_.nDeviceChannels[1] * formatBytes(stream_.deviceFormat[1]); + bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] ); + if ( mode == INPUT ) { if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { - long bytes_out = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - if ( buffer_bytes < bytes_out ) makeBuffer = false; + unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] ); + if ( bufferBytes <= bytesOut ) makeBuffer = false; } } if ( makeBuffer ) { - buffer_bytes *= *bufferSize; - if (stream_.deviceBuffer) free(stream_.deviceBuffer); - stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.deviceBuffer == NULL) { - sprintf(message_, "RtApiJack: error allocating device buffer memory (%s).", - devices_[device].name.c_str()); + bufferBytes *= *bufferSize; + if ( stream_.deviceBuffer ) free( stream_.deviceBuffer ); + stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 ); + if ( stream_.deviceBuffer == NULL ) { + errorText_ = "RtApiAsio::probeDeviceOpen: error allocating device buffer memory."; goto error; } } } - // Allocate memory for the Jack ports (channels) identifiers. - handle->ports[mode] = (jack_port_t **) malloc (sizeof (jack_port_t *) * channels); - if ( handle->ports[mode] == NULL ) { - sprintf(message_, "RtApiJack: error allocating port handle memory (%s).", - devices_[device].name.c_str()); - goto error; - } - + stream_.sampleRate = sampleRate; stream_.device[mode] = device; stream_.state = STREAM_STOPPED; - stream_.callbackInfo.usingCallback = false; + asioCallbackInfo = &stream_.callbackInfo; stream_.callbackInfo.object = (void *) this; - stream_.callbackInfo.apiInfo = (void *) handle; - if ( stream_.mode == OUTPUT && mode == INPUT ) - // We had already set up the stream for output. + // We had already set up an output stream. stream_.mode = DUPLEX; - else { + else stream_.mode = mode; - jack_set_process_callback( handle->client, jackCallbackHandler, (void *) &stream_.callbackInfo ); - jack_set_xrun_callback( handle->client, jackXrun, NULL ); - jack_on_shutdown( handle->client, jackShutdown, (void *) &stream_.callbackInfo ); - } - // Setup the buffer conversion information structure. - if ( stream_.doConvertBuffer[mode] ) { - if (mode == INPUT) { // convert device to user buffer - stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1]; - stream_.convertInfo[mode].outJump = stream_.nUserChannels[1]; - stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1]; - stream_.convertInfo[mode].outFormat = stream_.userFormat; - } - else { // convert user to device buffer - stream_.convertInfo[mode].inJump = stream_.nUserChannels[0]; - stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0]; - stream_.convertInfo[mode].inFormat = stream_.userFormat; - stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0]; - } - - if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump ) - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump; - else - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump; - - // Set up the interleave/deinterleave offsets. - if ( mode == INPUT && stream_.deInterleave[1] ) { - for (int k=0; kcondition); - if ( handle->clientOpen == true ) - jack_client_close(handle->client); - - if ( handle->ports[0] ) free(handle->ports[0]); - if ( handle->ports[1] ) free(handle->ports[1]); + if ( buffersAllocated ) + ASIODisposeBuffers(); + drivers.removeCurrentDriver(); - free( handle ); + if ( handle ) { + CloseHandle( handle->condition ); + if ( handle->bufferInfos ) + free( handle->bufferInfos ); + delete handle; stream_.apiHandle = 0; } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } + } + + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; } - error(RtError::DEBUG_WARNING); return FAILURE; } -void RtApiJack :: closeStream() +void RtApiAsio :: closeStream() { - // We don't want an exception to be thrown here because this - // function is called by our class destructor. So, do our own - // stream check. - if ( stream_.mode == UNINITIALIZED ) { - sprintf(message_, "RtApiJack::closeStream(): no open stream to close!"); - error(RtError::WARNING); + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiAsio::closeStream(): no open stream to close!"; + error( WARNING ); return; } - JackHandle *handle = (JackHandle *) stream_.apiHandle; - if ( handle && handle->clientOpen == true ) { - if (stream_.state == STREAM_RUNNING) - jack_deactivate(handle->client); - - jack_client_close(handle->client); + if ( stream_.state == STREAM_RUNNING ) { + stream_.state = STREAM_STOPPED; + ASIOStop(); } + ASIODisposeBuffers(); + drivers.removeCurrentDriver(); + AsioHandle *handle = (AsioHandle *) stream_.apiHandle; if ( handle ) { - if ( handle->ports[0] ) free(handle->ports[0]); - if ( handle->ports[1] ) free(handle->ports[1]); - pthread_cond_destroy(&handle->condition); - free( handle ); + CloseHandle( handle->condition ); + if ( handle->bufferInfos ) + free( handle->bufferInfos ); + delete handle; stream_.apiHandle = 0; } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } } - if (stream_.deviceBuffer) { - free(stream_.deviceBuffer); + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); stream_.deviceBuffer = 0; } stream_.mode = UNINITIALIZED; + stream_.state = STREAM_CLOSED; } - -void RtApiJack :: startStream() +void RtApiAsio :: startStream() { verifyStream(); - if (stream_.state == STREAM_RUNNING) return; + if ( stream_.state == STREAM_RUNNING ) { + errorText_ = "RtApiAsio::startStream(): the stream is already running!"; + error( WARNING ); + return; + } - MUTEX_LOCK(&stream_.mutex); + MUTEX_LOCK( &stream_.mutex ); - char label[64]; - JackHandle *handle = (JackHandle *) stream_.apiHandle; - if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - for ( int i=0; iports[0][i] = jack_port_register(handle->client, (const char *)label, - JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); - } + AsioHandle *handle = (AsioHandle *) stream_.apiHandle; + ASIOError result = ASIOStart(); + if ( result != ASE_OK ) { + errorStream_ << "RtApiAsio::startStream: error (" << getAsioErrorString( result ) << ") starting device."; + errorText_ = errorStream_.str(); + goto unlock; } - if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { - for ( int i=0; iports[1][i] = jack_port_register(handle->client, (const char *)label, - JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); - } - } + handle->drainCounter = 0; + handle->internalDrain = false; + stream_.state = STREAM_RUNNING; + asioXRun = false; - if (jack_activate(handle->client)) { - sprintf(message_, "RtApiJack: unable to activate JACK client!"); - error(RtError::SYSTEM_ERROR); - } + unlock: + MUTEX_UNLOCK( &stream_.mutex ); - const char **ports; - int result; - // Get the list of available ports. - if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - ports = jack_get_ports(handle->client, devices_[stream_.device[0]].name.c_str(), NULL, JackPortIsInput); - if ( ports == NULL) { - sprintf(message_, "RtApiJack: error determining available jack input ports!"); - error(RtError::SYSTEM_ERROR); - } + if ( result == ASE_OK ) return; + error( SYSTEM ); +} - // Now make the port connections. Since RtAudio wasn't designed to - // allow the user to select particular channels of a device, we'll - // just open the first "nChannels" ports. - for ( int i=0; iclient, jack_port_name(handle->ports[0][i]), ports[i] ); - if ( result ) { - free(ports); - sprintf(message_, "RtApiJack: error connecting output ports!"); - error(RtError::SYSTEM_ERROR); - } - } - free(ports); +void RtApiAsio :: stopStream() +{ + verifyStream(); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiAsio::stopStream(): the stream is already stopped!"; + error( WARNING ); + return; } - if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { - ports = jack_get_ports( handle->client, devices_[stream_.device[1]].name.c_str(), NULL, JackPortIsOutput ); - if ( ports == NULL) { - sprintf(message_, "RtApiJack: error determining available jack output ports!"); - error(RtError::SYSTEM_ERROR); - } + MUTEX_LOCK( &stream_.mutex ); - // Now make the port connections. See note above. - for ( int i=0; iclient, ports[i], jack_port_name(handle->ports[1][i]) ); - if ( result ) { - free(ports); - sprintf(message_, "RtApiJack: error connecting input ports!"); - error(RtError::SYSTEM_ERROR); - } + AsioHandle *handle = (AsioHandle *) stream_.apiHandle; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + if ( handle->drainCounter == 0 ) { + handle->drainCounter = 1; + MUTEX_UNLOCK( &stream_.mutex ); + WaitForMultipleObjects( 1, &handle->condition, FALSE, INFINITE ); // block until signaled + ResetEvent( handle->condition ); + MUTEX_LOCK( &stream_.mutex ); } - free(ports); } - handle->stopStream = false; - stream_.state = STREAM_RUNNING; - - MUTEX_UNLOCK(&stream_.mutex); -} - -void RtApiJack :: stopStream() -{ - verifyStream(); - if (stream_.state == STREAM_STOPPED) return; + ASIOError result = ASIOStop(); + if ( result != ASE_OK ) { + errorStream_ << "RtApiAsio::stopStream: error (" << getAsioErrorString( result ) << ") stopping device."; + errorText_ = errorStream_.str(); + } - // Change the state before the lock to improve shutdown response - // when using a callback. stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); - - JackHandle *handle = (JackHandle *) stream_.apiHandle; - jack_deactivate(handle->client); - - MUTEX_UNLOCK(&stream_.mutex); -} + MUTEX_UNLOCK( &stream_.mutex ); -void RtApiJack :: abortStream() -{ - stopStream(); + if ( result == ASE_OK ) return; + error( SYSTEM ); } -void RtApiJack :: tickStream() +void RtApiAsio :: abortStream() { verifyStream(); - - if (stream_.state == STREAM_STOPPED) return; - - if (stream_.callbackInfo.usingCallback) { - sprintf(message_, "RtApiJack: tickStream() should not be used when a callback function is set!"); - error(RtError::WARNING); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiAsio::abortStream(): the stream is already stopped!"; + error( WARNING ); return; } - JackHandle *handle = (JackHandle *) stream_.apiHandle; - - MUTEX_LOCK(&stream_.mutex); - - pthread_cond_wait(&handle->condition, &stream_.mutex); - - MUTEX_UNLOCK(&stream_.mutex); + // The following lines were commented-out because some behavior was + // noted where the device buffers need to be zeroed to avoid + // continuing sound, even when the device buffers are completed + // disposed. So now, calling abort is the same as calling stop. + //AsioHandle *handle = (AsioHandle *) stream_.apiHandle; + //handle->drainCounter = 1; + stopStream(); } -void RtApiJack :: callbackEvent( unsigned long nframes ) +bool RtApiAsio :: callbackEvent( long bufferIndex ) { - verifyStream(); - - if (stream_.state == STREAM_STOPPED) return; - - CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; - JackHandle *handle = (JackHandle *) stream_.apiHandle; - if ( info->usingCallback && handle->stopStream ) { - // Check if the stream should be stopped (via the previous user - // callback return value). We stop the stream here, rather than - // after the function call, so that output data can first be - // processed. - this->stopStream(); - return; + if ( stream_.state == STREAM_STOPPED ) return SUCCESS; + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiAsio::callbackEvent(): the stream is closed ... this shouldn't happen!"; + error( WARNING ); + return FAILURE; } - MUTEX_LOCK(&stream_.mutex); + CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; + AsioHandle *handle = (AsioHandle *) stream_.apiHandle; - // Invoke user callback first, to get fresh output data. - if ( info->usingCallback ) { - RtAudioCallback callback = (RtAudioCallback) info->callback; - handle->stopStream = callback(stream_.userBuffer, stream_.bufferSize, info->userData); + // Check if we were draining the stream and signal is finished. + if ( handle->drainCounter > 3 ) { + if ( handle->internalDrain == false ) + SetEvent( handle->condition ); + else + stopStream(); + return SUCCESS; } - jack_default_audio_sample_t *jackbuffer; - long bufferBytes = nframes * sizeof(jack_default_audio_sample_t); - if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - - if (stream_.doConvertBuffer[0]) { - convertBuffer( stream_.deviceBuffer, stream_.userBuffer, stream_.convertInfo[0] ); - - for ( int i=0; iports[0][i], - (jack_nframes_t) nframes); - memcpy(jackbuffer, &stream_.deviceBuffer[i*bufferBytes], bufferBytes ); - } - } - else { // single channel only - jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer(handle->ports[0][0], - (jack_nframes_t) nframes); - memcpy(jackbuffer, stream_.userBuffer, bufferBytes ); - } - } + MUTEX_LOCK( &stream_.mutex ); - if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { + // The state might change while waiting on a mutex. + if ( stream_.state == STREAM_STOPPED ) goto unlock; - if (stream_.doConvertBuffer[1]) { - for ( int i=0; iports[1][i], - (jack_nframes_t) nframes); - memcpy(&stream_.deviceBuffer[i*bufferBytes], jackbuffer, bufferBytes ); + // Invoke user callback to get fresh output data UNLESS we are + // draining stream. + if ( handle->drainCounter == 0 ) { + RtAudioCallback callback = (RtAudioCallback) info->callback; + double streamTime = getStreamTime(); + RtAudioStreamStatus status = 0; + if ( stream_.mode != INPUT && asioXRun == true ) { + status |= RTAUDIO_OUTPUT_UNDERFLOW; + asioXRun = false; } - convertBuffer( stream_.userBuffer, stream_.deviceBuffer, stream_.convertInfo[1] ); + if ( stream_.mode != OUTPUT && asioXRun == true ) { + status |= RTAUDIO_INPUT_OVERFLOW; + asioXRun = false; } - else { // single channel only - jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer(handle->ports[1][0], - (jack_nframes_t) nframes); - memcpy(stream_.userBuffer, jackbuffer, bufferBytes ); + handle->drainCounter = callback( stream_.userBuffer[0], stream_.userBuffer[1], + stream_.bufferSize, streamTime, status, info->userData ); + if ( handle->drainCounter == 2 ) { + MUTEX_UNLOCK( &stream_.mutex ); + abortStream(); + return SUCCESS; } + else if ( handle->drainCounter == 1 ) + handle->internalDrain = true; } - if ( !info->usingCallback ) - pthread_cond_signal(&handle->condition); + unsigned int bufferBytes, i, j; + unsigned int nChannels = stream_.nDeviceChannels[0] + stream_.nDeviceChannels[1]; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - MUTEX_UNLOCK(&stream_.mutex); -} + bufferBytes = stream_.bufferSize * formatBytes( stream_.deviceFormat[0] ); -void RtApiJack :: setStreamCallback(RtAudioCallback callback, void *userData) -{ - verifyStream(); + if ( handle->drainCounter > 1 ) { // write zeros to the output stream - if ( stream_.callbackInfo.usingCallback ) { - sprintf(message_, "RtApiJack: A callback is already set for this stream!"); - error(RtError::WARNING); - return; - } + for ( i=0, j=0; ibufferInfos[i].isInput != ASIOTrue ) + memset( handle->bufferInfos[i].buffers[bufferIndex], 0, bufferBytes ); + } - stream_.callbackInfo.callback = (void *) callback; - stream_.callbackInfo.userData = userData; - stream_.callbackInfo.usingCallback = true; -} + } + else if ( stream_.doConvertBuffer[0] ) { -void RtApiJack :: cancelStreamCallback() -{ - verifyStream(); + convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] ); + if ( stream_.doByteSwap[0] ) + byteSwapBuffer( stream_.deviceBuffer, + stream_.bufferSize * stream_.nDeviceChannels[0], + stream_.deviceFormat[0] ); + + for ( i=0, j=0; ibufferInfos[i].isInput != ASIOTrue ) + memcpy( handle->bufferInfos[i].buffers[bufferIndex], + &stream_.deviceBuffer[j++*bufferBytes], bufferBytes ); + } - if (stream_.callbackInfo.usingCallback) { + } + else { - if (stream_.state == STREAM_RUNNING) - stopStream(); + if ( stream_.doByteSwap[0] ) + byteSwapBuffer( stream_.userBuffer[0], + stream_.bufferSize * stream_.nUserChannels[0], + stream_.userFormat ); - MUTEX_LOCK(&stream_.mutex); + for ( i=0, j=0; ibufferInfos[i].isInput != ASIOTrue ) + memcpy( handle->bufferInfos[i].buffers[bufferIndex], + &stream_.userBuffer[0][bufferBytes*j++], bufferBytes ); + } - stream_.callbackInfo.usingCallback = false; - stream_.callbackInfo.userData = NULL; - stream_.state = STREAM_STOPPED; - stream_.callbackInfo.callback = NULL; + } - MUTEX_UNLOCK(&stream_.mutex); + if ( handle->drainCounter ) { + handle->drainCounter++; + goto unlock; + } } -} - -#endif -#if defined(__LINUX_ALSA__) + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { -#include -#include -#include + bufferBytes = stream_.bufferSize * formatBytes(stream_.deviceFormat[1]); -// A structure to hold various information related to the ALSA API -// implementation. -struct AlsaHandle { - snd_pcm_t *handles[2]; - bool synchronized; - char *tempBuffer; + if (stream_.doConvertBuffer[1]) { - AlsaHandle() - :synchronized(false), tempBuffer(0) {} -}; + // Always interleave ASIO input data. + for ( i=0, j=0; ibufferInfos[i].isInput == ASIOTrue ) + memcpy( &stream_.deviceBuffer[j++*bufferBytes], + handle->bufferInfos[i].buffers[bufferIndex], + bufferBytes ); + } -extern "C" void *alsaCallbackHandler(void * ptr); + if ( stream_.doByteSwap[1] ) + byteSwapBuffer( stream_.deviceBuffer, + stream_.bufferSize * stream_.nDeviceChannels[1], + stream_.deviceFormat[1] ); + convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] ); -RtApiAlsa :: RtApiAlsa() -{ - this->initialize(); + } + else { + for ( i=0, j=0; ibufferInfos[i].isInput == ASIOTrue ) { + memcpy( &stream_.userBuffer[1][bufferBytes*j++], + handle->bufferInfos[i].buffers[bufferIndex], + bufferBytes ); + } + } - if (nDevices_ <= 0) { - sprintf(message_, "RtApiAlsa: no Linux ALSA audio devices found!"); - error(RtError::NO_DEVICES_FOUND); + if ( stream_.doByteSwap[1] ) + byteSwapBuffer( stream_.userBuffer[1], + stream_.bufferSize * stream_.nUserChannels[1], + stream_.userFormat ); + } } -} -RtApiAlsa :: ~RtApiAlsa() -{ - if ( stream_.mode != UNINITIALIZED ) - closeStream(); -} + unlock: + // The following call was suggested by Malte Clasen. While the API + // documentation indicates it should not be required, some device + // drivers apparently do not function correctly without it. + ASIOOutputReady(); -void RtApiAlsa :: initialize(void) -{ - int card, subdevice, result; - char name[64]; - const char *cardId; - snd_ctl_t *handle; - snd_ctl_card_info_t *info; - snd_ctl_card_info_alloca(&info); - RtApiDevice device; + MUTEX_UNLOCK( &stream_.mutex ); - // Count cards and devices - nDevices_ = 0; - card = -1; - snd_card_next(&card); - while ( card >= 0 ) { - sprintf(name, "hw:%d", card); - result = snd_ctl_open(&handle, name, 0); - if (result < 0) { - sprintf(message_, "RtApiAlsa: control open (%i): %s.", card, snd_strerror(result)); - error(RtError::DEBUG_WARNING); - goto next_card; - } - result = snd_ctl_card_info(handle, info); - if (result < 0) { - sprintf(message_, "RtApiAlsa: control hardware info (%i): %s.", card, snd_strerror(result)); - error(RtError::DEBUG_WARNING); - goto next_card; - } - cardId = snd_ctl_card_info_get_id(info); - subdevice = -1; - while (1) { - result = snd_ctl_pcm_next_device(handle, &subdevice); - if (result < 0) { - sprintf(message_, "RtApiAlsa: control next device (%i): %s.", card, snd_strerror(result)); - error(RtError::DEBUG_WARNING); - break; - } - if (subdevice < 0) - break; - sprintf( name, "hw:%d,%d", card, subdevice ); - // If a cardId exists and it contains at least one non-numeric - // character, use it to identify the device. This avoids a bug - // in ALSA such that a numeric string is interpreted as a device - // number. - for ( unsigned int i=0; iname.c_str(), 64 ); - card = strtok(name, ","); - err = snd_ctl_open(&chandle, card, SND_CTL_NONBLOCK); - if (err < 0) { - sprintf(message_, "RtApiAlsa: control open (%s): %s.", card, snd_strerror(err)); - error(RtError::DEBUG_WARNING); + // The ASIO documentation says that this usually only happens during + // external sync. Audio processing is not stopped by the driver, + // actual sample rate might not have even changed, maybe only the + // sample rate status of an AES/EBU or S/PDIF digital input at the + // audio device. + + RtApi *object = (RtApi *) asioCallbackInfo->object; + try { + object->stopStream(); + } + catch ( RtError &exception ) { + std::cerr << "\nRtApiAsio: sampleRateChanged() error (" << exception.getMessage() << ")!\n" << std::endl; return; } - unsigned int dev = (unsigned int) atoi( strtok(NULL, ",") ); - // First try for playback - stream = SND_PCM_STREAM_PLAYBACK; - snd_pcm_info_set_device(pcminfo, dev); - snd_pcm_info_set_subdevice(pcminfo, 0); - snd_pcm_info_set_stream(pcminfo, stream); + std::cerr << "\nRtApiAsio: driver reports sample rate changed to " << sRate << " ... stream stopped!!!\n" << std::endl; +} - if ((err = snd_ctl_pcm_info(chandle, pcminfo)) < 0) { - if (err == -ENOENT) { - sprintf(message_, "RtApiAlsa: pcm device (%s) doesn't handle output!", info->name.c_str()); - error(RtError::DEBUG_WARNING); - } - else { - sprintf(message_, "RtApiAlsa: snd_ctl_pcm_info error for device (%s) output: %s", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - } - goto capture_probe; - } - - err = snd_pcm_open(&handle, info->name.c_str(), stream, open_mode | SND_PCM_NONBLOCK ); - if (err < 0) { - if ( err == EBUSY ) - sprintf(message_, "RtApiAlsa: pcm playback device (%s) is busy: %s.", - info->name.c_str(), snd_strerror(err)); - else - sprintf(message_, "RtApiAlsa: pcm playback open (%s) error: %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - goto capture_probe; - } +long asioMessages( long selector, long value, void* message, double* opt ) +{ + long ret = 0; - // We have an open device ... allocate the parameter structure. - err = snd_pcm_hw_params_any(handle, params); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: hardware probe error (%s): %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - goto capture_probe; + switch( selector ) { + case kAsioSelectorSupported: + if ( value == kAsioResetRequest + || value == kAsioEngineVersion + || value == kAsioResyncRequest + || value == kAsioLatenciesChanged + // The following three were added for ASIO 2.0, you don't + // necessarily have to support them. + || value == kAsioSupportsTimeInfo + || value == kAsioSupportsTimeCode + || value == kAsioSupportsInputMonitor) + ret = 1L; + break; + case kAsioResetRequest: + // Defer the task and perform the reset of the driver during the + // next "safe" situation. You cannot reset the driver right now, + // as this code is called from the driver. Reset the driver is + // done by completely destruct is. I.e. ASIOStop(), + // ASIODisposeBuffers(), Destruction Afterwards you initialize the + // driver again. + std::cerr << "\nRtApiAsio: driver reset requested!!!" << std::endl; + ret = 1L; + break; + case kAsioResyncRequest: + // This informs the application that the driver encountered some + // non-fatal data loss. It is used for synchronization purposes + // of different media. Added mainly to work around the Win16Mutex + // problems in Windows 95/98 with the Windows Multimedia system, + // which could lose data because the Mutex was held too long by + // another thread. However a driver can issue it in other + // situations, too. + // std::cerr << "\nRtApiAsio: driver resync requested!!!" << std::endl; + asioXRun = true; + ret = 1L; + break; + case kAsioLatenciesChanged: + // This will inform the host application that the drivers were + // latencies changed. Beware, it this does not mean that the + // buffer sizes have changed! You might need to update internal + // delay data. + std::cerr << "\nRtApiAsio: driver latency may have changed!!!" << std::endl; + ret = 1L; + break; + case kAsioEngineVersion: + // Return the supported ASIO version of the host application. If + // a host application does not implement this selector, ASIO 1.0 + // is assumed by the driver. + ret = 2L; + break; + case kAsioSupportsTimeInfo: + // Informs the driver whether the + // asioCallbacks.bufferSwitchTimeInfo() callback is supported. + // For compatibility with ASIO 1.0 drivers the host application + // should always support the "old" bufferSwitch method, too. + ret = 0; + break; + case kAsioSupportsTimeCode: + // Informs the driver whether application is interested in time + // code info. If an application does not need to know about time + // code, the driver has less work to do. + ret = 0; + break; } + return ret; +} - // Get output channel information. - unsigned int value; - err = snd_pcm_hw_params_get_channels_min(params, &value); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: hardware minimum channel probe error (%s): %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - goto capture_probe; - } - info->minOutputChannels = value; +static const char* getAsioErrorString( ASIOError result ) +{ + struct Messages + { + ASIOError value; + const char*message; + }; - err = snd_pcm_hw_params_get_channels_max(params, &value); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: hardware maximum channel probe error (%s): %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - goto capture_probe; - } - info->maxOutputChannels = value; + static Messages m[] = + { + { ASE_NotPresent, "Hardware input or output is not present or available." }, + { ASE_HWMalfunction, "Hardware is malfunctioning." }, + { ASE_InvalidParameter, "Invalid input parameter." }, + { ASE_InvalidMode, "Invalid mode." }, + { ASE_SPNotAdvancing, "Sample position not advancing." }, + { ASE_NoClock, "Sample clock or rate cannot be determined or is not present." }, + { ASE_NoMemory, "Not enough memory to complete the request." } + }; - snd_pcm_close(handle); + for ( unsigned int i = 0; i < sizeof(m)/sizeof(m[0]); ++i ) + if ( m[i].value == result ) return m[i].message; - capture_probe: - // Now try for capture - stream = SND_PCM_STREAM_CAPTURE; - snd_pcm_info_set_stream(pcminfo, stream); + return "Unknown error."; +} +//******************** End of __WINDOWS_ASIO__ *********************// +#endif - err = snd_ctl_pcm_info(chandle, pcminfo); - snd_ctl_close(chandle); - if ( err < 0 ) { - if (err == -ENOENT) { - sprintf(message_, "RtApiAlsa: pcm device (%s) doesn't handle input!", info->name.c_str()); - error(RtError::DEBUG_WARNING); - } - else { - sprintf(message_, "RtApiAlsa: snd_ctl_pcm_info error for device (%s) input: %s", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - } - if (info->maxOutputChannels == 0) - // didn't open for playback either ... device invalid - return; - goto probe_parameters; - } - err = snd_pcm_open(&handle, info->name.c_str(), stream, open_mode | SND_PCM_NONBLOCK); - if (err < 0) { - if ( err == EBUSY ) - sprintf(message_, "RtApiAlsa: pcm capture device (%s) is busy: %s.", - info->name.c_str(), snd_strerror(err)); - else - sprintf(message_, "RtApiAlsa: pcm capture open (%s) error: %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - if (info->maxOutputChannels == 0) - // didn't open for playback either ... device invalid - return; - goto probe_parameters; - } - - // We have an open capture device ... allocate the parameter structure. - err = snd_pcm_hw_params_any(handle, params); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: hardware probe error (%s): %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - if (info->maxOutputChannels > 0) - goto probe_parameters; - else - return; - } +#if defined(__WINDOWS_DS__) // Windows DirectSound API - // Get input channel information. - err = snd_pcm_hw_params_get_channels_min(params, &value); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: hardware minimum in channel probe error (%s): %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - if (info->maxOutputChannels > 0) - goto probe_parameters; - else - return; - } - info->minInputChannels = value; +// Modified by Robin Davies, October 2005 +// - Improvements to DirectX pointer chasing. +// - Backdoor RtDsStatistics hook provides DirectX performance information. +// - Bug fix for non-power-of-two Asio granularity used by Edirol PCR-A30. +// - Auto-call CoInitialize for DSOUND and ASIO platforms. +// Various revisions for RtAudio 4.0 by Gary Scavone, April 2007 - err = snd_pcm_hw_params_get_channels_max(params, &value); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: hardware maximum in channel probe error (%s): %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - if (info->maxOutputChannels > 0) - goto probe_parameters; - else - return; - } - info->maxInputChannels = value; +#include +#include - snd_pcm_close(handle); +#define MINIMUM_DEVICE_BUFFER_SIZE 32768 - // If device opens for both playback and capture, we determine the channels. - if (info->maxOutputChannels == 0 || info->maxInputChannels == 0) - goto probe_parameters; +#ifdef _MSC_VER // if Microsoft Visual C++ +#pragma comment( lib, "winmm.lib" ) // then, auto-link winmm.lib. Otherwise, it has to be added manually. +#endif - info->hasDuplexSupport = true; - info->maxDuplexChannels = (info->maxOutputChannels > info->maxInputChannels) ? - info->maxInputChannels : info->maxOutputChannels; - info->minDuplexChannels = (info->minOutputChannels > info->minInputChannels) ? - info->minInputChannels : info->minOutputChannels; +static inline DWORD dsPointerDifference( DWORD laterPointer, DWORD earlierPointer, DWORD bufferSize ) +{ + if (laterPointer > earlierPointer) + return laterPointer - earlierPointer; + else + return laterPointer - earlierPointer + bufferSize; +} - probe_parameters: - // At this point, we just need to figure out the supported data - // formats and sample rates. We'll proceed by opening the device in - // the direction with the maximum number of channels, or playback if - // they are equal. This might limit our sample rate options, but so - // be it. +static inline DWORD dsPointerBetween( DWORD pointer, DWORD laterPointer, DWORD earlierPointer, DWORD bufferSize ) +{ + if ( pointer > bufferSize ) pointer -= bufferSize; + if ( laterPointer < earlierPointer ) laterPointer += bufferSize; + if ( pointer < earlierPointer ) pointer += bufferSize; + return pointer >= earlierPointer && pointer < laterPointer; +} - if (info->maxOutputChannels >= info->maxInputChannels) - stream = SND_PCM_STREAM_PLAYBACK; - else - stream = SND_PCM_STREAM_CAPTURE; +// A structure to hold various information related to the DirectSound +// API implementation. +struct DsHandle { + unsigned int drainCounter; // Tracks callback counts when draining + bool internalDrain; // Indicates if stop is initiated from callback or not. + void *id[2]; + void *buffer[2]; + bool xrun[2]; + UINT bufferPointer[2]; + DWORD dsBufferSize[2]; + DWORD dsPointerLeadTime[2]; // the number of bytes ahead of the safe pointer to lead by. + HANDLE condition; - err = snd_pcm_open(&handle, info->name.c_str(), stream, open_mode); - if (err < 0) { - sprintf(message_, "RtApiAlsa: pcm (%s) won't reopen during probe: %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return; - } + DsHandle() + :drainCounter(0), internalDrain(false) { id[0] = 0, id[1] = 0; xrun[0] = false; xrun[1] = false; bufferPointer[0] = 0; bufferPointer[1] = 0; } +}; - // We have an open device ... allocate the parameter structure. - err = snd_pcm_hw_params_any(handle, params); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: hardware reopen probe error (%s): %s.", - info->name.c_str(), snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return; - } +/* +RtApiDs::RtDsStatistics RtApiDs::statistics; - // Test our discrete set of sample rate values. - int dir = 0; - info->sampleRates.clear(); - for (unsigned int i=0; isampleRates.push_back(SAMPLE_RATES[i]); - } - if (info->sampleRates.size() == 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: no supported sample rates found for device (%s).", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } +// Provides a backdoor hook to monitor for DirectSound read overruns and write underruns. +RtApiDs::RtDsStatistics RtApiDs::getDsStatistics() +{ + RtDsStatistics s = statistics; - // Probe the supported data formats ... we don't care about endian-ness just yet - snd_pcm_format_t format; - info->nativeFormats = 0; - format = SND_PCM_FORMAT_S8; - if (snd_pcm_hw_params_test_format(handle, params, format) == 0) - info->nativeFormats |= RTAUDIO_SINT8; - format = SND_PCM_FORMAT_S16; - if (snd_pcm_hw_params_test_format(handle, params, format) == 0) - info->nativeFormats |= RTAUDIO_SINT16; - format = SND_PCM_FORMAT_S24; - if (snd_pcm_hw_params_test_format(handle, params, format) == 0) - info->nativeFormats |= RTAUDIO_SINT24; - format = SND_PCM_FORMAT_S32; - if (snd_pcm_hw_params_test_format(handle, params, format) == 0) - info->nativeFormats |= RTAUDIO_SINT32; - format = SND_PCM_FORMAT_FLOAT; - if (snd_pcm_hw_params_test_format(handle, params, format) == 0) - info->nativeFormats |= RTAUDIO_FLOAT32; - format = SND_PCM_FORMAT_FLOAT64; - if (snd_pcm_hw_params_test_format(handle, params, format) == 0) - info->nativeFormats |= RTAUDIO_FLOAT64; + // update the calculated fields. + if ( s.inputFrameSize != 0 ) + s.latency += s.readDeviceSafeLeadBytes * 1.0 / s.inputFrameSize / s.sampleRate; - // Check that we have at least one supported format - if (info->nativeFormats == 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: pcm device (%s) data format not supported by RtAudio.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } + if ( s.outputFrameSize != 0 ) + s.latency += (s.writeDeviceSafeLeadBytes + s.writeDeviceBufferLeadBytes) * 1.0 / s.outputFrameSize / s.sampleRate; - // That's all ... close the device and return - snd_pcm_close(handle); - info->probed = true; - return; + return s; } +*/ + +// Declarations for utility functions, callbacks, and structures +// specific to the DirectSound implementation. +static bool CALLBACK deviceCountCallback( LPGUID lpguid, + LPCTSTR description, + LPCTSTR module, + LPVOID lpContext ); + +static char* getErrorString( int code ); + +extern "C" unsigned __stdcall callbackHandler( void *ptr ); -bool RtApiAlsa :: probeDeviceOpen( int device, StreamMode mode, int channels, - int sampleRate, RtAudioFormat format, - int *bufferSize, int numberOfBuffers ) +struct EnumInfo { + bool isInput; + bool getDefault; + bool findIndex; + unsigned int counter; + unsigned int index; + LPGUID id; + std::string name; + + EnumInfo() + : isInput(false), getDefault(false), findIndex(false), counter(0), index(0) {} +}; + +RtApiDs :: RtApiDs() { -#if defined(__RTAUDIO_DEBUG__) - snd_output_t *out; - snd_output_stdio_attach(&out, stderr, 0); -#endif + // Dsound will run both-threaded. If CoInitialize fails, then just + // accept whatever the mainline chose for a threading model. + coInitialized_ = false; + HRESULT hr = CoInitialize( NULL ); + if ( !FAILED( hr ) ) coInitialized_ = true; +} - // I'm not using the "plug" interface ... too much inconsistent behavior. - const char *name = devices_[device].name.c_str(); +RtApiDs :: ~RtApiDs() +{ + if ( coInitialized_ ) CoUninitialize(); // balanced call. + if ( stream_.state != STREAM_CLOSED ) closeStream(); +} - snd_pcm_stream_t alsa_stream; - if (mode == OUTPUT) - alsa_stream = SND_PCM_STREAM_PLAYBACK; - else - alsa_stream = SND_PCM_STREAM_CAPTURE; - - int err; - snd_pcm_t *handle; - int alsa_open_mode = SND_PCM_ASYNC; - err = snd_pcm_open(&handle, name, alsa_stream, alsa_open_mode); - if (err < 0) { - sprintf(message_,"RtApiAlsa: pcm device (%s) won't open: %s.", - name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; +unsigned int RtApiDs :: getDefaultInputDevice( void ) +{ + // Count output devices. + EnumInfo info; + HRESULT result = DirectSoundEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &info ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDefaultOutputDevice: error (" << getErrorString( result ) << ") counting output devices!"; + errorText_ = errorStream_.str(); + error( WARNING ); + return 0; } - // Fill the parameter structure. - snd_pcm_hw_params_t *hw_params; - snd_pcm_hw_params_alloca(&hw_params); - err = snd_pcm_hw_params_any(handle, hw_params); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error getting parameter handle (%s): %s.", - name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; + // Now enumerate input devices until we find the id = NULL. + info.isInput = true; + info.getDefault = true; + result = DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &info ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDefaultInputDevice: error (" << getErrorString( result ) << ") enumerating input devices!"; + errorText_ = errorStream_.str(); + error( WARNING ); + return 0; } -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\nRtApiAlsa: dump hardware params just after device open:\n\n"); - snd_pcm_hw_params_dump(hw_params, out); -#endif + if ( info.counter > 0 ) return info.counter - 1; + return 0; +} - // Set access ... try interleaved access first, then non-interleaved - if ( !snd_pcm_hw_params_test_access( handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED) ) { - err = snd_pcm_hw_params_set_access(handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED); - } - else if ( !snd_pcm_hw_params_test_access( handle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED) ) { - err = snd_pcm_hw_params_set_access(handle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED); - stream_.deInterleave[mode] = true; - } - else { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: device (%s) access not supported by RtAudio.", name); - error(RtError::DEBUG_WARNING); - return FAILURE; +unsigned int RtApiDs :: getDefaultOutputDevice( void ) +{ + // Enumerate output devices until we find the id = NULL. + EnumInfo info; + info.getDefault = true; + HRESULT result = DirectSoundEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &info ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDefaultOutputDevice: error (" << getErrorString( result ) << ") enumerating output devices!"; + errorText_ = errorStream_.str(); + error( WARNING ); + return 0; } - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error setting access ( (%s): %s.", name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + if ( info.counter > 0 ) return info.counter - 1; + return 0; +} - // Determine how to set the device format. - stream_.userFormat = format; - snd_pcm_format_t device_format = SND_PCM_FORMAT_UNKNOWN; - - if (format == RTAUDIO_SINT8) - device_format = SND_PCM_FORMAT_S8; - else if (format == RTAUDIO_SINT16) - device_format = SND_PCM_FORMAT_S16; - else if (format == RTAUDIO_SINT24) - device_format = SND_PCM_FORMAT_S24; - else if (format == RTAUDIO_SINT32) - device_format = SND_PCM_FORMAT_S32; - else if (format == RTAUDIO_FLOAT32) - device_format = SND_PCM_FORMAT_FLOAT; - else if (format == RTAUDIO_FLOAT64) - device_format = SND_PCM_FORMAT_FLOAT64; - - if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { - stream_.deviceFormat[mode] = format; - goto set_format; +unsigned int RtApiDs :: getDeviceCount( void ) +{ + // Count DirectSound devices. + EnumInfo info; + HRESULT result = DirectSoundEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &info ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDeviceCount: error (" << getErrorString( result ) << ") enumerating output devices!"; + errorText_ = errorStream_.str(); + error( WARNING ); } - // The user requested format is not natively supported by the device. - device_format = SND_PCM_FORMAT_FLOAT64; - if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { - stream_.deviceFormat[mode] = RTAUDIO_FLOAT64; - goto set_format; + // Count DirectSoundCapture devices. + info.isInput = true; + result = DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &info ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDeviceCount: error (" << getErrorString( result ) << ") enumerating input devices!"; + errorText_ = errorStream_.str(); + error( WARNING ); } - device_format = SND_PCM_FORMAT_FLOAT; - if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { - stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; - goto set_format; - } + return info.counter; +} - device_format = SND_PCM_FORMAT_S32; - if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { - stream_.deviceFormat[mode] = RTAUDIO_SINT32; - goto set_format; - } +RtAudio::DeviceInfo RtApiDs :: getDeviceInfo( unsigned int device ) +{ + // Because DirectSound always enumerates input and output devices + // separately (and because we don't attempt to combine devices + // internally), none of our "devices" will ever be duplex. - device_format = SND_PCM_FORMAT_S24; - if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { - stream_.deviceFormat[mode] = RTAUDIO_SINT24; - goto set_format; + RtAudio::DeviceInfo info; + info.probed = false; + + // Enumerate through devices to find the id (if it exists). Note + // that we have to do the output enumeration first, even if this is + // an input device, in order for the device counter to be correct. + EnumInfo dsinfo; + dsinfo.findIndex = true; + dsinfo.index = device; + HRESULT result = DirectSoundEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &dsinfo ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") enumerating output devices!"; + errorText_ = errorStream_.str(); + error( WARNING ); } - device_format = SND_PCM_FORMAT_S16; - if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - goto set_format; + if ( dsinfo.name.empty() ) goto probeInput; + + LPDIRECTSOUND output; + DSCAPS outCaps; + result = DirectSoundCreate( dsinfo.id, &output, NULL ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") opening output device (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - device_format = SND_PCM_FORMAT_S8; - if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { - stream_.deviceFormat[mode] = RTAUDIO_SINT8; - goto set_format; + outCaps.dwSize = sizeof( outCaps ); + result = output->GetCaps( &outCaps ); + if ( FAILED( result ) ) { + output->Release(); + errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") getting capabilities!"; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - // If we get here, no supported format was found. - sprintf(message_,"RtApiAlsa: pcm device (%s) data format not supported by RtAudio.", name); - snd_pcm_close(handle); - error(RtError::DEBUG_WARNING); - return FAILURE; + // Get output channel information. + info.outputChannels = ( outCaps.dwFlags & DSCAPS_PRIMARYSTEREO ) ? 2 : 1; - set_format: - err = snd_pcm_hw_params_set_format(handle, hw_params, device_format); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error setting format (%s): %s.", - name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; + // Get sample rate information. + info.sampleRates.clear(); + for ( unsigned int k=0; k= (unsigned int) outCaps.dwMinSecondarySampleRate && + SAMPLE_RATES[k] <= (unsigned int) outCaps.dwMaxSecondarySampleRate ) + info.sampleRates.push_back( SAMPLE_RATES[k] ); } - // Determine whether byte-swaping is necessary. - stream_.doByteSwap[mode] = false; - if (device_format != SND_PCM_FORMAT_S8) { - err = snd_pcm_format_cpu_endian(device_format); - if (err == 0) - stream_.doByteSwap[mode] = true; - else if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error getting format endian-ness (%s): %s.", - name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - } + // Get format information. + if ( outCaps.dwFlags & DSCAPS_PRIMARY16BIT ) info.nativeFormats |= RTAUDIO_SINT16; + if ( outCaps.dwFlags & DSCAPS_PRIMARY8BIT ) info.nativeFormats |= RTAUDIO_SINT8; - // Set the sample rate. - err = snd_pcm_hw_params_set_rate(handle, hw_params, (unsigned int)sampleRate, 0); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error setting sample rate (%d) on device (%s): %s.", - sampleRate, name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + output->Release(); - // Determine the number of channels for this device. We support a possible - // minimum device channel number > than the value requested by the user. - stream_.nUserChannels[mode] = channels; - unsigned int value; - err = snd_pcm_hw_params_get_channels_max(hw_params, &value); - int device_channels = value; - if (err < 0 || device_channels < channels) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: channels (%d) not supported by device (%s).", - channels, name); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + if ( getDefaultOutputDevice() == device ) + info.isDefaultOutput = true; - err = snd_pcm_hw_params_get_channels_min(hw_params, &value); - if (err < 0 ) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error getting min channels count on device (%s).", name); - error(RtError::DEBUG_WARNING); - return FAILURE; + // Copy name and return. + info.name = dsinfo.name; + + info.probed = true; + return info; + + probeInput: + + dsinfo.isInput = true; + result = DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &dsinfo ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") enumerating input devices!"; + errorText_ = errorStream_.str(); + error( WARNING ); } - device_channels = value; - if (device_channels < channels) device_channels = channels; - stream_.nDeviceChannels[mode] = device_channels; - // Set the device channels. - err = snd_pcm_hw_params_set_channels(handle, hw_params, device_channels); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error setting channels (%d) on device (%s): %s.", - device_channels, name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; + if ( dsinfo.name.empty() ) return info; + + LPDIRECTSOUNDCAPTURE input; + result = DirectSoundCaptureCreate( dsinfo.id, &input, NULL ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") opening input device (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - // Set the buffer number, which in ALSA is referred to as the "period". - int dir; - unsigned int periods = numberOfBuffers; - // Even though the hardware might allow 1 buffer, it won't work reliably. - if (periods < 2) periods = 2; - err = snd_pcm_hw_params_set_periods_near(handle, hw_params, &periods, &dir); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error setting periods (%s): %s.", - name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; + DSCCAPS inCaps; + inCaps.dwSize = sizeof( inCaps ); + result = input->GetCaps( &inCaps ); + if ( FAILED( result ) ) { + input->Release(); + errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") getting object capabilities (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - // Set the buffer (or period) size. - snd_pcm_uframes_t period_size = *bufferSize; - err = snd_pcm_hw_params_set_period_size_near(handle, hw_params, &period_size, &dir); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error setting period size (%s): %s.", - name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - *bufferSize = period_size; + // Get input channel information. + info.inputChannels = inCaps.dwChannels; - // If attempting to setup a duplex stream, the bufferSize parameter - // MUST be the same in both directions! - if ( stream_.mode == OUTPUT && mode == INPUT && *bufferSize != stream_.bufferSize ) { - sprintf( message_, "RtApiAlsa: error setting buffer size for duplex stream on device (%s).", - name ); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + // Get sample rate and format information. + if ( inCaps.dwChannels == 2 ) { + if ( inCaps.dwFormats & WAVE_FORMAT_1S16 ) info.nativeFormats |= RTAUDIO_SINT16; + if ( inCaps.dwFormats & WAVE_FORMAT_2S16 ) info.nativeFormats |= RTAUDIO_SINT16; + if ( inCaps.dwFormats & WAVE_FORMAT_4S16 ) info.nativeFormats |= RTAUDIO_SINT16; + if ( inCaps.dwFormats & WAVE_FORMAT_96S16 ) info.nativeFormats |= RTAUDIO_SINT16; + if ( inCaps.dwFormats & WAVE_FORMAT_1S08 ) info.nativeFormats |= RTAUDIO_SINT8; + if ( inCaps.dwFormats & WAVE_FORMAT_2S08 ) info.nativeFormats |= RTAUDIO_SINT8; + if ( inCaps.dwFormats & WAVE_FORMAT_4S08 ) info.nativeFormats |= RTAUDIO_SINT8; + if ( inCaps.dwFormats & WAVE_FORMAT_96S08 ) info.nativeFormats |= RTAUDIO_SINT8; + + if ( info.nativeFormats & RTAUDIO_SINT16 ) { + if ( inCaps.dwFormats & WAVE_FORMAT_1S16 ) info.sampleRates.push_back( 11025 ); + if ( inCaps.dwFormats & WAVE_FORMAT_2S16 ) info.sampleRates.push_back( 22050 ); + if ( inCaps.dwFormats & WAVE_FORMAT_4S16 ) info.sampleRates.push_back( 44100 ); + if ( inCaps.dwFormats & WAVE_FORMAT_96S16 ) info.sampleRates.push_back( 96000 ); + } + else if ( info.nativeFormats & RTAUDIO_SINT8 ) { + if ( inCaps.dwFormats & WAVE_FORMAT_1S08 ) info.sampleRates.push_back( 11025 ); + if ( inCaps.dwFormats & WAVE_FORMAT_2S08 ) info.sampleRates.push_back( 22050 ); + if ( inCaps.dwFormats & WAVE_FORMAT_4S08 ) info.sampleRates.push_back( 44100 ); + if ( inCaps.dwFormats & WAVE_FORMAT_96S08 ) info.sampleRates.push_back( 44100 ); + } + } + else if ( inCaps.dwChannels == 1 ) { + if ( inCaps.dwFormats & WAVE_FORMAT_1M16 ) info.nativeFormats |= RTAUDIO_SINT16; + if ( inCaps.dwFormats & WAVE_FORMAT_2M16 ) info.nativeFormats |= RTAUDIO_SINT16; + if ( inCaps.dwFormats & WAVE_FORMAT_4M16 ) info.nativeFormats |= RTAUDIO_SINT16; + if ( inCaps.dwFormats & WAVE_FORMAT_96M16 ) info.nativeFormats |= RTAUDIO_SINT16; + if ( inCaps.dwFormats & WAVE_FORMAT_1M08 ) info.nativeFormats |= RTAUDIO_SINT8; + if ( inCaps.dwFormats & WAVE_FORMAT_2M08 ) info.nativeFormats |= RTAUDIO_SINT8; + if ( inCaps.dwFormats & WAVE_FORMAT_4M08 ) info.nativeFormats |= RTAUDIO_SINT8; + if ( inCaps.dwFormats & WAVE_FORMAT_96M08 ) info.nativeFormats |= RTAUDIO_SINT8; + + if ( info.nativeFormats & RTAUDIO_SINT16 ) { + if ( inCaps.dwFormats & WAVE_FORMAT_1M16 ) info.sampleRates.push_back( 11025 ); + if ( inCaps.dwFormats & WAVE_FORMAT_2M16 ) info.sampleRates.push_back( 22050 ); + if ( inCaps.dwFormats & WAVE_FORMAT_4M16 ) info.sampleRates.push_back( 44100 ); + if ( inCaps.dwFormats & WAVE_FORMAT_96M16 ) info.sampleRates.push_back( 96000 ); + } + else if ( info.nativeFormats & RTAUDIO_SINT8 ) { + if ( inCaps.dwFormats & WAVE_FORMAT_1M08 ) info.sampleRates.push_back( 11025 ); + if ( inCaps.dwFormats & WAVE_FORMAT_2M08 ) info.sampleRates.push_back( 22050 ); + if ( inCaps.dwFormats & WAVE_FORMAT_4M08 ) info.sampleRates.push_back( 44100 ); + if ( inCaps.dwFormats & WAVE_FORMAT_96M08 ) info.sampleRates.push_back( 96000 ); + } + } + else info.inputChannels = 0; // technically, this would be an error - stream_.bufferSize = *bufferSize; + input->Release(); - // Install the hardware configuration - err = snd_pcm_hw_params(handle, hw_params); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtApiAlsa: error installing hardware configuration (%s): %s.", - name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + if ( info.inputChannels == 0 ) return info; -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\nRtApiAlsa: dump hardware params after installation:\n\n"); - snd_pcm_hw_params_dump(hw_params, out); -#endif + if ( getDefaultInputDevice() == device ) + info.isDefaultInput = true; - // Set the software configuration to fill buffers with zeros and prevent device stopping on xruns. - snd_pcm_sw_params_t *sw_params = NULL; - snd_pcm_sw_params_alloca( &sw_params ); - snd_pcm_sw_params_current( handle, sw_params ); - snd_pcm_sw_params_set_start_threshold( handle, sw_params, *bufferSize ); - snd_pcm_sw_params_set_stop_threshold( handle, sw_params, 0x7fffffff ); - snd_pcm_sw_params_set_silence_threshold( handle, sw_params, 0 ); - snd_pcm_sw_params_set_silence_size( handle, sw_params, INT_MAX ); - err = snd_pcm_sw_params( handle, sw_params ); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message_, "RtAudio: ALSA error installing software configuration (%s): %s.", - name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); + // Copy name and return. + info.name = dsinfo.name; + info.probed = true; + return info; +} + +bool RtApiDs :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, + unsigned int firstChannel, unsigned int sampleRate, + RtAudioFormat format, unsigned int *bufferSize, + RtAudio::StreamOptions *options ) +{ + if ( channels + firstChannel > 2 ) { + errorText_ = "RtApiDs::probeDeviceOpen: DirectSound does not support more than 2 channels per device."; return FAILURE; } -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\nRtApiAlsa: dump software params after installation:\n\n"); - snd_pcm_sw_params_dump(sw_params, out); -#endif + // Enumerate through devices to find the id (if it exists). Note + // that we have to do the output enumeration first, even if this is + // an input device, in order for the device counter to be correct. + EnumInfo dsinfo; + dsinfo.findIndex = true; + dsinfo.index = device; + HRESULT result = DirectSoundEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &dsinfo ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") enumerating output devices!"; + errorText_ = errorStream_.str(); + return FAILURE; + } - // Allocate the ApiHandle if necessary and then save. - AlsaHandle *apiInfo = 0; - if ( stream_.apiHandle == 0 ) { - apiInfo = (AlsaHandle *) new AlsaHandle; - stream_.apiHandle = (void *) apiInfo; - apiInfo->handles[0] = 0; - apiInfo->handles[1] = 0; + if ( mode == OUTPUT ) { + if ( dsinfo.name.empty() ) { + errorStream_ << "RtApiDs::probeDeviceOpen: device (" << device << ") does not support output!"; + errorText_ = errorStream_.str(); + return FAILURE; + } } - else { - apiInfo = (AlsaHandle *) stream_.apiHandle; + else { // mode == INPUT + dsinfo.isInput = true; + HRESULT result = DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK) deviceCountCallback, &dsinfo ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") enumerating input devices!"; + errorText_ = errorStream_.str(); + return FAILURE; + } + if ( dsinfo.name.empty() ) { + errorStream_ << "RtApiDs::probeDeviceOpen: device (" << device << ") does not support input!"; + errorText_ = errorStream_.str(); + return FAILURE; + } } - apiInfo->handles[mode] = handle; - // Set flags for buffer conversion - stream_.doConvertBuffer[mode] = false; - if (stream_.userFormat != stream_.deviceFormat[mode]) - stream_.doConvertBuffer[mode] = true; - if (stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode]) - stream_.doConvertBuffer[mode] = true; - if (stream_.nUserChannels[mode] > 1 && stream_.deInterleave[mode]) - stream_.doConvertBuffer[mode] = true; + // According to a note in PortAudio, using GetDesktopWindow() + // instead of GetForegroundWindow() is supposed to avoid problems + // that occur when the application's window is not the foreground + // window. Also, if the application window closes before the + // DirectSound buffer, DirectSound can crash. However, for console + // applications, no sound was produced when using GetDesktopWindow(). + HWND hWnd = GetForegroundWindow(); - // Allocate necessary internal buffers - if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { + // Check the numberOfBuffers parameter and limit the lowest value to + // two. This is a judgement call and a value of two is probably too + // low for capture, but it should work for playback. + int nBuffers = 0; + if ( options ) nBuffers = options->numberOfBuffers; + if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) nBuffers = 2; + if ( nBuffers < 2 ) nBuffers = 3; - long buffer_bytes; - if (stream_.nUserChannels[0] >= stream_.nUserChannels[1]) - buffer_bytes = stream_.nUserChannels[0]; - else - buffer_bytes = stream_.nUserChannels[1]; - - buffer_bytes *= *bufferSize * formatBytes(stream_.userFormat); - if (stream_.userBuffer) free(stream_.userBuffer); - if (apiInfo->tempBuffer) free(apiInfo->tempBuffer); - stream_.userBuffer = (char *) calloc(buffer_bytes, 1); - apiInfo->tempBuffer = (char *) calloc(buffer_bytes, 1); - if ( stream_.userBuffer == NULL || apiInfo->tempBuffer == NULL ) { - sprintf(message_, "RtApiAlsa: error allocating user buffer memory (%s).", - devices_[device].name.c_str()); - goto error; - } - } + // Create the wave format structure. The data format setting will + // be determined later. + WAVEFORMATEX waveFormat; + ZeroMemory( &waveFormat, sizeof(WAVEFORMATEX) ); + waveFormat.wFormatTag = WAVE_FORMAT_PCM; + waveFormat.nChannels = channels + firstChannel; + waveFormat.nSamplesPerSec = (unsigned long) sampleRate; - if ( stream_.doConvertBuffer[mode] ) { + // Determine the device buffer size. By default, 32k, but we will + // grow it to make allowances for very large software buffer sizes. + DWORD dsBufferSize = 0; + DWORD dsPointerLeadTime = 0; + long bufferBytes = MINIMUM_DEVICE_BUFFER_SIZE; // sound cards will always *knock wood* support this - long buffer_bytes; - bool makeBuffer = true; - if ( mode == OUTPUT ) - buffer_bytes = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - else { // mode == INPUT - buffer_bytes = stream_.nDeviceChannels[1] * formatBytes(stream_.deviceFormat[1]); - if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { - long bytes_out = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - if ( buffer_bytes < bytes_out ) makeBuffer = false; - } - } + void *ohandle = 0, *bhandle = 0; + if ( mode == OUTPUT ) { - if ( makeBuffer ) { - buffer_bytes *= *bufferSize; - if (stream_.deviceBuffer) free(stream_.deviceBuffer); - stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.deviceBuffer == NULL) { - sprintf(message_, "RtApiAlsa: error allocating device buffer memory (%s).", - devices_[device].name.c_str()); - goto error; - } + LPDIRECTSOUND output; + result = DirectSoundCreate( dsinfo.id, &output, NULL ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") opening output device (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; } - } - stream_.device[mode] = device; - stream_.state = STREAM_STOPPED; - if ( stream_.mode == OUTPUT && mode == INPUT ) { - // We had already set up an output stream. - stream_.mode = DUPLEX; - // Link the streams if possible. - apiInfo->synchronized = false; - if (snd_pcm_link( apiInfo->handles[0], apiInfo->handles[1] ) == 0) - apiInfo->synchronized = true; - else { - sprintf(message_, "RtApiAlsa: unable to synchronize input and output streams (%s).", - devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); + DSCAPS outCaps; + outCaps.dwSize = sizeof( outCaps ); + result = output->GetCaps( &outCaps ); + if ( FAILED( result ) ) { + output->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting capabilities (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; } - } - else - stream_.mode = mode; - stream_.nBuffers = periods; - stream_.sampleRate = sampleRate; - // Setup the buffer conversion information structure. - if ( stream_.doConvertBuffer[mode] ) { - if (mode == INPUT) { // convert device to user buffer - stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1]; - stream_.convertInfo[mode].outJump = stream_.nUserChannels[1]; - stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1]; - stream_.convertInfo[mode].outFormat = stream_.userFormat; - } - else { // convert user to device buffer - stream_.convertInfo[mode].inJump = stream_.nUserChannels[0]; - stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0]; - stream_.convertInfo[mode].inFormat = stream_.userFormat; - stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0]; + // Check channel information. + if ( channels + firstChannel == 2 && !( outCaps.dwFlags & DSCAPS_PRIMARYSTEREO ) ) { + errorStream_ << "RtApiDs::getDeviceInfo: the output device (" << dsinfo.name << ") does not support stereo playback."; + errorText_ = errorStream_.str(); + return FAILURE; } - if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump ) - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump; - else - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump; - - // Set up the interleave/deinterleave offsets. - if ( mode == INPUT && stream_.deInterleave[1] ) { - for (int k=0; khandles[0]) - snd_pcm_close(apiInfo->handles[0]); - if (apiInfo->handles[1]) - snd_pcm_close(apiInfo->handles[1]); - if ( apiInfo->tempBuffer ) free(apiInfo->tempBuffer); - delete apiInfo; - stream_.apiHandle = 0; - } + // If the user wants an even bigger buffer, increase the device buffer size accordingly. + while ( dsPointerLeadTime * 2U > (DWORD) bufferBytes ) + bufferBytes *= 2; - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; - } + // Set cooperative level to DSSCL_EXCLUSIVE + result = output->SetCooperativeLevel( hWnd, DSSCL_EXCLUSIVE ); + if ( FAILED( result ) ) { + output->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") setting cooperative level (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } - error(RtError::DEBUG_WARNING); - return FAILURE; -} + // Even though we will write to the secondary buffer, we need to + // access the primary buffer to set the correct output format + // (since the default is 8-bit, 22 kHz!). Setup the DS primary + // buffer description. + DSBUFFERDESC bufferDescription; + ZeroMemory( &bufferDescription, sizeof( DSBUFFERDESC ) ); + bufferDescription.dwSize = sizeof( DSBUFFERDESC ); + bufferDescription.dwFlags = DSBCAPS_PRIMARYBUFFER; -void RtApiAlsa :: closeStream() -{ - // We don't want an exception to be thrown here because this - // function is called by our class destructor. So, do our own - // stream check. - if ( stream_.mode == UNINITIALIZED ) { - sprintf(message_, "RtApiAlsa::closeStream(): no open stream to close!"); - error(RtError::WARNING); - return; - } + // Obtain the primary buffer + LPDIRECTSOUNDBUFFER buffer; + result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL ); + if ( FAILED( result ) ) { + output->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") accessing primary buffer (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } - AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; - if (stream_.state == STREAM_RUNNING) { - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) - snd_pcm_drop(apiInfo->handles[0]); - if (stream_.mode == INPUT || stream_.mode == DUPLEX) - snd_pcm_drop(apiInfo->handles[1]); - stream_.state = STREAM_STOPPED; - } + // Set the primary DS buffer sound format. + result = buffer->SetFormat( &waveFormat ); + if ( FAILED( result ) ) { + output->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") setting primary buffer format (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } - if (stream_.callbackInfo.usingCallback) { - stream_.callbackInfo.usingCallback = false; - pthread_join(stream_.callbackInfo.thread, NULL); - } + // Setup the secondary DS buffer description. + dsBufferSize = (DWORD) bufferBytes; + ZeroMemory( &bufferDescription, sizeof( DSBUFFERDESC ) ); + bufferDescription.dwSize = sizeof( DSBUFFERDESC ); + bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS | + DSBCAPS_GETCURRENTPOSITION2 | + DSBCAPS_LOCHARDWARE ); // Force hardware mixing + bufferDescription.dwBufferBytes = bufferBytes; + bufferDescription.lpwfxFormat = &waveFormat; - if (apiInfo) { - if (apiInfo->handles[0]) snd_pcm_close(apiInfo->handles[0]); - if (apiInfo->handles[1]) snd_pcm_close(apiInfo->handles[1]); - free(apiInfo->tempBuffer); - delete apiInfo; - stream_.apiHandle = 0; - } + // Try to create the secondary DS buffer. If that doesn't work, + // try to use software mixing. Otherwise, there's a problem. + result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL ); + if ( FAILED( result ) ) { + bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS | + DSBCAPS_GETCURRENTPOSITION2 | + DSBCAPS_LOCSOFTWARE ); // Force software mixing + result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL ); + if ( FAILED( result ) ) { + output->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") creating secondary buffer (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } + } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; - } + // Get the buffer size ... might be different from what we specified. + DSBCAPS dsbcaps; + dsbcaps.dwSize = sizeof( DSBCAPS ); + result = buffer->GetCaps( &dsbcaps ); + if ( FAILED( result ) ) { + output->Release(); + buffer->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting buffer settings (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } - if (stream_.deviceBuffer) { - free(stream_.deviceBuffer); - stream_.deviceBuffer = 0; - } + bufferBytes = dsbcaps.dwBufferBytes; - stream_.mode = UNINITIALIZED; -} + // Lock the DS buffer + LPVOID audioPtr; + DWORD dataLen; + result = buffer->Lock( 0, bufferBytes, &audioPtr, &dataLen, NULL, NULL, 0 ); + if ( FAILED( result ) ) { + output->Release(); + buffer->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") locking buffer (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } -// Pump a bunch of zeros into the output buffer. This is needed only when we -// are doing duplex operations. -bool RtApiAlsa :: primeOutputBuffer() -{ - int err; - char *buffer; - int channels; - snd_pcm_t **handle; - RtAudioFormat format; - AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; - handle = (snd_pcm_t **) apiInfo->handles; - - if (stream_.mode == DUPLEX) { + // Zero the DS buffer + ZeroMemory( audioPtr, dataLen ); - // Setup parameters and do buffer conversion if necessary. - if ( stream_.doConvertBuffer[0] ) { - convertBuffer( stream_.deviceBuffer, apiInfo->tempBuffer, stream_.convertInfo[0] ); - channels = stream_.nDeviceChannels[0]; - format = stream_.deviceFormat[0]; - } - else { - channels = stream_.nUserChannels[0]; - format = stream_.userFormat; + // Unlock the DS buffer + result = buffer->Unlock( audioPtr, dataLen, NULL, 0 ); + if ( FAILED( result ) ) { + output->Release(); + buffer->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") unlocking buffer (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; } - buffer = new char[stream_.bufferSize * formatBytes(format) * channels]; - bzero(buffer, stream_.bufferSize * formatBytes(format) * channels); - - for (int i=0; iGetCaps( &inCaps ); + if ( FAILED( result ) ) { + input->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting input capabilities (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } - MUTEX_LOCK(&stream_.mutex); + // Check channel information. + if ( inCaps.dwChannels < channels + firstChannel ) { + errorText_ = "RtApiDs::getDeviceInfo: the input device does not support requested input channels."; + return FAILURE; + } - int err; - snd_pcm_state_t state; - AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; - snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - state = snd_pcm_state(handle[0]); - if (state != SND_PCM_STATE_PREPARED) { - err = snd_pcm_prepare(handle[0]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error preparing pcm device (%s): %s.", - devices_[stream_.device[0]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + // Check format information. Use 16-bit format unless user + // requests 8-bit. + DWORD deviceFormats; + if ( channels + firstChannel == 2 ) { + deviceFormats = WAVE_FORMAT_1S08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_96S08; + if ( format == RTAUDIO_SINT8 && inCaps.dwFormats & deviceFormats ) { + waveFormat.wBitsPerSample = 8; + stream_.deviceFormat[mode] = RTAUDIO_SINT8; } - // Reprime output buffer if needed - if ( (stream_.mode == DUPLEX) && ( !primeOutputBuffer() ) ) { - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + else { // assume 16-bit is supported + waveFormat.wBitsPerSample = 16; + stream_.deviceFormat[mode] = RTAUDIO_SINT16; } } - } - - if ( (stream_.mode == INPUT || stream_.mode == DUPLEX) && !apiInfo->synchronized ) { - state = snd_pcm_state(handle[1]); - if (state != SND_PCM_STATE_PREPARED) { - err = snd_pcm_prepare(handle[1]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error preparing pcm device (%s): %s.", - devices_[stream_.device[1]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + else { // channel == 1 + deviceFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_2M08 | WAVE_FORMAT_4M08 | WAVE_FORMAT_96M08; + if ( format == RTAUDIO_SINT8 && inCaps.dwFormats & deviceFormats ) { + waveFormat.wBitsPerSample = 8; + stream_.deviceFormat[mode] = RTAUDIO_SINT8; + } + else { // assume 16-bit is supported + waveFormat.wBitsPerSample = 16; + stream_.deviceFormat[mode] = RTAUDIO_SINT16; } } - } + stream_.userFormat = format; - if ( (stream_.mode == DUPLEX) && ( !primeOutputBuffer() ) ) { - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - stream_.state = STREAM_RUNNING; + // Update wave format structure and buffer information. + waveFormat.nBlockAlign = waveFormat.nChannels * waveFormat.wBitsPerSample / 8; + waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign; - MUTEX_UNLOCK(&stream_.mutex); -} + // Setup the secondary DS buffer description. + dsBufferSize = bufferBytes; + DSCBUFFERDESC bufferDescription; + ZeroMemory( &bufferDescription, sizeof( DSCBUFFERDESC ) ); + bufferDescription.dwSize = sizeof( DSCBUFFERDESC ); + bufferDescription.dwFlags = 0; + bufferDescription.dwReserved = 0; + bufferDescription.dwBufferBytes = bufferBytes; + bufferDescription.lpwfxFormat = &waveFormat; -void RtApiAlsa :: stopStream() -{ - verifyStream(); - if (stream_.state == STREAM_STOPPED) return; + // Create the capture buffer. + LPDIRECTSOUNDCAPTUREBUFFER buffer; + result = input->CreateCaptureBuffer( &bufferDescription, &buffer, NULL ); + if ( FAILED( result ) ) { + input->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") creating input buffer (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } - // Change the state before the lock to improve shutdown response - // when using a callback. - stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); + // Lock the capture buffer + LPVOID audioPtr; + DWORD dataLen; + result = buffer->Lock( 0, bufferBytes, &audioPtr, &dataLen, NULL, NULL, 0 ); + if ( FAILED( result ) ) { + input->Release(); + buffer->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") locking input buffer (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; + } - int err; - AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; - snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - err = snd_pcm_drain(handle[0]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error draining pcm device (%s): %s.", - devices_[stream_.device[0]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + // Zero the buffer + ZeroMemory( audioPtr, dataLen ); + + // Unlock the buffer + result = buffer->Unlock( audioPtr, dataLen, NULL, 0 ); + if ( FAILED( result ) ) { + input->Release(); + buffer->Release(); + errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") unlocking input buffer (" << dsinfo.name << ")!"; + errorText_ = errorStream_.str(); + return FAILURE; } + + dsBufferSize = bufferBytes; + ohandle = (void *) input; + bhandle = (void *) buffer; + } + + // Set various stream parameters + stream_.nDeviceChannels[mode] = channels + firstChannel; + stream_.nUserChannels[mode] = channels; + stream_.bufferSize = *bufferSize; + stream_.channelOffset[mode] = firstChannel; + stream_.deviceInterleaved[mode] = true; + if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false; + else stream_.userInterleaved = true; + + // Set flag for buffer conversion + stream_.doConvertBuffer[mode] = false; + if (stream_.nUserChannels[mode] != stream_.nDeviceChannels[mode]) + stream_.doConvertBuffer[mode] = true; + if (stream_.userFormat != stream_.deviceFormat[mode]) + stream_.doConvertBuffer[mode] = true; + if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] && + stream_.nUserChannels[mode] > 1 ) + stream_.doConvertBuffer[mode] = true; + + // Allocate necessary internal buffers + bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat ); + stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 ); + if ( stream_.userBuffer[mode] == NULL ) { + errorText_ = "RtApiDs::probeDeviceOpen: error allocating user buffer memory."; + goto error; } - if ( (stream_.mode == INPUT || stream_.mode == DUPLEX) && !apiInfo->synchronized ) { - err = snd_pcm_drain(handle[1]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error draining pcm device (%s): %s.", - devices_[stream_.device[1]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + if ( stream_.doConvertBuffer[mode] ) { + + bool makeBuffer = true; + bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] ); + if ( mode == INPUT ) { + if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { + unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] ); + if ( bufferBytes <= (long) bytesOut ) makeBuffer = false; + } + } + + if ( makeBuffer ) { + bufferBytes *= *bufferSize; + if ( stream_.deviceBuffer ) free( stream_.deviceBuffer ); + stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 ); + if ( stream_.deviceBuffer == NULL ) { + errorText_ = "RtApiDs::probeDeviceOpen: error allocating device buffer memory."; + goto error; + } } } - MUTEX_UNLOCK(&stream_.mutex); -} + // Allocate our DsHandle structures for the stream. + DsHandle *handle; + if ( stream_.apiHandle == 0 ) { + try { + handle = new DsHandle; + } + catch ( std::bad_alloc& ) { + errorText_ = "RtApiDs::probeDeviceOpen: error allocating AsioHandle memory."; + goto error; + } -void RtApiAlsa :: abortStream() -{ - verifyStream(); - if (stream_.state == STREAM_STOPPED) return; + // Create a manual-reset event. + handle->condition = CreateEvent( NULL, // no security + TRUE, // manual-reset + FALSE, // non-signaled initially + NULL ); // unnamed + stream_.apiHandle = (void *) handle; + } + else + handle = (DsHandle *) stream_.apiHandle; + handle->id[mode] = ohandle; + handle->buffer[mode] = bhandle; + handle->dsBufferSize[mode] = dsBufferSize; + handle->dsPointerLeadTime[mode] = dsPointerLeadTime; - // Change the state before the lock to improve shutdown response - // when using a callback. + stream_.device[mode] = device; stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); + if ( stream_.mode == OUTPUT && mode == INPUT ) + // We had already set up an output stream. + stream_.mode = DUPLEX; + else + stream_.mode = mode; + stream_.nBuffers = nBuffers; + stream_.sampleRate = sampleRate; - int err; - AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; - snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - err = snd_pcm_drop(handle[0]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error draining pcm device (%s): %s.", - devices_[stream_.device[0]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + // Setup the buffer conversion information structure. + if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel ); + + // Setup the callback thread. + unsigned threadId; + stream_.callbackInfo.object = (void *) this; + stream_.callbackInfo.isRunning = true; + stream_.callbackInfo.thread = _beginthreadex( NULL, 0, &callbackHandler, + &stream_.callbackInfo, 0, &threadId ); + if ( stream_.callbackInfo.thread == 0 ) { + errorText_ = "RtApiDs::probeDeviceOpen: error creating callback thread!"; + goto error; + } + + return SUCCESS; + + error: + if ( handle ) { + if ( handle->buffer[0] ) { // the object pointer can be NULL and valid + LPDIRECTSOUND object = (LPDIRECTSOUND) handle->id[0]; + LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0]; + if ( buffer ) buffer->Release(); + object->Release(); } + if ( handle->buffer[1] ) { + LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handle->id[1]; + LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1]; + if ( buffer ) buffer->Release(); + object->Release(); + } + CloseHandle( handle->condition ); + delete handle; + stream_.apiHandle = 0; } - if ( (stream_.mode == INPUT || stream_.mode == DUPLEX) && !apiInfo->synchronized ) { - err = snd_pcm_drop(handle[1]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error draining pcm device (%s): %s.", - devices_[stream_.device[1]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; } } - MUTEX_UNLOCK(&stream_.mutex); + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; + } + + return FAILURE; } -int RtApiAlsa :: streamWillBlock() +void RtApiDs :: closeStream() { - verifyStream(); - if (stream_.state == STREAM_STOPPED) return 0; + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiDs::closeStream(): no open stream to close!"; + error( WARNING ); + return; + } - MUTEX_LOCK(&stream_.mutex); + // Stop the callback thread. + stream_.callbackInfo.isRunning = false; + WaitForSingleObject( (HANDLE) stream_.callbackInfo.thread, INFINITE ); + CloseHandle( (HANDLE) stream_.callbackInfo.thread ); - int err = 0, frames = 0; - AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; - snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - err = snd_pcm_avail_update(handle[0]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error getting available frames for device (%s): %s.", - devices_[stream_.device[0]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + DsHandle *handle = (DsHandle *) stream_.apiHandle; + if ( handle ) { + if ( handle->buffer[0] ) { // the object pointer can be NULL and valid + LPDIRECTSOUND object = (LPDIRECTSOUND) handle->id[0]; + LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0]; + if ( buffer ) { + buffer->Stop(); + buffer->Release(); + } + object->Release(); + } + if ( handle->buffer[1] ) { + LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handle->id[1]; + LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1]; + if ( buffer ) { + buffer->Stop(); + buffer->Release(); + } + object->Release(); } + CloseHandle( handle->condition ); + delete handle; + stream_.apiHandle = 0; } - frames = err; - - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - err = snd_pcm_avail_update(handle[1]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error getting available frames for device (%s): %s.", - devices_[stream_.device[1]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; } - if (frames > err) frames = err; } - frames = stream_.bufferSize - frames; - if (frames < 0) frames = 0; + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; + } - MUTEX_UNLOCK(&stream_.mutex); - return frames; + stream_.mode = UNINITIALIZED; + stream_.state = STREAM_CLOSED; } -void RtApiAlsa :: tickStream() +void RtApiDs :: startStream() { verifyStream(); - - int stopStream = 0; - if (stream_.state == STREAM_STOPPED) { - if (stream_.callbackInfo.usingCallback) usleep(50000); // sleep 50 milliseconds + if ( stream_.state == STREAM_RUNNING ) { + errorText_ = "RtApiDs::startStream(): the stream is already running!"; + error( WARNING ); return; } - else if (stream_.callbackInfo.usingCallback) { - RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; - stopStream = callback(stream_.userBuffer, stream_.bufferSize, stream_.callbackInfo.userData); - } - MUTEX_LOCK(&stream_.mutex); + // Increase scheduler frequency on lesser windows (a side-effect of + // increasing timer accuracy). On greater windows (Win2K or later), + // this is already in effect. - // The state might change while waiting on a mutex. - if (stream_.state == STREAM_STOPPED) - goto unlock; + MUTEX_LOCK( &stream_.mutex ); + + DsHandle *handle = (DsHandle *) stream_.apiHandle; - int err; - char *buffer; - int channels; - AlsaHandle *apiInfo; - snd_pcm_t **handle; - RtAudioFormat format; - apiInfo = (AlsaHandle *) stream_.apiHandle; - handle = (snd_pcm_t **) apiInfo->handles; + timeBeginPeriod( 1 ); + + /* + memset( &statistics, 0, sizeof( statistics ) ); + statistics.sampleRate = stream_.sampleRate; + statistics.writeDeviceBufferLeadBytes = handle->dsPointerLeadTime[0]; + */ + + buffersRolling = false; + duplexPrerollBytes = 0; if ( stream_.mode == DUPLEX ) { - // In duplex mode, we need to make the snd_pcm_read call before - // the snd_pcm_write call in order to avoid under/over runs. So, - // copy the userData to our temporary buffer. - int bufferBytes; - bufferBytes = stream_.bufferSize * stream_.nUserChannels[0] * formatBytes(stream_.userFormat); - memcpy( apiInfo->tempBuffer, stream_.userBuffer, bufferBytes ); + // 0.5 seconds of silence in DUPLEX mode while the devices spin up and synchronize. + duplexPrerollBytes = (int) ( 0.5 * stream_.sampleRate * formatBytes( stream_.deviceFormat[1] ) * stream_.nDeviceChannels[1] ); } - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + HRESULT result; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + //statistics.outputFrameSize = formatBytes( stream_.deviceFormat[0] ) * stream_.nDeviceChannels[0]; - // Setup parameters. - if (stream_.doConvertBuffer[1]) { - buffer = stream_.deviceBuffer; - channels = stream_.nDeviceChannels[1]; - format = stream_.deviceFormat[1]; + LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0]; + result = buffer->Play( 0, 0, DSBPLAY_LOOPING ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::startStream: error (" << getErrorString( result ) << ") starting output buffer!"; + errorText_ = errorStream_.str(); + goto unlock; } - else { - buffer = stream_.userBuffer; - channels = stream_.nUserChannels[1]; - format = stream_.userFormat; + } + + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { + //statistics.inputFrameSize = formatBytes( stream_.deviceFormat[1]) * stream_.nDeviceChannels[1]; + + LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1]; + result = buffer->Start( DSCBSTART_LOOPING ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::startStream: error (" << getErrorString( result ) << ") starting input buffer!"; + errorText_ = errorStream_.str(); + goto unlock; } + } - // Read samples from device in interleaved/non-interleaved format. - if (stream_.deInterleave[1]) { - void *bufs[channels]; - size_t offset = stream_.bufferSize * formatBytes(format); - for (int i=0; idrainCounter = 0; + handle->internalDrain = false; + stream_.state = STREAM_RUNNING; + + unlock: + MUTEX_UNLOCK( &stream_.mutex ); + + if ( FAILED( result ) ) error( SYSTEM ); +} + +void RtApiDs :: stopStream() +{ + verifyStream(); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiDs::stopStream(): the stream is already stopped!"; + error( WARNING ); + return; + } + + MUTEX_LOCK( &stream_.mutex ); + + HRESULT result; + LPVOID audioPtr; + DWORD dataLen; + DsHandle *handle = (DsHandle *) stream_.apiHandle; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + if ( handle->drainCounter == 0 ) { + handle->drainCounter = 1; + MUTEX_UNLOCK( &stream_.mutex ); + WaitForMultipleObjects( 1, &handle->condition, FALSE, INFINITE ); // block until signaled + ResetEvent( handle->condition ); + MUTEX_LOCK( &stream_.mutex ); } - else - err = snd_pcm_readi(handle[1], buffer, stream_.bufferSize); - if (err < stream_.bufferSize) { - // Either an error or underrun occured. - if (err == -EPIPE) { - snd_pcm_state_t state = snd_pcm_state(handle[1]); - if (state == SND_PCM_STATE_XRUN) { - sprintf(message_, "RtApiAlsa: overrun detected."); - error(RtError::WARNING); - err = snd_pcm_prepare(handle[1]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error preparing handle after overrun: %s.", - snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - // Reprime output buffer if needed. - if ( (stream_.mode == DUPLEX) && ( !primeOutputBuffer() ) ) { - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - } - else { - sprintf(message_, "RtApiAlsa: tickStream() error, current state is %s.", - snd_pcm_state_name(state)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - goto unlock; - } - else { - sprintf(message_, "RtApiAlsa: audio read error for device (%s): %s.", - devices_[stream_.device[1]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } + // Stop the buffer and clear memory + LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0]; + result = buffer->Stop(); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::abortStream: error (" << getErrorString( result ) << ") stopping output buffer!"; + errorText_ = errorStream_.str(); + goto unlock; } - // Do byte swapping if necessary. - if (stream_.doByteSwap[1]) - byteSwapBuffer(buffer, stream_.bufferSize * channels, format); + // Lock the buffer and clear it so that if we start to play again, + // we won't have old data playing. + result = buffer->Lock( 0, handle->dsBufferSize[0], &audioPtr, &dataLen, NULL, NULL, 0 ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::abortStream: error (" << getErrorString( result ) << ") locking output buffer!"; + errorText_ = errorStream_.str(); + goto unlock; + } - // Do buffer conversion if necessary. - if (stream_.doConvertBuffer[1]) - convertBuffer( stream_.userBuffer, stream_.deviceBuffer, stream_.convertInfo[1] ); + // Zero the DS buffer + ZeroMemory( audioPtr, dataLen ); + + // Unlock the DS buffer + result = buffer->Unlock( audioPtr, dataLen, NULL, 0 ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::abortStream: error (" << getErrorString( result ) << ") unlocking output buffer!"; + errorText_ = errorStream_.str(); + goto unlock; + } + + // If we start playing again, we must begin at beginning of buffer. + handle->bufferPointer[0] = 0; } - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { + LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1]; + audioPtr = NULL; + dataLen = 0; - // Setup parameters and do buffer conversion if necessary. - if (stream_.doConvertBuffer[0]) { - buffer = stream_.deviceBuffer; - if ( stream_.mode == DUPLEX ) - convertBuffer( buffer, apiInfo->tempBuffer, stream_.convertInfo[0] ); - else - convertBuffer( buffer, stream_.userBuffer, stream_.convertInfo[0] ); - channels = stream_.nDeviceChannels[0]; - format = stream_.deviceFormat[0]; + result = buffer->Stop(); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::abortStream: error (" << getErrorString( result ) << ") stopping input buffer!"; + errorText_ = errorStream_.str(); + goto unlock; } - else { - if ( stream_.mode == DUPLEX ) - buffer = apiInfo->tempBuffer; - else - buffer = stream_.userBuffer; - channels = stream_.nUserChannels[0]; - format = stream_.userFormat; + + // Lock the buffer and clear it so that if we start to play again, + // we won't have old data playing. + result = buffer->Lock( 0, handle->dsBufferSize[1], &audioPtr, &dataLen, NULL, NULL, 0 ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::abortStream: error (" << getErrorString( result ) << ") locking input buffer!"; + errorText_ = errorStream_.str(); + goto unlock; } - // Do byte swapping if necessary. - if (stream_.doByteSwap[0]) - byteSwapBuffer(buffer, stream_.bufferSize * channels, format); + // Zero the DS buffer + ZeroMemory( audioPtr, dataLen ); - // Write samples to device in interleaved/non-interleaved format. - if (stream_.deInterleave[0]) { - void *bufs[channels]; - size_t offset = stream_.bufferSize * formatBytes(format); - for (int i=0; iUnlock( audioPtr, dataLen, NULL, 0 ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::abortStream: error (" << getErrorString( result ) << ") unlocking input buffer!"; + errorText_ = errorStream_.str(); + goto unlock; } - else - err = snd_pcm_writei(handle[0], buffer, stream_.bufferSize); - if (err < stream_.bufferSize) { - // Either an error or underrun occured. - if (err == -EPIPE) { - snd_pcm_state_t state = snd_pcm_state(handle[0]); - if (state == SND_PCM_STATE_XRUN) { - sprintf(message_, "RtApiAlsa: underrun detected."); - error(RtError::WARNING); - err = snd_pcm_prepare(handle[0]); - if (err < 0) { - sprintf(message_, "RtApiAlsa: error preparing handle after underrun: %s.", - snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - } - else { - sprintf(message_, "RtApiAlsa: tickStream() error, current state is %s.", - snd_pcm_state_name(state)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - goto unlock; - } - else { - sprintf(message_, "RtApiAlsa: audio write error for device (%s): %s.", - devices_[stream_.device[0]].name.c_str(), snd_strerror(err)); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - } + // If we start recording again, we must begin at beginning of buffer. + handle->bufferPointer[1] = 0; } unlock: - MUTEX_UNLOCK(&stream_.mutex); - - if (stream_.callbackInfo.usingCallback && stopStream) - this->stopStream(); + timeEndPeriod( 1 ); // revert to normal scheduler frequency on lesser windows. + stream_.state = STREAM_STOPPED; + MUTEX_UNLOCK( &stream_.mutex ); + if ( FAILED( result ) ) error( SYSTEM ); } -void RtApiAlsa :: setStreamCallback(RtAudioCallback callback, void *userData) +void RtApiDs :: abortStream() { verifyStream(); - - CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; - if ( info->usingCallback ) { - sprintf(message_, "RtApiAlsa: A callback is already set for this stream!"); - error(RtError::WARNING); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiDs::abortStream(): the stream is already stopped!"; + error( WARNING ); return; } - info->callback = (void *) callback; - info->userData = userData; - info->usingCallback = true; - info->object = (void *) this; - - // Set the thread attributes for joinable and realtime scheduling - // priority. The higher priority will only take affect if the - // program is run as root or suid. - pthread_attr_t attr; - pthread_attr_init(&attr); - pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); - pthread_attr_setschedpolicy(&attr, SCHED_RR); + DsHandle *handle = (DsHandle *) stream_.apiHandle; + handle->drainCounter = 1; - int err = pthread_create(&info->thread, &attr, alsaCallbackHandler, &stream_.callbackInfo); - pthread_attr_destroy(&attr); - if (err) { - info->usingCallback = false; - sprintf(message_, "RtApiAlsa: error starting callback thread!"); - error(RtError::THREAD_ERROR); - } + stopStream(); } -void RtApiAlsa :: cancelStreamCallback() +void RtApiDs :: callbackEvent() { - verifyStream(); + if ( stream_.state == STREAM_STOPPED ) { + Sleep(50); // sleep 50 milliseconds + return; + } + + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiDs::callbackEvent(): the stream is closed ... this shouldn't happen!"; + error( WARNING ); + return; + } - if (stream_.callbackInfo.usingCallback) { + CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; + DsHandle *handle = (DsHandle *) stream_.apiHandle; - if (stream_.state == STREAM_RUNNING) + // Check if we were draining the stream and signal is finished. + if ( handle->drainCounter > stream_.nBuffers + 2 ) { + if ( handle->internalDrain == false ) + SetEvent( handle->condition ); + else stopStream(); + return; + } - MUTEX_LOCK(&stream_.mutex); + MUTEX_LOCK( &stream_.mutex ); - stream_.callbackInfo.usingCallback = false; - pthread_join(stream_.callbackInfo.thread, NULL); - stream_.callbackInfo.thread = 0; - stream_.callbackInfo.callback = NULL; - stream_.callbackInfo.userData = NULL; - - MUTEX_UNLOCK(&stream_.mutex); - } -} - -extern "C" void *alsaCallbackHandler(void *ptr) -{ - CallbackInfo *info = (CallbackInfo *) ptr; - RtApiAlsa *object = (RtApiAlsa *) info->object; - bool *usingCallback = &info->usingCallback; - - while ( *usingCallback ) { - try { - object->tickStream(); - } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiAlsa: callback thread error (%s) ... closing thread.\n\n", - exception.getMessageString()); - break; - } - } - - pthread_exit(NULL); -} - -//******************** End of __LINUX_ALSA__ *********************// -#endif - -#if defined(__WINDOWS_ASIO__) // ASIO API on Windows - -// The ASIO API is designed around a callback scheme, so this -// implementation is similar to that used for OS-X CoreAudio and Linux -// Jack. The primary constraint with ASIO is that it only allows -// access to a single driver at a time. Thus, it is not possible to -// have more than one simultaneous RtAudio stream. -// -// This implementation also requires a number of external ASIO files -// and a few global variables. The ASIO callback scheme does not -// allow for the passing of user data, so we must create a global -// pointer to our callbackInfo structure. -// -// On unix systems, we make use of a pthread condition variable. -// Since there is no equivalent in Windows, I hacked something based -// on information found in -// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html. - -#include "asio/asiosys.h" -#include "asio/asio.h" -#include "asio/iasiothiscallresolver.h" -#include "asio/asiodrivers.h" -#include - -AsioDrivers drivers; -ASIOCallbacks asioCallbacks; -ASIODriverInfo driverInfo; -CallbackInfo *asioCallbackInfo; - -struct AsioHandle { - bool stopStream; - ASIOBufferInfo *bufferInfos; - HANDLE condition; - - AsioHandle() - :stopStream(false), bufferInfos(0) {} -}; - -static const char* GetAsioErrorString( ASIOError result ) -{ - struct Messages - { - ASIOError value; - const char*message; - }; - static Messages m[] = - { - { ASE_NotPresent, "Hardware input or output is not present or available." }, - { ASE_HWMalfunction, "Hardware is malfunctioning." }, - { ASE_InvalidParameter, "Invalid input parameter." }, - { ASE_InvalidMode, "Invalid mode." }, - { ASE_SPNotAdvancing, "Sample position not advancing." }, - { ASE_NoClock, "Sample clock or rate cannot be determined or is not present." }, - { ASE_NoMemory, "Not enough memory to complete the request." } - }; - - for (unsigned int i = 0; i < sizeof(m)/sizeof(m[0]); ++i) - if (m[i].value == result) return m[i].message; - - return "Unknown error."; -} - -RtApiAsio :: RtApiAsio() -{ - this->coInitialized = false; - this->initialize(); - - if (nDevices_ <= 0) { - sprintf(message_, "RtApiAsio: no Windows ASIO audio drivers found!"); - error(RtError::NO_DEVICES_FOUND); - } -} - -RtApiAsio :: ~RtApiAsio() -{ - if ( stream_.mode != UNINITIALIZED ) closeStream(); - - if ( coInitialized ) - CoUninitialize(); -} - -void RtApiAsio :: initialize(void) -{ - - // ASIO cannot run on a multi-threaded appartment. You can call CoInitialize beforehand, but it must be - // for appartment threading (in which case, CoInitilialize will return S_FALSE here). - coInitialized = false; - HRESULT hr = CoInitialize(NULL); - if ( FAILED(hr) ) { - sprintf(message_,"RtApiAsio: ASIO requires a single-threaded appartment. Call CoInitializeEx(0,COINIT_APARTMENTTHREADED)"); - } - coInitialized = true; - - nDevices_ = drivers.asioGetNumDev(); - if (nDevices_ <= 0) return; - - // Create device structures and write device driver names to each. - RtApiDevice device; - char name[128]; - for (int i=0; iname.c_str() ) ) { - sprintf(message_, "RtApiAsio: error loading driver (%s).", info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } - - ASIOError result = ASIOInit( &driverInfo ); - if ( result != ASE_OK ) { - sprintf(message_, "RtApiAsio: error (%s) initializing driver (%s).", - GetAsioErrorString(result), info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } - - // Determine the device channel information. - long inputChannels, outputChannels; - result = ASIOGetChannels( &inputChannels, &outputChannels ); - if ( result != ASE_OK ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: error (%s) getting input/output channel count (%s).", - GetAsioErrorString(result), - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } - - info->maxOutputChannels = outputChannels; - if ( outputChannels > 0 ) info->minOutputChannels = 1; - - info->maxInputChannels = inputChannels; - if ( inputChannels > 0 ) info->minInputChannels = 1; - - // If device opens for both playback and capture, we determine the channels. - if (info->maxOutputChannels > 0 && info->maxInputChannels > 0) { - info->hasDuplexSupport = true; - info->maxDuplexChannels = (info->maxOutputChannels > info->maxInputChannels) ? - info->maxInputChannels : info->maxOutputChannels; - info->minDuplexChannels = (info->minOutputChannels > info->minInputChannels) ? - info->minInputChannels : info->minOutputChannels; - } - - // Determine the supported sample rates. - info->sampleRates.clear(); - for (unsigned int i=0; isampleRates.push_back( SAMPLE_RATES[i] ); - } - - if (info->sampleRates.size() == 0) { - drivers.removeCurrentDriver(); - sprintf( message_, "RtApiAsio: No supported sample rates found for driver (%s).", info->name.c_str() ); - error(RtError::DEBUG_WARNING); - return; - } - - // Determine supported data types ... just check first channel and assume rest are the same. - ASIOChannelInfo channelInfo; - channelInfo.channel = 0; - channelInfo.isInput = true; - if ( info->maxInputChannels <= 0 ) channelInfo.isInput = false; - result = ASIOGetChannelInfo( &channelInfo ); - if ( result != ASE_OK ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: error (%s) getting driver (%s) channel information.", - GetAsioErrorString(result), - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } - - if ( channelInfo.type == ASIOSTInt16MSB || channelInfo.type == ASIOSTInt16LSB ) - info->nativeFormats |= RTAUDIO_SINT16; - else if ( channelInfo.type == ASIOSTInt32MSB || channelInfo.type == ASIOSTInt32LSB ) - info->nativeFormats |= RTAUDIO_SINT32; - else if ( channelInfo.type == ASIOSTFloat32MSB || channelInfo.type == ASIOSTFloat32LSB ) - info->nativeFormats |= RTAUDIO_FLOAT32; - else if ( channelInfo.type == ASIOSTFloat64MSB || channelInfo.type == ASIOSTFloat64LSB ) - info->nativeFormats |= RTAUDIO_FLOAT64; - - // Check that we have at least one supported format. - if (info->nativeFormats == 0) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: driver (%s) data format not supported by RtAudio.", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } - - info->probed = true; - drivers.removeCurrentDriver(); -} - -void bufferSwitch(long index, ASIOBool processNow) -{ - RtApiAsio *object = (RtApiAsio *) asioCallbackInfo->object; - try { - object->callbackEvent( index ); - } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiAsio: callback handler error (%s)!\n\n", exception.getMessageString()); - return; - } - - return; -} - -void sampleRateChanged(ASIOSampleRate sRate) -{ - // The ASIO documentation says that this usually only happens during - // external sync. Audio processing is not stopped by the driver, - // actual sample rate might not have even changed, maybe only the - // sample rate status of an AES/EBU or S/PDIF digital input at the - // audio device. - - RtAudio *object = (RtAudio *) asioCallbackInfo->object; - try { - object->stopStream(); - } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiAsio: sampleRateChanged() error (%s)!\n\n", exception.getMessageString()); - return; - } - - fprintf(stderr, "\nRtApiAsio: driver reports sample rate changed to %d ... stream stopped!!!", (int) sRate); -} - -long asioMessages(long selector, long value, void* message, double* opt) -{ - long ret = 0; - switch(selector) { - case kAsioSelectorSupported: - if(value == kAsioResetRequest - || value == kAsioEngineVersion - || value == kAsioResyncRequest - || value == kAsioLatenciesChanged - // The following three were added for ASIO 2.0, you don't - // necessarily have to support them. - || value == kAsioSupportsTimeInfo - || value == kAsioSupportsTimeCode - || value == kAsioSupportsInputMonitor) - ret = 1L; - break; - case kAsioResetRequest: - // Defer the task and perform the reset of the driver during the - // next "safe" situation. You cannot reset the driver right now, - // as this code is called from the driver. Reset the driver is - // done by completely destruct is. I.e. ASIOStop(), - // ASIODisposeBuffers(), Destruction Afterwards you initialize the - // driver again. - fprintf(stderr, "\nRtApiAsio: driver reset requested!!!"); - ret = 1L; - break; - case kAsioResyncRequest: - // This informs the application that the driver encountered some - // non-fatal data loss. It is used for synchronization purposes - // of different media. Added mainly to work around the Win16Mutex - // problems in Windows 95/98 with the Windows Multimedia system, - // which could lose data because the Mutex was held too long by - // another thread. However a driver can issue it in other - // situations, too. - fprintf(stderr, "\nRtApiAsio: driver resync requested!!!"); - ret = 1L; - break; - case kAsioLatenciesChanged: - // This will inform the host application that the drivers were - // latencies changed. Beware, it this does not mean that the - // buffer sizes have changed! You might need to update internal - // delay data. - fprintf(stderr, "\nRtApiAsio: driver latency may have changed!!!"); - ret = 1L; - break; - case kAsioEngineVersion: - // Return the supported ASIO version of the host application. If - // a host application does not implement this selector, ASIO 1.0 - // is assumed by the driver. - ret = 2L; - break; - case kAsioSupportsTimeInfo: - // Informs the driver whether the - // asioCallbacks.bufferSwitchTimeInfo() callback is supported. - // For compatibility with ASIO 1.0 drivers the host application - // should always support the "old" bufferSwitch method, too. - ret = 0; - break; - case kAsioSupportsTimeCode: - // Informs the driver wether application is interested in time - // code info. If an application does not need to know about time - // code, the driver has less work to do. - ret = 0; - break; - } - return ret; -} - -bool RtApiAsio :: probeDeviceOpen(int device, StreamMode mode, int channels, - int sampleRate, RtAudioFormat format, - int *bufferSize, int numberOfBuffers) -{ - // For ASIO, a duplex stream MUST use the same driver. - if ( mode == INPUT && stream_.mode == OUTPUT && stream_.device[0] != device ) { - sprintf(message_, "RtApiAsio: duplex stream must use the same device for input and output."); - error(RtError::WARNING); - return FAILURE; - } - - // Only load the driver once for duplex stream. - ASIOError result; - if ( mode != INPUT || stream_.mode != OUTPUT ) { - if ( !drivers.loadDriver( (char *)devices_[device].name.c_str() ) ) { - sprintf(message_, "RtApiAsio: error loading driver (%s).", - devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - result = ASIOInit( &driverInfo ); - if ( result != ASE_OK ) { - sprintf(message_, "RtApiAsio: error (%s) initializing driver (%s).", - GetAsioErrorString(result), devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - } - - // Check the device channel count. - long inputChannels, outputChannels; - result = ASIOGetChannels( &inputChannels, &outputChannels ); - if ( result != ASE_OK ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: error (%s) getting input/output channel count (%s).", - GetAsioErrorString(result), - devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - if ( ( mode == OUTPUT && channels > outputChannels) || - ( mode == INPUT && channels > inputChannels) ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: driver (%s) does not support requested channel count (%d).", - devices_[device].name.c_str(), channels); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - stream_.nDeviceChannels[mode] = channels; - stream_.nUserChannels[mode] = channels; - - // Verify the sample rate is supported. - result = ASIOCanSampleRate( (ASIOSampleRate) sampleRate ); - if ( result != ASE_OK ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: driver (%s) does not support requested sample rate (%d).", - devices_[device].name.c_str(), sampleRate); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - // Set the sample rate. - result = ASIOSetSampleRate( (ASIOSampleRate) sampleRate ); - if ( result != ASE_OK ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: driver (%s) error setting sample rate (%d).", - devices_[device].name.c_str(), sampleRate); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - // Determine the driver data type. - ASIOChannelInfo channelInfo; - channelInfo.channel = 0; - if ( mode == OUTPUT ) channelInfo.isInput = false; - else channelInfo.isInput = true; - result = ASIOGetChannelInfo( &channelInfo ); - if ( result != ASE_OK ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: driver (%s) error getting data format.", - devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - // Assuming WINDOWS host is always little-endian. - stream_.doByteSwap[mode] = false; - stream_.userFormat = format; - stream_.deviceFormat[mode] = 0; - if ( channelInfo.type == ASIOSTInt16MSB || channelInfo.type == ASIOSTInt16LSB ) { - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - if ( channelInfo.type == ASIOSTInt16MSB ) stream_.doByteSwap[mode] = true; - } - else if ( channelInfo.type == ASIOSTInt32MSB || channelInfo.type == ASIOSTInt32LSB ) { - stream_.deviceFormat[mode] = RTAUDIO_SINT32; - if ( channelInfo.type == ASIOSTInt32MSB ) stream_.doByteSwap[mode] = true; - } - else if ( channelInfo.type == ASIOSTFloat32MSB || channelInfo.type == ASIOSTFloat32LSB ) { - stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; - if ( channelInfo.type == ASIOSTFloat32MSB ) stream_.doByteSwap[mode] = true; - } - else if ( channelInfo.type == ASIOSTFloat64MSB || channelInfo.type == ASIOSTFloat64LSB ) { - stream_.deviceFormat[mode] = RTAUDIO_FLOAT64; - if ( channelInfo.type == ASIOSTFloat64MSB ) stream_.doByteSwap[mode] = true; - } - - if ( stream_.deviceFormat[mode] == 0 ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: driver (%s) data format not supported by RtAudio.", - devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - // Set the buffer size. For a duplex stream, this will end up - // setting the buffer size based on the input constraints, which - // should be ok. - long minSize, maxSize, preferSize, granularity; - result = ASIOGetBufferSize( &minSize, &maxSize, &preferSize, &granularity ); - if ( result != ASE_OK ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: error (%s) on driver (%s) error getting buffer size.", - GetAsioErrorString(result), - devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - if ( *bufferSize < minSize ) *bufferSize = minSize; - else if ( *bufferSize > maxSize ) *bufferSize = maxSize; - else if ( granularity == -1 ) { - // Make sure bufferSize is a power of two. - double power = log10( (double) *bufferSize ) / log10( 2.0 ); - *bufferSize = (int) pow( 2.0, floor(power+0.5) ); - if ( *bufferSize < minSize ) *bufferSize = minSize; - else if ( *bufferSize > maxSize ) *bufferSize = maxSize; - else *bufferSize = preferSize; - } else if (granularity != 0) - { - // to an even multiple of granularity, rounding up. - *bufferSize = (*bufferSize + granularity-1)/granularity*granularity; - } - - - - if ( mode == INPUT && stream_.mode == OUTPUT && stream_.bufferSize != *bufferSize ) - std::cerr << "Possible input/output buffersize discrepancy!" << std::endl; - - stream_.bufferSize = *bufferSize; - stream_.nBuffers = 2; - - // ASIO always uses deinterleaved channels. - stream_.deInterleave[mode] = true; - - // Allocate, if necessary, our AsioHandle structure for the stream. - AsioHandle *handle = (AsioHandle *) stream_.apiHandle; - if ( handle == 0 ) { - handle = (AsioHandle *) calloc(1, sizeof(AsioHandle)); - if ( handle == NULL ) { - drivers.removeCurrentDriver(); - sprintf(message_, "RtApiAsio: error allocating AsioHandle memory (%s).", - devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - handle->bufferInfos = 0; - // Create a manual-reset event. - handle->condition = CreateEvent( NULL, // no security - TRUE, // manual-reset - FALSE, // non-signaled initially - NULL ); // unnamed - stream_.apiHandle = (void *) handle; - } - - // Create the ASIO internal buffers. Since RtAudio sets up input - // and output separately, we'll have to dispose of previously - // created output buffers for a duplex stream. - if ( mode == INPUT && stream_.mode == OUTPUT ) { - ASIODisposeBuffers(); - if ( handle->bufferInfos ) free( handle->bufferInfos ); - } - - // Allocate, initialize, and save the bufferInfos in our stream callbackInfo structure. - int i, nChannels = stream_.nDeviceChannels[0] + stream_.nDeviceChannels[1]; - handle->bufferInfos = (ASIOBufferInfo *) malloc( nChannels * sizeof(ASIOBufferInfo) ); - if (handle->bufferInfos == NULL) { - sprintf(message_, "RtApiAsio: error allocating bufferInfo memory (%s).", - devices_[device].name.c_str()); - goto error; - } - ASIOBufferInfo *infos; - infos = handle->bufferInfos; - for ( i=0; iisInput = ASIOFalse; - infos->channelNum = i; - infos->buffers[0] = infos->buffers[1] = 0; - } - for ( i=0; iisInput = ASIOTrue; - infos->channelNum = i; - infos->buffers[0] = infos->buffers[1] = 0; - } - - // Set up the ASIO callback structure and create the ASIO data buffers. - asioCallbacks.bufferSwitch = &bufferSwitch; - asioCallbacks.sampleRateDidChange = &sampleRateChanged; - asioCallbacks.asioMessage = &asioMessages; - asioCallbacks.bufferSwitchTimeInfo = NULL; - result = ASIOCreateBuffers( handle->bufferInfos, nChannels, stream_.bufferSize, &asioCallbacks); - if ( result != ASE_OK ) { - sprintf(message_, "RtApiAsio: eror (%s) on driver (%s) error creating buffers.", - GetAsioErrorString(result), - devices_[device].name.c_str()); - goto error; - } - - // Set flags for buffer conversion. - stream_.doConvertBuffer[mode] = false; - if (stream_.userFormat != stream_.deviceFormat[mode]) - stream_.doConvertBuffer[mode] = true; - if (stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode]) - stream_.doConvertBuffer[mode] = true; - if (stream_.nUserChannels[mode] > 1 && stream_.deInterleave[mode]) - stream_.doConvertBuffer[mode] = true; - - // Allocate necessary internal buffers - if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { - - long buffer_bytes; - if (stream_.nUserChannels[0] >= stream_.nUserChannels[1]) - buffer_bytes = stream_.nUserChannels[0]; - else - buffer_bytes = stream_.nUserChannels[1]; - - buffer_bytes *= *bufferSize * formatBytes(stream_.userFormat); - if (stream_.userBuffer) free(stream_.userBuffer); - stream_.userBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.userBuffer == NULL) { - sprintf(message_, "RtApiAsio: error (%s) allocating user buffer memory (%s).", - GetAsioErrorString(result), - devices_[device].name.c_str()); - goto error; - } - } - - if ( stream_.doConvertBuffer[mode] ) { - - long buffer_bytes; - bool makeBuffer = true; - if ( mode == OUTPUT ) - buffer_bytes = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - else { // mode == INPUT - buffer_bytes = stream_.nDeviceChannels[1] * formatBytes(stream_.deviceFormat[1]); - if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { - long bytes_out = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - if ( buffer_bytes < bytes_out ) makeBuffer = false; - } - } - - if ( makeBuffer ) { - buffer_bytes *= *bufferSize; - if (stream_.deviceBuffer) free(stream_.deviceBuffer); - stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.deviceBuffer == NULL) { - sprintf(message_, "RtApiAsio: error (%s) allocating device buffer memory (%s).", - GetAsioErrorString(result), - devices_[device].name.c_str()); - goto error; - } - } - } - - stream_.device[mode] = device; - stream_.state = STREAM_STOPPED; - if ( stream_.mode == OUTPUT && mode == INPUT ) - // We had already set up an output stream. - stream_.mode = DUPLEX; - else - stream_.mode = mode; - stream_.sampleRate = sampleRate; - asioCallbackInfo = &stream_.callbackInfo; - stream_.callbackInfo.object = (void *) this; - - // Setup the buffer conversion information structure. - if ( stream_.doConvertBuffer[mode] ) { - if (mode == INPUT) { // convert device to user buffer - stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1]; - stream_.convertInfo[mode].outJump = stream_.nUserChannels[1]; - stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1]; - stream_.convertInfo[mode].outFormat = stream_.userFormat; - } - else { // convert user to device buffer - stream_.convertInfo[mode].inJump = stream_.nUserChannels[0]; - stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0]; - stream_.convertInfo[mode].inFormat = stream_.userFormat; - stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0]; - } - - if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump ) - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump; - else - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump; - - // Set up the interleave/deinterleave offsets. - if ( mode == INPUT && stream_.deInterleave[1] ) { - for (int k=0; kcondition ); - if ( handle->bufferInfos ) - free( handle->bufferInfos ); - free( handle ); - stream_.apiHandle = 0; - } - - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; - } - - error(RtError::DEBUG_WARNING); - return FAILURE; -} - -void RtApiAsio :: closeStream() -{ - // We don't want an exception to be thrown here because this - // function is called by our class destructor. So, do our own - // streamId check. - if ( stream_.mode == UNINITIALIZED ) { - sprintf(message_, "RtApiAsio::closeStream(): no open stream to close!"); - error(RtError::WARNING); - return; - } - - if (stream_.state == STREAM_RUNNING) - ASIOStop(); - - ASIODisposeBuffers(); - drivers.removeCurrentDriver(); - - AsioHandle *handle = (AsioHandle *) stream_.apiHandle; - if ( handle ) { - CloseHandle( handle->condition ); - if ( handle->bufferInfos ) - free( handle->bufferInfos ); - free( handle ); - stream_.apiHandle = 0; - } - - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; - } - - if (stream_.deviceBuffer) { - free(stream_.deviceBuffer); - stream_.deviceBuffer = 0; - } - - stream_.mode = UNINITIALIZED; -} - -void RtApiAsio :: setStreamCallback(RtAudioCallback callback, void *userData) -{ - verifyStream(); - - if ( stream_.callbackInfo.usingCallback ) { - sprintf(message_, "RtApiAsio: A callback is already set for this stream!"); - error(RtError::WARNING); - return; - } - - stream_.callbackInfo.callback = (void *) callback; - stream_.callbackInfo.userData = userData; - stream_.callbackInfo.usingCallback = true; -} - -void RtApiAsio :: cancelStreamCallback() -{ - verifyStream(); - - if (stream_.callbackInfo.usingCallback) { - - if (stream_.state == STREAM_RUNNING) - stopStream(); - - MUTEX_LOCK(&stream_.mutex); - - stream_.callbackInfo.usingCallback = false; - stream_.callbackInfo.userData = NULL; - stream_.state = STREAM_STOPPED; - stream_.callbackInfo.callback = NULL; - - MUTEX_UNLOCK(&stream_.mutex); - } -} - -void RtApiAsio :: startStream() -{ - verifyStream(); - if (stream_.state == STREAM_RUNNING) return; - - MUTEX_LOCK(&stream_.mutex); - - ASIOError result = ASIOStart(); - if ( result != ASE_OK ) { - sprintf(message_, "RtApiAsio: error starting device (%s).", - devices_[stream_.device[0]].name.c_str()); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - AsioHandle *handle = (AsioHandle *) stream_.apiHandle; - handle->stopStream = false; - stream_.state = STREAM_RUNNING; - - MUTEX_UNLOCK(&stream_.mutex); -} - -void RtApiAsio :: stopStream() -{ - verifyStream(); - if (stream_.state == STREAM_STOPPED) return; - - // Change the state before the lock to improve shutdown response - // when using a callback. - stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); - - ASIOError result = ASIOStop(); - if ( result != ASE_OK ) { - sprintf(message_, "RtApiAsio: error stopping device (%s).", - devices_[stream_.device[0]].name.c_str()); - MUTEX_UNLOCK(&stream_.mutex); - error(RtError::DRIVER_ERROR); - } - - MUTEX_UNLOCK(&stream_.mutex); -} - -void RtApiAsio :: abortStream() -{ - stopStream(); -} - -void RtApiAsio :: tickStream() -{ - verifyStream(); - - if (stream_.state == STREAM_STOPPED) - return; - - if (stream_.callbackInfo.usingCallback) { - sprintf(message_, "RtApiAsio: tickStream() should not be used when a callback function is set!"); - error(RtError::WARNING); - return; - } - - AsioHandle *handle = (AsioHandle *) stream_.apiHandle; - - MUTEX_LOCK(&stream_.mutex); - - // Release the stream_mutex here and wait for the event - // to become signaled by the callback process. - MUTEX_UNLOCK(&stream_.mutex); - WaitForMultipleObjects(1, &handle->condition, FALSE, INFINITE); - ResetEvent( handle->condition ); -} - -void RtApiAsio :: callbackEvent(long bufferIndex) -{ - verifyStream(); - - if (stream_.state == STREAM_STOPPED) return; - - CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; - AsioHandle *handle = (AsioHandle *) stream_.apiHandle; - if ( info->usingCallback && handle->stopStream ) { - // Check if the stream should be stopped (via the previous user - // callback return value). We stop the stream here, rather than - // after the function call, so that output data can first be - // processed. - this->stopStream(); - return; - } - - MUTEX_LOCK(&stream_.mutex); - - // Invoke user callback first, to get fresh output data. - if ( info->usingCallback ) { - RtAudioCallback callback = (RtAudioCallback) info->callback; - if ( callback(stream_.userBuffer, stream_.bufferSize, info->userData) ) - handle->stopStream = true; - } - - int bufferBytes, j; - int nChannels = stream_.nDeviceChannels[0] + stream_.nDeviceChannels[1]; - if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - - bufferBytes = stream_.bufferSize * formatBytes(stream_.deviceFormat[0]); - if (stream_.doConvertBuffer[0]) { - - convertBuffer( stream_.deviceBuffer, stream_.userBuffer, stream_.convertInfo[0] ); - if ( stream_.doByteSwap[0] ) - byteSwapBuffer(stream_.deviceBuffer, - stream_.bufferSize * stream_.nDeviceChannels[0], - stream_.deviceFormat[0]); - - // Always de-interleave ASIO output data. - j = 0; - for ( int i=0; ibufferInfos[i].isInput != ASIOTrue ) - memcpy(handle->bufferInfos[i].buffers[bufferIndex], - &stream_.deviceBuffer[j++*bufferBytes], bufferBytes ); - } - } - else { // single channel only - - if (stream_.doByteSwap[0]) - byteSwapBuffer(stream_.userBuffer, - stream_.bufferSize * stream_.nUserChannels[0], - stream_.userFormat); - - for ( int i=0; ibufferInfos[i].isInput != ASIOTrue ) { - memcpy(handle->bufferInfos[i].buffers[bufferIndex], stream_.userBuffer, bufferBytes ); - break; - } - } - } - } - - if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { - - bufferBytes = stream_.bufferSize * formatBytes(stream_.deviceFormat[1]); - if (stream_.doConvertBuffer[1]) { - - // Always interleave ASIO input data. - j = 0; - for ( int i=0; ibufferInfos[i].isInput == ASIOTrue ) - memcpy(&stream_.deviceBuffer[j++*bufferBytes], - handle->bufferInfos[i].buffers[bufferIndex], - bufferBytes ); - } - - if ( stream_.doByteSwap[1] ) - byteSwapBuffer(stream_.deviceBuffer, - stream_.bufferSize * stream_.nDeviceChannels[1], - stream_.deviceFormat[1]); - convertBuffer( stream_.userBuffer, stream_.deviceBuffer, stream_.convertInfo[1] ); - - } - else { // single channel only - for ( int i=0; ibufferInfos[i].isInput == ASIOTrue ) { - memcpy(stream_.userBuffer, - handle->bufferInfos[i].buffers[bufferIndex], - bufferBytes ); - break; - } - } - - if (stream_.doByteSwap[1]) - byteSwapBuffer(stream_.userBuffer, - stream_.bufferSize * stream_.nUserChannels[1], - stream_.userFormat); - } - } - - if ( !info->usingCallback ) - SetEvent( handle->condition ); - - // The following call was suggested by Malte Clasen. While the API - // documentation indicates it should not be required, some device - // drivers apparently do not function correctly without it. - ASIOOutputReady(); - - MUTEX_UNLOCK(&stream_.mutex); -} - -//******************** End of __WINDOWS_ASIO__ *********************// -#endif - -#if defined(__WINDOWS_DS__) // Windows DirectSound API - - -#include -#include - -#define MINIMUM_DEVICE_BUFFER_SIZE 32768 - - -#ifdef _MSC_VER // if Microsoft Visual C++ -#pragma comment(lib,"winmm.lib") // then, auto-link winmm.lib. Otherwise, it has to be added manually. -#endif - - -static inline DWORD dsPointerDifference(DWORD laterPointer,DWORD earlierPointer,DWORD bufferSize) -{ - if (laterPointer > earlierPointer) - return laterPointer-earlierPointer; - else - return laterPointer-earlierPointer+bufferSize; -} - -static inline DWORD dsPointerBetween(DWORD pointer, DWORD laterPointer,DWORD earlierPointer, DWORD bufferSize) -{ - if (pointer > bufferSize) pointer -= bufferSize; - - if (laterPointer < earlierPointer) - laterPointer += bufferSize; - - if (pointer < earlierPointer) - pointer += bufferSize; - - return pointer >= earlierPointer && pointer < laterPointer; -} - -#undef GENERATE_DEBUG_LOG // Define this to generate a debug timing log file in c:/rtaudiolog.txt" -#ifdef GENERATE_DEBUG_LOG - -#include "mmsystem.h" -#include "fstream" - -struct TTickRecord -{ - DWORD currentReadPointer, safeReadPointer; - DWORD currentWritePointer, safeWritePointer; - DWORD readTime, writeTime; - DWORD nextWritePointer, nextReadPointer; -}; - -int currentDebugLogEntry = 0; -std::vector debugLog(2000); - - -#endif - -// A structure to hold various information related to the DirectSound -// API implementation. -struct DsHandle { - void *object; - void *buffer; - UINT bufferPointer; - DWORD dsBufferSize; - DWORD dsPointerLeadTime; // the number of bytes ahead of the safe pointer to lead by. -}; - - -RtApiDs::RtDsStatistics RtApiDs::statistics; - -// Provides a backdoor hook to monitor for DirectSound read overruns and write underruns. -RtApiDs::RtDsStatistics RtApiDs::getDsStatistics() -{ - RtDsStatistics s = statistics; - // update the calculated fields. - - - if (s.inputFrameSize != 0) - s.latency += s.readDeviceSafeLeadBytes*1.0/s.inputFrameSize / s.sampleRate; - - if (s.outputFrameSize != 0) - s.latency += (s.writeDeviceSafeLeadBytes+ s.writeDeviceBufferLeadBytes)*1.0/s.outputFrameSize / s.sampleRate; - - return s; -} - -// Declarations for utility functions, callbacks, and structures -// specific to the DirectSound implementation. -static bool CALLBACK deviceCountCallback(LPGUID lpguid, - LPCTSTR description, - LPCTSTR module, - LPVOID lpContext); - -static bool CALLBACK deviceInfoCallback(LPGUID lpguid, - LPCTSTR description, - LPCTSTR module, - LPVOID lpContext); - -static bool CALLBACK defaultDeviceCallback(LPGUID lpguid, - LPCTSTR description, - LPCTSTR module, - LPVOID lpContext); - -static bool CALLBACK deviceIdCallback(LPGUID lpguid, - LPCTSTR description, - LPCTSTR module, - LPVOID lpContext); - -static char* getErrorString(int code); - -extern "C" unsigned __stdcall callbackHandler(void *ptr); - -struct enum_info { - std::string name; - LPGUID id; - bool isInput; - bool isValid; -}; - -RtApiDs :: RtApiDs() -{ - // Dsound will run both-threaded. If CoInitialize fails, then just - // accept whatever the mainline chose for a threading model. - coInitialized = false; - HRESULT hr = CoInitialize(NULL); - if ( !FAILED(hr) ) - coInitialized = true; - - this->initialize(); - - if (nDevices_ <= 0) { - sprintf(message_, "RtApiDs: no Windows DirectSound audio devices found!"); - error(RtError::NO_DEVICES_FOUND); - } -} - -RtApiDs :: ~RtApiDs() -{ - if (coInitialized) - CoUninitialize(); // balanced call. - - if ( stream_.mode != UNINITIALIZED ) closeStream(); -} - -int RtApiDs :: getDefaultInputDevice(void) -{ - enum_info info; - - // Enumerate through devices to find the default output. - HRESULT result = DirectSoundCaptureEnumerate((LPDSENUMCALLBACK)defaultDeviceCallback, &info); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Error performing default input device enumeration: %s.", - getErrorString(result)); - error(RtError::WARNING); - return 0; - } - - for ( int i=0; i info(count); - for (i=0; iname; - dsinfo.isValid = false; - - // Enumerate through input devices to find the id (if it exists). - HRESULT result = DirectSoundCaptureEnumerate((LPDSENUMCALLBACK)deviceIdCallback, &dsinfo); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Error performing input device id enumeration: %s.", - getErrorString(result)); - error(RtError::DEBUG_WARNING); - return; - } - - // Do capture probe first. - if ( dsinfo.isValid == false ) - goto playback_probe; - - LPDIRECTSOUNDCAPTURE input; - result = DirectSoundCaptureCreate( dsinfo.id, &input, NULL ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Could not create capture object (%s): %s.", - info->name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - goto playback_probe; - } - - DSCCAPS in_caps; - in_caps.dwSize = sizeof(in_caps); - result = input->GetCaps( &in_caps ); - if ( FAILED(result) ) { - input->Release(); - sprintf(message_, "RtApiDs: Could not get capture capabilities (%s): %s.", - info->name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - goto playback_probe; - } - - // Get input channel information. - info->minInputChannels = 1; - info->maxInputChannels = in_caps.dwChannels; - - // Get sample rate and format information. - info->sampleRates.clear(); - if( in_caps.dwChannels == 2 ) { - if( in_caps.dwFormats & WAVE_FORMAT_1S16 ) info->nativeFormats |= RTAUDIO_SINT16; - if( in_caps.dwFormats & WAVE_FORMAT_2S16 ) info->nativeFormats |= RTAUDIO_SINT16; - if( in_caps.dwFormats & WAVE_FORMAT_4S16 ) info->nativeFormats |= RTAUDIO_SINT16; - if( in_caps.dwFormats & WAVE_FORMAT_1S08 ) info->nativeFormats |= RTAUDIO_SINT8; - if( in_caps.dwFormats & WAVE_FORMAT_2S08 ) info->nativeFormats |= RTAUDIO_SINT8; - if( in_caps.dwFormats & WAVE_FORMAT_4S08 ) info->nativeFormats |= RTAUDIO_SINT8; - - if ( info->nativeFormats & RTAUDIO_SINT16 ) { - if( in_caps.dwFormats & WAVE_FORMAT_1S16 ) info->sampleRates.push_back( 11025 ); - if( in_caps.dwFormats & WAVE_FORMAT_2S16 ) info->sampleRates.push_back( 22050 ); - if( in_caps.dwFormats & WAVE_FORMAT_4S16 ) info->sampleRates.push_back( 44100 ); - } - else if ( info->nativeFormats & RTAUDIO_SINT8 ) { - if( in_caps.dwFormats & WAVE_FORMAT_1S08 ) info->sampleRates.push_back( 11025 ); - if( in_caps.dwFormats & WAVE_FORMAT_2S08 ) info->sampleRates.push_back( 22050 ); - if( in_caps.dwFormats & WAVE_FORMAT_4S08 ) info->sampleRates.push_back( 44100 ); - } - } - else if ( in_caps.dwChannels == 1 ) { - if( in_caps.dwFormats & WAVE_FORMAT_1M16 ) info->nativeFormats |= RTAUDIO_SINT16; - if( in_caps.dwFormats & WAVE_FORMAT_2M16 ) info->nativeFormats |= RTAUDIO_SINT16; - if( in_caps.dwFormats & WAVE_FORMAT_4M16 ) info->nativeFormats |= RTAUDIO_SINT16; - if( in_caps.dwFormats & WAVE_FORMAT_1M08 ) info->nativeFormats |= RTAUDIO_SINT8; - if( in_caps.dwFormats & WAVE_FORMAT_2M08 ) info->nativeFormats |= RTAUDIO_SINT8; - if( in_caps.dwFormats & WAVE_FORMAT_4M08 ) info->nativeFormats |= RTAUDIO_SINT8; - - if ( info->nativeFormats & RTAUDIO_SINT16 ) { - if( in_caps.dwFormats & WAVE_FORMAT_1M16 ) info->sampleRates.push_back( 11025 ); - if( in_caps.dwFormats & WAVE_FORMAT_2M16 ) info->sampleRates.push_back( 22050 ); - if( in_caps.dwFormats & WAVE_FORMAT_4M16 ) info->sampleRates.push_back( 44100 ); - } - else if ( info->nativeFormats & RTAUDIO_SINT8 ) { - if( in_caps.dwFormats & WAVE_FORMAT_1M08 ) info->sampleRates.push_back( 11025 ); - if( in_caps.dwFormats & WAVE_FORMAT_2M08 ) info->sampleRates.push_back( 22050 ); - if( in_caps.dwFormats & WAVE_FORMAT_4M08 ) info->sampleRates.push_back( 44100 ); - } - } - else info->minInputChannels = 0; // technically, this would be an error - - input->Release(); - - playback_probe: - - dsinfo.isValid = false; - - // Enumerate through output devices to find the id (if it exists). - result = DirectSoundEnumerate((LPDSENUMCALLBACK)deviceIdCallback, &dsinfo); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Error performing output device id enumeration: %s.", - getErrorString(result)); - error(RtError::DEBUG_WARNING); - return; - } - - // Now do playback probe. - if ( dsinfo.isValid == false ) - goto check_parameters; - - LPDIRECTSOUND output; - DSCAPS out_caps; - result = DirectSoundCreate( dsinfo.id, &output, NULL ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Could not create playback object (%s): %s.", - info->name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - goto check_parameters; - } - - out_caps.dwSize = sizeof(out_caps); - result = output->GetCaps( &out_caps ); - if ( FAILED(result) ) { - output->Release(); - sprintf(message_, "RtApiDs: Could not get playback capabilities (%s): %s.", - info->name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - goto check_parameters; - } - - // Get output channel information. - info->minOutputChannels = 1; - info->maxOutputChannels = ( out_caps.dwFlags & DSCAPS_PRIMARYSTEREO ) ? 2 : 1; - - // Get sample rate information. Use capture device rate information - // if it exists. - if ( info->sampleRates.size() == 0 ) { - info->sampleRates.push_back( (int) out_caps.dwMinSecondarySampleRate ); - if ( out_caps.dwMaxSecondarySampleRate > out_caps.dwMinSecondarySampleRate ) - info->sampleRates.push_back( (int) out_caps.dwMaxSecondarySampleRate ); - } - else { - // Check input rates against output rate range. If there's an - // inconsistency (such as a duplex-capable device which reports a - // single output rate of 48000 Hz), we'll go with the output - // rate(s) since the DirectSoundCapture API is stupid and broken. - // Note that the probed sample rate values are NOT used when - // opening the device. Thanks to Tue Andersen for reporting this. - if ( info->sampleRates.back() < (int) out_caps.dwMinSecondarySampleRate ) { - info->sampleRates.clear(); - info->sampleRates.push_back( (int) out_caps.dwMinSecondarySampleRate ); - if ( out_caps.dwMaxSecondarySampleRate > out_caps.dwMinSecondarySampleRate ) - info->sampleRates.push_back( (int) out_caps.dwMaxSecondarySampleRate ); - } - else { - for ( int i=info->sampleRates.size()-1; i>=0; i-- ) { - if ( (unsigned int) info->sampleRates[i] > out_caps.dwMaxSecondarySampleRate ) - info->sampleRates.erase( info->sampleRates.begin() + i ); - } - while ( info->sampleRates.size() > 0 && - ((unsigned int) info->sampleRates[0] < out_caps.dwMinSecondarySampleRate) ) { - info->sampleRates.erase( info->sampleRates.begin() ); - } + // Invoke user callback to get fresh output data UNLESS we are + // draining stream. + if ( handle->drainCounter == 0 ) { + RtAudioCallback callback = (RtAudioCallback) info->callback; + double streamTime = getStreamTime(); + RtAudioStreamStatus status = 0; + if ( stream_.mode != INPUT && handle->xrun[0] == true ) { + status |= RTAUDIO_OUTPUT_UNDERFLOW; + handle->xrun[0] = false; + } + if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) { + status |= RTAUDIO_INPUT_OVERFLOW; + handle->xrun[1] = false; + } + handle->drainCounter = callback( stream_.userBuffer[0], stream_.userBuffer[1], + stream_.bufferSize, streamTime, status, info->userData ); + if ( handle->drainCounter == 2 ) { + MUTEX_UNLOCK( &stream_.mutex ); + abortStream(); + return; } + else if ( handle->drainCounter == 1 ) + handle->internalDrain = true; } - // Get format information. - if ( out_caps.dwFlags & DSCAPS_PRIMARY16BIT ) info->nativeFormats |= RTAUDIO_SINT16; - if ( out_caps.dwFlags & DSCAPS_PRIMARY8BIT ) info->nativeFormats |= RTAUDIO_SINT8; - - output->Release(); - - check_parameters: - if ( info->maxInputChannels == 0 && info->maxOutputChannels == 0 ) { - sprintf(message_, "RtApiDs: no reported input or output channels for device (%s).", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } - if ( info->sampleRates.size() == 0 || info->nativeFormats == 0 ) { - sprintf(message_, "RtApiDs: no reported sample rates or data formats for device (%s).", - info->name.c_str()); - error(RtError::DEBUG_WARNING); - return; - } - - // Determine duplex status. - if (info->maxInputChannels < info->maxOutputChannels) - info->maxDuplexChannels = info->maxInputChannels; - else - info->maxDuplexChannels = info->maxOutputChannels; - if (info->minInputChannels < info->minOutputChannels) - info->minDuplexChannels = info->minInputChannels; - else - info->minDuplexChannels = info->minOutputChannels; - - if ( info->maxDuplexChannels > 0 ) info->hasDuplexSupport = true; - else info->hasDuplexSupport = false; - - info->probed = true; - - return; -} - -bool RtApiDs :: probeDeviceOpen( int device, StreamMode mode, int channels, - int sampleRate, RtAudioFormat format, - int *bufferSize, int numberOfBuffers) -{ HRESULT result; - HWND hWnd = GetForegroundWindow(); - - // According to a note in PortAudio, using GetDesktopWindow() - // instead of GetForegroundWindow() is supposed to avoid problems - // that occur when the application's window is not the foreground - // window. Also, if the application window closes before the - // DirectSound buffer, DirectSound can crash. However, for console - // applications, no sound was produced when using GetDesktopWindow(). - long buffer_size; - LPVOID audioPtr; - DWORD dataLen; - int nBuffers; - - // Check the numberOfBuffers parameter and limit the lowest value to - // two. This is a judgement call and a value of two is probably too - // low for capture, but it should work for playback. - if (numberOfBuffers < 2) - nBuffers = 2; - else - nBuffers = numberOfBuffers; - - // Define the wave format structure (16-bit PCM, srate, channels) - WAVEFORMATEX waveFormat; - ZeroMemory(&waveFormat, sizeof(WAVEFORMATEX)); - waveFormat.wFormatTag = WAVE_FORMAT_PCM; - waveFormat.nChannels = channels; - waveFormat.nSamplesPerSec = (unsigned long) sampleRate; - - // Determine the data format. - if ( devices_[device].nativeFormats ) { // 8-bit and/or 16-bit support - if ( format == RTAUDIO_SINT8 ) { - if ( devices_[device].nativeFormats & RTAUDIO_SINT8 ) - waveFormat.wBitsPerSample = 8; - else - waveFormat.wBitsPerSample = 16; - } - else { - if ( devices_[device].nativeFormats & RTAUDIO_SINT16 ) - waveFormat.wBitsPerSample = 16; - else - waveFormat.wBitsPerSample = 8; - } - } - else { - sprintf(message_, "RtApiDs: no reported data formats for device (%s).", - devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - waveFormat.nBlockAlign = waveFormat.nChannels * waveFormat.wBitsPerSample / 8; - waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign; - - // Determine the device buffer size. By default, 32k, but we will - // grow it to make allowances for very large software buffer sizes. - DWORD dsBufferSize = 0; - DWORD dsPointerLeadTime = 0; - - buffer_size = MINIMUM_DEVICE_BUFFER_SIZE; // sound cards will always *knock wood* support this + DWORD currentWritePos, safeWritePos; + DWORD currentReadPos, safeReadPos; + DWORD leadPos; + UINT nextWritePos; - enum_info dsinfo; - void *ohandle = 0, *bhandle = 0; - // strncpy( dsinfo.name, devices_[device].name.c_str(), 64 ); - dsinfo.name = devices_[device].name; - dsinfo.isValid = false; - if ( mode == OUTPUT ) { +#ifdef GENERATE_DEBUG_LOG + DWORD writeTime, readTime; +#endif - dsPointerLeadTime = numberOfBuffers * (*bufferSize) * (waveFormat.wBitsPerSample / 8) * channels; + LPVOID buffer1 = NULL; + LPVOID buffer2 = NULL; + DWORD bufferSize1 = 0; + DWORD bufferSize2 = 0; - // If the user wants an even bigger buffer, increase the device buffer size accordingly. - while ( dsPointerLeadTime * 2U > (DWORD)buffer_size ) - buffer_size *= 2; + char *buffer; + long bufferBytes; - if ( devices_[device].maxOutputChannels < channels ) { - sprintf(message_, "RtApiDs: requested channels (%d) > than supported (%d) by device (%s).", - channels, devices_[device].maxOutputChannels, devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + if ( stream_.mode == DUPLEX && !buffersRolling ) { + assert( handle->dsBufferSize[0] == handle->dsBufferSize[1] ); - // Enumerate through output devices to find the id (if it exists). - result = DirectSoundEnumerate((LPDSENUMCALLBACK)deviceIdCallback, &dsinfo); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Error performing output device id enumeration: %s.", - getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + // It takes a while for the devices to get rolling. As a result, + // there's no guarantee that the capture and write device pointers + // will move in lockstep. Wait here for both devices to start + // rolling, and then set our buffer pointers accordingly. + // e.g. Crystal Drivers: the capture buffer starts up 5700 to 9600 + // bytes later than the write buffer. - if ( dsinfo.isValid == false ) { - sprintf(message_, "RtApiDs: output device (%s) id not found!", devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + // Stub: a serious risk of having a pre-emptive scheduling round + // take place between the two GetCurrentPosition calls... but I'm + // really not sure how to solve the problem. Temporarily boost to + // Realtime priority, maybe; but I'm not sure what priority the + // DirectSound service threads run at. We *should* be roughly + // within a ms or so of correct. - LPGUID id = dsinfo.id; - LPDIRECTSOUND object; - LPDIRECTSOUNDBUFFER buffer; - DSBUFFERDESC bufferDescription; - - result = DirectSoundCreate( id, &object, NULL ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Could not create playback object (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + LPDIRECTSOUNDBUFFER dsWriteBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0]; + LPDIRECTSOUNDCAPTUREBUFFER dsCaptureBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1]; - // Set cooperative level to DSSCL_EXCLUSIVE - result = object->SetCooperativeLevel(hWnd, DSSCL_EXCLUSIVE); - if ( FAILED(result) ) { - object->Release(); - sprintf(message_, "RtApiDs: Unable to set cooperative level (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + DWORD initialWritePos, initialSafeWritePos; + DWORD initialReadPos, initialSafeReadPos; - // Even though we will write to the secondary buffer, we need to - // access the primary buffer to set the correct output format - // (since the default is 8-bit, 22 kHz!). Setup the DS primary - // buffer description. - ZeroMemory(&bufferDescription, sizeof(DSBUFFERDESC)); - bufferDescription.dwSize = sizeof(DSBUFFERDESC); - bufferDescription.dwFlags = DSBCAPS_PRIMARYBUFFER; - // Obtain the primary buffer - result = object->CreateSoundBuffer(&bufferDescription, &buffer, NULL); - if ( FAILED(result) ) { - object->Release(); - sprintf(message_, "RtApiDs: Unable to access primary buffer (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; + result = dsWriteBuffer->GetCurrentPosition( &initialWritePos, &initialSafeWritePos ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); } - - // Set the primary DS buffer sound format. - result = buffer->SetFormat(&waveFormat); - if ( FAILED(result) ) { - object->Release(); - sprintf(message_, "RtApiDs: Unable to set primary buffer format (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; + result = dsCaptureBuffer->GetCurrentPosition( &initialReadPos, &initialSafeReadPos ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); } - - // Setup the secondary DS buffer description. - dsBufferSize = (DWORD)buffer_size; - ZeroMemory(&bufferDescription, sizeof(DSBUFFERDESC)); - bufferDescription.dwSize = sizeof(DSBUFFERDESC); - bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS | - DSBCAPS_GETCURRENTPOSITION2 | - DSBCAPS_LOCHARDWARE ); // Force hardware mixing - bufferDescription.dwBufferBytes = buffer_size; - bufferDescription.lpwfxFormat = &waveFormat; - - // Try to create the secondary DS buffer. If that doesn't work, - // try to use software mixing. Otherwise, there's a problem. - result = object->CreateSoundBuffer(&bufferDescription, &buffer, NULL); - if ( FAILED(result) ) { - bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS | - DSBCAPS_GETCURRENTPOSITION2 | - DSBCAPS_LOCSOFTWARE ); // Force software mixing - result = object->CreateSoundBuffer(&bufferDescription, &buffer, NULL); - if ( FAILED(result) ) { - object->Release(); - sprintf(message_, "RtApiDs: Unable to create secondary DS buffer (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; + while ( true ) { + result = dsWriteBuffer->GetCurrentPosition( ¤tWritePos, &safeWritePos ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); } + result = dsCaptureBuffer->GetCurrentPosition( ¤tReadPos, &safeReadPos ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); + } + if ( safeWritePos != initialSafeWritePos && safeReadPos != initialSafeReadPos ) break; + Sleep( 1 ); } - // Get the buffer size ... might be different from what we specified. - DSBCAPS dsbcaps; - dsbcaps.dwSize = sizeof(DSBCAPS); - buffer->GetCaps(&dsbcaps); - buffer_size = dsbcaps.dwBufferBytes; - - // Lock the DS buffer - result = buffer->Lock(0, buffer_size, &audioPtr, &dataLen, NULL, NULL, 0); - if ( FAILED(result) ) { - object->Release(); - buffer->Release(); - sprintf(message_, "RtApiDs: Unable to lock buffer (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } - - // Zero the DS buffer - ZeroMemory(audioPtr, dataLen); - - // Unlock the DS buffer - result = buffer->Unlock(audioPtr, dataLen, NULL, 0); - if ( FAILED(result) ) { - object->Release(); - buffer->Release(); - sprintf(message_, "RtApiDs: Unable to unlock buffer(%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + assert( handle->dsBufferSize[0] == handle->dsBufferSize[1] ); - ohandle = (void *) object; - bhandle = (void *) buffer; - stream_.nDeviceChannels[0] = channels; + buffersRolling = true; + handle->bufferPointer[0] = ( safeWritePos + handle->dsPointerLeadTime[0] ); + handle->bufferPointer[1] = safeReadPos; } - if ( mode == INPUT ) { + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + + LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0]; - if ( devices_[device].maxInputChannels < channels ) { - sprintf(message_, "RtAudioDS: device (%s) does not support %d channels.", devices_[device].name.c_str(), channels); - error(RtError::DEBUG_WARNING); - return FAILURE; + if ( handle->drainCounter > 1 ) { // write zeros to the output stream + bufferBytes = stream_.bufferSize * stream_.nUserChannels[0]; + bufferBytes *= formatBytes( stream_.userFormat ); + memset( stream_.userBuffer[0], 0, bufferBytes ); } - // Enumerate through input devices to find the id (if it exists). - result = DirectSoundCaptureEnumerate((LPDSENUMCALLBACK)deviceIdCallback, &dsinfo); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Error performing input device id enumeration: %s.", - getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; + // Setup parameters and do buffer conversion if necessary. + if ( stream_.doConvertBuffer[0] ) { + buffer = stream_.deviceBuffer; + convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] ); + bufferBytes = stream_.bufferSize * stream_.nDeviceChannels[0]; + bufferBytes *= formatBytes( stream_.deviceFormat[0] ); } - - if ( dsinfo.isValid == false ) { - sprintf(message_, "RtAudioDS: input device (%s) id not found!", devices_[device].name.c_str()); - error(RtError::DEBUG_WARNING); - return FAILURE; + else { + buffer = stream_.userBuffer[0]; + bufferBytes = stream_.bufferSize * stream_.nUserChannels[0]; + bufferBytes *= formatBytes( stream_.userFormat ); } - LPGUID id = dsinfo.id; - LPDIRECTSOUNDCAPTURE object; - LPDIRECTSOUNDCAPTUREBUFFER buffer; - DSCBUFFERDESC bufferDescription; + // No byte swapping necessary in DirectSound implementation. - result = DirectSoundCaptureCreate( id, &object, NULL ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Could not create capture object (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + // Ahhh ... windoze. 16-bit data is signed but 8-bit data is + // unsigned. So, we need to convert our signed 8-bit data here to + // unsigned. + if ( stream_.deviceFormat[0] == RTAUDIO_SINT8 ) + for ( int i=0; idsBufferSize[0]; + nextWritePos = handle->bufferPointer[0]; - // Create the capture buffer. - result = object->CreateCaptureBuffer(&bufferDescription, &buffer, NULL); - if ( FAILED(result) ) { - object->Release(); - sprintf(message_, "RtApiDs: Unable to create capture buffer (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + DWORD endWrite; + while ( true ) { + // Find out where the read and "safe write" pointers are. + result = dsBuffer->GetCurrentPosition( ¤tWritePos, &safeWritePos ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); + } - // Lock the capture buffer - result = buffer->Lock(0, buffer_size, &audioPtr, &dataLen, NULL, NULL, 0); - if ( FAILED(result) ) { - object->Release(); - buffer->Release(); - sprintf(message_, "RtApiDs: Unable to lock capture buffer (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + leadPos = safeWritePos + handle->dsPointerLeadTime[0]; + if ( leadPos > dsBufferSize ) leadPos -= dsBufferSize; + if ( leadPos < nextWritePos ) leadPos += dsBufferSize; // unwrap offset + endWrite = nextWritePos + bufferBytes; - // Zero the buffer - ZeroMemory(audioPtr, dataLen); + // Check whether the entire write region is behind the play pointer. + if ( leadPos >= endWrite ) break; - // Unlock the buffer - result = buffer->Unlock(audioPtr, dataLen, NULL, 0); - if ( FAILED(result) ) { - object->Release(); - buffer->Release(); - sprintf(message_, "RtApiDs: Unable to unlock capture buffer (%s): %s.", - devices_[device].name.c_str(), getErrorString(result)); - error(RtError::DEBUG_WARNING); - return FAILURE; + // If we are here, then we must wait until the play pointer gets + // beyond the write region. The approach here is to use the + // Sleep() function to suspend operation until safePos catches + // up. Calculate number of milliseconds to wait as: + // time = distance * (milliseconds/second) * fudgefactor / + // ((bytes/sample) * (samples/second)) + // A "fudgefactor" less than 1 is used because it was found + // that sleeping too long was MUCH worse than sleeping for + // several shorter periods. + double millis = ( endWrite - leadPos ) * 900.0; + millis /= ( formatBytes( stream_.deviceFormat[0]) * stream_.nDeviceChannels[0] * stream_.sampleRate); + if ( millis < 1.0 ) millis = 1.0; + if ( millis > 50.0 ) { + static int nOverruns = 0; + ++nOverruns; + } + Sleep( (DWORD) millis ); } - ohandle = (void *) object; - bhandle = (void *) buffer; - stream_.nDeviceChannels[1] = channels; - } + //if ( statistics.writeDeviceSafeLeadBytes < dsPointerDifference( safeWritePos, currentWritePos, handle->dsBufferSize[0] ) ) { + // statistics.writeDeviceSafeLeadBytes = dsPointerDifference( safeWritePos, currentWritePos, handle->dsBufferSize[0] ); + //} - stream_.userFormat = format; - if ( waveFormat.wBitsPerSample == 8 ) - stream_.deviceFormat[mode] = RTAUDIO_SINT8; - else - stream_.deviceFormat[mode] = RTAUDIO_SINT16; - stream_.nUserChannels[mode] = channels; + if ( dsPointerBetween( nextWritePos, safeWritePos, currentWritePos, dsBufferSize ) + || dsPointerBetween( endWrite, safeWritePos, currentWritePos, dsBufferSize ) ) { + // We've strayed into the forbidden zone ... resync the read pointer. + //++statistics.numberOfWriteUnderruns; + handle->xrun[0] = true; + nextWritePos = safeWritePos + handle->dsPointerLeadTime[0] - bufferBytes + dsBufferSize; + while ( nextWritePos >= dsBufferSize ) nextWritePos -= dsBufferSize; + handle->bufferPointer[0] = nextWritePos; + endWrite = nextWritePos + bufferBytes; + } - stream_.bufferSize = *bufferSize; + // Lock free space in the buffer + result = dsBuffer->Lock( nextWritePos, bufferBytes, &buffer1, + &bufferSize1, &buffer2, &bufferSize2, 0 ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") locking buffer during playback!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); + } - // Set flags for buffer conversion - stream_.doConvertBuffer[mode] = false; - if (stream_.userFormat != stream_.deviceFormat[mode]) - stream_.doConvertBuffer[mode] = true; - if (stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode]) - stream_.doConvertBuffer[mode] = true; + // Copy our buffer into the DS buffer + CopyMemory( buffer1, buffer, bufferSize1 ); + if ( buffer2 != NULL ) CopyMemory( buffer2, buffer+bufferSize1, bufferSize2 ); - // Allocate necessary internal buffers - if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { + // Update our buffer offset and unlock sound buffer + dsBuffer->Unlock( buffer1, bufferSize1, buffer2, bufferSize2 ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") unlocking buffer during playback!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); + } + nextWritePos = ( nextWritePos + bufferSize1 + bufferSize2 ) % dsBufferSize; + handle->bufferPointer[0] = nextWritePos; - long buffer_bytes; - if (stream_.nUserChannels[0] >= stream_.nUserChannels[1]) - buffer_bytes = stream_.nUserChannels[0]; - else - buffer_bytes = stream_.nUserChannels[1]; - - buffer_bytes *= *bufferSize * formatBytes(stream_.userFormat); - if (stream_.userBuffer) free(stream_.userBuffer); - stream_.userBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.userBuffer == NULL) { - sprintf(message_, "RtApiDs: error allocating user buffer memory (%s).", - devices_[device].name.c_str()); - goto error; + if ( handle->drainCounter ) { + handle->drainCounter++; + goto unlock; } } - if ( stream_.doConvertBuffer[mode] ) { + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { - long buffer_bytes; - bool makeBuffer = true; - if ( mode == OUTPUT ) - buffer_bytes = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - else { // mode == INPUT - buffer_bytes = stream_.nDeviceChannels[1] * formatBytes(stream_.deviceFormat[1]); - if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { - long bytes_out = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - if ( buffer_bytes < bytes_out ) makeBuffer = false; - } + // Setup parameters. + if ( stream_.doConvertBuffer[1] ) { + buffer = stream_.deviceBuffer; + bufferBytes = stream_.bufferSize * stream_.nDeviceChannels[1]; + bufferBytes *= formatBytes( stream_.deviceFormat[1] ); } - - if ( makeBuffer ) { - buffer_bytes *= *bufferSize; - if (stream_.deviceBuffer) free(stream_.deviceBuffer); - stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.deviceBuffer == NULL) { - sprintf(message_, "RtApiDs: error allocating device buffer memory (%s).", - devices_[device].name.c_str()); - goto error; - } + else { + buffer = stream_.userBuffer[1]; + bufferBytes = stream_.bufferSize * stream_.nUserChannels[1]; + bufferBytes *= formatBytes( stream_.userFormat ); } - } - // Allocate our DsHandle structures for the stream. - DsHandle *handles; - if ( stream_.apiHandle == 0 ) { - handles = (DsHandle *) calloc(2, sizeof(DsHandle)); - if ( handles == NULL ) { - sprintf(message_, "RtApiDs: Error allocating DsHandle memory (%s).", - devices_[device].name.c_str()); - goto error; + LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1]; + long nextReadPos = handle->bufferPointer[1]; + DWORD dsBufferSize = handle->dsBufferSize[1]; + + // Find out where the write and "safe read" pointers are. + result = dsBuffer->GetCurrentPosition( ¤tReadPos, &safeReadPos ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); } - handles[0].object = 0; - handles[1].object = 0; - stream_.apiHandle = (void *) handles; - } - else - handles = (DsHandle *) stream_.apiHandle; - handles[mode].object = ohandle; - handles[mode].buffer = bhandle; - handles[mode].dsBufferSize = dsBufferSize; - handles[mode].dsPointerLeadTime = dsPointerLeadTime; - stream_.device[mode] = device; - stream_.state = STREAM_STOPPED; - if ( stream_.mode == OUTPUT && mode == INPUT ) - // We had already set up an output stream. - stream_.mode = DUPLEX; - else - stream_.mode = mode; - stream_.nBuffers = nBuffers; - stream_.sampleRate = sampleRate; + if ( safeReadPos < (DWORD)nextReadPos ) safeReadPos += dsBufferSize; // unwrap offset + DWORD endRead = nextReadPos + bufferBytes; - // Setup the buffer conversion information structure. - if ( stream_.doConvertBuffer[mode] ) { - if (mode == INPUT) { // convert device to user buffer - stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1]; - stream_.convertInfo[mode].outJump = stream_.nUserChannels[1]; - stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1]; - stream_.convertInfo[mode].outFormat = stream_.userFormat; - } - else { // convert user to device buffer - stream_.convertInfo[mode].inJump = stream_.nUserChannels[0]; - stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0]; - stream_.convertInfo[mode].inFormat = stream_.userFormat; - stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0]; - } + // Handling depends on whether we are INPUT or DUPLEX. + // If we're in INPUT mode then waiting is a good thing. If we're in DUPLEX mode, + // then a wait here will drag the write pointers into the forbidden zone. + // + // In DUPLEX mode, rather than wait, we will back off the read pointer until + // it's in a safe position. This causes dropouts, but it seems to be the only + // practical way to sync up the read and write pointers reliably, given the + // the very complex relationship between phase and increment of the read and write + // pointers. + // + // In order to minimize audible dropouts in DUPLEX mode, we will + // provide a pre-roll period of 0.5 seconds in which we return + // zeros from the read buffer while the pointers sync up. - if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump ) - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump; - else - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump; + if ( stream_.mode == DUPLEX ) { + if ( safeReadPos < endRead ) { + if ( duplexPrerollBytes <= 0 ) { + // Pre-roll time over. Be more agressive. + int adjustment = endRead-safeReadPos; - // Set up the interleave/deinterleave offsets. - if ( mode == INPUT && stream_.deInterleave[1] ) { - for (int k=0; kxrun[1] = true; + //++statistics.numberOfReadOverruns; + // Two cases: + // - large adjustments: we've probably run out of CPU cycles, so just resync exactly, + // and perform fine adjustments later. + // - small adjustments: back off by twice as much. + if ( adjustment >= 2*bufferBytes ) + nextReadPos = safeReadPos-2*bufferBytes; + else + nextReadPos = safeReadPos-bufferBytes-adjustment; + + //statistics.readDeviceSafeLeadBytes = currentReadPos-nextReadPos; + //if ( statistics.readDeviceSafeLeadBytes < 0) statistics.readDeviceSafeLeadBytes += dsBufferSize; + if ( nextReadPos < 0 ) nextReadPos += dsBufferSize; + + } + else { + // In pre=roll time. Just do it. + nextReadPos = safeReadPos-bufferBytes; + while ( nextReadPos < 0 ) nextReadPos += dsBufferSize; + } + endRead = nextReadPos + bufferBytes; } } - else { - for (int k=0; kGetCurrentPosition( ¤tReadPos, &safeReadPos ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); + } + + if ( safeReadPos < (DWORD)nextReadPos ) safeReadPos += dsBufferSize; // unwrap offset } } - } - return SUCCESS; + //if (statistics.readDeviceSafeLeadBytes < dsPointerDifference( currentReadPos, nextReadPos, dsBufferSize ) ) + // statistics.readDeviceSafeLeadBytes = dsPointerDifference( currentReadPos, nextReadPos, dsBufferSize ); - error: - if (handles) { - if (handles[0].object) { - LPDIRECTSOUND object = (LPDIRECTSOUND) handles[0].object; - LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; - if (buffer) buffer->Release(); - object->Release(); + // Lock free space in the buffer + result = dsBuffer->Lock( nextReadPos, bufferBytes, &buffer1, + &bufferSize1, &buffer2, &bufferSize2, 0 ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") locking capture buffer!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); } - if (handles[1].object) { - LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handles[1].object; - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; - if (buffer) buffer->Release(); - object->Release(); + + if ( duplexPrerollBytes <= 0 ) { + // Copy our buffer into the DS buffer + CopyMemory( buffer, buffer1, bufferSize1 ); + if ( buffer2 != NULL ) CopyMemory( buffer+bufferSize1, buffer2, bufferSize2 ); + } + else { + memset( buffer, 0, bufferSize1 ); + if ( buffer2 != NULL ) memset( buffer + bufferSize1, 0, bufferSize2 ); + duplexPrerollBytes -= bufferSize1 + bufferSize2; } - free(handles); - stream_.apiHandle = 0; - } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; - } + // Update our buffer offset and unlock sound buffer + nextReadPos = ( nextReadPos + bufferSize1 + bufferSize2 ) % dsBufferSize; + dsBuffer->Unlock( buffer1, bufferSize1, buffer2, bufferSize2 ); + if ( FAILED( result ) ) { + errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") unlocking capture buffer!"; + errorText_ = errorStream_.str(); + error( SYSTEM ); + } + handle->bufferPointer[1] = nextReadPos; - error(RtError::DEBUG_WARNING); - return FAILURE; -} + // No byte swapping necessary in DirectSound implementation. -void RtApiDs :: setStreamCallback(RtAudioCallback callback, void *userData) -{ - verifyStream(); + // If necessary, convert 8-bit data from unsigned to signed. + if ( stream_.deviceFormat[1] == RTAUDIO_SINT8 ) + for ( int j=0; jusingCallback ) { - sprintf(message_, "RtApiDs: A callback is already set for this stream!"); - error(RtError::WARNING); - return; + // Do buffer conversion if necessary. + if ( stream_.doConvertBuffer[1] ) + convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] ); } - - info->callback = (void *) callback; - info->userData = userData; - info->usingCallback = true; - info->object = (void *) this; - - unsigned thread_id; - info->thread = _beginthreadex(NULL, 0, &callbackHandler, - &stream_.callbackInfo, 0, &thread_id); - if (info->thread == 0) { - info->usingCallback = false; - sprintf(message_, "RtApiDs: error starting callback thread!"); - error(RtError::THREAD_ERROR); +#ifdef GENERATE_DEBUG_LOG + if ( currentDebugLogEntry < debugLog.size() ) + { + TTickRecord &r = debugLog[currentDebugLogEntry++]; + r.currentReadPointer = currentReadPos; + r.safeReadPointer = safeReadPos; + r.currentWritePointer = currentWritePos; + r.safeWritePointer = safeWritePos; + r.readTime = readTime; + r.writeTime = writeTime; + r.nextReadPointer = handles[1].bufferPointer; + r.nextWritePointer = handles[0].bufferPointer; } +#endif + + unlock: + MUTEX_UNLOCK( &stream_.mutex ); - // When spawning multiple threads in quick succession, it appears to be - // necessary to wait a bit for each to initialize ... another windoism! - Sleep(1); + RtApi::tickStreamTime(); } -void RtApiDs :: cancelStreamCallback() +// Definitions for utility functions and callbacks +// specific to the DirectSound implementation. + +extern "C" unsigned __stdcall callbackHandler( void *ptr ) { - verifyStream(); + CallbackInfo *info = (CallbackInfo *) ptr; + RtApiDs *object = (RtApiDs *) info->object; + bool* isRunning = &info->isRunning; - if (stream_.callbackInfo.usingCallback) { + while ( *isRunning == true ) { + object->callbackEvent(); + } - if (stream_.state == STREAM_RUNNING) - stopStream(); + _endthreadex( 0 ); + return 0; +} - MUTEX_LOCK(&stream_.mutex); +#include "tchar.h" - stream_.callbackInfo.usingCallback = false; - WaitForSingleObject( (HANDLE)stream_.callbackInfo.thread, INFINITE ); - CloseHandle( (HANDLE)stream_.callbackInfo.thread ); - stream_.callbackInfo.thread = 0; - stream_.callbackInfo.callback = NULL; - stream_.callbackInfo.userData = NULL; +std::string convertTChar( LPCTSTR name ) +{ + std::string s; - MUTEX_UNLOCK(&stream_.mutex); - } +#if defined( UNICODE ) || defined( _UNICODE ) + // Yes, this conversion doesn't make sense for two-byte characters + // but RtAudio is currently written to return an std::string of + // one-byte chars for the device name. + for ( unsigned int i=0; iisInput == true ) { + DSCCAPS caps; + LPDIRECTSOUNDCAPTURE object; - DsHandle *handles = (DsHandle *) stream_.apiHandle; - if (handles) { - if (handles[0].object) { - LPDIRECTSOUND object = (LPDIRECTSOUND) handles[0].object; - LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; - if (buffer) { - buffer->Stop(); - buffer->Release(); - } - object->Release(); - } + hr = DirectSoundCaptureCreate( lpguid, &object, NULL ); + if ( hr != DS_OK ) return true; - if (handles[1].object) { - LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handles[1].object; - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; - if (buffer) { - buffer->Stop(); - buffer->Release(); - } - object->Release(); + caps.dwSize = sizeof(caps); + hr = object->GetCaps( &caps ); + if ( hr == DS_OK ) { + if ( caps.dwChannels > 0 && caps.dwFormats > 0 ) + info->counter++; } - free(handles); - stream_.apiHandle = 0; + object->Release(); } - - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + else { + DSCAPS caps; + LPDIRECTSOUND object; + hr = DirectSoundCreate( lpguid, &object, NULL ); + if ( hr != DS_OK ) return true; + + caps.dwSize = sizeof(caps); + hr = object->GetCaps( &caps ); + if ( hr == DS_OK ) { + if ( caps.dwFlags & DSCAPS_PRIMARYMONO || caps.dwFlags & DSCAPS_PRIMARYSTEREO ) + info->counter++; + } + object->Release(); } - if (stream_.deviceBuffer) { - free(stream_.deviceBuffer); - stream_.deviceBuffer = 0; + if ( info->getDefault && lpguid == NULL ) return false; + + if ( info->findIndex && info->counter > info->index ) { + info->id = lpguid; + info->name = convertTChar( description ); + return false; } - stream_.mode = UNINITIALIZED; + return true; } -void RtApiDs :: startStream() +static char* getErrorString( int code ) { - verifyStream(); - if (stream_.state == STREAM_RUNNING) return; + switch (code) { - // Increase scheduler frequency on lesser windows (a side-effect of - // increasing timer accuracy). On greater windows (Win2K or later), - // this is already in effect. + case DSERR_ALLOCATED: + return "Already allocated"; - MUTEX_LOCK(&stream_.mutex); - - DsHandle *handles = (DsHandle *) stream_.apiHandle; + case DSERR_CONTROLUNAVAIL: + return "Control unavailable"; - timeBeginPeriod(1); + case DSERR_INVALIDPARAM: + return "Invalid parameter"; - memset(&statistics,0,sizeof(statistics)); - statistics.sampleRate = stream_.sampleRate; - statistics.writeDeviceBufferLeadBytes = handles[0].dsPointerLeadTime ; + case DSERR_INVALIDCALL: + return "Invalid call"; - buffersRolling = false; - duplexPrerollBytes = 0; + case DSERR_GENERIC: + return "Generic error"; - if (stream_.mode == DUPLEX) { - // 0.5 seconds of silence in DUPLEX mode while the devices spin up and synchronize. - duplexPrerollBytes = (int)(0.5*stream_.sampleRate*formatBytes( stream_.deviceFormat[1])*stream_.nDeviceChannels[1]); - } + case DSERR_PRIOLEVELNEEDED: + return "Priority level needed"; -#ifdef GENERATE_DEBUG_LOG - currentDebugLogEntry = 0; -#endif + case DSERR_OUTOFMEMORY: + return "Out of memory"; - HRESULT result; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - statistics.outputFrameSize = formatBytes( stream_.deviceFormat[0]) - *stream_.nDeviceChannels[0]; + case DSERR_BADFORMAT: + return "The sample rate or the channel format is not supported"; - LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; - result = buffer->Play( 0, 0, DSBPLAY_LOOPING ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to start buffer (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - } + case DSERR_UNSUPPORTED: + return "Not supported"; - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - statistics.inputFrameSize = formatBytes( stream_.deviceFormat[1]) - *stream_.nDeviceChannels[1]; + case DSERR_NODRIVER: + return "No driver"; - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; - result = buffer->Start(DSCBSTART_LOOPING ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to start capture buffer (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - } - stream_.state = STREAM_RUNNING; + case DSERR_ALREADYINITIALIZED: + return "Already initialized"; - MUTEX_UNLOCK(&stream_.mutex); -} + case DSERR_NOAGGREGATION: + return "No aggregation"; -void RtApiDs :: stopStream() -{ - verifyStream(); - if (stream_.state == STREAM_STOPPED) return; + case DSERR_BUFFERLOST: + return "Buffer lost"; - // Change the state before the lock to improve shutdown response - // when using a callback. - stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); + case DSERR_OTHERAPPHASPRIO: + return "Another application already has priority"; - timeEndPeriod(1); // revert to normal scheduler frequency on lesser windows. + case DSERR_UNINITIALIZED: + return "Uninitialized"; -#ifdef GENERATE_DEBUG_LOG - // Write the timing log to a .TSV file for analysis in Excel. - unlink("c:/rtaudiolog.txt"); - std::ofstream os("c:/rtaudiolog.txt"); - os << "writeTime\treadDelay\tnextWritePointer\tnextReadPointer\tcurrentWritePointer\tsafeWritePointer\tcurrentReadPointer\tsafeReadPointer" << std::endl; - for (int i = 0; i < currentDebugLogEntry ; ++i) { - TTickRecord &r = debugLog[i]; - os << r.writeTime-debugLog[0].writeTime << "\t" << (r.readTime-r.writeTime) << "\t" - << r.nextWritePointer % BUFFER_SIZE << "\t" << r.nextReadPointer % BUFFER_SIZE - << "\t" << r.currentWritePointer % BUFFER_SIZE << "\t" << r.safeWritePointer % BUFFER_SIZE - << "\t" << r.currentReadPointer % BUFFER_SIZE << "\t" << r.safeReadPointer % BUFFER_SIZE << std::endl; - } + default: + return "DirectSound unknown error"; + } +} +//******************** End of __WINDOWS_DS__ *********************// #endif - // There is no specific DirectSound API call to "drain" a buffer - // before stopping. We can hack this for playback by writing - // buffers of zeroes over the entire buffer. For capture, the - // concept is less clear so we'll repeat what we do in the - // abortStream() case. - HRESULT result; - DWORD dsBufferSize; - LPVOID buffer1 = NULL; - LPVOID buffer2 = NULL; - DWORD bufferSize1 = 0; - DWORD bufferSize2 = 0; - DsHandle *handles = (DsHandle *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - DWORD currentPos, safePos; - long buffer_bytes = stream_.bufferSize * stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); +#if defined(__LINUX_ALSA__) - LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; - DWORD nextWritePos = handles[0].bufferPointer; - dsBufferSize = handles[0].dsBufferSize; - DWORD dsBytesWritten = 0; +#include +#include - // Write zeroes for at least dsBufferSize bytes. - while ( dsBytesWritten < dsBufferSize ) { +// A structure to hold various information related to the ALSA API +// implementation. +struct AlsaHandle { + snd_pcm_t *handles[2]; + bool synchronized; + bool xrun[2]; - // Find out where the read and "safe write" pointers are. - result = dsBuffer->GetCurrentPosition( ¤tPos, &safePos ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + AlsaHandle() + :synchronized(false) { xrun[0] = false; xrun[1] = false; } +}; - // Chase nextWritePosition. - if ( currentPos < nextWritePos ) currentPos += dsBufferSize; // unwrap offset - DWORD endWrite = nextWritePos + buffer_bytes; +extern "C" void *alsaCallbackHandler( void * ptr ); - // Check whether the entire write region is behind the play pointer. - while ( currentPos < endWrite ) { - double millis = (endWrite - currentPos) * 900.0; - millis /= ( formatBytes(stream_.deviceFormat[0]) * stream_.nDeviceChannels[0] *stream_.sampleRate); - if ( millis < 1.0 ) millis = 1.0; - Sleep( (DWORD) millis ); +RtApiAlsa :: RtApiAlsa() +{ + // Nothing to do here. +} - // Wake up, find out where we are now - result = dsBuffer->GetCurrentPosition( ¤tPos, &safePos ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } +RtApiAlsa :: ~RtApiAlsa() +{ + if ( stream_.state != STREAM_CLOSED ) closeStream(); +} - if ( currentPos < (DWORD)nextWritePos ) currentPos += dsBufferSize; // unwrap offset - } +unsigned int RtApiAlsa :: getDeviceCount( void ) +{ + unsigned nDevices = 0; + int result, subdevice, card; + char name[64]; + snd_ctl_t *handle; - // Lock free space in the buffer - result = dsBuffer->Lock( nextWritePos, buffer_bytes, &buffer1, - &bufferSize1, &buffer2, &bufferSize2, 0); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to lock buffer during playback (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); + // Count cards and devices + card = -1; + snd_card_next( &card ); + while ( card >= 0 ) { + sprintf( name, "hw:%d", card ); + result = snd_ctl_open( &handle, name, 0 ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::getDeviceCount: control open, card = " << card << ", " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + goto nextcard; + } + subdevice = -1; + while( 1 ) { + result = snd_ctl_pcm_next_device( handle, &subdevice ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::getDeviceCount: control next device, card = " << card << ", " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + break; } + if ( subdevice < 0 ) + break; + nDevices++; + } + nextcard: + snd_ctl_close( handle ); + snd_card_next( &card ); + } - // Zero the free space - ZeroMemory( buffer1, bufferSize1 ); - if (buffer2 != NULL) ZeroMemory( buffer2, bufferSize2 ); + return nDevices; +} - // Update our buffer offset and unlock sound buffer - dsBuffer->Unlock( buffer1, bufferSize1, buffer2, bufferSize2 ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to unlock buffer during playback (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - nextWritePos = (nextWritePos + bufferSize1 + bufferSize2) % dsBufferSize; - handles[0].bufferPointer = nextWritePos; - dsBytesWritten += buffer_bytes; - } +RtAudio::DeviceInfo RtApiAlsa :: getDeviceInfo( unsigned int device ) +{ + RtAudio::DeviceInfo info; + info.probed = false; + + unsigned nDevices = 0; + int result, subdevice, card; + char name[64]; + snd_ctl_t *chandle; - // OK, now stop the buffer. - result = dsBuffer->Stop(); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to stop buffer (%s): %s", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); + // Count cards and devices + card = -1; + snd_card_next( &card ); + while ( card >= 0 ) { + sprintf( name, "hw:%d", card ); + result = snd_ctl_open( &chandle, name, SND_CTL_NONBLOCK ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::getDeviceInfo: control open, card = " << card << ", " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + goto nextcard; + } + subdevice = -1; + while( 1 ) { + result = snd_ctl_pcm_next_device( chandle, &subdevice ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::getDeviceInfo: control next device, card = " << card << ", " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + break; + } + if ( subdevice < 0 ) break; + if ( nDevices == device ) { + sprintf( name, "hw:%d,%d", card, subdevice ); + goto foundDevice; + } + nDevices++; } + nextcard: + snd_ctl_close( chandle ); + snd_card_next( &card ); + } - // If we play again, start at the beginning of the buffer. - handles[0].bufferPointer = 0; + if ( nDevices == 0 ) { + errorText_ = "RtApiAlsa::getDeviceInfo: no devices found!"; + error( INVALID_CALL ); } - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + if ( device >= nDevices ) { + errorText_ = "RtApiAlsa::getDeviceInfo: device ID is invalid!"; + error( INVALID_CALL ); + } - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; - buffer1 = NULL; - bufferSize1 = 0; + foundDevice: - result = buffer->Stop(); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to stop capture buffer (%s): %s", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + int openMode = SND_PCM_ASYNC; + snd_pcm_stream_t stream; + snd_pcm_info_t *pcminfo; + snd_pcm_info_alloca( &pcminfo ); + snd_pcm_t *phandle; + snd_pcm_hw_params_t *params; + snd_pcm_hw_params_alloca( ¶ms ); - dsBufferSize = handles[1].dsBufferSize; + // First try for playback + stream = SND_PCM_STREAM_PLAYBACK; + snd_pcm_info_set_device( pcminfo, subdevice ); + snd_pcm_info_set_subdevice( pcminfo, 0 ); + snd_pcm_info_set_stream( pcminfo, stream ); - // Lock the buffer and clear it so that if we start to play again, - // we won't have old data playing. - result = buffer->Lock(0, dsBufferSize, &buffer1, &bufferSize1, NULL, NULL, 0); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to lock capture buffer (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + result = snd_ctl_pcm_info( chandle, pcminfo ); + if ( result < 0 ) { + // Device probably doesn't support playback. + goto captureProbe; + } - // Zero the DS buffer - ZeroMemory(buffer1, bufferSize1); + result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + goto captureProbe; + } - // Unlock the DS buffer - result = buffer->Unlock(buffer1, bufferSize1, NULL, 0); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to unlock capture buffer (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + // The device is open ... fill the parameter structure. + result = snd_pcm_hw_params_any( phandle, params ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + goto captureProbe; + } - // If we start recording again, we must begin at beginning of buffer. - handles[1].bufferPointer = 0; + // Get output channel information. + unsigned int value; + result = snd_pcm_hw_params_get_channels_max( params, &value ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::getDeviceInfo: error getting device (" << name << ") output channels, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + goto captureProbe; } + info.outputChannels = value; + snd_pcm_close( phandle ); - MUTEX_UNLOCK(&stream_.mutex); -} + captureProbe: + // Now try for capture + stream = SND_PCM_STREAM_CAPTURE; + snd_pcm_info_set_stream( pcminfo, stream ); -void RtApiDs :: abortStream() -{ - verifyStream(); - if (stream_.state == STREAM_STOPPED) return; + result = snd_ctl_pcm_info( chandle, pcminfo ); + snd_ctl_close( chandle ); + if ( result < 0 ) { + // Device probably doesn't support capture. + if ( info.outputChannels == 0 ) return info; + goto probeParameters; + } - // Change the state before the lock to improve shutdown response - // when using a callback. - stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); + result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + if ( info.outputChannels == 0 ) return info; + goto probeParameters; + } - timeEndPeriod(1); // revert to normal scheduler frequency on lesser windows. + // The device is open ... fill the parameter structure. + result = snd_pcm_hw_params_any( phandle, params ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + if ( info.outputChannels == 0 ) return info; + goto probeParameters; + } - HRESULT result; - long dsBufferSize; - LPVOID audioPtr; - DWORD dataLen; - DsHandle *handles = (DsHandle *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - - LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; - result = buffer->Stop(); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to stop buffer (%s): %s", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + result = snd_pcm_hw_params_get_channels_max( params, &value ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::getDeviceInfo: error getting device (" << name << ") input channels, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + if ( info.outputChannels == 0 ) return info; + goto probeParameters; + } + info.inputChannels = value; + snd_pcm_close( phandle ); - dsBufferSize = handles[0].dsBufferSize; + // If device opens for both playback and capture, we determine the channels. + if ( info.outputChannels > 0 && info.inputChannels > 0 ) + info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels; - // Lock the buffer and clear it so that if we start to play again, - // we won't have old data playing. - result = buffer->Lock(0, dsBufferSize, &audioPtr, &dataLen, NULL, NULL, 0); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to lock buffer (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + // ALSA doesn't provide default devices so we'll use the first available one. + if ( device == 0 && info.outputChannels > 0 ) + info.isDefaultOutput = true; + if ( device == 0 && info.inputChannels > 0 ) + info.isDefaultInput = true; - // Zero the DS buffer - ZeroMemory(audioPtr, dataLen); + probeParameters: + // At this point, we just need to figure out the supported data + // formats and sample rates. We'll proceed by opening the device in + // the direction with the maximum number of channels, or playback if + // they are equal. This might limit our sample rate options, but so + // be it. - // Unlock the DS buffer - result = buffer->Unlock(audioPtr, dataLen, NULL, 0); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to unlock buffer (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + if ( info.outputChannels >= info.inputChannels ) + stream = SND_PCM_STREAM_PLAYBACK; + else + stream = SND_PCM_STREAM_CAPTURE; + snd_pcm_info_set_stream( pcminfo, stream ); - // If we start playing again, we must begin at beginning of buffer. - handles[0].bufferPointer = 0; + result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; - audioPtr = NULL; - dataLen = 0; - - result = buffer->Stop(); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to stop capture buffer (%s): %s", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - - dsBufferSize = handles[1].dsBufferSize; - - // Lock the buffer and clear it so that if we start to play again, - // we won't have old data playing. - result = buffer->Lock(0, dsBufferSize, &audioPtr, &dataLen, NULL, NULL, 0); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to lock capture buffer (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + // The device is open ... fill the parameter structure. + result = snd_pcm_hw_params_any( phandle, params ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; + } - // Zero the DS buffer - ZeroMemory(audioPtr, dataLen); + // Test our discrete set of sample rate values. + info.sampleRates.clear(); + for ( unsigned int i=0; iUnlock(audioPtr, dataLen, NULL, 0); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to unlock capture buffer (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + // Probe the supported data formats ... we don't care about endian-ness just yet + snd_pcm_format_t format; + info.nativeFormats = 0; + format = SND_PCM_FORMAT_S8; + if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 ) + info.nativeFormats |= RTAUDIO_SINT8; + format = SND_PCM_FORMAT_S16; + if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 ) + info.nativeFormats |= RTAUDIO_SINT16; + format = SND_PCM_FORMAT_S24; + if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 ) + info.nativeFormats |= RTAUDIO_SINT24; + format = SND_PCM_FORMAT_S32; + if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 ) + info.nativeFormats |= RTAUDIO_SINT32; + format = SND_PCM_FORMAT_FLOAT; + if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 ) + info.nativeFormats |= RTAUDIO_FLOAT32; + format = SND_PCM_FORMAT_FLOAT64; + if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 ) + info.nativeFormats |= RTAUDIO_FLOAT64; - // If we start recording again, we must begin at beginning of buffer. - handles[1].bufferPointer = 0; + // Check that we have at least one supported format + if ( info.nativeFormats == 0 ) { + errorStream_ << "RtApiAlsa::getDeviceInfo: pcm device (" << name << ") data format not supported by RtAudio."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; } - MUTEX_UNLOCK(&stream_.mutex); -} + // Get the device name + char *cardname; + result = snd_card_get_name( card, &cardname ); + if ( result >= 0 ) + sprintf( name, "hw:%s,%d", cardname, subdevice ); + info.name = name; -int RtApiDs :: streamWillBlock() -{ - verifyStream(); - if (stream_.state == STREAM_STOPPED) return 0; + // That's all ... close the device and return + snd_pcm_close( phandle ); + info.probed = true; + return info; +} - MUTEX_LOCK(&stream_.mutex); +bool RtApiAlsa :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, + unsigned int firstChannel, unsigned int sampleRate, + RtAudioFormat format, unsigned int *bufferSize, + RtAudio::StreamOptions *options ) - int channels; - int frames = 0; - HRESULT result; - DWORD currentPos, safePos; - channels = 1; - DsHandle *handles = (DsHandle *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { +{ +#if defined(__RTAUDIO_DEBUG__) + snd_output_t *out; + snd_output_stdio_attach(&out, stderr, 0); +#endif - LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; - UINT nextWritePos = handles[0].bufferPointer; - channels = stream_.nDeviceChannels[0]; - DWORD dsBufferSize = handles[0].dsBufferSize; + // I'm not using the "plug" interface ... too much inconsistent behavior. - // Find out where the read and "safe write" pointers are. - result = dsBuffer->GetCurrentPosition(¤tPos, &safePos); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + unsigned nDevices = 0; + int result, subdevice, card; + char name[64]; + snd_ctl_t *chandle; - DWORD leadPos = safePos + handles[0].dsPointerLeadTime; - if (leadPos > dsBufferSize) { - leadPos -= dsBufferSize; + // Count cards and devices + card = -1; + snd_card_next( &card ); + while ( card >= 0 ) { + sprintf( name, "hw:%d", card ); + result = snd_ctl_open( &chandle, name, SND_CTL_NONBLOCK ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::probeDeviceOpen: control open, card = " << card << ", " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } + subdevice = -1; + while( 1 ) { + result = snd_ctl_pcm_next_device( chandle, &subdevice ); + if ( result < 0 ) break; + if ( subdevice < 0 ) break; + if ( nDevices == device ) { + sprintf( name, "hw:%d,%d", card, subdevice ); + goto foundDevice; + } + nDevices++; } - if ( leadPos < nextWritePos ) leadPos += dsBufferSize; // unwrap offset - - frames = (leadPos - nextWritePos); - frames /= channels * formatBytes(stream_.deviceFormat[0]); + snd_ctl_close( chandle ); + snd_card_next( &card ); } - if (stream_.mode == INPUT ) { - // note that we don't block on DUPLEX input anymore. We run lockstep with the write pointer instead. + if ( nDevices == 0 ) { + // This should not happen because a check is made before this function is called. + errorText_ = "RtApiAlsa::probeDeviceOpen: no devices found!"; + return FAILURE; + } - LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; - UINT nextReadPos = handles[1].bufferPointer; - channels = stream_.nDeviceChannels[1]; - DWORD dsBufferSize = handles[1].dsBufferSize; + if ( device >= nDevices ) { + // This should not happen because a check is made before this function is called. + errorText_ = "RtApiAlsa::probeDeviceOpen: device ID is invalid!"; + return FAILURE; + } - // Find out where the write and "safe read" pointers are. - result = dsBuffer->GetCurrentPosition(¤tPos, &safePos); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current capture position (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + foundDevice: - if ( safePos < (DWORD)nextReadPos ) safePos += dsBufferSize; // unwrap offset + snd_pcm_stream_t stream; + if ( mode == OUTPUT ) + stream = SND_PCM_STREAM_PLAYBACK; + else + stream = SND_PCM_STREAM_CAPTURE; - frames = (int)(safePos - nextReadPos); - frames /= channels * formatBytes(stream_.deviceFormat[1]); + snd_pcm_t *phandle; + int openMode = SND_PCM_ASYNC; + result = snd_pcm_open( &phandle, name, stream, openMode ); + if ( result < 0 ) { + if ( mode == OUTPUT ) + errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device (" << name << ") won't open for output."; + else + errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device (" << name << ") won't open for input."; + errorText_ = errorStream_.str(); + return FAILURE; } - frames = stream_.bufferSize - frames; - if (frames < 0) frames = 0; - - MUTEX_UNLOCK(&stream_.mutex); - return frames; -} + // Fill the parameter structure. + snd_pcm_hw_params_t *hw_params; + snd_pcm_hw_params_alloca( &hw_params ); + result = snd_pcm_hw_params_any( phandle, hw_params ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting pcm device (" << name << ") parameters, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } -void RtApiDs :: tickStream() -{ - verifyStream(); +#if defined(__RTAUDIO_DEBUG__) + fprintf( stderr, "\nRtApiAlsa: dump hardware params just after device open:\n\n" ); + snd_pcm_hw_params_dump( hw_params, out ); +#endif - int stopStream = 0; - if (stream_.state == STREAM_STOPPED) { - if (stream_.callbackInfo.usingCallback) Sleep(50); // sleep 50 milliseconds - return; + // Set access ... check user preference. + if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) { + stream_.userInterleaved = false; + result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED ); + if ( result < 0 ) { + result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED ); + stream_.deviceInterleaved[mode] = true; + } + else + stream_.deviceInterleaved[mode] = false; } - else if (stream_.callbackInfo.usingCallback) { - RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; - stopStream = callback(stream_.userBuffer, stream_.bufferSize, stream_.callbackInfo.userData); + else { + stream_.userInterleaved = true; + result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED ); + if ( result < 0 ) { + result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED ); + stream_.deviceInterleaved[mode] = false; + } + else + stream_.deviceInterleaved[mode] = true; } - MUTEX_LOCK(&stream_.mutex); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting pcm device (" << name << ") access, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } - // The state might change while waiting on a mutex. - if (stream_.state == STREAM_STOPPED) { - MUTEX_UNLOCK(&stream_.mutex); - return; + // Determine how to set the device format. + stream_.userFormat = format; + snd_pcm_format_t deviceFormat = SND_PCM_FORMAT_UNKNOWN; + + if ( format == RTAUDIO_SINT8 ) + deviceFormat = SND_PCM_FORMAT_S8; + else if ( format == RTAUDIO_SINT16 ) + deviceFormat = SND_PCM_FORMAT_S16; + else if ( format == RTAUDIO_SINT24 ) + deviceFormat = SND_PCM_FORMAT_S24; + else if ( format == RTAUDIO_SINT32 ) + deviceFormat = SND_PCM_FORMAT_S32; + else if ( format == RTAUDIO_FLOAT32 ) + deviceFormat = SND_PCM_FORMAT_FLOAT; + else if ( format == RTAUDIO_FLOAT64 ) + deviceFormat = SND_PCM_FORMAT_FLOAT64; + + if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) { + stream_.deviceFormat[mode] = format; + goto setFormat; } - HRESULT result; - DWORD currentWritePos, safeWritePos; - DWORD currentReadPos, safeReadPos; - DWORD leadPos; - UINT nextWritePos; + // The user requested format is not natively supported by the device. + deviceFormat = SND_PCM_FORMAT_FLOAT64; + if ( snd_pcm_hw_params_test_format( phandle, hw_params, deviceFormat ) == 0 ) { + stream_.deviceFormat[mode] = RTAUDIO_FLOAT64; + goto setFormat; + } -#ifdef GENERATE_DEBUG_LOG - DWORD writeTime, readTime; -#endif + deviceFormat = SND_PCM_FORMAT_FLOAT; + if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) { + stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; + goto setFormat; + } - LPVOID buffer1 = NULL; - LPVOID buffer2 = NULL; - DWORD bufferSize1 = 0; - DWORD bufferSize2 = 0; + deviceFormat = SND_PCM_FORMAT_S32; + if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) { + stream_.deviceFormat[mode] = RTAUDIO_SINT32; + goto setFormat; + } - char *buffer; - long buffer_bytes; - DsHandle *handles = (DsHandle *) stream_.apiHandle; + deviceFormat = SND_PCM_FORMAT_S24; + if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) { + stream_.deviceFormat[mode] = RTAUDIO_SINT24; + goto setFormat; + } - if (stream_.mode == DUPLEX && !buffersRolling) { - assert(handles[0].dsBufferSize == handles[1].dsBufferSize); + deviceFormat = SND_PCM_FORMAT_S16; + if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) { + stream_.deviceFormat[mode] = RTAUDIO_SINT16; + goto setFormat; + } - // It takes a while for the devices to get rolling. As a result, - // there's no guarantee that the capture and write device pointers - // will move in lockstep. Wait here for both devices to start - // rolling, and then set our buffer pointers accordingly. - // e.g. Crystal Drivers: the capture buffer starts up 5700 to 9600 - // bytes later than the write buffer. + deviceFormat = SND_PCM_FORMAT_S8; + if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) { + stream_.deviceFormat[mode] = RTAUDIO_SINT8; + goto setFormat; + } - // Stub: a serious risk of having a pre-emptive scheduling round - // take place between the two GetCurrentPosition calls... but I'm - // really not sure how to solve the problem. Temporarily boost to - // Realtime priority, maybe; but I'm not sure what priority the - // directsound service threads run at. We *should* be roughly - // within a ms or so of correct. + // If we get here, no supported format was found. + errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device " << device << " data format not supported by RtAudio."; + errorText_ = errorStream_.str(); + return FAILURE; - LPDIRECTSOUNDBUFFER dsWriteBuffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; - LPDIRECTSOUNDCAPTUREBUFFER dsCaptureBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; + setFormat: + result = snd_pcm_hw_params_set_format( phandle, hw_params, deviceFormat ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting pcm device (" << name << ") data format, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } - DWORD initialWritePos, initialSafeWritePos; - DWORD initialReadPos, initialSafeReadPos;; - - result = dsWriteBuffer->GetCurrentPosition(&initialWritePos, &initialSafeWritePos); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - result = dsCaptureBuffer->GetCurrentPosition(&initialReadPos, &initialSafeReadPos); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current capture position (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - while (true) { - result = dsWriteBuffer->GetCurrentPosition(¤tWritePos, &safeWritePos); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - result = dsCaptureBuffer->GetCurrentPosition(¤tReadPos, &safeReadPos); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current capture position (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - if (safeWritePos != initialSafeWritePos && safeReadPos != initialSafeReadPos) { - break; - } - Sleep(1); + // Determine whether byte-swaping is necessary. + stream_.doByteSwap[mode] = false; + if ( deviceFormat != SND_PCM_FORMAT_S8 ) { + result = snd_pcm_format_cpu_endian( deviceFormat ); + if ( result == 0 ) + stream_.doByteSwap[mode] = true; + else if (result < 0) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting pcm device (" << name << ") endian-ness, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; } + } - assert( handles[0].dsBufferSize == handles[1].dsBufferSize ); - - buffersRolling = true; - handles[0].bufferPointer = (safeWritePos + handles[0].dsPointerLeadTime); - handles[1].bufferPointer = safeReadPos; + // Set the sample rate. + result = snd_pcm_hw_params_set_rate_near( phandle, hw_params, (unsigned int*) &sampleRate, 0 ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting sample rate on device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } + // Determine the number of channels for this device. We support a possible + // minimum device channel number > than the value requested by the user. + stream_.nUserChannels[mode] = channels; + unsigned int value; + result = snd_pcm_hw_params_get_channels_max( hw_params, &value ); + unsigned int deviceChannels = value; + if ( result < 0 || deviceChannels < channels + firstChannel ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: requested channel parameters not supported by device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; } - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - - LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; + result = snd_pcm_hw_params_get_channels_min( hw_params, &value ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting minimum channels for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } + deviceChannels = value; + if ( deviceChannels < channels + firstChannel ) deviceChannels = channels + firstChannel; + stream_.nDeviceChannels[mode] = deviceChannels; - // Setup parameters and do buffer conversion if necessary. - if (stream_.doConvertBuffer[0]) { - buffer = stream_.deviceBuffer; - convertBuffer( buffer, stream_.userBuffer, stream_.convertInfo[0] ); - buffer_bytes = stream_.bufferSize * stream_.nDeviceChannels[0]; - buffer_bytes *= formatBytes(stream_.deviceFormat[0]); - } - else { - buffer = stream_.userBuffer; - buffer_bytes = stream_.bufferSize * stream_.nUserChannels[0]; - buffer_bytes *= formatBytes(stream_.userFormat); - } + // Set the device channels. + result = snd_pcm_hw_params_set_channels( phandle, hw_params, deviceChannels ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting channels for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } - // No byte swapping necessary in DirectSound implementation. + // Set the buffer number, which in ALSA is referred to as the "period". + int dir; + unsigned int periods = 0; + if ( options ) periods = options->numberOfBuffers; + if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) periods = 2; + // Even though the hardware might allow 1 buffer, it won't work reliably. + if ( periods < 2 ) periods = 2; + result = snd_pcm_hw_params_set_periods_near( phandle, hw_params, &periods, &dir ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting periods for device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } - // Ahhh ... windoze. 16-bit data is signed but 8-bit data is - // unsigned. So, we need to convert our signed 8-bit data here to - // unsigned. - if ( stream_.deviceFormat[0] == RTAUDIO_SINT8 ) - for ( int i=0; iGetCurrentPosition(¤tWritePos, &safeWritePos); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } + stream_.bufferSize = *bufferSize; - leadPos = safeWritePos + handles[0].dsPointerLeadTime; - if ( leadPos > dsBufferSize ) leadPos -= dsBufferSize; - if ( leadPos < nextWritePos ) leadPos += dsBufferSize; // unwrap offset - endWrite = nextWritePos + buffer_bytes; + // Install the hardware configuration + result = snd_pcm_hw_params( phandle, hw_params ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error installing hardware configuration on device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } - // Check whether the entire write region is behind the play pointer. - if ( leadPos >= endWrite ) break; +#if defined(__RTAUDIO_DEBUG__) + fprintf(stderr, "\nRtApiAlsa: dump hardware params after installation:\n\n"); + snd_pcm_hw_params_dump( hw_params, out ); +#endif - // If we are here, then we must wait until the play pointer gets - // beyond the write region. The approach here is to use the - // Sleep() function to suspend operation until safePos catches - // up. Calculate number of milliseconds to wait as: - // time = distance * (milliseconds/second) * fudgefactor / - // ((bytes/sample) * (samples/second)) - // A "fudgefactor" less than 1 is used because it was found - // that sleeping too long was MUCH worse than sleeping for - // several shorter periods. - double millis = (endWrite - leadPos) * 900.0; - millis /= ( formatBytes(stream_.deviceFormat[0]) *stream_.nDeviceChannels[0]* stream_.sampleRate); - if ( millis < 1.0 ) millis = 1.0; - if ( millis > 50.0 ) { - static int nOverruns = 0; - ++nOverruns; - } - Sleep( (DWORD) millis ); - } + // Set the software configuration to fill buffers with zeros and prevent device stopping on xruns. + snd_pcm_sw_params_t *sw_params = NULL; + snd_pcm_sw_params_alloca( &sw_params ); + snd_pcm_sw_params_current( phandle, sw_params ); + snd_pcm_sw_params_set_start_threshold( phandle, sw_params, *bufferSize ); + snd_pcm_sw_params_set_stop_threshold( phandle, sw_params, 0x7fffffff ); + snd_pcm_sw_params_set_silence_threshold( phandle, sw_params, 0 ); + snd_pcm_sw_params_set_silence_size( phandle, sw_params, INT_MAX ); + result = snd_pcm_sw_params( phandle, sw_params ); + if ( result < 0 ) { + snd_pcm_close( phandle ); + errorStream_ << "RtApiAlsa::probeDeviceOpen: error installing software configuration on device (" << name << "), " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + return FAILURE; + } -#ifdef GENERATE_DEBUG_LOG - writeTime = timeGetTime(); +#if defined(__RTAUDIO_DEBUG__) + fprintf(stderr, "\nRtApiAlsa: dump software params after installation:\n\n"); + snd_pcm_sw_params_dump( sw_params, out ); #endif - if (statistics.writeDeviceSafeLeadBytes < dsPointerDifference(safeWritePos,currentWritePos,handles[0].dsBufferSize)) { - statistics.writeDeviceSafeLeadBytes = dsPointerDifference(safeWritePos,currentWritePos,handles[0].dsBufferSize); - } + // Set flags for buffer conversion + stream_.doConvertBuffer[mode] = false; + if ( stream_.userFormat != stream_.deviceFormat[mode] ) + stream_.doConvertBuffer[mode] = true; + if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] ) + stream_.doConvertBuffer[mode] = true; + if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] && + stream_.nUserChannels[mode] > 1 ) + stream_.doConvertBuffer[mode] = true; - if ( dsPointerBetween( nextWritePos, safeWritePos, currentWritePos, dsBufferSize ) - || dsPointerBetween( endWrite, safeWritePos, currentWritePos, dsBufferSize ) ) { - // We've strayed into the forbidden zone ... resync the read pointer. - ++statistics.numberOfWriteUnderruns; - nextWritePos = safeWritePos + handles[0].dsPointerLeadTime-buffer_bytes+dsBufferSize; - while (nextWritePos >= dsBufferSize) nextWritePos-= dsBufferSize; - handles[0].bufferPointer = nextWritePos; - endWrite = nextWritePos + buffer_bytes; - } - - // Lock free space in the buffer - result = dsBuffer->Lock( nextWritePos, buffer_bytes, &buffer1, - &bufferSize1, &buffer2, &bufferSize2, 0 ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to lock buffer during playback (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); + // Allocate the ApiHandle if necessary and then save. + AlsaHandle *apiInfo = 0; + if ( stream_.apiHandle == 0 ) { + try { + apiInfo = (AlsaHandle *) new AlsaHandle; } - - // Copy our buffer into the DS buffer - CopyMemory(buffer1, buffer, bufferSize1); - if (buffer2 != NULL) CopyMemory(buffer2, buffer+bufferSize1, bufferSize2); - - // Update our buffer offset and unlock sound buffer - dsBuffer->Unlock( buffer1, bufferSize1, buffer2, bufferSize2 ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to unlock buffer during playback (%s): %s.", - devices_[stream_.device[0]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); + catch ( std::bad_alloc& ) { + errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating AlsaHandle memory."; + goto error; } - nextWritePos = (nextWritePos + bufferSize1 + bufferSize2) % dsBufferSize; - handles[0].bufferPointer = nextWritePos; + stream_.apiHandle = (void *) apiInfo; + apiInfo->handles[0] = 0; + apiInfo->handles[1] = 0; } + else { + apiInfo = (AlsaHandle *) stream_.apiHandle; + } + apiInfo->handles[mode] = phandle; - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - - // Setup parameters. - if (stream_.doConvertBuffer[1]) { - buffer = stream_.deviceBuffer; - buffer_bytes = stream_.bufferSize * stream_.nDeviceChannels[1]; - buffer_bytes *= formatBytes(stream_.deviceFormat[1]); - } - else { - buffer = stream_.userBuffer; - buffer_bytes = stream_.bufferSize * stream_.nUserChannels[1]; - buffer_bytes *= formatBytes(stream_.userFormat); - } - LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; - long nextReadPos = handles[1].bufferPointer; - DWORD dsBufferSize = handles[1].dsBufferSize; - - // Find out where the write and "safe read" pointers are. - result = dsBuffer->GetCurrentPosition(¤tReadPos, &safeReadPos); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current capture position (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - - if ( safeReadPos < (DWORD)nextReadPos ) safeReadPos += dsBufferSize; // unwrap offset - DWORD endRead = nextReadPos + buffer_bytes; - - // Handling depends on whether we are INPUT or DUPLEX. - // If we're in INPUT mode then waiting is a good thing. If we're in DUPLEX mode, - // then a wait here will drag the write pointers into the forbidden zone. - // - // In DUPLEX mode, rather than wait, we will back off the read pointer until - // it's in a safe position. This causes dropouts, but it seems to be the only - // practical way to sync up the read and write pointers reliably, given the - // the very complex relationship between phase and increment of the read and write - // pointers. - // - // In order to minimize audible dropouts in DUPLEX mode, we will - // provide a pre-roll period of 0.5 seconds in which we return - // zeros from the read buffer while the pointers sync up. - - if (stream_.mode == DUPLEX) - { - if (safeReadPos < endRead) - { - if (duplexPrerollBytes <= 0) - { - // pre-roll time over. Be more agressive. - int adjustment = endRead-safeReadPos; - - ++statistics.numberOfReadOverruns; - // Two cases: - // large adjustments: we've probably run out of CPU cycles, so just resync exactly, - // and perform fine adjustments later. - // small adjustments: back off by twice as much. - if (adjustment >= 2*buffer_bytes) - { - nextReadPos = safeReadPos-2*buffer_bytes; - } else - { - nextReadPos = safeReadPos-buffer_bytes-adjustment; - } - statistics.readDeviceSafeLeadBytes = currentReadPos-nextReadPos; - if (statistics.readDeviceSafeLeadBytes < 0) statistics.readDeviceSafeLeadBytes += dsBufferSize; - - if (nextReadPos < 0) nextReadPos += dsBufferSize; - - } else { - // in pre=roll time. Just do it. - nextReadPos = safeReadPos-buffer_bytes; - while (nextReadPos < 0) nextReadPos += dsBufferSize; - } - endRead = nextReadPos + buffer_bytes; - } - } else { - while ( safeReadPos < endRead ) { - // See comments for playback. - double millis = (endRead - safeReadPos) * 900.0; - millis /= ( formatBytes(stream_.deviceFormat[1]) * stream_.nDeviceChannels[1] * stream_.sampleRate); - if ( millis < 1.0 ) millis = 1.0; - Sleep( (DWORD) millis ); - - // Wake up, find out where we are now - result = dsBuffer->GetCurrentPosition( ¤tReadPos, &safeReadPos ); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to get current capture position (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); - } - - if ( safeReadPos < (DWORD)nextReadPos ) safeReadPos += dsBufferSize; // unwrap offset + // Allocate necessary internal buffers. + unsigned long bufferBytes; + bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat ); + stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 ); + if ( stream_.userBuffer[mode] == NULL ) { + errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating user buffer memory."; + goto error; + } + + if ( stream_.doConvertBuffer[mode] ) { + + bool makeBuffer = true; + bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] ); + if ( mode == INPUT ) { + if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { + unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] ); + if ( bufferBytes <= bytesOut ) makeBuffer = false; } } -#ifdef GENERATE_DEBUG_LOG - readTime = timeGetTime(); -#endif - if (statistics.readDeviceSafeLeadBytes < dsPointerDifference(currentReadPos,nextReadPos ,dsBufferSize)) - { - statistics.readDeviceSafeLeadBytes = dsPointerDifference(currentReadPos,nextReadPos ,dsBufferSize); + + if ( makeBuffer ) { + bufferBytes *= *bufferSize; + if ( stream_.deviceBuffer ) free( stream_.deviceBuffer ); + stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 ); + if ( stream_.deviceBuffer == NULL ) { + errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating device buffer memory."; + goto error; + } } + } - // Lock free space in the buffer - result = dsBuffer->Lock (nextReadPos, buffer_bytes, &buffer1, - &bufferSize1, &buffer2, &bufferSize2, 0); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to lock buffer during capture (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); + stream_.sampleRate = sampleRate; + stream_.nBuffers = periods; + stream_.device[mode] = device; + stream_.state = STREAM_STOPPED; + + // Setup the buffer conversion information structure. + if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel ); + + // Setup thread if necessary. + if ( stream_.mode == OUTPUT && mode == INPUT ) { + // We had already set up an output stream. + stream_.mode = DUPLEX; + // Link the streams if possible. + apiInfo->synchronized = false; + if ( snd_pcm_link( apiInfo->handles[0], apiInfo->handles[1] ) == 0 ) + apiInfo->synchronized = true; + else { + errorText_ = "RtApiAlsa::probeDeviceOpen: unable to synchronize input and output devices."; + error( WARNING ); } + } + else { + stream_.mode = mode; - if (duplexPrerollBytes <= 0) - { - // Copy our buffer into the DS buffer - CopyMemory(buffer, buffer1, bufferSize1); - if (buffer2 != NULL) CopyMemory(buffer+bufferSize1, buffer2, bufferSize2); - } else { - memset(buffer,0,bufferSize1); - if (buffer2 != NULL) memset(buffer+bufferSize1,0,bufferSize2); - duplexPrerollBytes -= bufferSize1 + bufferSize2; + // Setup callback thread. + stream_.callbackInfo.object = (void *) this; + + // Set the thread attributes for joinable and realtime scheduling + // priority. The higher priority will only take affect if the + // program is run as root or suid. + pthread_attr_t attr; + pthread_attr_init( &attr ); + pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); +#ifdef SCHED_RR // Undefined with some OSes (eg: NetBSD 1.6.x with GNU Pthread) + pthread_attr_setschedpolicy( &attr, SCHED_RR ); +#else + pthread_attr_setschedpolicy( &attr, SCHED_OTHER ); +#endif + + stream_.callbackInfo.isRunning = true; + result = pthread_create( &stream_.callbackInfo.thread, &attr, alsaCallbackHandler, &stream_.callbackInfo ); + pthread_attr_destroy( &attr ); + if ( result ) { + stream_.callbackInfo.isRunning = false; + errorText_ = "RtApiAlsa::error creating callback thread!"; + goto error; } + } - // Update our buffer offset and unlock sound buffer - nextReadPos = (nextReadPos + bufferSize1 + bufferSize2) % dsBufferSize; - dsBuffer->Unlock (buffer1, bufferSize1, buffer2, bufferSize2); - if ( FAILED(result) ) { - sprintf(message_, "RtApiDs: Unable to unlock buffer during capture (%s): %s.", - devices_[stream_.device[1]].name.c_str(), getErrorString(result)); - error(RtError::DRIVER_ERROR); + return SUCCESS; + + error: + if ( apiInfo ) { + if ( apiInfo->handles[0] ) snd_pcm_close( apiInfo->handles[0] ); + if ( apiInfo->handles[1] ) snd_pcm_close( apiInfo->handles[1] ); + delete apiInfo; + stream_.apiHandle = 0; + } + + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; } - handles[1].bufferPointer = nextReadPos; + } + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; + } - // No byte swapping necessary in DirectSound implementation. + return FAILURE; +} - // If necessary, convert 8-bit data from unsigned to signed. - if ( stream_.deviceFormat[1] == RTAUDIO_SINT8 ) - for ( int j=0; jhandles[0] ); + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) + snd_pcm_drop( apiInfo->handles[1] ); } -#ifdef GENERATE_DEBUG_LOG - if (currentDebugLogEntry < debugLog.size()) - { - TTickRecord &r = debugLog[currentDebugLogEntry++]; - r.currentReadPointer = currentReadPos; - r.safeReadPointer = safeReadPos; - r.currentWritePointer = currentWritePos; - r.safeWritePointer = safeWritePos; - r.readTime = readTime; - r.writeTime = writeTime; - r.nextReadPointer = handles[1].bufferPointer; - r.nextWritePointer = handles[0].bufferPointer; + + if ( apiInfo ) { + if ( apiInfo->handles[0] ) snd_pcm_close( apiInfo->handles[0] ); + if ( apiInfo->handles[1] ) snd_pcm_close( apiInfo->handles[1] ); + delete apiInfo; + stream_.apiHandle = 0; } -#endif + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } + } - MUTEX_UNLOCK(&stream_.mutex); + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; + } - if (stream_.callbackInfo.usingCallback && stopStream) - this->stopStream(); + stream_.mode = UNINITIALIZED; + stream_.state = STREAM_CLOSED; } -// Definitions for utility functions and callbacks -// specific to the DirectSound implementation. -extern "C" unsigned __stdcall callbackHandler(void *ptr) +void RtApiAlsa :: startStream() { - CallbackInfo *info = (CallbackInfo *) ptr; - RtApiDs *object = (RtApiDs *) info->object; - bool *usingCallback = &info->usingCallback; + // This method calls snd_pcm_prepare if the device isn't already in that state. - while ( *usingCallback ) { - try { - object->tickStream(); + verifyStream(); + if ( stream_.state == STREAM_RUNNING ) { + errorText_ = "RtApiAlsa::startStream(): the stream is already running!"; + error( WARNING ); + return; + } + + MUTEX_LOCK( &stream_.mutex ); + + int result = 0; + snd_pcm_state_t state; + AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; + snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + state = snd_pcm_state( handle[0] ); + if ( state != SND_PCM_STATE_PREPARED ) { + result = snd_pcm_prepare( handle[0] ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::startStream: error preparing output pcm device, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + goto unlock; + } } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiDs: callback thread error (%s) ... closing thread.\n\n", - exception.getMessageString()); - break; + } + + if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) { + state = snd_pcm_state( handle[1] ); + if ( state != SND_PCM_STATE_PREPARED ) { + result = snd_pcm_prepare( handle[1] ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::startStream: error preparing input pcm device, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + goto unlock; + } } } - _endthreadex( 0 ); - return 0; + stream_.state = STREAM_RUNNING; + + unlock: + MUTEX_UNLOCK( &stream_.mutex ); + + if ( result >= 0 ) return; + error( SYSTEM ); } -static bool CALLBACK deviceCountCallback(LPGUID lpguid, - LPCTSTR description, - LPCTSTR module, - LPVOID lpContext) +void RtApiAlsa :: stopStream() { - int *pointer = ((int *) lpContext); - (*pointer)++; + verifyStream(); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiAlsa::stopStream(): the stream is already stopped!"; + error( WARNING ); + return; + } - return true; -} + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK( &stream_.mutex ); -#include "tchar.h" + int result = 0; + AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; + snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + if ( apiInfo->synchronized ) + result = snd_pcm_drop( handle[0] ); + else + result = snd_pcm_drain( handle[0] ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::stopStream: error draining output pcm device, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + goto unlock; + } + } -std::string convertTChar( LPCTSTR name ) -{ - std::string s; + if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) { + result = snd_pcm_drop( handle[1] ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::stopStream: error stopping input pcm device, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + goto unlock; + } + } -#if defined( UNICODE ) || defined( _UNICODE ) - // Yes, this conversion doesn't make sense for two-byte characters - // but RtAudio is currently written to return an std::string of - // one-byte chars for the device name. - for ( unsigned int i=0; i= 0 ) return; + error( SYSTEM ); } -static bool CALLBACK deviceInfoCallback(LPGUID lpguid, - LPCTSTR description, - LPCTSTR module, - LPVOID lpContext) +void RtApiAlsa :: abortStream() { - enum_info *info = ((enum_info *) lpContext); - while ( !info->name.empty() ) info++; - - info->name = convertTChar( description ); - info->id = lpguid; - - HRESULT hr; - info->isValid = false; - if (info->isInput == true) { - DSCCAPS caps; - LPDIRECTSOUNDCAPTURE object; + verifyStream(); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiAlsa::abortStream(): the stream is already stopped!"; + error( WARNING ); + return; + } - hr = DirectSoundCaptureCreate( lpguid, &object, NULL ); - if( hr != DS_OK ) return true; + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK( &stream_.mutex ); - caps.dwSize = sizeof(caps); - hr = object->GetCaps( &caps ); - if( hr == DS_OK ) { - if (caps.dwChannels > 0 && caps.dwFormats > 0) - info->isValid = true; + int result = 0; + AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; + snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + result = snd_pcm_drop( handle[0] ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::abortStream: error aborting output pcm device, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + goto unlock; } - object->Release(); } - else { - DSCAPS caps; - LPDIRECTSOUND object; - hr = DirectSoundCreate( lpguid, &object, NULL ); - if( hr != DS_OK ) return true; - caps.dwSize = sizeof(caps); - hr = object->GetCaps( &caps ); - if( hr == DS_OK ) { - if ( caps.dwFlags & DSCAPS_PRIMARYMONO || caps.dwFlags & DSCAPS_PRIMARYSTEREO ) - info->isValid = true; + if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) { + result = snd_pcm_drop( handle[1] ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::abortStream: error aborting input pcm device, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + goto unlock; } - object->Release(); } - return true; + unlock: + MUTEX_UNLOCK( &stream_.mutex ); + + stream_.state = STREAM_STOPPED; + if ( result >= 0 ) return; + error( SYSTEM ); } -static bool CALLBACK defaultDeviceCallback(LPGUID lpguid, - LPCTSTR description, - LPCTSTR module, - LPVOID lpContext) +void RtApiAlsa :: callbackEvent() { - enum_info *info = ((enum_info *) lpContext); + if ( stream_.state == STREAM_STOPPED ) { + if ( stream_.callbackInfo.isRunning ) usleep( 50000 ); // sleep 50 milliseconds + return; + } - if ( lpguid == NULL ) { - info->name = convertTChar( description ); - return false; + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiAlsa::callbackEvent(): the stream is closed ... this shouldn't happen!"; + error( WARNING ); + return; } - return true; -} + int doStopStream = 0; + AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle; + RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; + double streamTime = getStreamTime(); + RtAudioStreamStatus status = 0; + if ( stream_.mode != INPUT && apiInfo->xrun[0] == true ) { + status |= RTAUDIO_OUTPUT_UNDERFLOW; + apiInfo->xrun[0] = false; + } + if ( stream_.mode != OUTPUT && apiInfo->xrun[1] == true ) { + status |= RTAUDIO_INPUT_OVERFLOW; + apiInfo->xrun[1] = false; + } + doStopStream = callback( stream_.userBuffer[0], stream_.userBuffer[1], + stream_.bufferSize, streamTime, status, stream_.callbackInfo.userData ); -static bool CALLBACK deviceIdCallback(LPGUID lpguid, - LPCTSTR description, - LPCTSTR module, - LPVOID lpContext) -{ - enum_info *info = ((enum_info *) lpContext); + MUTEX_LOCK( &stream_.mutex ); - std::string s = convertTChar( description ); - if ( info->name == s ) { - info->id = lpguid; - info->isValid = true; - return false; - } + // The state might change while waiting on a mutex. + if ( stream_.state == STREAM_STOPPED ) goto unlock; - return true; -} + int result; + char *buffer; + int channels; + snd_pcm_t **handle; + snd_pcm_sframes_t frames; + RtAudioFormat format; + handle = (snd_pcm_t **) apiInfo->handles; -static char* getErrorString(int code) -{ - switch (code) { + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { - case DSERR_ALLOCATED: - return "Already allocated."; + // Setup parameters. + if ( stream_.doConvertBuffer[1] ) { + buffer = stream_.deviceBuffer; + channels = stream_.nDeviceChannels[1]; + format = stream_.deviceFormat[1]; + } + else { + buffer = stream_.userBuffer[1]; + channels = stream_.nUserChannels[1]; + format = stream_.userFormat; + } - case DSERR_CONTROLUNAVAIL: - return "Control unavailable."; + // Read samples from device in interleaved/non-interleaved format. + if ( stream_.deviceInterleaved[1] ) + result = snd_pcm_readi( handle[1], buffer, stream_.bufferSize ); + else { + void *bufs[channels]; + size_t offset = stream_.bufferSize * formatBytes( format ); + for ( int i=0; ixrun[1] = true; + result = snd_pcm_prepare( handle[1] ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::callbackEvent: error preparing device after overrun, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + } + } + else { + errorStream_ << "RtApiAlsa::callbackEvent: error, current state is " << snd_pcm_state_name( state ) << ", " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + } + } + else { + errorStream_ << "RtApiAlsa::callbackEvent: audio read error, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + } + error( WARNING ); + goto unlock; + } - case DSERR_INVALIDCALL: - return "Invalid call."; + // Do byte swapping if necessary. + if ( stream_.doByteSwap[1] ) + byteSwapBuffer( buffer, stream_.bufferSize * channels, format ); - case DSERR_GENERIC: - return "Generic error."; + // Do buffer conversion if necessary. + if ( stream_.doConvertBuffer[1] ) + convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] ); - case DSERR_PRIOLEVELNEEDED: - return "Priority level needed"; + // Check stream latency + result = snd_pcm_delay( handle[1], &frames ); + if ( result == 0 && frames > 0 ) stream_.latency[1] = frames; + } + + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + + // Setup parameters and do buffer conversion if necessary. + if ( stream_.doConvertBuffer[0] ) { + buffer = stream_.deviceBuffer; + convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] ); + channels = stream_.nDeviceChannels[0]; + format = stream_.deviceFormat[0]; + } + else { + buffer = stream_.userBuffer[0]; + channels = stream_.nUserChannels[0]; + format = stream_.userFormat; + } - case DSERR_OUTOFMEMORY: - return "Out of memory"; + // Do byte swapping if necessary. + if ( stream_.doByteSwap[0] ) + byteSwapBuffer(buffer, stream_.bufferSize * channels, format); - case DSERR_BADFORMAT: - return "The sample rate or the channel format is not supported."; + // Write samples to device in interleaved/non-interleaved format. + if ( stream_.deviceInterleaved[0] ) + result = snd_pcm_writei( handle[0], buffer, stream_.bufferSize ); + else { + void *bufs[channels]; + size_t offset = stream_.bufferSize * formatBytes( format ); + for ( int i=0; ixrun[0] = true; + result = snd_pcm_prepare( handle[0] ); + if ( result < 0 ) { + errorStream_ << "RtApiAlsa::callbackEvent: error preparing device after underrun, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + } + } + else { + errorStream_ << "RtApiAlsa::callbackEvent: error, current state is " << snd_pcm_state_name( state ) << ", " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + } + } + else { + errorStream_ << "RtApiAlsa::callbackEvent: audio write error, " << snd_strerror( result ) << "."; + errorText_ = errorStream_.str(); + } + error( WARNING ); + goto unlock; + } - case DSERR_NODRIVER: - return "No driver."; + // Check stream latency + result = snd_pcm_delay( handle[0], &frames ); + if ( result == 0 && frames > 0 ) stream_.latency[0] = frames; + } - case DSERR_ALREADYINITIALIZED: - return "Already initialized."; + unlock: + MUTEX_UNLOCK( &stream_.mutex ); - case DSERR_NOAGGREGATION: - return "No aggregation."; + RtApi::tickStreamTime(); + if ( doStopStream == 1 ) this->stopStream(); + else if ( doStopStream == 2 ) this->abortStream(); +} - case DSERR_BUFFERLOST: - return "Buffer lost."; +extern "C" void *alsaCallbackHandler( void *ptr ) +{ + CallbackInfo *info = (CallbackInfo *) ptr; + RtApiAlsa *object = (RtApiAlsa *) info->object; + bool *isRunning = &info->isRunning; - case DSERR_OTHERAPPHASPRIO: - return "Another application already has priority."; +#ifdef SCHED_RR + // Set a higher scheduler priority (P.J. Leonard) + struct sched_param param; + param.sched_priority = 39; // Is this the best number? + sched_setscheduler( 0, SCHED_RR, ¶m ); +#endif - case DSERR_UNINITIALIZED: - return "Uninitialized."; + while ( *isRunning == true ) { + pthread_testcancel(); + object->callbackEvent(); + } - default: - return "DirectSound unknown error"; - } + pthread_exit( NULL ); } -//******************** End of __WINDOWS_DS__ *********************// +//******************** End of __LINUX_ALSA__ *********************// #endif -#if defined(__IRIX_AL__) // SGI's AL API for IRIX -#include +#if defined(__LINUX_OSS__) + +#include +#include #include +#include +#include "oss/soundcard.h" #include +#include + +extern "C" void *ossCallbackHandler(void * ptr); -extern "C" void *callbackHandler(void * ptr); +// A structure to hold various information related to the OSS API +// implementation. +struct OssHandle { + int id[2]; // device ids + bool xrun[2]; + bool triggered; + + OssHandle() + :triggered(false) { id[0] = 0; id[1] = 0; xrun[0] = false; xrun[1] = false; } +}; -RtApiAl :: RtApiAl() +RtApiOss :: RtApiOss() { - this->initialize(); + // Nothing to do here. +} - if (nDevices_ <= 0) { - sprintf(message_, "RtApiAl: no Irix AL audio devices found!"); - error(RtError::NO_DEVICES_FOUND); - } +RtApiOss :: ~RtApiOss() +{ + if ( stream_.state != STREAM_CLOSED ) closeStream(); } -RtApiAl :: ~RtApiAl() +unsigned int RtApiOss :: getDeviceCount( void ) { - // The subclass destructor gets called before the base class - // destructor, so close any existing streams before deallocating - // apiDeviceId memory. - if ( stream_.mode != UNINITIALIZED ) closeStream(); + int mixerfd = open( "/dev/mixer", O_RDWR, 0 ); + if ( mixerfd == -1 ) { + errorText_ = "RtApiOss::getDeviceCount: error opening '/dev/mixer'."; + error( WARNING ); + return 0; + } - // Free our allocated apiDeviceId memory. - long *id; - for ( unsigned int i=0; i= nDevices ) { + close( mixerfd ); + errorText_ = "RtApiOss::getDeviceInfo: device ID is invalid!"; + error( INVALID_CALL ); + } -int RtApiAl :: getDefaultInputDevice(void) -{ - ALvalue value; - long *id; - int result = alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, &value, 1, 0, 0); - if (result < 0) { - sprintf(message_, "RtApiAl: error getting default input device id: %s.", - alGetErrorString(oserror())); - error(RtError::WARNING); + oss_audioinfo ainfo; + ainfo.dev = device; + result = ioctl( mixerfd, SNDCTL_AUDIOINFO, &ainfo ); + close( mixerfd ); + if ( result == -1 ) { + errorStream_ << "RtApiOss::getDeviceInfo: error getting device (" << ainfo.name << ") info."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; + } + + // Probe channels + if ( ainfo.caps & PCM_CAP_OUTPUT ) info.outputChannels = ainfo.max_channels; + if ( ainfo.caps & PCM_CAP_INPUT ) info.inputChannels = ainfo.max_channels; + if ( ainfo.caps & PCM_CAP_DUPLEX ) { + if ( info.outputChannels > 0 && info.inputChannels > 0 && ainfo.caps & PCM_CAP_DUPLEX ) + info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels; + } + + // Probe data formats ... do for input + unsigned long mask = ainfo.iformats; + if ( mask & AFMT_S16_LE || mask & AFMT_S16_BE ) + info.nativeFormats |= RTAUDIO_SINT16; + if ( mask & AFMT_S8 ) + info.nativeFormats |= RTAUDIO_SINT8; + if ( mask & AFMT_S32_LE || mask & AFMT_S32_BE ) + info.nativeFormats |= RTAUDIO_SINT32; + if ( mask & AFMT_FLOAT ) + info.nativeFormats |= RTAUDIO_FLOAT32; + if ( mask & AFMT_S24_LE || mask & AFMT_S24_BE ) + info.nativeFormats |= RTAUDIO_SINT24; + + // Check that we have at least one supported format + if ( info.nativeFormats == 0 ) { + errorStream_ << "RtApiOss::getDeviceInfo: device (" << ainfo.name << ") data format not supported by RtAudio."; + errorText_ = errorStream_.str(); + error( WARNING ); + return info; + } + + // Probe the supported sample rates. + info.sampleRates.clear(); + if ( ainfo.nrates ) { + for ( unsigned int i=0; i= (int) SAMPLE_RATES[k] ) + info.sampleRates.push_back( SAMPLE_RATES[k] ); } } - return 0; -} - -int RtApiAl :: getDefaultOutputDevice(void) -{ - ALvalue value; - long *id; - int result = alQueryValues(AL_SYSTEM, AL_DEFAULT_OUTPUT, &value, 1, 0, 0); - if (result < 0) { - sprintf(message_, "RtApiAl: error getting default output device id: %s.", - alGetErrorString(oserror())); - error(RtError::WARNING); + if ( info.sampleRates.size() == 0 ) { + errorStream_ << "RtApiOss::getDeviceInfo: no supported sample rates found for device (" << ainfo.name << ")."; + errorText_ = errorStream_.str(); + error( WARNING ); } else { - for ( unsigned int i=0; iapiDeviceId; - resource = id[0]; - if (resource > 0) { - - // Probe output device parameters. - result = alQueryValues(resource, AL_CHANNELS, &value, 1, 0, 0); - if (result < 0) { - sprintf(message_, "RtApiAl: error getting device (%s) channels: %s.", - info->name.c_str(), alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - } - else { - info->maxOutputChannels = value.i; - info->minOutputChannels = 1; - } + int mixerfd = open( "/dev/mixer", O_RDWR, 0 ); + if ( mixerfd == -1 ) { + errorText_ = "RtApiOss::probeDeviceOpen: error opening '/dev/mixer'."; + return FAILURE; + } - result = alGetParamInfo(resource, AL_RATE, &pinfo); - if (result < 0) { - sprintf(message_, "RtApiAl: error getting device (%s) rates: %s.", - info->name.c_str(), alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - } - else { - info->sampleRates.clear(); - for (unsigned int k=0; k= pinfo.min.i && SAMPLE_RATES[k] <= pinfo.max.i ) - info->sampleRates.push_back( SAMPLE_RATES[k] ); - } - } + oss_sysinfo sysinfo; + int result = ioctl( mixerfd, SNDCTL_SYSINFO, &sysinfo ); + if ( result == -1 ) { + close( mixerfd ); + errorText_ = "RtApiOss::probeDeviceOpen: error getting sysinfo, OSS version >= 4.0 is required."; + return FAILURE; + } - // The AL library supports all our formats, except 24-bit and 32-bit ints. - info->nativeFormats = (RtAudioFormat) 51; + unsigned nDevices = sysinfo.numaudios; + if ( nDevices == 0 ) { + // This should not happen because a check is made before this function is called. + close( mixerfd ); + errorText_ = "RtApiOss::probeDeviceOpen: no devices found!"; + return FAILURE; } - // Now get input resource ID if it exists. - resource = id[1]; - if (resource > 0) { + if ( device >= nDevices ) { + // This should not happen because a check is made before this function is called. + close( mixerfd ); + errorText_ = "RtApiOss::probeDeviceOpen: device ID is invalid!"; + return FAILURE; + } - // Probe input device parameters. - result = alQueryValues(resource, AL_CHANNELS, &value, 1, 0, 0); - if (result < 0) { - sprintf(message_, "RtApiAl: error getting device (%s) channels: %s.", - info->name.c_str(), alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - } - else { - info->maxInputChannels = value.i; - info->minInputChannels = 1; - } + oss_audioinfo ainfo; + ainfo.dev = device; + result = ioctl( mixerfd, SNDCTL_AUDIOINFO, &ainfo ); + close( mixerfd ); + if ( result == -1 ) { + errorStream_ << "RtApiOss::getDeviceInfo: error getting device (" << ainfo.name << ") info."; + errorText_ = errorStream_.str(); + return FAILURE; + } - result = alGetParamInfo(resource, AL_RATE, &pinfo); - if (result < 0) { - sprintf(message_, "RtApiAl: error getting device (%s) rates: %s.", - info->name.c_str(), alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - } - else { - // In the case of the default device, these values will - // overwrite the rates determined for the output device. Since - // the input device is most likely to be more limited than the - // output device, this is ok. - info->sampleRates.clear(); - for (unsigned int k=0; k= pinfo.min.i && SAMPLE_RATES[k] <= pinfo.max.i ) - info->sampleRates.push_back( SAMPLE_RATES[k] ); + // Check if device supports input or output + if ( ( mode == OUTPUT && !( ainfo.caps & PCM_CAP_OUTPUT ) ) || + ( mode == INPUT && !( ainfo.caps & PCM_CAP_INPUT ) ) ) { + if ( mode == OUTPUT ) + errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support output."; + else + errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support input."; + errorText_ = errorStream_.str(); + return FAILURE; + } + + int flags = 0; + OssHandle *handle = (OssHandle *) stream_.apiHandle; + if ( mode == OUTPUT ) + flags |= O_WRONLY; + else { // mode == INPUT + if (stream_.mode == OUTPUT && stream_.device[0] == device) { + // We just set the same device for playback ... close and reopen for duplex (OSS only). + close( handle->id[0] ); + handle->id[0] = 0; + if ( !( ainfo.caps & PCM_CAP_DUPLEX ) ) { + errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support duplex mode."; + errorText_ = errorStream_.str(); + return FAILURE; } + // Check that the number previously set channels is the same. + if ( stream_.nUserChannels[0] != channels ) { + errorStream_ << "RtApiOss::probeDeviceOpen: input/output channels must be equal for OSS duplex device (" << ainfo.name << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + flags |= O_RDWR; } - - // The AL library supports all our formats, except 24-bit and 32-bit ints. - info->nativeFormats = (RtAudioFormat) 51; + else + flags |= O_RDONLY; } - if ( info->maxInputChannels == 0 && info->maxOutputChannels == 0 ) - return; - if ( info->sampleRates.size() == 0 ) - return; - - // Determine duplex status. - if (info->maxInputChannels < info->maxOutputChannels) - info->maxDuplexChannels = info->maxInputChannels; - else - info->maxDuplexChannels = info->maxOutputChannels; - if (info->minInputChannels < info->minOutputChannels) - info->minDuplexChannels = info->minInputChannels; - else - info->minDuplexChannels = info->minOutputChannels; - - if ( info->maxDuplexChannels > 0 ) info->hasDuplexSupport = true; - else info->hasDuplexSupport = false; - - info->probed = true; - - return; -} - -bool RtApiAl :: probeDeviceOpen(int device, StreamMode mode, int channels, - int sampleRate, RtAudioFormat format, - int *bufferSize, int numberOfBuffers) -{ - int result, nBuffers; - long resource; - ALconfig al_config; - ALport port; - ALpv pvs[2]; - long *id = (long *) devices_[device].apiDeviceId; - - // Get a new ALconfig structure. - al_config = alNewConfig(); - if ( !al_config ) { - sprintf(message_,"RtApiAl: can't get AL config: %s.", - alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - return FAILURE; - } + // Set exclusive access if specified. + if ( options && options->flags & RTAUDIO_HOG_DEVICE ) flags |= O_EXCL; - // Set the channels. - result = alSetChannels(al_config, channels); - if ( result < 0 ) { - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: can't set %d channels in AL config: %s.", - channels, alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); + // Try to open the device. + int fd; + fd = open( ainfo.devnode, flags, 0 ); + if ( fd == -1 ) { + if ( errno == EBUSY ) + errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") is busy."; + else + errorStream_ << "RtApiOss::probeDeviceOpen: error opening device (" << ainfo.name << ")."; + errorText_ = errorStream_.str(); return FAILURE; } - // Attempt to set the queue size. The al API doesn't provide a - // means for querying the minimum/maximum buffer size of a device, - // so if the specified size doesn't work, take whatever the - // al_config structure returns. - if ( numberOfBuffers < 1 ) - nBuffers = 1; - else - nBuffers = numberOfBuffers; - long buffer_size = *bufferSize * nBuffers; - result = alSetQueueSize(al_config, buffer_size); // in sample frames - if ( result < 0 ) { - // Get the buffer size specified by the al_config and try that. - buffer_size = alGetQueueSize(al_config); - result = alSetQueueSize(al_config, buffer_size); - if ( result < 0 ) { - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: can't set buffer size (%ld) in AL config: %s.", - buffer_size, alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); + // For duplex operation, specifically set this mode (this doesn't seem to work). + /* + if ( flags | O_RDWR ) { + result = ioctl( fd, SNDCTL_DSP_SETDUPLEX, NULL ); + if ( result == -1) { + errorStream_ << "RtApiOss::probeDeviceOpen: error setting duplex mode for device (" << ainfo.name << ")."; + errorText_ = errorStream_.str(); return FAILURE; } - *bufferSize = buffer_size / nBuffers; } + */ - // Set the data format. - stream_.userFormat = format; - stream_.deviceFormat[mode] = format; - if (format == RTAUDIO_SINT8) { - result = alSetSampFmt(al_config, AL_SAMPFMT_TWOSCOMP); - result = alSetWidth(al_config, AL_SAMPLE_8); - } - else if (format == RTAUDIO_SINT16) { - result = alSetSampFmt(al_config, AL_SAMPFMT_TWOSCOMP); - result = alSetWidth(al_config, AL_SAMPLE_16); - } - else if (format == RTAUDIO_SINT24) { - // Our 24-bit format assumes the upper 3 bytes of a 4 byte word. - // The AL library uses the lower 3 bytes, so we'll need to do our - // own conversion. - result = alSetSampFmt(al_config, AL_SAMPFMT_FLOAT); - stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; + // Check the device channel support. + stream_.nUserChannels[mode] = channels; + if ( ainfo.max_channels < (int)(channels + firstChannel) ) { + close( fd ); + errorStream_ << "RtApiOss::probeDeviceOpen: the device (" << ainfo.name << ") does not support requested channel parameters."; + errorText_ = errorStream_.str(); + return FAILURE; } - else if (format == RTAUDIO_SINT32) { - // The AL library doesn't seem to support the 32-bit integer - // format, so we'll need to do our own conversion. - result = alSetSampFmt(al_config, AL_SAMPFMT_FLOAT); - stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; + + // Set the number of channels. + int deviceChannels = channels + firstChannel; + result = ioctl( fd, SNDCTL_DSP_CHANNELS, &deviceChannels ); + if ( result == -1 || deviceChannels < (int)(channels + firstChannel) ) { + close( fd ); + errorStream_ << "RtApiOss::probeDeviceOpen: error setting channel parameters on device (" << ainfo.name << ")."; + errorText_ = errorStream_.str(); + return FAILURE; } - else if (format == RTAUDIO_FLOAT32) - result = alSetSampFmt(al_config, AL_SAMPFMT_FLOAT); - else if (format == RTAUDIO_FLOAT64) - result = alSetSampFmt(al_config, AL_SAMPFMT_DOUBLE); + stream_.nDeviceChannels[mode] = deviceChannels; + // Get the data format mask + int mask; + result = ioctl( fd, SNDCTL_DSP_GETFMTS, &mask ); if ( result == -1 ) { - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: error setting sample format in AL config: %s.", - alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); + close( fd ); + errorStream_ << "RtApiOss::probeDeviceOpen: error getting device (" << ainfo.name << ") data formats."; + errorText_ = errorStream_.str(); return FAILURE; } - if (mode == OUTPUT) { - - // Set our device. - if (device == 0) - resource = AL_DEFAULT_OUTPUT; - else - resource = id[0]; - result = alSetDevice(al_config, resource); - if ( result == -1 ) { - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: error setting device (%s) in AL config: %s.", - devices_[device].name.c_str(), alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - return FAILURE; + // Determine how to set the device format. + stream_.userFormat = format; + int deviceFormat = -1; + stream_.doByteSwap[mode] = false; + if ( format == RTAUDIO_SINT8 ) { + if ( mask & AFMT_S8 ) { + deviceFormat = AFMT_S8; + stream_.deviceFormat[mode] = RTAUDIO_SINT8; } - - // Open the port. - port = alOpenPort("RtApiAl Output Port", "w", al_config); - if( !port ) { - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: error opening output port: %s.", - alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - return FAILURE; + } + else if ( format == RTAUDIO_SINT16 ) { + if ( mask & AFMT_S16_NE ) { + deviceFormat = AFMT_S16_NE; + stream_.deviceFormat[mode] = RTAUDIO_SINT16; } - - // Set the sample rate - pvs[0].param = AL_MASTER_CLOCK; - pvs[0].value.i = AL_CRYSTAL_MCLK_TYPE; - pvs[1].param = AL_RATE; - pvs[1].value.ll = alDoubleToFixed((double)sampleRate); - result = alSetParams(resource, pvs, 2); - if ( result < 0 ) { - alClosePort(port); - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: error setting sample rate (%d) for device (%s): %s.", - sampleRate, devices_[device].name.c_str(), alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - return FAILURE; + else if ( mask & AFMT_S16_OE ) { + deviceFormat = AFMT_S16_OE; + stream_.deviceFormat[mode] = RTAUDIO_SINT16; + stream_.doByteSwap[mode] = true; } } - else { // mode == INPUT - - // Set our device. - if (device == 0) - resource = AL_DEFAULT_INPUT; - else - resource = id[1]; - result = alSetDevice(al_config, resource); - if ( result == -1 ) { - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: error setting device (%s) in AL config: %s.", - devices_[device].name.c_str(), alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - return FAILURE; + else if ( format == RTAUDIO_SINT24 ) { + if ( mask & AFMT_S24_NE ) { + deviceFormat = AFMT_S24_NE; + stream_.deviceFormat[mode] = RTAUDIO_SINT24; } - - // Open the port. - port = alOpenPort("RtApiAl Input Port", "r", al_config); - if( !port ) { - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: error opening input port: %s.", - alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - return FAILURE; + else if ( mask & AFMT_S24_OE ) { + deviceFormat = AFMT_S24_OE; + stream_.deviceFormat[mode] = RTAUDIO_SINT24; + stream_.doByteSwap[mode] = true; } + } + else if ( format == RTAUDIO_SINT32 ) { + if ( mask & AFMT_S32_NE ) { + deviceFormat = AFMT_S32_NE; + stream_.deviceFormat[mode] = RTAUDIO_SINT32; + } + else if ( mask & AFMT_S32_OE ) { + deviceFormat = AFMT_S32_OE; + stream_.deviceFormat[mode] = RTAUDIO_SINT32; + stream_.doByteSwap[mode] = true; + } + } - // Set the sample rate - pvs[0].param = AL_MASTER_CLOCK; - pvs[0].value.i = AL_CRYSTAL_MCLK_TYPE; - pvs[1].param = AL_RATE; - pvs[1].value.ll = alDoubleToFixed((double)sampleRate); - result = alSetParams(resource, pvs, 2); - if ( result < 0 ) { - alClosePort(port); - alFreeConfig(al_config); - sprintf(message_,"RtApiAl: error setting sample rate (%d) for device (%s): %s.", - sampleRate, devices_[device].name.c_str(), alGetErrorString(oserror())); - error(RtError::DEBUG_WARNING); - return FAILURE; + if ( deviceFormat == -1 ) { + // The user requested format is not natively supported by the device. + if ( mask & AFMT_S16_NE ) { + deviceFormat = AFMT_S16_NE; + stream_.deviceFormat[mode] = RTAUDIO_SINT16; + } + else if ( mask & AFMT_S32_NE ) { + deviceFormat = AFMT_S32_NE; + stream_.deviceFormat[mode] = RTAUDIO_SINT32; + } + else if ( mask & AFMT_S24_NE ) { + deviceFormat = AFMT_S24_NE; + stream_.deviceFormat[mode] = RTAUDIO_SINT24; + } + else if ( mask & AFMT_S16_OE ) { + deviceFormat = AFMT_S16_OE; + stream_.deviceFormat[mode] = RTAUDIO_SINT16; + stream_.doByteSwap[mode] = true; + } + else if ( mask & AFMT_S32_OE ) { + deviceFormat = AFMT_S32_OE; + stream_.deviceFormat[mode] = RTAUDIO_SINT32; + stream_.doByteSwap[mode] = true; + } + else if ( mask & AFMT_S24_OE ) { + deviceFormat = AFMT_S24_OE; + stream_.deviceFormat[mode] = RTAUDIO_SINT24; + stream_.doByteSwap[mode] = true; + } + else if ( mask & AFMT_S8) { + deviceFormat = AFMT_S8; + stream_.deviceFormat[mode] = RTAUDIO_SINT8; } } - alFreeConfig(al_config); + if ( stream_.deviceFormat[mode] == 0 ) { + // This really shouldn't happen ... + close( fd ); + errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") data format not supported by RtAudio."; + errorText_ = errorStream_.str(); + return FAILURE; + } - stream_.nUserChannels[mode] = channels; - stream_.nDeviceChannels[mode] = channels; + // Set the data format. + int temp = deviceFormat; + result = ioctl( fd, SNDCTL_DSP_SETFMT, &deviceFormat ); + if ( result == -1 || deviceFormat != temp ) { + close( fd ); + errorStream_ << "RtApiOss::probeDeviceOpen: error setting data format on device (" << ainfo.name << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } - // Save stream handle. - ALport *handle = (ALport *) stream_.apiHandle; - if ( handle == 0 ) { - handle = (ALport *) calloc(2, sizeof(ALport)); - if ( handle == NULL ) { - sprintf(message_, "RtApiAl: Irix Al error allocating handle memory (%s).", - devices_[device].name.c_str()); - goto error; - } - stream_.apiHandle = (void *) handle; - handle[0] = 0; - handle[1] = 0; + // Attempt to set the buffer size. According to OSS, the minimum + // number of buffers is two. The supposed minimum buffer size is 16 + // bytes, so that will be our lower bound. The argument to this + // call is in the form 0xMMMMSSSS (hex), where the buffer size (in + // bytes) is given as 2^SSSS and the number of buffers as 2^MMMM. + // We'll check the actual value used near the end of the setup + // procedure. + int ossBufferBytes = *bufferSize * formatBytes( stream_.deviceFormat[mode] ) * deviceChannels; + if ( ossBufferBytes < 16 ) ossBufferBytes = 16; + int buffers = 0; + if ( options ) buffers = options->numberOfBuffers; + if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) buffers = 2; + if ( buffers < 2 ) buffers = 3; + temp = ((int) buffers << 16) + (int)( log10( (double)ossBufferBytes ) / log10( 2.0 ) ); + result = ioctl( fd, SNDCTL_DSP_SETFRAGMENT, &temp ); + if ( result == -1 ) { + close( fd ); + errorStream_ << "RtApiOss::probeDeviceOpen: error setting buffer size on device (" << ainfo.name << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + stream_.nBuffers = buffers; + + // Save buffer size (in sample frames). + *bufferSize = ossBufferBytes / ( formatBytes(stream_.deviceFormat[mode]) * deviceChannels ); + stream_.bufferSize = *bufferSize; + + // Set the sample rate. + int srate = sampleRate; + result = ioctl( fd, SNDCTL_DSP_SPEED, &srate ); + if ( result == -1 ) { + close( fd ); + errorStream_ << "RtApiOss::probeDeviceOpen: error setting sample rate (" << sampleRate << ") on device (" << ainfo.name << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + + // Verify the sample rate setup worked. + if ( abs( srate - sampleRate ) > 100 ) { + close( fd ); + errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support sample rate (" << sampleRate << ")."; + errorText_ = errorStream_.str(); + return FAILURE; + } + stream_.sampleRate = sampleRate; + + if ( mode == INPUT && stream_.mode == OUTPUT && stream_.device[0] == device) { + // We're doing duplex setup here. + stream_.deviceFormat[0] = stream_.deviceFormat[1]; + stream_.nDeviceChannels[0] = deviceChannels; } - handle[mode] = port; + + // Set interleaving parameters. + stream_.userInterleaved = true; + stream_.deviceInterleaved[mode] = true; + if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) + stream_.userInterleaved = false; // Set flags for buffer conversion stream_.doConvertBuffer[mode] = false; - if (stream_.userFormat != stream_.deviceFormat[mode]) + if ( stream_.userFormat != stream_.deviceFormat[mode] ) + stream_.doConvertBuffer[mode] = true; + if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] ) + stream_.doConvertBuffer[mode] = true; + if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] && + stream_.nUserChannels[mode] > 1 ) stream_.doConvertBuffer[mode] = true; - // Allocate necessary internal buffers - if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { - - long buffer_bytes; - if (stream_.nUserChannels[0] >= stream_.nUserChannels[1]) - buffer_bytes = stream_.nUserChannels[0]; - else - buffer_bytes = stream_.nUserChannels[1]; - - buffer_bytes *= *bufferSize * formatBytes(stream_.userFormat); - if (stream_.userBuffer) free(stream_.userBuffer); - stream_.userBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.userBuffer == NULL) { - sprintf(message_, "RtApiAl: error allocating user buffer memory (%s).", - devices_[device].name.c_str()); + // Allocate the stream handles if necessary and then save. + if ( stream_.apiHandle == 0 ) { + try { + handle = new OssHandle; + } + catch ( std::bad_alloc& ) { + errorText_ = "RtApiOss::probeDeviceOpen: error allocating OssHandle memory."; goto error; } + + stream_.apiHandle = (void *) handle; + } + else { + handle = (OssHandle *) stream_.apiHandle; + } + handle->id[mode] = fd; + + // Allocate necessary internal buffers. + unsigned long bufferBytes; + bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat ); + stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 ); + if ( stream_.userBuffer[mode] == NULL ) { + errorText_ = "RtApiOss::probeDeviceOpen: error allocating user buffer memory."; + goto error; } if ( stream_.doConvertBuffer[mode] ) { - long buffer_bytes; bool makeBuffer = true; - if ( mode == OUTPUT ) - buffer_bytes = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - else { // mode == INPUT - buffer_bytes = stream_.nDeviceChannels[1] * formatBytes(stream_.deviceFormat[1]); + bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] ); + if ( mode == INPUT ) { if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) { - long bytes_out = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]); - if ( buffer_bytes < bytes_out ) makeBuffer = false; + unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] ); + if ( bufferBytes <= bytesOut ) makeBuffer = false; } } if ( makeBuffer ) { - buffer_bytes *= *bufferSize; - if (stream_.deviceBuffer) free(stream_.deviceBuffer); - stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1); - if (stream_.deviceBuffer == NULL) { - sprintf(message_, "RtApiAl: error allocating device buffer memory (%s).", - devices_[device].name.c_str()); + bufferBytes *= *bufferSize; + if ( stream_.deviceBuffer ) free( stream_.deviceBuffer ); + stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 ); + if ( stream_.deviceBuffer == NULL ) { + errorText_ = "RtApiOss::probeDeviceOpen: error allocating device buffer memory."; goto error; } } @@ -8108,388 +6436,389 @@ bool RtApiAl :: probeDeviceOpen(int device, StreamMode mode, int channels, stream_.device[mode] = device; stream_.state = STREAM_STOPPED; - if ( stream_.mode == OUTPUT && mode == INPUT ) + + // Setup the buffer conversion information structure. + if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel ); + + // Setup thread if necessary. + if ( stream_.mode == OUTPUT && mode == INPUT ) { // We had already set up an output stream. stream_.mode = DUPLEX; - else + if ( stream_.device[0] == device ) handle->id[0] = fd; + } + else { stream_.mode = mode; - stream_.nBuffers = nBuffers; - stream_.bufferSize = *bufferSize; - stream_.sampleRate = sampleRate; - // Setup the buffer conversion information structure. - if ( stream_.doConvertBuffer[mode] ) { - if (mode == INPUT) { // convert device to user buffer - stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1]; - stream_.convertInfo[mode].outJump = stream_.nUserChannels[1]; - stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1]; - stream_.convertInfo[mode].outFormat = stream_.userFormat; - } - else { // convert user to device buffer - stream_.convertInfo[mode].inJump = stream_.nUserChannels[0]; - stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0]; - stream_.convertInfo[mode].inFormat = stream_.userFormat; - stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0]; - } - - if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump ) - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump; - else - stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump; + // Setup callback thread. + stream_.callbackInfo.object = (void *) this; + + // Set the thread attributes for joinable and realtime scheduling + // priority. The higher priority will only take affect if the + // program is run as root or suid. + pthread_attr_t attr; + pthread_attr_init( &attr ); + pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); +#ifdef SCHED_RR // Undefined with some OSes (eg: NetBSD 1.6.x with GNU Pthread) + pthread_attr_setschedpolicy( &attr, SCHED_RR ); +#else + pthread_attr_setschedpolicy( &attr, SCHED_OTHER ); +#endif - // Set up the interleave/deinterleave offsets. - if ( mode == INPUT && stream_.deInterleave[1] ) { - for (int k=0; kid[0] ) close( handle->id[0] ); + if ( handle->id[1] ) close( handle->id[1] ); + delete handle; stream_.apiHandle = 0; } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } + } + + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); + stream_.deviceBuffer = 0; } - error(RtError::DEBUG_WARNING); return FAILURE; } -void RtApiAl :: closeStream() +void RtApiOss :: closeStream() { - // We don't want an exception to be thrown here because this - // function is called by our class destructor. So, do our own - // streamId check. - if ( stream_.mode == UNINITIALIZED ) { - sprintf(message_, "RtApiAl::closeStream(): no open stream to close!"); - error(RtError::WARNING); + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiOss::closeStream(): no open stream to close!"; + error( WARNING ); return; } - ALport *handle = (ALport *) stream_.apiHandle; - if (stream_.state == STREAM_RUNNING) { - int buffer_size = stream_.bufferSize * stream_.nBuffers; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) - alDiscardFrames(handle[0], buffer_size); - if (stream_.mode == INPUT || stream_.mode == DUPLEX) - alDiscardFrames(handle[1], buffer_size); - stream_.state = STREAM_STOPPED; - } + stream_.callbackInfo.isRunning = false; + pthread_join( stream_.callbackInfo.thread, NULL ); - if (stream_.callbackInfo.usingCallback) { - stream_.callbackInfo.usingCallback = false; - pthread_join(stream_.callbackInfo.thread, NULL); + OssHandle *handle = (OssHandle *) stream_.apiHandle; + if ( stream_.state == STREAM_RUNNING ) { + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) + ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 ); + else + ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 ); + stream_.state = STREAM_STOPPED; } - if (handle) { - if (handle[0]) alClosePort(handle[0]); - if (handle[1]) alClosePort(handle[1]); - free(handle); + if ( handle ) { + if ( handle->id[0] ) close( handle->id[0] ); + if ( handle->id[1] ) close( handle->id[1] ); + delete handle; stream_.apiHandle = 0; } - if (stream_.userBuffer) { - free(stream_.userBuffer); - stream_.userBuffer = 0; + for ( int i=0; i<2; i++ ) { + if ( stream_.userBuffer[i] ) { + free( stream_.userBuffer[i] ); + stream_.userBuffer[i] = 0; + } } - if (stream_.deviceBuffer) { - free(stream_.deviceBuffer); + if ( stream_.deviceBuffer ) { + free( stream_.deviceBuffer ); stream_.deviceBuffer = 0; } stream_.mode = UNINITIALIZED; + stream_.state = STREAM_CLOSED; } -void RtApiAl :: startStream() +void RtApiOss :: startStream() { verifyStream(); - if (stream_.state == STREAM_RUNNING) return; + if ( stream_.state == STREAM_RUNNING ) { + errorText_ = "RtApiOss::startStream(): the stream is already running!"; + error( WARNING ); + return; + } - MUTEX_LOCK(&stream_.mutex); + MUTEX_LOCK( &stream_.mutex ); - // The AL port is ready as soon as it is opened. stream_.state = STREAM_RUNNING; - MUTEX_UNLOCK(&stream_.mutex); + // No need to do anything else here ... OSS automatically starts + // when fed samples. + + MUTEX_UNLOCK( &stream_.mutex ); } -void RtApiAl :: stopStream() +void RtApiOss :: stopStream() { verifyStream(); - if (stream_.state == STREAM_STOPPED) return; + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiOss::stopStream(): the stream is already stopped!"; + error( WARNING ); + return; + } // Change the state before the lock to improve shutdown response // when using a callback. stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); + MUTEX_LOCK( &stream_.mutex ); - int result, buffer_size = stream_.bufferSize * stream_.nBuffers; - ALport *handle = (ALport *) stream_.apiHandle; + int result = 0; + OssHandle *handle = (OssHandle *) stream_.apiHandle; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) - alZeroFrames(handle[0], buffer_size); + // Flush the output with zeros a few times. + char *buffer; + int samples; + RtAudioFormat format; - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - result = alDiscardFrames(handle[1], buffer_size); - if (result == -1) { - sprintf(message_, "RtApiAl: error draining stream device (%s): %s.", - devices_[stream_.device[1]].name.c_str(), alGetErrorString(oserror())); - error(RtError::DRIVER_ERROR); + if ( stream_.doConvertBuffer[0] ) { + buffer = stream_.deviceBuffer; + samples = stream_.bufferSize * stream_.nDeviceChannels[0]; + format = stream_.deviceFormat[0]; + } + else { + buffer = stream_.userBuffer[0]; + samples = stream_.bufferSize * stream_.nUserChannels[0]; + format = stream_.userFormat; } - } - - MUTEX_UNLOCK(&stream_.mutex); -} - -void RtApiAl :: abortStream() -{ - verifyStream(); - if (stream_.state == STREAM_STOPPED) return; - // Change the state before the lock to improve shutdown response - // when using a callback. - stream_.state = STREAM_STOPPED; - MUTEX_LOCK(&stream_.mutex); + memset( buffer, 0, samples * formatBytes(format) ); + for ( unsigned int i=0; iid[0], buffer, samples * formatBytes(format) ); + if ( result == -1 ) { + errorText_ = "RtApiOss::stopStream: audio write error."; + error( WARNING ); + } + } - ALport *handle = (ALport *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { + result = ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 ); + if ( result == -1 ) { + errorStream_ << "RtApiOss::stopStream: system error stopping callback procedure on device (" << stream_.device[0] << ")."; + errorText_ = errorStream_.str(); + goto unlock; + } + handle->triggered = false; + } - int buffer_size = stream_.bufferSize * stream_.nBuffers; - int result = alDiscardFrames(handle[0], buffer_size); - if (result == -1) { - sprintf(message_, "RtApiAl: error aborting stream device (%s): %s.", - devices_[stream_.device[0]].name.c_str(), alGetErrorString(oserror())); - error(RtError::DRIVER_ERROR); + if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && handle->id[0] != handle->id[1] ) ) { + result = ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 ); + if ( result == -1 ) { + errorStream_ << "RtApiOss::stopStream: system error stopping input callback procedure on device (" << stream_.device[0] << ")."; + errorText_ = errorStream_.str(); + goto unlock; } } - // There is no clear action to take on the input stream, since the - // port will continue to run in any event. + unlock: + MUTEX_UNLOCK( &stream_.mutex ); - MUTEX_UNLOCK(&stream_.mutex); + stream_.state = STREAM_STOPPED; + if ( result != -1 ) return; + error( SYSTEM ); } -int RtApiAl :: streamWillBlock() +void RtApiOss :: abortStream() { verifyStream(); + if ( stream_.state == STREAM_STOPPED ) { + errorText_ = "RtApiOss::abortStream(): the stream is already stopped!"; + error( WARNING ); + return; + } - if (stream_.state == STREAM_STOPPED) return 0; - - MUTEX_LOCK(&stream_.mutex); + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK( &stream_.mutex ); - int frames = 0; - int err = 0; - ALport *handle = (ALport *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - err = alGetFillable(handle[0]); - if (err < 0) { - sprintf(message_, "RtApiAl: error getting available frames for stream (%s): %s.", - devices_[stream_.device[0]].name.c_str(), alGetErrorString(oserror())); - error(RtError::DRIVER_ERROR); + int result = 0; + OssHandle *handle = (OssHandle *) stream_.apiHandle; + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + result = ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 ); + if ( result == -1 ) { + errorStream_ << "RtApiOss::abortStream: system error stopping callback procedure on device (" << stream_.device[0] << ")."; + errorText_ = errorStream_.str(); + goto unlock; } + handle->triggered = false; } - frames = err; - - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - err = alGetFilled(handle[1]); - if (err < 0) { - sprintf(message_, "RtApiAl: error getting available frames for stream (%s): %s.", - devices_[stream_.device[1]].name.c_str(), alGetErrorString(oserror())); - error(RtError::DRIVER_ERROR); + if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && handle->id[0] != handle->id[1] ) ) { + result = ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 ); + if ( result == -1 ) { + errorStream_ << "RtApiOss::abortStream: system error stopping input callback procedure on device (" << stream_.device[0] << ")."; + errorText_ = errorStream_.str(); + goto unlock; } - if (frames > err) frames = err; } - frames = stream_.bufferSize - frames; - if (frames < 0) frames = 0; + unlock: + MUTEX_UNLOCK( &stream_.mutex ); - MUTEX_UNLOCK(&stream_.mutex); - return frames; + stream_.state = STREAM_STOPPED; + if ( result != -1 ) return; + error( SYSTEM ); } -void RtApiAl :: tickStream() +void RtApiOss :: callbackEvent() { - verifyStream(); + if ( stream_.state == STREAM_STOPPED ) { + if ( stream_.callbackInfo.isRunning ) usleep( 50000 ); // sleep 50 milliseconds + return; + } - int stopStream = 0; - if (stream_.state == STREAM_STOPPED) { - if (stream_.callbackInfo.usingCallback) usleep(50000); // sleep 50 milliseconds + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApiOss::callbackEvent(): the stream is closed ... this shouldn't happen!"; + error( WARNING ); return; } - else if (stream_.callbackInfo.usingCallback) { - RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; - stopStream = callback(stream_.userBuffer, stream_.bufferSize, stream_.callbackInfo.userData); + + // Invoke user callback to get fresh output data. + int doStopStream = 0; + RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; + double streamTime = getStreamTime(); + RtAudioStreamStatus status = 0; + OssHandle *handle = (OssHandle *) stream_.apiHandle; + if ( stream_.mode != INPUT && handle->xrun[0] == true ) { + status |= RTAUDIO_OUTPUT_UNDERFLOW; + handle->xrun[0] = false; + } + if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) { + status |= RTAUDIO_INPUT_OVERFLOW; + handle->xrun[1] = false; } + doStopStream = callback( stream_.userBuffer[0], stream_.userBuffer[1], + stream_.bufferSize, streamTime, status, stream_.callbackInfo.userData ); - MUTEX_LOCK(&stream_.mutex); + MUTEX_LOCK( &stream_.mutex ); // The state might change while waiting on a mutex. - if (stream_.state == STREAM_STOPPED) - goto unlock; + if ( stream_.state == STREAM_STOPPED ) goto unlock; + int result; char *buffer; - int channels; + int samples; RtAudioFormat format; - ALport *handle = (ALport *) stream_.apiHandle; - if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { + + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { // Setup parameters and do buffer conversion if necessary. - if (stream_.doConvertBuffer[0]) { + if ( stream_.doConvertBuffer[0] ) { buffer = stream_.deviceBuffer; - convertBuffer( buffer, stream_.userBuffer, stream_.convertInfo[0] ); - channels = stream_.nDeviceChannels[0]; + convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] ); + samples = stream_.bufferSize * stream_.nDeviceChannels[0]; format = stream_.deviceFormat[0]; } else { - buffer = stream_.userBuffer; - channels = stream_.nUserChannels[0]; + buffer = stream_.userBuffer[0]; + samples = stream_.bufferSize * stream_.nUserChannels[0]; format = stream_.userFormat; } // Do byte swapping if necessary. - if (stream_.doByteSwap[0]) - byteSwapBuffer(buffer, stream_.bufferSize * channels, format); + if ( stream_.doByteSwap[0] ) + byteSwapBuffer( buffer, samples, format ); + + if ( stream_.mode == DUPLEX && handle->triggered == false ) { + int trig = 0; + ioctl( handle->id[0], SNDCTL_DSP_SETTRIGGER, &trig ); + result = write( handle->id[0], buffer, samples * formatBytes(format) ); + trig = PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT; + ioctl( handle->id[0], SNDCTL_DSP_SETTRIGGER, &trig ); + handle->triggered = true; + } + else + // Write samples to device. + result = write( handle->id[0], buffer, samples * formatBytes(format) ); - // Write interleaved samples to device. - alWriteFrames(handle[0], buffer, stream_.bufferSize); + if ( result == -1 ) { + // We'll assume this is an underrun, though there isn't a + // specific means for determining that. + handle->xrun[0] = true; + errorText_ = "RtApiOss::callbackEvent: audio write error."; + error( WARNING ); + goto unlock; + } } - if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { // Setup parameters. - if (stream_.doConvertBuffer[1]) { + if ( stream_.doConvertBuffer[1] ) { buffer = stream_.deviceBuffer; - channels = stream_.nDeviceChannels[1]; + samples = stream_.bufferSize * stream_.nDeviceChannels[1]; format = stream_.deviceFormat[1]; } else { - buffer = stream_.userBuffer; - channels = stream_.nUserChannels[1]; + buffer = stream_.userBuffer[1]; + samples = stream_.bufferSize * stream_.nUserChannels[1]; format = stream_.userFormat; } - // Read interleaved samples from device. - alReadFrames(handle[1], buffer, stream_.bufferSize); + // Read samples from device. + result = read( handle->id[1], buffer, samples * formatBytes(format) ); + + if ( result == -1 ) { + // We'll assume this is an overrun, though there isn't a + // specific means for determining that. + handle->xrun[1] = true; + errorText_ = "RtApiOss::callbackEvent: audio read error."; + error( WARNING ); + goto unlock; + } // Do byte swapping if necessary. - if (stream_.doByteSwap[1]) - byteSwapBuffer(buffer, stream_.bufferSize * channels, format); + if ( stream_.doByteSwap[1] ) + byteSwapBuffer( buffer, samples, format ); // Do buffer conversion if necessary. - if (stream_.doConvertBuffer[1]) - convertBuffer( stream_.userBuffer, stream_.deviceBuffer, stream_.convertInfo[1] ); + if ( stream_.doConvertBuffer[1] ) + convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] ); } unlock: - MUTEX_UNLOCK(&stream_.mutex); - - if (stream_.callbackInfo.usingCallback && stopStream) - this->stopStream(); -} - -void RtApiAl :: setStreamCallback(RtAudioCallback callback, void *userData) -{ - verifyStream(); - - CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; - if ( info->usingCallback ) { - sprintf(message_, "RtApiAl: A callback is already set for this stream!"); - error(RtError::WARNING); - return; - } - - info->callback = (void *) callback; - info->userData = userData; - info->usingCallback = true; - info->object = (void *) this; - - // Set the thread attributes for joinable and realtime scheduling - // priority. The higher priority will only take affect if the - // program is run as root or suid. - pthread_attr_t attr; - pthread_attr_init(&attr); - pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); - pthread_attr_setschedpolicy(&attr, SCHED_RR); - - int err = pthread_create(&info->thread, &attr, callbackHandler, &stream_.callbackInfo); - pthread_attr_destroy(&attr); - if (err) { - info->usingCallback = false; - sprintf(message_, "RtApiAl: error starting callback thread!"); - error(RtError::THREAD_ERROR); - } -} - -void RtApiAl :: cancelStreamCallback() -{ - verifyStream(); - - if (stream_.callbackInfo.usingCallback) { - - if (stream_.state == STREAM_RUNNING) - stopStream(); + MUTEX_UNLOCK( &stream_.mutex ); - MUTEX_LOCK(&stream_.mutex); - - stream_.callbackInfo.usingCallback = false; - pthread_join(stream_.callbackInfo.thread, NULL); - stream_.callbackInfo.thread = 0; - stream_.callbackInfo.callback = NULL; - stream_.callbackInfo.userData = NULL; - - MUTEX_UNLOCK(&stream_.mutex); - } + RtApi::tickStreamTime(); + if ( doStopStream == 1 ) this->stopStream(); + else if ( doStopStream == 2 ) this->abortStream(); } -extern "C" void *callbackHandler(void *ptr) +extern "C" void *ossCallbackHandler( void *ptr ) { CallbackInfo *info = (CallbackInfo *) ptr; - RtApiAl *object = (RtApiAl *) info->object; - bool *usingCallback = &info->usingCallback; + RtApiOss *object = (RtApiOss *) info->object; + bool *isRunning = &info->isRunning; - while ( *usingCallback ) { - try { - object->tickStream(); - } - catch (RtError &exception) { - fprintf(stderr, "\nRtApiAl: callback thread error (%s) ... closing thread.\n\n", - exception.getMessageString()); - break; - } +#ifdef SCHED_RR + // Set a higher scheduler priority (P.J. Leonard) + struct sched_param param; + param.sched_priority = 39; // Is this the best number? + sched_setscheduler( 0, SCHED_RR, ¶m ); +#endif + + while ( *isRunning == true ) { + pthread_testcancel(); + object->callbackEvent(); } - return 0; + pthread_exit( NULL ); } -//******************** End of __IRIX_AL__ *********************// +//******************** End of __LINUX_OSS__ *********************// #endif @@ -8500,86 +6829,160 @@ extern "C" void *callbackHandler(void *ptr) // *************************************************** // // This method can be modified to control the behavior of error -// message reporting and throwing. -void RtApi :: error(RtError::Type type) +// message printing. +void RtApi :: error( ErrorType type ) { - if (type == RtError::WARNING) { - fprintf(stderr, "\n%s\n\n", message_); - } - else if (type == RtError::DEBUG_WARNING) { -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\n%s\n\n", message_); -#endif - } - else { -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\n%s\n\n", message_); -#endif - throw RtError(std::string(message_), type); - } + if ( type == WARNING && showWarnings_ == true ) + std::cerr << '\n' << errorText_ << "\n\n"; + else if ( type == INVALID_CALL ) + throw( RtError( errorText_, RtError::INVALID_USE ) ); + else if ( type == SYSTEM ) + throw( RtError( errorText_, RtError::SYSTEM_ERROR ) ); + errorStream_.str(""); // clear the ostringstream } void RtApi :: verifyStream() { - if ( stream_.mode == UNINITIALIZED ) { - sprintf(message_, "RtAudio: stream is not open!"); - error(RtError::INVALID_STREAM); + if ( stream_.state == STREAM_CLOSED ) { + errorText_ = "RtApi:: a stream is not open!"; + error( INVALID_CALL ); } } -void RtApi :: clearDeviceInfo(RtApiDevice *info) -{ - // Don't clear the name or DEVICE_ID fields here ... they are - // typically set prior to a call of this function. - info->probed = false; - info->maxOutputChannels = 0; - info->maxInputChannels = 0; - info->maxDuplexChannels = 0; - info->minOutputChannels = 0; - info->minInputChannels = 0; - info->minDuplexChannels = 0; - info->hasDuplexSupport = false; - info->sampleRates.clear(); - info->nativeFormats = 0; -} - void RtApi :: clearStreamInfo() { stream_.mode = UNINITIALIZED; - stream_.state = STREAM_STOPPED; + stream_.state = STREAM_CLOSED; stream_.sampleRate = 0; stream_.bufferSize = 0; stream_.nBuffers = 0; stream_.userFormat = 0; + stream_.userInterleaved = true; + stream_.streamTime = 0.0; + stream_.apiHandle = 0; + stream_.deviceBuffer = 0; + stream_.callbackInfo.callback = 0; + stream_.callbackInfo.userData = 0; + stream_.callbackInfo.isRunning = false; for ( int i=0; i<2; i++ ) { stream_.device[i] = 0; stream_.doConvertBuffer[i] = false; - stream_.deInterleave[i] = false; + stream_.deviceInterleaved[i] = true; stream_.doByteSwap[i] = false; stream_.nUserChannels[i] = 0; stream_.nDeviceChannels[i] = 0; + stream_.channelOffset[i] = 0; stream_.deviceFormat[i] = 0; + stream_.latency[i] = 0; + stream_.userBuffer[i] = 0; + stream_.convertInfo[i].channels = 0; + stream_.convertInfo[i].inJump = 0; + stream_.convertInfo[i].outJump = 0; + stream_.convertInfo[i].inFormat = 0; + stream_.convertInfo[i].outFormat = 0; + stream_.convertInfo[i].inOffset.clear(); + stream_.convertInfo[i].outOffset.clear(); } } -int RtApi :: formatBytes(RtAudioFormat format) +unsigned int RtApi :: formatBytes( RtAudioFormat format ) { - if (format == RTAUDIO_SINT16) + if ( format == RTAUDIO_SINT16 ) return 2; - else if (format == RTAUDIO_SINT24 || format == RTAUDIO_SINT32 || - format == RTAUDIO_FLOAT32) + else if ( format == RTAUDIO_SINT24 || format == RTAUDIO_SINT32 || + format == RTAUDIO_FLOAT32 ) return 4; - else if (format == RTAUDIO_FLOAT64) + else if ( format == RTAUDIO_FLOAT64 ) return 8; - else if (format == RTAUDIO_SINT8) + else if ( format == RTAUDIO_SINT8 ) return 1; - sprintf(message_,"RtApi: undefined format in formatBytes()."); - error(RtError::WARNING); + errorText_ = "RtApi::formatBytes: undefined format."; + error( WARNING ); return 0; } +void RtApi :: setConvertInfo( StreamMode mode, unsigned int firstChannel ) +{ + if ( mode == INPUT ) { // convert device to user buffer + stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1]; + stream_.convertInfo[mode].outJump = stream_.nUserChannels[1]; + stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1]; + stream_.convertInfo[mode].outFormat = stream_.userFormat; + } + else { // convert user to device buffer + stream_.convertInfo[mode].inJump = stream_.nUserChannels[0]; + stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0]; + stream_.convertInfo[mode].inFormat = stream_.userFormat; + stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0]; + } + + if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump ) + stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump; + else + stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump; + + // Set up the interleave/deinterleave offsets. + if ( stream_.deviceInterleaved[mode] != stream_.userInterleaved ) { + if ( ( mode == OUTPUT && stream_.deviceInterleaved[mode] ) || + ( mode == INPUT && stream_.userInterleaved ) ) { + for ( int k=0; k 0 ) { + if ( stream_.deviceInterleaved[mode] ) { + if ( mode == OUTPUT ) { + for ( int k=0; k>= 8; } in += info.inJump; out += info.outJump; @@ -8853,9 +7258,9 @@ void RtApi :: convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info } else if (info.inFormat == RTAUDIO_FLOAT32) { Float32 *in = (Float32 *)inBuffer; - for (int i=0; i> 16) & 0x0000ffff); + out[info.outOffset[j]] = (Int16) ((in[info.inOffset[j]] >> 8) & 0x0000ffff); } in += info.inJump; out += info.outJump; @@ -8908,7 +7313,7 @@ void RtApi :: convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info } else if (info.inFormat == RTAUDIO_SINT32) { Int32 *in = (Int32 *)inBuffer; - for (int i=0; i> 16) & 0x0000ffff); } @@ -8918,7 +7323,7 @@ void RtApi :: convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info } else if (info.inFormat == RTAUDIO_FLOAT32) { Float32 *in = (Float32 *)inBuffer; - for (int i=0; i> 8) & 0x00ff); } @@ -8962,9 +7367,9 @@ void RtApi :: convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info } else if (info.inFormat == RTAUDIO_SINT24) { Int32 *in = (Int32 *)inBuffer; - for (int i=0; i> 24) & 0x000000ff); + out[info.outOffset[j]] = (signed char) ((in[info.inOffset[j]] >> 16) & 0x000000ff); } in += info.inJump; out += info.outJump; @@ -8972,7 +7377,7 @@ void RtApi :: convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info } else if (info.inFormat == RTAUDIO_SINT32) { Int32 *in = (Int32 *)inBuffer; - for (int i=0; i> 24) & 0x000000ff); } @@ -8982,7 +7387,7 @@ void RtApi :: convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info } else if (info.inFormat == RTAUDIO_FLOAT32) { Float32 *in = (Float32 *)inBuffer; - for (int i=0; i