From 8cd04dd6b77f05fe0f032959dfefda58b2ce38ae Mon Sep 17 00:00:00 2001 From: Gary Scavone Date: Wed, 9 Oct 2013 23:46:54 +0200 Subject: Version 3.0 --- RtAudio.cpp | 8028 ++++++++++++++++++++++++++++++++++------------------------- 1 file changed, 4573 insertions(+), 3455 deletions(-) (limited to 'RtAudio.cpp') diff --git a/RtAudio.cpp b/RtAudio.cpp index 8e44ba2..4211e4e 100644 --- a/RtAudio.cpp +++ b/RtAudio.cpp @@ -1,16 +1,16 @@ /************************************************************************/ /*! \class RtAudio - \brief Realtime audio i/o C++ class. + \brief Realtime audio i/o C++ classes. RtAudio provides a common API (Application Programming Interface) - for realtime audio input/output across Linux (native ALSA and - OSS), SGI, Macintosh OS X (CoreAudio), and Windows (DirectSound - and ASIO) operating systems. + for realtime audio input/output across Linux (native ALSA, Jack, + and OSS), SGI, Macintosh OS X (CoreAudio), and Windows + (DirectSound and ASIO) operating systems. - RtAudio WWW site: http://www-ccrma.stanford.edu/~gary/rtaudio/ + RtAudio WWW site: http://music.mcgill.ca/~gary/rtaudio/ RtAudio: a realtime audio i/o C++ class - Copyright (c) 2001-2002 Gary P. Scavone + Copyright (c) 2001-2004 Gary P. Scavone Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files @@ -37,31 +37,26 @@ */ /************************************************************************/ -// RtAudio: Version 2.1.1, 24 October 2002 +// RtAudio: Version 3.0, 11 March 2004 #include "RtAudio.h" -#include -#include -#include +#include // Static variable definitions. -const unsigned int RtAudio :: SAMPLE_RATES[] = { +const unsigned int RtApi::MAX_SAMPLE_RATES = 14; +const unsigned int RtApi::SAMPLE_RATES[] = { 4000, 5512, 8000, 9600, 11025, 16000, 22050, 32000, 44100, 48000, 88200, 96000, 176400, 192000 }; -const RtAudio::RTAUDIO_FORMAT RtAudio :: RTAUDIO_SINT8 = 1; -const RtAudio::RTAUDIO_FORMAT RtAudio :: RTAUDIO_SINT16 = 2; -const RtAudio::RTAUDIO_FORMAT RtAudio :: RTAUDIO_SINT24 = 4; -const RtAudio::RTAUDIO_FORMAT RtAudio :: RTAUDIO_SINT32 = 8; -const RtAudio::RTAUDIO_FORMAT RtAudio :: RTAUDIO_FLOAT32 = 16; -const RtAudio::RTAUDIO_FORMAT RtAudio :: RTAUDIO_FLOAT64 = 32; #if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) #define MUTEX_INITIALIZE(A) InitializeCriticalSection(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 #define MUTEX_INITIALIZE(A) pthread_mutex_init(A, NULL) + #define MUTEX_DESTROY(A) pthread_mutex_destroy(A); #define MUTEX_LOCK(A) pthread_mutex_lock(A) #define MUTEX_UNLOCK(A) pthread_mutex_unlock(A) #endif @@ -72,93 +67,202 @@ const RtAudio::RTAUDIO_FORMAT RtAudio :: RTAUDIO_FLOAT64 = 32; // // *************************************************** // -RtAudio :: RtAudio() +RtAudio :: RtAudio( RtAudioApi api ) { - initialize(); - - if (nDevices <= 0) { - sprintf(message, "RtAudio: no audio devices found!"); - error(RtError::NO_DEVICES_FOUND); - } + initialize( api ); } -RtAudio :: RtAudio(int *streamId, - int outputDevice, int outputChannels, - int inputDevice, int inputChannels, - RTAUDIO_FORMAT format, int sampleRate, - int *bufferSize, int numberOfBuffers) +RtAudio :: RtAudio( int outputDevice, int outputChannels, + int inputDevice, int inputChannels, + RtAudioFormat format, int sampleRate, + int *bufferSize, int numberOfBuffers, RtAudioApi api ) { - initialize(); - - if (nDevices <= 0) { - sprintf(message, "RtAudio: no audio devices found!"); - error(RtError::NO_DEVICES_FOUND); - } + initialize( api ); try { - *streamId = openStream(outputDevice, outputChannels, inputDevice, inputChannels, - format, sampleRate, bufferSize, numberOfBuffers); + rtapi_->openStream( outputDevice, outputChannels, + inputDevice, inputChannels, + format, sampleRate, + bufferSize, numberOfBuffers ); } catch (RtError &exception) { - // deallocate the RTAUDIO_DEVICE structures - if (devices) free(devices); + // Deallocate the RtApi instance. + delete rtapi_; throw exception; } } RtAudio :: ~RtAudio() { - // close any existing streams - while ( streams.size() ) - closeStream( streams.begin()->first ); + delete rtapi_; +} + +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 ); +} + +void RtAudio::initialize( RtAudioApi 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 ) + rtapi_ = new RtApiJack(); +#endif +#if defined(__LINUX_ALSA__) + if ( api == LINUX_ALSA ) + rtapi_ = new RtApiAlsa(); +#endif +#if defined(__LINUX_OSS__) + if ( api == LINUX_OSS ) + rtapi_ = new RtApiOss(); +#endif +#if defined(__WINDOWS_ASIO__) + if ( api == WINDOWS_ASIO ) + rtapi_ = new RtApiAsio(); +#endif +#if defined(__WINDOWS_DS__) + 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 ( 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 ); + } + + // 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 ( rtapi_ ) return; + +// 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; + } + } + + 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 + } + + if ( rtapi_ == 0 ) { + // No devices found. + throw RtError( "RtAudio: no devices found for compiled audio APIs!", RtError::NO_DEVICES_FOUND ); + } +} + +RtApi :: RtApi() +{ + stream_.mode = UNINITIALIZED; + stream_.apiHandle = 0; + MUTEX_INITIALIZE(&stream_.mutex); +} - // deallocate the RTAUDIO_DEVICE structures - if (devices) free(devices); +RtApi :: ~RtApi() +{ + MUTEX_DESTROY(&stream_.mutex); } -int RtAudio :: openStream(int outputDevice, int outputChannels, - int inputDevice, int inputChannels, - RTAUDIO_FORMAT format, int sampleRate, - int *bufferSize, int numberOfBuffers) +void RtApi :: openStream( int outputDevice, int outputChannels, + int inputDevice, int inputChannels, + RtAudioFormat format, int sampleRate, + int *bufferSize, int numberOfBuffers ) { - static int streamKey = 0; // Unique stream identifier ... OK for multiple instances. + if ( stream_.mode != UNINITIALIZED ) { + sprintf(message_, "RtApi: only one open stream allowed per class instance."); + error(RtError::INVALID_STREAM); + } if (outputChannels < 1 && inputChannels < 1) { - sprintf(message,"RtAudio: one or both 'channel' parameters must be greater than zero."); + sprintf(message_,"RtApi: one or both 'channel' parameters must be greater than zero."); error(RtError::INVALID_PARAMETER); } if ( formatBytes(format) == 0 ) { - sprintf(message,"RtAudio: 'format' parameter value is undefined."); + sprintf(message_,"RtApi: 'format' parameter value is undefined."); error(RtError::INVALID_PARAMETER); } if ( outputChannels > 0 ) { - if (outputDevice > nDevices || outputDevice < 0) { - sprintf(message,"RtAudio: 'outputDevice' parameter value (%d) is invalid.", outputDevice); + if (outputDevice > nDevices_ || outputDevice < 0) { + sprintf(message_,"RtApi: 'outputDevice' parameter value (%d) is invalid.", outputDevice); error(RtError::INVALID_PARAMETER); } } if ( inputChannels > 0 ) { - if (inputDevice > nDevices || inputDevice < 0) { - sprintf(message,"RtAudio: 'inputDevice' parameter value (%d) is invalid.", inputDevice); + if (inputDevice > nDevices_ || inputDevice < 0) { + sprintf(message_,"RtApi: 'inputDevice' parameter value (%d) is invalid.", inputDevice); error(RtError::INVALID_PARAMETER); } } - // Allocate a new stream structure. - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) calloc(1, sizeof(RTAUDIO_STREAM)); - if (stream == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); - error(RtError::MEMORY_ERROR); - } - stream->mode = UNINITIALIZED; - MUTEX_INITIALIZE(&stream->mutex); - + clearStreamInfo(); bool result = FAILURE; int device, defaultDevice = 0; - STREAM_MODE mode; + StreamMode mode; int channels; if ( outputChannels > 0 ) { @@ -172,22 +276,23 @@ int RtAudio :: openStream(int outputDevice, int outputChannels, else device = outputDevice - 1; - for (int i=-1; i= 0 ) { + for ( int i=-1; i= 0 ) { if ( i == defaultDevice ) continue; device = i; } - if (devices[device].probed == false) { + if (devices_[device].probed == false) { // If the device wasn't successfully probed before, try it - // again now. - clearDeviceInfo(&devices[device]); - probeDeviceInfo(&devices[device]); + // (again) now. + clearDeviceInfo(&devices_[device]); + probeDeviceInfo(&devices_[device]); } - if ( devices[device].probed ) - result = probeDeviceOpen(device, stream, mode, channels, sampleRate, + if ( devices_[device].probed ) + result = probeDeviceOpen(device, mode, channels, sampleRate, format, bufferSize, numberOfBuffers); - if (result == SUCCESS) break; + if ( result == SUCCESS ) break; if ( outputDevice > 0 ) break; + clearStreamInfo(); } } @@ -203,153 +308,116 @@ int RtAudio :: openStream(int outputDevice, int outputChannels, else device = inputDevice - 1; - for (int i=-1; i= 0 ) { if ( i == defaultDevice ) continue; device = i; } - if (devices[device].probed == false) { + if (devices_[device].probed == false) { // If the device wasn't successfully probed before, try it - // again now. - clearDeviceInfo(&devices[device]); - probeDeviceInfo(&devices[device]); + // (again) now. + clearDeviceInfo(&devices_[device]); + probeDeviceInfo(&devices_[device]); } - if ( devices[device].probed ) - result = probeDeviceOpen(device, stream, mode, channels, sampleRate, + if ( devices_[device].probed ) + result = probeDeviceOpen(device, mode, channels, sampleRate, format, bufferSize, numberOfBuffers); if (result == SUCCESS) break; if ( outputDevice > 0 ) break; } } - streams[++streamKey] = (void *) stream; if ( result == SUCCESS ) - return streamKey; + return; // If we get here, all attempted probes failed. Close any opened - // devices and delete the allocated stream. - closeStream(streamKey); + // devices and clear the stream structure. + if ( stream_.mode != UNINITIALIZED ) closeStream(); + clearStreamInfo(); if ( ( outputDevice == 0 && outputChannels > 0 ) || ( inputDevice == 0 && inputChannels > 0 ) ) - sprintf(message,"RtAudio: no devices found for given parameters."); + sprintf(message_,"RtApi: no devices found for given stream parameters."); else - sprintf(message,"RtAudio: unable to open specified device(s) with given stream parameters."); + sprintf(message_,"RtApi: unable to open specified device(s) with given stream parameters."); error(RtError::INVALID_PARAMETER); - return -1; + return; } -int RtAudio :: getDeviceCount(void) +int RtApi :: getDeviceCount(void) { - return nDevices; + return devices_.size(); } -void RtAudio :: getDeviceInfo(int device, RTAUDIO_DEVICE *info) +RtAudioDeviceInfo RtApi :: getDeviceInfo( int device ) { - if (device > nDevices || device < 1) { - sprintf(message, "RtAudio: invalid device specifier (%d)!", device); + if (device > (int) devices_.size() || device < 1) { + sprintf(message_, "RtApi: invalid device specifier (%d)!", device); error(RtError::INVALID_DEVICE); } + RtAudioDeviceInfo info; int deviceIndex = device - 1; // If the device wasn't successfully probed before, try it now (or again). - if (devices[deviceIndex].probed == false) { - clearDeviceInfo(&devices[deviceIndex]); - probeDeviceInfo(&devices[deviceIndex]); - } - - // Clear the info structure. - memset(info, 0, sizeof(RTAUDIO_DEVICE)); - - strncpy(info->name, devices[deviceIndex].name, 128); - info->probed = devices[deviceIndex].probed; - if ( info->probed == true ) { - info->maxOutputChannels = devices[deviceIndex].maxOutputChannels; - info->maxInputChannels = devices[deviceIndex].maxInputChannels; - info->maxDuplexChannels = devices[deviceIndex].maxDuplexChannels; - info->minOutputChannels = devices[deviceIndex].minOutputChannels; - info->minInputChannels = devices[deviceIndex].minInputChannels; - info->minDuplexChannels = devices[deviceIndex].minDuplexChannels; - info->hasDuplexSupport = devices[deviceIndex].hasDuplexSupport; - info->nSampleRates = devices[deviceIndex].nSampleRates; - if (info->nSampleRates == -1) { - info->sampleRates[0] = devices[deviceIndex].sampleRates[0]; - info->sampleRates[1] = devices[deviceIndex].sampleRates[1]; - } - else { - for (int i=0; inSampleRates; i++) - info->sampleRates[i] = devices[deviceIndex].sampleRates[i]; - } - info->nativeFormats = devices[deviceIndex].nativeFormats; - if ( deviceIndex == getDefaultOutputDevice() || - deviceIndex == getDefaultInputDevice() ) - info->isDefault = true; - } - - return; + if (devices_[deviceIndex].probed == false) { + clearDeviceInfo(&devices_[deviceIndex]); + probeDeviceInfo(&devices_[deviceIndex]); + } + + 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; iuserBuffer; + verifyStream(); + return stream_.userBuffer; } -#if defined(__LINUX_ALSA__) || defined(__LINUX_OSS__) || defined(__IRIX_AL__) - -extern "C" void *callbackHandler(void * ptr); - -void RtAudio :: setStreamCallback(int streamId, RTAUDIO_CALLBACK callback, void *userData) +int RtApi :: getDefaultInputDevice(void) { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - CALLBACK_INFO *info = (CALLBACK_INFO *) &stream->callbackInfo; - if ( info->usingCallback ) { - sprintf(message, "RtAudio: 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; - info->streamId = streamId; - - int err = pthread_create(&info->thread, NULL, callbackHandler, &stream->callbackInfo); - - if (err) { - info->usingCallback = false; - sprintf(message, "RtAudio: error starting callback thread!"); - error(RtError::THREAD_ERROR); - } + // Should be implemented in subclasses if appropriate. + return 0; } -void RtAudio :: cancelStreamCallback(int streamId) +int RtApi :: getDefaultOutputDevice(void) { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - if (stream->callbackInfo.usingCallback) { - - if (stream->state == STREAM_RUNNING) - stopStream( streamId ); + // Should be implemented in subclasses if appropriate. + return 0; +} - MUTEX_LOCK(&stream->mutex); +void RtApi :: closeStream(void) +{ + // MUST be implemented in subclasses! +} - stream->callbackInfo.usingCallback = false; - pthread_cancel(stream->callbackInfo.thread); - pthread_join(stream->callbackInfo.thread, NULL); - stream->callbackInfo.thread = 0; - stream->callbackInfo.callback = NULL; - stream->callbackInfo.userData = NULL; +void RtApi :: probeDeviceInfo( RtApiDevice *info ) +{ + // MUST be implemented in subclasses! +} - MUTEX_UNLOCK(&stream->mutex); - } +bool RtApi :: probeDeviceOpen( int device, StreamMode mode, int channels, + int sampleRate, RtAudioFormat format, + int *bufferSize, int numberOfBuffers ) +{ + // MUST be implemented in subclasses! + return FAILURE; } -#endif // *************************************************** // // @@ -357,126 +425,1188 @@ void RtAudio :: cancelStreamCallback(int streamId) // // *************************************************** // -#if defined(__MACOSX_CORE__) - -// 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()). -// -// The possibility of having multiple RtAudio streams accessing the -// same CoreAudio device is not currently supported. The problem -// involves the inability to install our callbackHandler function for -// the same device more than once. I experimented with a workaround -// for this, but it requires an additional buffer for mixing output -// data before filling the CoreAudio device buffer. In the end, I -// decided it wasn't worth supporting. -// -// Property listeners are currently not used. The issue is 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. Some initial listener code is -// commented out. - -void RtAudio :: initialize(void) -{ - OSStatus err = noErr; - UInt32 dataSize; - AudioDeviceID *deviceList = NULL; - nDevices = 0; - - // Find out how many audio devices there are, if any. - err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &dataSize, NULL); - if (err != noErr) { - sprintf(message, "RtAudio: OSX error getting device info!"); - error(RtError::SYSTEM_ERROR); - } - - nDevices = dataSize / sizeof(AudioDeviceID); - if (nDevices == 0) return; +#if defined(__LINUX_OSS__) - // Allocate the RTAUDIO_DEVICE structures. - devices = (RTAUDIO_DEVICE *) calloc(nDevices, sizeof(RTAUDIO_DEVICE)); - if (devices == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); - error(RtError::MEMORY_ERROR); - } +#include +#include +#include +#include +#include +#include +#include +#include +#include - // Make space for the devices we are about to get. - deviceList = (AudioDeviceID *) malloc( dataSize ); - if (deviceList == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); - error(RtError::MEMORY_ERROR); - } +#define DAC_NAME "/dev/dsp" +#define MAX_DEVICES 16 +#define MAX_CHANNELS 16 - // Get the array of AudioDeviceIDs. - err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &dataSize, (void *) deviceList); - if (err != noErr) { - free(deviceList); - sprintf(message, "RtAudio: OSX error getting device properties!"); - error(RtError::SYSTEM_ERROR); - } +extern "C" void *ossCallbackHandler(void * ptr); - // Write device identifiers to device structures and then - // probe the device capabilities. - for (int i=0; iinitialize(); - free(deviceList); + if (nDevices_ <= 0) { + sprintf(message_, "RtApiOss: no Linux OSS audio devices found!"); + error(RtError::NO_DEVICES_FOUND); + } } -int RtAudio :: getDefaultInputDevice(void) +RtApiOss :: ~RtApiOss() { - AudioDeviceID id; - UInt32 dataSize = sizeof( AudioDeviceID ); + if ( stream_.mode != UNINITIALIZED ) + closeStream(); +} - OSStatus result = AudioHardwareGetProperty( kAudioHardwarePropertyDefaultInputDevice, - &dataSize, &id ); +void RtApiOss :: initialize(void) +{ + // Count cards and devices + nDevices_ = 0; - if (result != noErr) { - sprintf( message, "RtAudio: OSX error getting default input device." ); - error(RtError::WARNING); - return 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); + } + } } - - for ( int i=0; i= 0) close(fd); + device.name.erase(); + device.name.append( (const char *)device_name, strlen(device_name)+1); + devices_.push_back(device); + nDevices_++; } - - return 0; } -static bool deviceSupportsFormat( AudioDeviceID id, bool isInput, - AudioStreamBasicDescription *desc, bool isDuplex ) +void RtApiOss :: probeDeviceInfo(RtApiDevice *info) { - OSStatus result = noErr; + int i, fd, channels, mask; + + // The OSS API doesn't provide a means for probing the capabilities + // of devices. Thus, we'll just pursue a brute force method. + + // 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; + } + 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; + } + 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; + } + + // We have the device open for capture ... 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->maxInputChannels = i; + + // 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; + } + 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; + } + + // 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; + + // Now find the minimum number of channels it can handle + for (i=1; i<=info->maxDuplexChannels; 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); + + 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. + + 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; + } + + 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; + } + + // 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; + } + + 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; + } + + // 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; + } +#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; + } +#endif + if (mask & AFMT_S8) { + format = AFMT_S8; + info->nativeFormats |= RTAUDIO_SINT8; + } + if (mask & AFMT_S16_BE) { + format = AFMT_S16_BE; + info->nativeFormats |= RTAUDIO_SINT16; + } + if (mask & AFMT_S16_LE) { + format = AFMT_S16_LE; + info->nativeFormats |= RTAUDIO_SINT16; + } + + // 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; + } + + // 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; + } + + // 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; + } + + // That's all ... close the device and return + close(fd); + info->probed = true; + return; +} + +bool RtApiOss :: probeDeviceOpen(int device, StreamMode mode, int channels, + int sampleRate, RtAudioFormat format, + int *bufferSize, int numberOfBuffers) +{ + int buffers, buffer_bytes, device_channels, device_format; + int srate, temp, fd; + int *handle = (int *) stream_.apiHandle; + + const char *name = devices_[device].name.c_str(); + + 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); + } + else + fd = open(name, O_RDONLY | O_NONBLOCK); + } + + 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; + } + + // 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); + } + + if (fd == -1) { + sprintf(message_, "RtApiOss: device (%s) cannot be opened.", name); + goto error; + } + + // 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; + } + + // 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 + } +#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 + } +#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; + } + } + + 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; + } + + // 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; + } + 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; + } + else { + if (channels < devices_[device].minInputChannels) + device_channels = devices_[device].minInputChannels; + } + } + stream_.nDeviceChannels[mode] = device_channels; + + // 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; + } + 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; + } + + // 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; + } + + // 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; + } + + // 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; + } + 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; + } + + // Save buffer size (in sample frames). + *bufferSize = buffer_bytes / (formatBytes(stream_.deviceFormat[mode]) * device_channels); + stream_.bufferSize = *bufferSize; + + 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; + } + + // 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; + } + else { + handle = (int *) stream_.apiHandle; + } + handle[mode] = fd; + + // 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; + + // 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) { + close(fd); + sprintf(message_, "RtApiOss: error allocating user buffer memory (%s).", + name); + 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) { + close(fd); + sprintf(message_, "RtApiOss: error allocating device buffer memory (%s).", + name); + goto error; + } + } + } + + stream_.device[mode] = device; + stream_.state = STREAM_STOPPED; + + if ( stream_.mode == OUTPUT && mode == INPUT ) { + stream_.mode = DUPLEX; + if (stream_.device[0] == device) + handle[0] = fd; + } + else + stream_.mode = mode; + + return SUCCESS; + + error: + if (handle) { + if (handle[0]) + close(handle[0]); + free(handle); + stream_.apiHandle = 0; + } + + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; + } + + error(RtError::WARNING); + return FAILURE; +} + +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 + // stream check. + if ( stream_.mode == UNINITIALIZED ) { + sprintf(message_, "RtApiOss::closeStream(): no open stream to close!"); + error(RtError::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); + } + + if (handle) { + if (handle[0]) close(handle[0]); + if (handle[1]) close(handle[1]); + 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 RtApiOss :: startStream() +{ + verifyStream(); + if (stream_.state == STREAM_RUNNING) return; + + MUTEX_LOCK(&stream_.mutex); + + stream_.state = STREAM_RUNNING; + + // No need to do anything else here ... OSS automatically starts + // when fed samples. + + MUTEX_UNLOCK(&stream_.mutex); +} + +void RtApiOss :: 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); + + 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); + } + } + 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); + } + } + + MUTEX_UNLOCK(&stream_.mutex); +} + +void RtApiOss :: abortStream() +{ + stopStream(); +} + +int RtApiOss :: streamWillBlock() +{ + verifyStream(); + if (stream_.state == STREAM_STOPPED) return 0; + + MUTEX_LOCK(&stream_.mutex); + + 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]; + } + + 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]; + } + else { + bytes = info.bytes; + channels = stream_.nDeviceChannels[1]; + } + } + + frames = (int) (bytes / (channels * formatBytes(stream_.deviceFormat[0]))); + frames -= stream_.bufferSize; + if (frames < 0) frames = 0; + + MUTEX_UNLOCK(&stream_.mutex); + return frames; +} + +void RtApiOss :: tickStream() +{ + verifyStream(); + + 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); + } + + MUTEX_LOCK(&stream_.mutex); + + // The state might change while waiting on a mutex. + if (stream_.state == STREAM_STOPPED) + goto unlock; + + int result, *handle; + char *buffer; + int samples; + RtAudioFormat format; + handle = (int *) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { + + // Setup parameters and do buffer conversion if necessary. + if (stream_.doConvertBuffer[0]) { + convertStreamBuffer(OUTPUT); + buffer = stream_.deviceBuffer; + samples = stream_.bufferSize * stream_.nDeviceChannels[0]; + format = stream_.deviceFormat[0]; + } + else { + buffer = stream_.userBuffer; + samples = stream_.bufferSize * stream_.nUserChannels[0]; + format = stream_.userFormat; + } + + // 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 (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; + } + + // Read samples from device. + result = read(handle[1], buffer, samples * formatBytes(format)); + + 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); + } + + // Do byte swapping if necessary. + if (stream_.doByteSwap[1]) + byteSwapBuffer(buffer, samples, format); + + // Do buffer conversion if necessary. + if (stream_.doConvertBuffer[1]) + convertStreamBuffer(INPUT); + } + + unlock: + MUTEX_UNLOCK(&stream_.mutex); + + if (stream_.callbackInfo.usingCallback && stopStream) + this->stopStream(); +} + +void RtApiOss :: setStreamCallback(RtAudioCallback callback, void *userData) +{ + verifyStream(); + + CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; + if ( info->usingCallback ) { + sprintf(message_, "RtApiOss: 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, ossCallbackHandler, &stream_.callbackInfo); + pthread_attr_destroy(&attr); + if (err) { + info->usingCallback = false; + sprintf(message_, "RtApiOss: error starting callback thread!"); + error(RtError::THREAD_ERROR); + } +} + +void RtApiOss :: cancelStreamCallback() +{ + verifyStream(); + + if (stream_.callbackInfo.usingCallback) { + + if (stream_.state == STREAM_RUNNING) + stopStream(); + + 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 *ossCallbackHandler(void *ptr) +{ + CallbackInfo *info = (CallbackInfo *) ptr; + RtApiOss *object = (RtApiOss *) info->object; + bool *usingCallback = &info->usingCallback; + + while ( *usingCallback ) { + pthread_testcancel(); + try { + object->tickStream(); + } + catch (RtError &exception) { + fprintf(stderr, "\nRtApiOss: callback thread error (%s) ... closing thread.\n\n", + exception.getMessageString()); + break; + } + } + + return 0; +} + +//******************** End of __LINUX_OSS__ *********************// +#endif + +#if defined(__MACOSX_CORE__) + + +// 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()). +// +// 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. + +// A structure to hold various information related to the CoreAuio API +// implementation. +struct CoreHandle { + UInt32 index[2]; + bool stopStream; + bool xrun; + char *deviceBuffer; + pthread_cond_t condition; + + CoreHandle() + :stopStream(false), xrun(false), deviceBuffer(0) {} +}; + +RtApiCore :: RtApiCore() +{ + this->initialize(); + + if (nDevices_ <= 0) { + sprintf(message_, "RtApiCore: no Macintosh OS-X Core Audio devices found!"); + error(RtError::NO_DEVICES_FOUND); + } +} + +RtApiCore :: ~RtApiCore() +{ + // 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; iid[0], 0, false, + AudioDeviceID *id = (AudioDeviceID *) info->apiDeviceId; + err = AudioDeviceGetProperty( *id, 0, false, kAudioDevicePropertyDeviceManufacturer, &dataSize, name ); if (err != noErr) { - sprintf( message, "RtAudio: OSX error getting device manufacturer." ); + sprintf( message_, "RtApiCore: OS-X error getting device manufacturer." ); error(RtError::DEBUG_WARNING); return; } @@ -519,32 +1650,33 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) strcat(fullname, ": " ); dataSize = 256; - err = AudioDeviceGetProperty( info->id[0], 0, false, + err = AudioDeviceGetProperty( *id, 0, false, kAudioDevicePropertyDeviceName, &dataSize, name ); if (err != noErr) { - sprintf( message, "RtAudio: OSX error getting device name." ); + sprintf( message_, "RtApiCore: OS-X error getting device name." ); error(RtError::DEBUG_WARNING); return; } strncat(fullname, name, 254); - strncat(info->name, fullname, 128); + info->name.erase(); + info->name.append( (const char *)fullname, strlen(fullname)+1); // Get output channel information. - unsigned int i, minChannels, maxChannels, nStreams = 0; + unsigned int i, minChannels = 0, maxChannels = 0, nStreams = 0; AudioBufferList *bufferList = nil; - err = AudioDeviceGetPropertyInfo( info->id[0], 0, false, + err = AudioDeviceGetPropertyInfo( *id, 0, false, kAudioDevicePropertyStreamConfiguration, &dataSize, NULL ); if (err == noErr && dataSize > 0) { bufferList = (AudioBufferList *) malloc( dataSize ); if (bufferList == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); + sprintf(message_, "RtApiCore: memory allocation error!"); error(RtError::DEBUG_WARNING); return; } - err = AudioDeviceGetProperty( info->id[0], 0, false, + err = AudioDeviceGetProperty( *id, 0, false, kAudioDevicePropertyStreamConfiguration, &dataSize, bufferList ); if (err == noErr) { @@ -558,13 +1690,15 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) } } } + free (bufferList); + if (err != noErr || dataSize <= 0) { - sprintf( message, "RtAudio: OSX error getting output channels for device (%s).", info->name ); + sprintf( message_, "RtApiCore: OS-X error getting output channels for device (%s).", + info->name.c_str() ); error(RtError::DEBUG_WARNING); return; } - free (bufferList); if ( nStreams ) { if ( maxChannels > 0 ) info->maxOutputChannels = maxChannels; @@ -574,17 +1708,17 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) // Get input channel information. bufferList = nil; - err = AudioDeviceGetPropertyInfo( info->id[0], 0, true, + err = AudioDeviceGetPropertyInfo( *id, 0, true, kAudioDevicePropertyStreamConfiguration, &dataSize, NULL ); if (err == noErr && dataSize > 0) { bufferList = (AudioBufferList *) malloc( dataSize ); if (bufferList == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); + sprintf(message_, "RtApiCore: memory allocation error!"); error(RtError::DEBUG_WARNING); return; } - err = AudioDeviceGetProperty( info->id[0], 0, true, + err = AudioDeviceGetProperty( *id, 0, true, kAudioDevicePropertyStreamConfiguration, &dataSize, bufferList ); if (err == noErr) { @@ -598,13 +1732,15 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) } } } + free (bufferList); + if (err != noErr || dataSize <= 0) { - sprintf( message, "RtAudio: OSX error getting input channels for device (%s).", info->name ); + sprintf( message_, "RtApiCore: OS-X error getting input channels for device (%s).", + info->name.c_str() ); error(RtError::DEBUG_WARNING); return; } - free (bufferList); if ( nStreams ) { if ( maxChannels > 0 ) info->maxInputChannels = maxChannels; @@ -636,93 +1772,87 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) if ( info->maxDuplexChannels > 0 ) isDuplex = true; // Determine the supported sample rates. - info->nSampleRates = 0; - for (i=0; iid[0], isInput, &description, isDuplex ) ) - info->sampleRates[info->nSampleRates++] = SAMPLE_RATES[i]; + info->sampleRates.clear(); + for (unsigned int k=0; ksampleRates.push_back( SAMPLE_RATES[k] ); } - if (info->nSampleRates == 0) { - sprintf( message, "RtAudio: No supported sample rates found for OSX device (%s).", info->name ); + 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; } - // Check for continuous sample rate support. - description.mSampleRate = kAudioStreamAnyRate; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) { - info->sampleRates[1] = info->sampleRates[info->nSampleRates-1]; - info->nSampleRates = -1; - } - // Determine the supported data formats. info->nativeFormats = 0; description.mFormatID = kAudioFormatLinearPCM; description.mBitsPerChannel = 8; description.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_SINT8; else { description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_SINT8; } description.mBitsPerChannel = 16; description.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_SINT16; else { description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_SINT16; } description.mBitsPerChannel = 32; description.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_SINT32; else { description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_SINT32; } description.mBitsPerChannel = 24; description.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsAlignedHigh | kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_SINT24; else { description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_SINT24; } description.mBitsPerChannel = 32; description.mFormatFlags = kLinearPCMFormatFlagIsFloat | kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_FLOAT32; else { description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_FLOAT32; } description.mBitsPerChannel = 64; description.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_FLOAT64; else { description.mFormatFlags &= ~kLinearPCMFormatFlagIsBigEndian; - if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) ) + if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) ) info->nativeFormats |= RTAUDIO_FLOAT64; } // Check that we have at least one supported format. if (info->nativeFormats == 0) { - sprintf(message, "RtAudio: OSX PCM device (%s) data format not supported by RtAudio.", - info->name); + sprintf(message_, "RtApiCore: OS-X device (%s) data format not supported by RtAudio.", + info->name.c_str()); error(RtError::DEBUG_WARNING); return; } @@ -738,68 +1868,51 @@ OSStatus callbackHandler(AudioDeviceID inDevice, const AudioTimeStamp* inOutputTime, void* infoPointer) { - CALLBACK_INFO *info = (CALLBACK_INFO *) infoPointer; + CallbackInfo *info = (CallbackInfo *) infoPointer; - RtAudio *object = (RtAudio *) info->object; + RtApiCore *object = (RtApiCore *) info->object; try { - object->callbackEvent( info->streamId, inDevice, (void *)inInputData, (void *)outOutputData ); + object->callbackEvent( inDevice, (void *)inInputData, (void *)outOutputData ); } catch (RtError &exception) { - fprintf(stderr, "\nCallback handler error (%s)!\n\n", exception.getMessage()); + fprintf(stderr, "\nRtApiCore: callback handler error (%s)!\n\n", exception.getMessageString()); return kAudioHardwareUnspecifiedError; } return kAudioHardwareNoError; } -/* OSStatus deviceListener(AudioDeviceID inDevice, UInt32 channel, Boolean isInput, AudioDevicePropertyID propertyID, - void* infoPointer) + void* handlePointer) { - CALLBACK_INFO *info = (CALLBACK_INFO *) infoPointer; - - RtAudio *object = (RtAudio *) info->object; - try { - object->settingChange( info->streamId ); - } - catch (RtError &exception) { - fprintf(stderr, "\nDevice listener error (%s)!\n\n", exception.getMessage()); - return kAudioHardwareUnspecifiedError; + 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; } return kAudioHardwareNoError; } -*/ -bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, - STREAM_MODE mode, int channels, - int sampleRate, RTAUDIO_FORMAT format, - int *bufferSize, int numberOfBuffers) +bool RtApiCore :: probeDeviceOpen( int device, StreamMode mode, int channels, + int sampleRate, RtAudioFormat format, + int *bufferSize, int numberOfBuffers ) { - // Check to make sure we don't already have a stream accessing this device. - RTAUDIO_STREAM *streamPtr; - std::map::const_iterator i; - for ( i=streams.begin(); i!=streams.end(); ++i ) { - streamPtr = (RTAUDIO_STREAM *) i->second; - if ( streamPtr->device[0] == device || streamPtr->device[1] == device ) { - sprintf(message, "RtAudio: no current OS X support for multiple streams accessing the same device!"); - error(RtError::WARNING); - return FAILURE; - } - } - // Setup for stream mode. bool isInput = false; - AudioDeviceID id = devices[device].id[0]; + AudioDeviceID id = *((AudioDeviceID *) devices_[device].apiDeviceId); if ( mode == INPUT ) isInput = true; // Search for a stream which contains the desired number of channels. OSStatus err = noErr; UInt32 dataSize; - unsigned int deviceChannels, nStreams; + unsigned int deviceChannels, nStreams = 0; UInt32 iChannel = 0, iStream = 0; AudioBufferList *bufferList = nil; err = AudioDeviceGetPropertyInfo( id, 0, isInput, @@ -809,7 +1922,7 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, if (err == noErr && dataSize > 0) { bufferList = (AudioBufferList *) malloc( dataSize ); if (bufferList == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); + sprintf(message_, "RtApiCore: memory allocation error in probeDeviceOpen()!"); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -818,7 +1931,7 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, &dataSize, bufferList ); if (err == noErr) { - stream->deInterleave[mode] = false; + stream_.deInterleave[mode] = false; nStreams = bufferList->mNumberBuffers; for ( iStream=0; iStreammBuffers[iStream].mNumberChannels >= (unsigned int) channels ) break; @@ -840,7 +1953,7 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, if ( counter == channels ) { iStream -= channels - 1; iChannel -= channels - 1; - stream->deInterleave[mode] = true; + stream_.deInterleave[mode] = true; break; } iChannel += bufferList->mBuffers[iStream].mNumberChannels; @@ -850,15 +1963,16 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, } if (err != noErr || dataSize <= 0) { if ( bufferList ) free( bufferList ); - sprintf( message, "RtAudio: OSX error getting channels for device (%s).", devices[device].name ); + sprintf( message_, "RtApiCore: OS-X error getting channels for device (%s).", + devices_[device].name.c_str() ); error(RtError::DEBUG_WARNING); return FAILURE; } if (iStream >= nStreams) { free (bufferList); - sprintf( message, "RtAudio: unable to find OSX audio stream on device (%s) for requested channels (%d).", - devices[device].name, channels ); + 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); return FAILURE; } @@ -874,8 +1988,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, kAudioDevicePropertyBufferSizeRange, &dataSize, &bufferRange); if (err != noErr) { - sprintf( message, "RtAudio: OSX error getting buffer size range for device (%s).", - devices[device].name ); + sprintf( message_, "RtApiCore: OS-X error getting buffer size range for device (%s).", + devices_[device].name.c_str() ); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -892,8 +2006,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, kAudioDevicePropertyBufferSize, dataSize, &theSize); if (err != noErr) { - sprintf( message, "RtAudio: OSX error setting the buffer size for device (%s).", - devices[device].name ); + sprintf( message_, "RtApiCore: OS-X error setting the buffer size for device (%s).", + devices_[device].name.c_str() ); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -901,20 +2015,20 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, // 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, "RtAudio: OSX error setting buffer size for duplex stream on device (%s).", - devices[device].name ); + 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); return FAILURE; } - stream->bufferSize = *bufferSize; - stream->nBuffers = 1; + stream_.bufferSize = *bufferSize; + stream_.nBuffers = 1; // Set the stream format description. Do for each channel in mono mode. AudioStreamBasicDescription description; dataSize = sizeof( AudioStreamBasicDescription ); - if ( stream->deInterleave[mode] ) nStreams = channels; + if ( stream_.deInterleave[mode] ) nStreams = channels; else nStreams = 1; for ( unsigned int i=0; idoByteSwap[mode] = false; + stream_.doByteSwap[mode] = false; if ( !description.mFormatFlags & kLinearPCMFormatFlagIsBigEndian ) - stream->doByteSwap[mode] = true; + 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; + stream_.userFormat = format; + stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; - if ( stream->deInterleave[mode] ) - stream->nDeviceChannels[mode] = channels; + if ( stream_.deInterleave[mode] ) // mono mode + stream_.nDeviceChannels[mode] = channels; + else + stream_.nDeviceChannels[mode] = description.mChannelsPerFrame; + stream_.nUserChannels[mode] = channels; + + // 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 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()); + 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()); + goto error; + } + stream_.apiHandle = (void *) handle; + } else - stream->nDeviceChannels[mode] = description.mChannelsPerFrame; - stream->nUserChannels[mode] = channels; - - // Set handle and flags for buffer conversion. - stream->handle[mode] = iStream; - 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; + handle = (CoreHandle *) stream_.apiHandle; + handle->index[mode] = iStream; // Allocate necessary internal buffers. - if ( stream->nUserChannels[0] != stream->nUserChannels[1] ) { + if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { long buffer_bytes; - if (stream->nUserChannels[0] >= stream->nUserChannels[1]) - buffer_bytes = stream->nUserChannels[0]; + 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) - goto memory_error; + 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; + } } - if ( stream->deInterleave[mode] ) { + if ( stream_.deInterleave[mode] ) { long buffer_bytes; bool makeBuffer = true; if ( mode == OUTPUT ) - buffer_bytes = stream->nDeviceChannels[0] * formatBytes(stream->deviceFormat[0]); + 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]); + 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) - goto memory_error; + 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()); + goto error; + } - // If not de-interleaving, we point stream->deviceBuffer to the + // 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 CALLBACK_INFO structure. - stream->callbackInfo.buffers = stream->deviceBuffer; + // device buffer in the CallbackInfo structure. + handle->deviceBuffer = stream_.deviceBuffer; } } - stream->sampleRate = sampleRate; - stream->device[mode] = device; - stream->state = STREAM_STOPPED; - stream->callbackInfo.object = (void *) this; - stream->callbackInfo.waitTime = (unsigned long) (200000.0 * stream->bufferSize / stream->sampleRate); - stream->callbackInfo.device[mode] = id; - if ( stream->mode == OUTPUT && mode == INPUT && stream->device[0] == device ) + stream_.sampleRate = sampleRate; + stream_.device[mode] = device; + stream_.state = STREAM_STOPPED; + stream_.callbackInfo.object = (void *) this; + + if ( stream_.mode == OUTPUT && mode == INPUT && stream_.device[0] == device ) // Only one callback procedure per device. - stream->mode = DUPLEX; + stream_.mode = DUPLEX; else { - err = AudioDeviceAddIOProc( id, callbackHandler, (void *) &stream->callbackInfo ); + err = AudioDeviceAddIOProc( id, callbackHandler, (void *) &stream_.callbackInfo ); if (err != noErr) { - sprintf( message, "RtAudio: OSX error setting callback for device (%s).", devices[device].name ); + sprintf( message_, "RtApiCore: OS-X error setting callback for device (%s).", devices_[device].name.c_str() ); error(RtError::DEBUG_WARNING); return FAILURE; } - if ( stream->mode == OUTPUT && mode == INPUT ) - stream->mode = DUPLEX; + if ( stream_.mode == OUTPUT && mode == INPUT ) + stream_.mode = DUPLEX; else - stream->mode = mode; + stream_.mode = mode; } - // If we wanted to use property listeners, they would be setup here. + // Setup the device property listener for over/underload. + err = AudioDeviceAddPropertyListener( id, iChannel, isInput, + kAudioDeviceProcessorOverload, + deviceListener, (void *) handle ); return SUCCESS; - memory_error: - if (stream->userBuffer) { - free(stream->userBuffer); - stream->userBuffer = 0; + error: + if ( handle ) { + pthread_cond_destroy(&handle->condition); + free(handle); + stream_.apiHandle = 0; } - sprintf(message, "RtAudio: OSX error allocating buffer memory (%s).", devices[device].name); - error(RtError::WARNING); - return FAILURE; -} - -void RtAudio :: cancelStreamCallback(int streamId) -{ - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - if (stream->callbackInfo.usingCallback) { - - if (stream->state == STREAM_RUNNING) - stopStream( streamId ); - - MUTEX_LOCK(&stream->mutex); - - stream->callbackInfo.usingCallback = false; - stream->callbackInfo.userData = NULL; - stream->state = STREAM_STOPPED; - stream->callbackInfo.callback = NULL; - MUTEX_UNLOCK(&stream->mutex); + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; } + + error(RtError::WARNING); + return FAILURE; } -void RtAudio :: closeStream(int streamId) +void RtApiCore :: 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 ( streams.find( streamId ) == streams.end() ) { - sprintf(message, "RtAudio: invalid stream identifier!"); + // stream check. + if ( stream_.mode == UNINITIALIZED ) { + sprintf(message_, "RtApiCore::closeStream(): no open stream to close!"); error(RtError::WARNING); return; } - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) streams[streamId]; - - AudioDeviceID id; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - id = devices[stream->device[0]].id[0]; - if (stream->state == STREAM_RUNNING) + 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 ); } - if (stream->mode == INPUT || ( stream->mode == DUPLEX && stream->device[0] != stream->device[1]) ) { - id = devices[stream->device[1]].id[0]; - if (stream->state == STREAM_RUNNING) + 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 ); } - pthread_mutex_destroy(&stream->mutex); + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; + } + + if ( stream_.deInterleave[0] || stream_.deInterleave[1] ) { + free(stream_.deviceBuffer); + stream_.deviceBuffer = 0; + } - if (stream->userBuffer) - free(stream->userBuffer); + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; - if ( stream->deInterleave[0] || stream->deInterleave[1] ) - free(stream->callbackInfo.buffers); + // Destroy pthread condition variable and free the CoreHandle structure. + if ( handle ) { + pthread_cond_destroy(&handle->condition); + free( handle ); + stream_.apiHandle = 0; + } - free(stream); - streams.erase(streamId); + stream_.mode = UNINITIALIZED; } -void RtAudio :: startStream(int streamId) +void RtApiCore :: startStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_RUNNING) return; - MUTEX_LOCK(&stream->mutex); - - if (stream->state == STREAM_RUNNING) - goto unlock; + MUTEX_LOCK(&stream_.mutex); OSStatus err; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { + AudioDeviceID id; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - err = AudioDeviceStart(devices[stream->device[0]].id[0], callbackHandler); + id = *( (AudioDeviceID *) devices_[stream_.device[0]].apiDeviceId ); + err = AudioDeviceStart(id, callbackHandler); if (err != noErr) { - sprintf(message, "RtAudio: OSX error starting callback procedure on device (%s).", - devices[stream->device[0]].name); - MUTEX_UNLOCK(&stream->mutex); + 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); } } - if (stream->mode == INPUT || ( stream->mode == DUPLEX && stream->device[0] != stream->device[1]) ) { + if (stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1]) ) { - err = AudioDeviceStart(devices[stream->device[1]].id[0], callbackHandler); + id = *( (AudioDeviceID *) devices_[stream_.device[1]].apiDeviceId ); + err = AudioDeviceStart(id, callbackHandler); if (err != noErr) { - sprintf(message, "RtAudio: OSX error starting input callback procedure on device (%s).", - devices[stream->device[0]].name); - MUTEX_UNLOCK(&stream->mutex); + 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); } } - stream->callbackInfo.streamId = streamId; - stream->state = STREAM_RUNNING; - stream->callbackInfo.blockTick = true; - stream->callbackInfo.stopStream = false; + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; + handle->stopStream = false; + stream_.state = STREAM_RUNNING; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: stopStream(int streamId) +void RtApiCore :: stopStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - MUTEX_LOCK(&stream->mutex); - - if (stream->state == STREAM_STOPPED) - goto unlock; + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK(&stream_.mutex); OSStatus err; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { + AudioDeviceID id; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - err = AudioDeviceStop(devices[stream->device[0]].id[0], callbackHandler); + id = *( (AudioDeviceID *) devices_[stream_.device[0]].apiDeviceId ); + err = AudioDeviceStop(id, callbackHandler); if (err != noErr) { - sprintf(message, "RtAudio: OSX error stopping callback procedure on device (%s).", - devices[stream->device[0]].name); - MUTEX_UNLOCK(&stream->mutex); + 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->mode == INPUT || ( stream->mode == DUPLEX && stream->device[0] != stream->device[1]) ) { + if (stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1]) ) { - err = AudioDeviceStop(devices[stream->device[1]].id[0], callbackHandler); + id = *( (AudioDeviceID *) devices_[stream_.device[1]].apiDeviceId ); + err = AudioDeviceStop(id, callbackHandler); if (err != noErr) { - sprintf(message, "RtAudio: OSX error stopping input callback procedure on device (%s).", - devices[stream->device[0]].name); - MUTEX_UNLOCK(&stream->mutex); + 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); } } - stream->state = STREAM_STOPPED; - - unlock: - MUTEX_UNLOCK(&stream->mutex); -} - -void RtAudio :: abortStream(int streamId) -{ - stopStream( streamId ); + MUTEX_UNLOCK(&stream_.mutex); } -// I don't know how this function can be implemented. -int RtAudio :: streamWillBlock(int streamId) +void RtApiCore :: abortStream() { - sprintf(message, "RtAudio: streamWillBlock() cannot be implemented for OS X."); - error(RtError::WARNING); - return 0; + stopStream(); } -void RtAudio :: tickStream(int streamId) +void RtApiCore :: tickStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); - if (stream->state == STREAM_STOPPED) - return; + if (stream_.state == STREAM_STOPPED) return; - if (stream->callbackInfo.usingCallback) { - sprintf(message, "RtAudio: tickStream() should not be used when a callback function is set!"); + if (stream_.callbackInfo.usingCallback) { + sprintf(message_, "RtApiCore: tickStream() should not be used when a callback function is set!"); error(RtError::WARNING); return; } - // Block waiting here until the user data is processed in callbackEvent(). - while ( stream->callbackInfo.blockTick ) - usleep(stream->callbackInfo.waitTime); + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; - MUTEX_LOCK(&stream->mutex); + MUTEX_LOCK(&stream_.mutex); - stream->callbackInfo.blockTick = true; + pthread_cond_wait(&handle->condition, &stream_.mutex); - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: callbackEvent( int streamId, DEVICE_ID deviceId, void *inData, void *outData ) +void RtApiCore :: callbackEvent( AudioDeviceID deviceId, void *inData, void *outData ) { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + + if (stream_.state == STREAM_STOPPED) return; - CALLBACK_INFO *info; + CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; + CoreHandle *handle = (CoreHandle *) stream_.apiHandle; AudioBufferList *inBufferList = (AudioBufferList *) inData; AudioBufferList *outBufferList = (AudioBufferList *) outData; - if (stream->state == STREAM_STOPPED) return; - - info = (CALLBACK_INFO *) &stream->callbackInfo; - if ( !info->usingCallback ) { - // Block waiting here until we get new user data in tickStream(). - while ( !info->blockTick ) - usleep(info->waitTime); - } - else if ( info->stopStream ) { + 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(info->streamId); + this->stopStream(); return; } - 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, the input/output devices - // are different, and this function is called for the input device. - if ( info->usingCallback && (stream->mode != DUPLEX || deviceId == info->device[0] ) ) { - RTAUDIO_CALLBACK callback = (RTAUDIO_CALLBACK) info->callback; - info->stopStream = callback(stream->userBuffer, stream->bufferSize, info->userData); + // 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 ) ) { + 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; + } } - if ( stream->mode == OUTPUT || ( stream->mode == DUPLEX && deviceId == info->device[0] ) ) { + if ( stream_.mode == OUTPUT || ( stream_.mode == DUPLEX && deviceId == id ) ) { - if (stream->doConvertBuffer[0]) { + if (stream_.doConvertBuffer[0]) { - if ( !stream->deInterleave[0] ) - stream->deviceBuffer = (char *) outBufferList->mBuffers[stream->handle[0]].mData; + if ( !stream_.deInterleave[0] ) + stream_.deviceBuffer = (char *) outBufferList->mBuffers[handle->index[0]].mData; else - stream->deviceBuffer = (char *) stream->callbackInfo.buffers; - - convertStreamBuffer(stream, OUTPUT); - if ( stream->doByteSwap[0] ) - byteSwapBuffer(stream->deviceBuffer, - stream->bufferSize * stream->nDeviceChannels[0], - stream->deviceFormat[0]); - - if ( stream->deInterleave[0] ) { - int bufferBytes = outBufferList->mBuffers[stream->handle[0]].mDataByteSize; - for ( int i=0; inDeviceChannels[0]; i++ ) { - memcpy(outBufferList->mBuffers[stream->handle[0]+i].mData, - &stream->deviceBuffer[i*bufferBytes], bufferBytes ); + stream_.deviceBuffer = handle->deviceBuffer; + + convertStreamBuffer(OUTPUT); + 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 ); } } } else { - if (stream->doByteSwap[0]) - byteSwapBuffer(stream->userBuffer, - stream->bufferSize * stream->nUserChannels[0], - stream->userFormat); + if (stream_.doByteSwap[0]) + byteSwapBuffer(stream_.userBuffer, + stream_.bufferSize * stream_.nUserChannels[0], + stream_.userFormat); - memcpy(outBufferList->mBuffers[stream->handle[0]].mData, - stream->userBuffer, - outBufferList->mBuffers[stream->handle[0]].mDataByteSize ); + memcpy(outBufferList->mBuffers[handle->index[0]].mData, + stream_.userBuffer, + outBufferList->mBuffers[handle->index[0]].mDataByteSize ); } } - if ( stream->mode == INPUT || ( stream->mode == DUPLEX && deviceId == info->device[1] ) ) { + if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && deviceId == id ) ) { - if (stream->doConvertBuffer[1]) { + if (stream_.doConvertBuffer[1]) { - if ( stream->deInterleave[1] ) { - stream->deviceBuffer = (char *) stream->callbackInfo.buffers; - int bufferBytes = inBufferList->mBuffers[stream->handle[1]].mDataByteSize; - for ( int i=0; inDeviceChannels[1]; i++ ) { - memcpy(&stream->deviceBuffer[i*bufferBytes], - inBufferList->mBuffers[stream->handle[1]+i].mData, bufferBytes ); + 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 ); } } else - stream->deviceBuffer = (char *) inBufferList->mBuffers[stream->handle[1]].mData; - - if ( stream->doByteSwap[1] ) - byteSwapBuffer(stream->deviceBuffer, - stream->bufferSize * stream->nDeviceChannels[1], - stream->deviceFormat[1]); - convertStreamBuffer(stream, INPUT); - - } - else { - memcpy(stream->userBuffer, - inBufferList->mBuffers[stream->handle[1]].mData, - inBufferList->mBuffers[stream->handle[1]].mDataByteSize ); - - if (stream->doByteSwap[1]) - byteSwapBuffer(stream->userBuffer, - stream->bufferSize * stream->nUserChannels[1], - stream->userFormat); - } - } - - if ( !info->usingCallback && (stream->mode != DUPLEX || deviceId == info->device[1] ) ) - info->blockTick = false; - - MUTEX_UNLOCK(&stream->mutex); - -} - -void RtAudio :: setStreamCallback(int streamId, RTAUDIO_CALLBACK callback, void *userData) -{ - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - stream->callbackInfo.callback = (void *) callback; - stream->callbackInfo.userData = userData; - stream->callbackInfo.usingCallback = true; -} - -//******************** End of __MACOSX_CORE__ *********************// - -#elif defined(__LINUX_ALSA__) - -#define MAX_DEVICES 16 - -void RtAudio :: initialize(void) -{ - int card, result, device; - char name[32]; - const char *cardId; - char deviceNames[MAX_DEVICES][32]; - snd_ctl_t *handle; - snd_ctl_card_info_t *info; - snd_ctl_card_info_alloca(&info); - - // 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, "RtAudio: ALSA 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, "RtAudio: ALSA control hardware info (%i): %s.", card, snd_strerror(result)); - error(RtError::DEBUG_WARNING); - goto next_card; - } - cardId = snd_ctl_card_info_get_id(info); - device = -1; - while (1) { - result = snd_ctl_pcm_next_device(handle, &device); - if (result < 0) { - sprintf(message, "RtAudio: ALSA control next device (%i): %s.", card, snd_strerror(result)); - error(RtError::DEBUG_WARNING); - break; - } - if (device < 0) - break; - if ( strlen(cardId) ) - sprintf( deviceNames[nDevices++], "hw:%s,%d", cardId, device ); - else - sprintf( deviceNames[nDevices++], "hw:%d,%d", card, device ); - if ( nDevices > MAX_DEVICES ) break; - } - if ( nDevices > MAX_DEVICES ) break; - next_card: - snd_ctl_close(handle); - snd_card_next(&card); - } - - if (nDevices == 0) return; - - // Allocate the RTAUDIO_DEVICE structures. - devices = (RTAUDIO_DEVICE *) calloc(nDevices, sizeof(RTAUDIO_DEVICE)); - if (devices == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); - error(RtError::MEMORY_ERROR); - } - - // Write device ascii identifiers to device structures and then - // probe the device capabilities. - for (int i=0; iname, 32 ); - card = strtok(name, ","); - err = snd_ctl_open(&chandle, card, 0); - if (err < 0) { - sprintf(message, "RtAudio: ALSA control open (%s): %s.", card, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - 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); - - if ((err = snd_ctl_pcm_info(chandle, pcminfo)) < 0) { - if (err == -ENOENT) { - sprintf(message, "RtAudio: ALSA pcm device (%s) doesn't handle output!", info->name); - error(RtError::DEBUG_WARNING); - } - else { - sprintf(message, "RtAudio: ALSA snd_ctl_pcm_info error for device (%s) output: %s", - info->name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - } - goto capture_probe; - } - - err = snd_pcm_open(&handle, info->name, stream, open_mode | SND_PCM_NONBLOCK ); - if (err < 0) { - if ( err == EBUSY ) - sprintf(message, "RtAudio: ALSA pcm playback device (%s) is busy: %s.", - info->name, snd_strerror(err)); - else - sprintf(message, "RtAudio: ALSA pcm playback open (%s) error: %s.", - info->name, snd_strerror(err)); - error(RtError::DEBUG_WARNING); - goto capture_probe; - } - - // 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, "RtAudio: ALSA hardware probe error (%s): %s.", - info->name, snd_strerror(err)); - error(RtError::WARNING); - goto capture_probe; - } - - // Get output channel information. - info->minOutputChannels = snd_pcm_hw_params_get_channels_min(params); - info->maxOutputChannels = snd_pcm_hw_params_get_channels_max(params); - - snd_pcm_close(handle); - - capture_probe: - // Now try for capture - stream = SND_PCM_STREAM_CAPTURE; - snd_pcm_info_set_stream(pcminfo, stream); - - err = snd_ctl_pcm_info(chandle, pcminfo); - snd_ctl_close(chandle); - if ( err < 0 ) { - if (err == -ENOENT) { - sprintf(message, "RtAudio: ALSA pcm device (%s) doesn't handle input!", info->name); - error(RtError::DEBUG_WARNING); - } - else { - sprintf(message, "RtAudio: ALSA snd_ctl_pcm_info error for device (%s) input: %s", - info->name, 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, stream, open_mode | SND_PCM_NONBLOCK); - if (err < 0) { - if ( err == EBUSY ) - sprintf(message, "RtAudio: ALSA pcm capture device (%s) is busy: %s.", - info->name, snd_strerror(err)); - else - sprintf(message, "RtAudio: ALSA pcm capture open (%s) error: %s.", - info->name, 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, "RtAudio: ALSA hardware probe error (%s): %s.", - info->name, snd_strerror(err)); - error(RtError::WARNING); - if (info->maxOutputChannels > 0) - goto probe_parameters; - else - return; - } - - // Get input channel information. - info->minInputChannels = snd_pcm_hw_params_get_channels_min(params); - info->maxInputChannels = snd_pcm_hw_params_get_channels_max(params); - - snd_pcm_close(handle); - - // If device opens for both playback and capture, we determine the channels. - if (info->maxOutputChannels == 0 || info->maxInputChannels == 0) - goto probe_parameters; - - info->hasDuplexSupport = true; - info->maxDuplexChannels = (info->maxOutputChannels > info->maxInputChannels) ? - info->maxInputChannels : info->maxOutputChannels; - info->minDuplexChannels = (info->minOutputChannels > info->minInputChannels) ? - info->minInputChannels : info->minOutputChannels; - - 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. - - if (info->maxOutputChannels >= info->maxInputChannels) - stream = SND_PCM_STREAM_PLAYBACK; - else - stream = SND_PCM_STREAM_CAPTURE; - - err = snd_pcm_open(&handle, info->name, stream, open_mode); - if (err < 0) { - sprintf(message, "RtAudio: ALSA pcm (%s) won't reopen during probe: %s.", - info->name, snd_strerror(err)); - error(RtError::WARNING); - return; - } - - // 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, "RtAudio: ALSA hardware reopen probe error (%s): %s.", - info->name, snd_strerror(err)); - error(RtError::WARNING); - return; - } - - // Test a non-standard sample rate to see if continuous rate is supported. - int dir = 0; - if (snd_pcm_hw_params_test_rate(handle, params, 35500, dir) == 0) { - // It appears that continuous sample rate support is available. - info->nSampleRates = -1; - info->sampleRates[0] = snd_pcm_hw_params_get_rate_min(params, &dir); - info->sampleRates[1] = snd_pcm_hw_params_get_rate_max(params, &dir); - } - else { - // No continuous rate support ... test our discrete set of sample rate values. - info->nSampleRates = 0; - for (int i=0; isampleRates[info->nSampleRates] = SAMPLE_RATES[i]; - info->nSampleRates++; - } + stream_.deviceBuffer = (char *) inBufferList->mBuffers[handle->index[1]].mData; + + if ( stream_.doByteSwap[1] ) + byteSwapBuffer(stream_.deviceBuffer, + stream_.bufferSize * stream_.nDeviceChannels[1], + stream_.deviceFormat[1]); + convertStreamBuffer(INPUT); + } - if (info->nSampleRates == 0) { - snd_pcm_close(handle); - return; + 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); } } - // 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; + if ( !info->usingCallback && (stream_.mode != DUPLEX || deviceId == id ) ) + pthread_cond_signal(&handle->condition); - // Check that we have at least one supported format - if (info->nativeFormats == 0) { - snd_pcm_close(handle); - sprintf(message, "RtAudio: ALSA PCM device (%s) data format not supported by RtAudio.", - info->name); + MUTEX_UNLOCK(&stream_.mutex); +} + +void RtApiCore :: setStreamCallback(RtAudioCallback callback, void *userData) +{ + verifyStream(); + + if ( stream_.callbackInfo.usingCallback ) { + sprintf(message_, "RtApiCore: A callback is already set for this stream!"); error(RtError::WARNING); return; } - // That's all ... close the device and return - snd_pcm_close(handle); - info->probed = true; - return; + stream_.callbackInfo.callback = (void *) callback; + stream_.callbackInfo.userData = userData; + stream_.callbackInfo.usingCallback = true; } -bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, - STREAM_MODE mode, int channels, - int sampleRate, RTAUDIO_FORMAT format, - int *bufferSize, int numberOfBuffers) +void RtApiCore :: cancelStreamCallback() { -#if defined(__RTAUDIO_DEBUG__) - snd_output_t *out; - snd_output_stdio_attach(&out, stderr, 0); -#endif + verifyStream(); - // I'm not using the "plug" interface ... too much inconsistent behavior. - const char *name = devices[device].name; + if (stream_.callbackInfo.usingCallback) { - snd_pcm_stream_t alsa_stream; - if (mode == OUTPUT) - alsa_stream = SND_PCM_STREAM_PLAYBACK; - else - alsa_stream = SND_PCM_STREAM_CAPTURE; + if (stream_.state == STREAM_RUNNING) + stopStream(); - 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,"RtAudio: ALSA pcm device (%s) won't open: %s.", - name, snd_strerror(err)); - error(RtError::WARNING); - return FAILURE; - } + MUTEX_LOCK(&stream_.mutex); - // 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, "RtAudio: ALSA error getting parameter handle (%s): %s.", - name, snd_strerror(err)); - error(RtError::WARNING); - return FAILURE; + stream_.callbackInfo.usingCallback = false; + stream_.callbackInfo.userData = NULL; + stream_.state = STREAM_STOPPED; + stream_.callbackInfo.callback = NULL; + + MUTEX_UNLOCK(&stream_.mutex); } +} -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\nRtAudio: ALSA dump hardware params just after device open:\n\n"); - snd_pcm_hw_params_dump(hw_params, out); + +//******************** End of __MACOSX_CORE__ *********************// #endif +#if defined(__LINUX_JACK__) - // 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, "RtAudio: ALSA device (%s) access not supported by RtAudio.", name); - error(RtError::WARNING); - return FAILURE; - } +// 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 +// +// 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. - if (err < 0) { - snd_pcm_close(handle); - sprintf(message, "RtAudio: ALSA error setting access ( (%s): %s.", name, snd_strerror(err)); - error(RtError::WARNING); - return FAILURE; - } +#include +#include - // Determine how to set the device format. - stream->userFormat = format; - snd_pcm_format_t device_format; +// 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; + + JackHandle() + :client(0), clientOpen(false), stopStream(false) {} +}; - 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; +std::string jackmsg; - if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { - stream->deviceFormat[mode] = format; - goto set_format; - } +static void jackerror (const char *desc) +{ + jackmsg.erase(); + jackmsg.append( desc, strlen(desc)+1 ); +} - // 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; - } +RtApiJack :: RtApiJack() +{ + this->initialize(); - 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; + if (nDevices_ <= 0) { + sprintf(message_, "RtApiJack: no Linux Jack server found or connection error (jack: %s)!", + jackmsg.c_str()); + error(RtError::NO_DEVICES_FOUND); } +} - 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; - } +RtApiJack :: ~RtApiJack() +{ + if ( stream_.mode != UNINITIALIZED ) closeStream(); +} - 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; - } +void RtApiJack :: initialize(void) +{ + nDevices_ = 0; - 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; - } + // 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 ); - 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; - } + // Look for jack server and try to become a client. + jack_client_t *client; + if ( (client = jack_client_new( "RtApiJack" )) == 0) + return; - // If we get here, no supported format was found. - sprintf(message,"RtAudio: ALSA pcm device (%s) data format not supported by RtAudio.", name); - snd_pcm_close(handle); - error(RtError::WARNING); - return FAILURE; + RtApiDevice device; + // Determine the name of the device. + device.name = "Jack Server"; + devices_.push_back(device); + nDevices_++; - set_format: - err = snd_pcm_hw_params_set_format(handle, hw_params, device_format); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message, "RtAudio: ALSA error setting format (%s): %s.", - name, snd_strerror(err)); + 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" )) == 0) { + sprintf(message_, "RtApiJack: error connecting to Linux Jack server in probeDeviceInfo() (jack: %s)!", + jackmsg.c_str()); error(RtError::WARNING); - return FAILURE; + return; } - // 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, "RtAudio: ALSA error getting format endian-ness (%s): %s.", - name, snd_strerror(err)); - error(RtError::WARNING); - return FAILURE; - } + // Get the current jack server sample rate. + info->sampleRates.clear(); + info->sampleRates.push_back( jack_get_sample_rate(client) ); + + // 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, NULL, NULL, JackPortIsInput ); + if ( ports ) { + port = (char *) ports[nChannels]; + while ( port ) + port = (char *) ports[++nChannels]; + free( ports ); + info->maxOutputChannels = nChannels; + info->minOutputChannels = 1; + } + + // Jack "output ports" equal RtAudio input channels. + nChannels = 0; + ports = jack_get_ports( client, NULL, NULL, JackPortIsOutput ); + if ( ports ) { + port = (char *) ports[nChannels]; + while ( port ) + port = (char *) ports[++nChannels]; + free( ports ); + info->maxInputChannels = nChannels; + info->minInputChannels = 1; } - // 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, "RtAudio: ALSA error setting sample rate (%d) on device (%s): %s.", - sampleRate, name, snd_strerror(err)); + if (info->maxOutputChannels == 0 && info->maxInputChannels == 0) { + jack_client_close(client); + sprintf(message_, "RtApiJack: error determining jack input/output channels!"); error(RtError::WARNING); - return FAILURE; + return; } - // 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; - int device_channels = snd_pcm_hw_params_get_channels_max(hw_params); - if (device_channels < channels) { - snd_pcm_close(handle); - sprintf(message, "RtAudio: channels (%d) not supported by device (%s).", - channels, name); - error(RtError::WARNING); - return FAILURE; + 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; } - device_channels = snd_pcm_hw_params_get_channels_min(hw_params); - if (device_channels < channels) device_channels = channels; - stream->nDeviceChannels[mode] = device_channels; + // 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; - // 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, "RtAudio: ALSA error setting channels (%d) on device (%s): %s.", - device_channels, name, snd_strerror(err)); + // Check that we have a supported format + if (info->nativeFormats == 0) { + jack_client_close(client); + sprintf(message_, "RtApiJack: error determining jack server data format!"); error(RtError::WARNING); - return FAILURE; + return; } - // Set the buffer number, which in ALSA is referred to as the "period". - int dir; - 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_get_periods_min(hw_params, &dir); - if (err > periods) periods = err; - err = snd_pcm_hw_params_get_periods_max(hw_params, &dir); - if (err < periods) periods = err; + jack_client_close(client); + info->probed = true; +} - err = snd_pcm_hw_params_set_periods(handle, hw_params, periods, 0); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message, "RtAudio: ALSA error setting periods (%s): %s.", - name, snd_strerror(err)); - error(RtError::WARNING); - return FAILURE; +int jackCallbackHandler(jack_nframes_t nframes, void *infoPointer) +{ + 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; } - // Set the buffer (or period) size. - err = snd_pcm_hw_params_get_period_size_min(hw_params, &dir); - if (err > *bufferSize) *bufferSize = err; + return 0; +} - err = snd_pcm_hw_params_set_period_size(handle, hw_params, *bufferSize, 0); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message, "RtAudio: ALSA error setting period size (%s): %s.", - name, snd_strerror(err)); - error(RtError::WARNING); - return FAILURE; +void jackShutdown(void *infoPointer) +{ + CallbackInfo *info = (CallbackInfo *) infoPointer; + JackHandle *handle = (JackHandle *) info->apiInfo; + handle->clientOpen = false; + RtApiJack *object = (RtApiJack *) info->object; + try { + object->closeStream(); + } + catch (RtError &exception) { + fprintf(stderr, "\nRtApiJack: jackShutdown error (%s)!\n\n", exception.getMessageString()); + return; } - // 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, "RtAudio: ALSA error setting buffer size for duplex stream on device (%s).", - name ); + fprintf(stderr, "\nRtApiJack: the Jack server is shutting down ... stream stopped and closed!!!\n\n"); +} + +int jackXrun( void * ) +{ + fprintf(stderr, "\nRtApiJack: audio overrun/underrun reported!\n"); + return 0; +} + +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); return FAILURE; } - stream->bufferSize = *bufferSize; + JackHandle *handle = (JackHandle *) stream_.apiHandle; - // Install the hardware configuration - err = snd_pcm_hw_params(handle, hw_params); - if (err < 0) { - snd_pcm_close(handle); - sprintf(message, "RtAudio: ALSA error installing hardware configuration (%s): %s.", - name, snd_strerror(err)); - error(RtError::WARNING); - 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; + } + } + else { + // The handle must have been created on an earlier pass. + client = handle->client; } -#if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\nRtAudio: ALSA dump hardware params after installation:\n\n"); - snd_pcm_hw_params_dump(hw_params, out); -#endif - - /* - // Install the software configuration - snd_pcm_sw_params_t *sw_params = NULL; - snd_pcm_sw_params_alloca(&sw_params); - snd_pcm_sw_params_current(handle, sw_params); - 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::WARNING); + // 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); return FAILURE; } - */ - - // Set handle and flags for buffer conversion - stream->handle[mode] = handle; - 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; + 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; + + // 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; + + // Jack always provides host byte-ordered data. + stream_.doByteSwap[mode] = false; + + // 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_.nDeviceChannels[mode] = channels; + stream_.nUserChannels[mode] = channels; + + stream_.doConvertBuffer[mode] = false; + if (stream_.userFormat != stream_.deviceFormat[mode]) + stream_.doConvertBuffer[mode] = true; + if (stream_.deInterleave[mode]) + stream_.doConvertBuffer[mode] = true; + + // Allocate our JackHandle structure for the stream. + 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; + } + 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; + } + stream_.apiHandle = (void *) handle; + handle->client = client; + handle->clientOpen = true; + } - // Allocate necessary internal buffers - if ( stream->nUserChannels[0] != stream->nUserChannels[1] ) { + // 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]; + 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) - goto memory_error; + 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; + } } - if ( stream->doConvertBuffer[mode] ) { + if ( stream_.doConvertBuffer[mode] ) { long buffer_bytes; bool makeBuffer = true; if ( mode == OUTPUT ) - buffer_bytes = stream->nDeviceChannels[0] * formatBytes(stream->deviceFormat[0]); + 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]); + 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) - goto memory_error; + 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()); + 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->nBuffers = periods; - 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 ) { + sprintf(message_, "RtApiJack: error allocating port handle memory (%s).", + devices_[device].name.c_str()); + goto error; + } - return SUCCESS; + stream_.device[mode] = device; + stream_.state = STREAM_STOPPED; + stream_.callbackInfo.usingCallback = false; + stream_.callbackInfo.object = (void *) this; + stream_.callbackInfo.apiInfo = (void *) handle; - memory_error: - if (stream->handle[0]) { - snd_pcm_close(stream->handle[0]); - stream->handle[0] = 0; + 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, NULL ); + jack_on_shutdown( handle->client, jackShutdown, (void *) &stream_.callbackInfo ); } - if (stream->handle[1]) { - snd_pcm_close(stream->handle[1]); - stream->handle[1] = 0; + + return SUCCESS; + + error: + if ( handle ) { + pthread_cond_destroy(&handle->condition); + 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]); + + free( handle ); + stream_.apiHandle = 0; } - if (stream->userBuffer) { - free(stream->userBuffer); - stream->userBuffer = 0; + + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; } - sprintf(message, "RtAudio: ALSA error allocating buffer memory (%s).", name); + error(RtError::WARNING); return FAILURE; } -void RtAudio :: closeStream(int streamId) +void RtApiJack :: 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 ( streams.find( streamId ) == streams.end() ) { - sprintf(message, "RtAudio: invalid stream identifier!"); + // stream check. + if ( stream_.mode == UNINITIALIZED ) { + sprintf(message_, "RtApiJack::closeStream(): no open stream to close!"); error(RtError::WARNING); return; } - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) streams[streamId]; + JackHandle *handle = (JackHandle *) stream_.apiHandle; + if ( handle && handle->clientOpen == true ) { + if (stream_.state == STREAM_RUNNING) + jack_deactivate(handle->client); - if (stream->callbackInfo.usingCallback) { - pthread_cancel(stream->callbackInfo.thread); - pthread_join(stream->callbackInfo.thread, NULL); + jack_client_close(handle->client); } - if (stream->state == STREAM_RUNNING) { - if (stream->mode == OUTPUT || stream->mode == DUPLEX) - snd_pcm_drop(stream->handle[0]); - if (stream->mode == INPUT || stream->mode == DUPLEX) - snd_pcm_drop(stream->handle[1]); + 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 ); + stream_.apiHandle = 0; } - pthread_mutex_destroy(&stream->mutex); - - if (stream->handle[0]) - snd_pcm_close(stream->handle[0]); - - if (stream->handle[1]) - snd_pcm_close(stream->handle[1]); - - if (stream->userBuffer) - free(stream->userBuffer); - - if (stream->deviceBuffer) - free(stream->deviceBuffer); - - free(stream); - streams.erase(streamId); -} - -void RtAudio :: startStream(int streamId) -{ - // This method calls snd_pcm_prepare if the device isn't already in that state. - - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); - - if (stream->state == STREAM_RUNNING) - goto unlock; - - int err; - snd_pcm_state_t state; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - state = snd_pcm_state(stream->handle[0]); - if (state != SND_PCM_STATE_PREPARED) { - err = snd_pcm_prepare(stream->handle[0]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error preparing pcm device (%s): %s.", - devices[stream->device[0]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - } + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; } - if (stream->mode == INPUT || stream->mode == DUPLEX) { - state = snd_pcm_state(stream->handle[1]); - if (state != SND_PCM_STATE_PREPARED) { - err = snd_pcm_prepare(stream->handle[1]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error preparing pcm device (%s): %s.", - devices[stream->device[1]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - } + if (stream_.deviceBuffer) { + free(stream_.deviceBuffer); + stream_.deviceBuffer = 0; } - stream->state = STREAM_RUNNING; - unlock: - MUTEX_UNLOCK(&stream->mutex); + stream_.mode = UNINITIALIZED; } -void RtAudio :: stopStream(int streamId) -{ - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); - - if (stream->state == STREAM_STOPPED) - goto unlock; - - int err; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - err = snd_pcm_drain(stream->handle[0]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error draining pcm device (%s): %s.", - devices[stream->device[0]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - } - - if (stream->mode == INPUT || stream->mode == DUPLEX) { - err = snd_pcm_drain(stream->handle[1]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error draining pcm device (%s): %s.", - devices[stream->device[1]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - } - stream->state = STREAM_STOPPED; - unlock: - MUTEX_UNLOCK(&stream->mutex); -} - -void RtAudio :: abortStream(int streamId) +void RtApiJack :: startStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); + verifyStream(); + if (stream_.state == STREAM_RUNNING) return; - if (stream->state == STREAM_STOPPED) - goto unlock; + MUTEX_LOCK(&stream_.mutex); - int err; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - err = snd_pcm_drop(stream->handle[0]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error draining pcm device (%s): %s.", - devices[stream->device[0]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); + 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); } } - if (stream->mode == INPUT || stream->mode == DUPLEX) { - err = snd_pcm_drop(stream->handle[1]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error draining pcm device (%s): %s.", - devices[stream->device[1]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); + 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); } } - stream->state = STREAM_STOPPED; - - unlock: - MUTEX_UNLOCK(&stream->mutex); -} - -int RtAudio :: streamWillBlock(int streamId) -{ - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); - int err = 0, frames = 0; - if (stream->state == STREAM_STOPPED) - goto unlock; - - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - err = snd_pcm_avail_update(stream->handle[0]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error getting available frames for device (%s): %s.", - devices[stream->device[0]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } + if (jack_activate(handle->client)) { + sprintf(message_, "RtApiJack: unable to activate JACK client!"); + error(RtError::SYSTEM_ERROR); } - frames = err; - - if (stream->mode == INPUT || stream->mode == DUPLEX) { - err = snd_pcm_avail_update(stream->handle[1]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error getting available frames for device (%s): %s.", - devices[stream->device[1]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); + const char **ports; + int result; + // Get the list of available ports. + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { + ports = jack_get_ports(handle->client, NULL, NULL, JackPortIsPhysical|JackPortIsInput); + if ( ports == NULL) { + sprintf(message_, "RtApiJack: error determining available jack input ports!"); + error(RtError::SYSTEM_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. + 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); + } } - if (frames > err) frames = err; - } - - frames = stream->bufferSize - frames; - if (frames < 0) frames = 0; - - unlock: - MUTEX_UNLOCK(&stream->mutex); - return frames; -} - -void RtAudio :: tickStream(int streamId) -{ - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - int stopStream = 0; - if (stream->state == STREAM_STOPPED) { - if (stream->callbackInfo.usingCallback) usleep(50000); // sleep 50 milliseconds - return; - } - else if (stream->callbackInfo.usingCallback) { - RTAUDIO_CALLBACK callback = (RTAUDIO_CALLBACK) stream->callbackInfo.callback; - stopStream = callback(stream->userBuffer, stream->bufferSize, stream->callbackInfo.userData); + free(ports); } - MUTEX_LOCK(&stream->mutex); - - // The state might change while waiting on a mutex. - if (stream->state == STREAM_STOPPED) - goto unlock; - - int err; - char *buffer; - int channels; - RTAUDIO_FORMAT format; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - - // Setup parameters and do buffer conversion if necessary. - if (stream->doConvertBuffer[0]) { - convertStreamBuffer(stream, OUTPUT); - buffer = stream->deviceBuffer; - channels = stream->nDeviceChannels[0]; - format = stream->deviceFormat[0]; - } - else { - buffer = stream->userBuffer; - channels = stream->nUserChannels[0]; - format = stream->userFormat; - } - - // Do byte swapping if necessary. - if (stream->doByteSwap[0]) - byteSwapBuffer(buffer, stream->bufferSize * channels, format); - - // 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; ihandle[0], bufs, stream->bufferSize); + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { + ports = jack_get_ports( handle->client, NULL, NULL, JackPortIsPhysical|JackPortIsOutput ); + if ( ports == NULL) { + sprintf(message_, "RtApiJack: error determining available jack output ports!"); + error(RtError::SYSTEM_ERROR); } - else - err = snd_pcm_writei(stream->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(stream->handle[0]); - if (state == SND_PCM_STATE_XRUN) { - sprintf(message, "RtAudio: ALSA underrun detected."); - error(RtError::WARNING); - err = snd_pcm_prepare(stream->handle[0]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error preparing handle after underrun: %s.", - snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - } - else { - sprintf(message, "RtAudio: ALSA error, current state is %s.", - snd_pcm_state_name(state)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - goto unlock; - } - else { - sprintf(message, "RtAudio: ALSA audio write error for device (%s): %s.", - devices[stream->device[0]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); + // 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); } } + free(ports); } - if (stream->mode == INPUT || stream->mode == DUPLEX) { - - // Setup parameters. - if (stream->doConvertBuffer[1]) { - buffer = stream->deviceBuffer; - channels = stream->nDeviceChannels[1]; - format = stream->deviceFormat[1]; - } - else { - buffer = stream->userBuffer; - channels = stream->nUserChannels[1]; - format = stream->userFormat; - } + handle->stopStream = false; + stream_.state = STREAM_RUNNING; - // 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; ihandle[1], bufs, stream->bufferSize); - } - else - err = snd_pcm_readi(stream->handle[1], buffer, stream->bufferSize); + MUTEX_UNLOCK(&stream_.mutex); +} - if (err < stream->bufferSize) { - // Either an error or underrun occured. - if (err == -EPIPE) { - snd_pcm_state_t state = snd_pcm_state(stream->handle[1]); - if (state == SND_PCM_STATE_XRUN) { - sprintf(message, "RtAudio: ALSA overrun detected."); - error(RtError::WARNING); - err = snd_pcm_prepare(stream->handle[1]); - if (err < 0) { - sprintf(message, "RtAudio: ALSA error preparing handle after overrun: %s.", - snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - } - else { - sprintf(message, "RtAudio: ALSA error, current state is %s.", - snd_pcm_state_name(state)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - goto unlock; - } - else { - sprintf(message, "RtAudio: ALSA audio read error for device (%s): %s.", - devices[stream->device[1]].name, snd_strerror(err)); - MUTEX_UNLOCK(&stream->mutex); - error(RtError::DRIVER_ERROR); - } - } +void RtApiJack :: stopStream() +{ + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - // Do byte swapping if necessary. - if (stream->doByteSwap[1]) - byteSwapBuffer(buffer, stream->bufferSize * channels, format); + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK(&stream_.mutex); - // Do buffer conversion if necessary. - if (stream->doConvertBuffer[1]) - convertStreamBuffer(stream, INPUT); - } + JackHandle *handle = (JackHandle *) stream_.apiHandle; + jack_deactivate(handle->client); - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); +} - if (stream->callbackInfo.usingCallback && stopStream) - this->stopStream(streamId); +void RtApiJack :: abortStream() +{ + stopStream(); } -extern "C" void *callbackHandler(void *ptr) +void RtApiJack :: tickStream() { - CALLBACK_INFO *info = (CALLBACK_INFO *) ptr; - RtAudio *object = (RtAudio *) info->object; - int stream = info->streamId; - bool *usingCallback = &info->usingCallback; + verifyStream(); - while ( *usingCallback ) { - pthread_testcancel(); - try { - object->tickStream(stream); - } - catch (RtError &exception) { - fprintf(stderr, "\nRtAudio: Callback thread error (%s) ... closing thread.\n\n", - exception.getMessage()); - break; - } - } + if (stream_.state == STREAM_STOPPED) return; - return 0; -} + if (stream_.callbackInfo.usingCallback) { + sprintf(message_, "RtApiJack: tickStream() should not be used when a callback function is set!"); + error(RtError::WARNING); + return; + } -//******************** End of __LINUX_ALSA__ *********************// + JackHandle *handle = (JackHandle *) stream_.apiHandle; -#elif defined(__LINUX_OSS__) + MUTEX_LOCK(&stream_.mutex); -#include -#include -#include -#include -#include -#include -#include -#include + pthread_cond_wait(&handle->condition, &stream_.mutex); -#define DAC_NAME "/dev/dsp" -#define MAX_DEVICES 16 -#define MAX_CHANNELS 16 + MUTEX_UNLOCK(&stream_.mutex); +} -void RtAudio :: initialize(void) +void RtApiJack :: callbackEvent( unsigned long nframes ) { - // Count cards and devices - nDevices = 0; + verifyStream(); - // 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, "RtAudio: cannot read value of symbolic link %s.", DAC_NAME); - error(RtError::SYSTEM_ERROR); - } - } - } - else { - sprintf(message, "RtAudio: cannot stat %s.", DAC_NAME); - error(RtError::SYSTEM_ERROR); + 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; } - // 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. + MUTEX_LOCK(&stream_.mutex); - int fd = 0; - char names[MAX_DEVICES][16]; - for (i=-1; iusingCallback ) { + RtAudioCallback callback = (RtAudioCallback) info->callback; + handle->stopStream = callback(stream_.userBuffer, stream_.bufferSize, info->userData); + } - // Probe /dev/dsp first, since it is supposed to be the default device. - if (i == -1) - sprintf(device_name, "%s", DAC_NAME); - else if (i == dsplink) - continue; // We've aready probed this device via /dev/dsp link ... try next device. - else - sprintf(device_name, "%s%d", DAC_NAME, i); + jack_default_audio_sample_t *jackbuffer; + long bufferBytes = nframes * sizeof (jack_default_audio_sample_t); + if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) { - // First try to open the device for playback, then record mode. - fd = open(device_name, O_WRONLY | O_NONBLOCK); - if (fd == -1) { - // Open device for playback failed ... either busy or doesn't exist. - if (errno != EBUSY && errno != EAGAIN) { - // Try to open for capture - fd = open(device_name, O_RDONLY | O_NONBLOCK); - if (fd == -1) { - // Open device for record failed. - if (errno != EBUSY && errno != EAGAIN) - continue; - else { - sprintf(message, "RtAudio: OSS record device (%s) is busy.", device_name); - error(RtError::WARNING); - // still count it for now - } - } - } - else { - sprintf(message, "RtAudio: OSS playback device (%s) is busy.", device_name); - error(RtError::WARNING); - // still count it for now + if (stream_.doConvertBuffer[0]) { + convertStreamBuffer(OUTPUT); + + 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 ); + } + } - if (fd >= 0) close(fd); - strncpy(names[nDevices], device_name, 16); - nDevices++; + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { + + if (stream_.doConvertBuffer[1]) { + for ( int i=0; iports[1][i], + (jack_nframes_t) nframes); + memcpy(&stream_.deviceBuffer[i*bufferBytes], jackbuffer, bufferBytes ); + } + convertStreamBuffer(INPUT); + } + 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 ); + } } - if (nDevices == 0) return; + if ( !info->usingCallback ) + pthread_cond_signal(&handle->condition); - // Allocate the RTAUDIO_DEVICE structures. - devices = (RTAUDIO_DEVICE *) calloc(nDevices, sizeof(RTAUDIO_DEVICE)); - if (devices == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); - error(RtError::MEMORY_ERROR); + MUTEX_UNLOCK(&stream_.mutex); +} + +void RtApiJack :: setStreamCallback(RtAudioCallback callback, void *userData) +{ + verifyStream(); + + if ( stream_.callbackInfo.usingCallback ) { + sprintf(message_, "RtApiJack: A callback is already set for this stream!"); + error(RtError::WARNING); + return; } - // Write device ascii identifiers to device control structure and then probe capabilities. - for (i=0; i +#include +#include + +extern "C" void *alsaCallbackHandler(void * ptr); + +RtApiAlsa :: RtApiAlsa() +{ + this->initialize(); + + if (nDevices_ <= 0) { + sprintf(message_, "RtApiAlsa: no Linux ALSA audio devices found!"); + error(RtError::NO_DEVICES_FOUND); + } } -int RtAudio :: getDefaultInputDevice(void) +RtApiAlsa :: ~RtApiAlsa() { - // No OSS API functions for default devices. - return 0; + if ( stream_.mode != UNINITIALIZED ) + closeStream(); } -int RtAudio :: getDefaultOutputDevice(void) +void RtApiAlsa :: initialize(void) { - // No OSS API functions for default devices. - return 0; + 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; + + // 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); + return; + } + unsigned int dev = (unsigned int) atoi( strtok(NULL, ",") ); // First try for playback - fd = open(info->name, O_WRONLY | O_NONBLOCK); - if (fd == -1) { - // Open device failed ... either busy or doesn't exist - if (errno == EBUSY || errno == EAGAIN) - sprintf(message, "RtAudio: OSS playback device (%s) is busy and cannot be probed.", - info->name); + 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); + + 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, "RtAudio: OSS playback device (%s) open error.", info->name); + sprintf(message_, "RtApiAlsa: pcm playback open (%s) error: %s.", + info->name.c_str(), snd_strerror(err)); 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; + // 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::WARNING); + goto capture_probe; } - 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; + // 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::WARNING); + goto capture_probe; } - info->minOutputChannels = i; - close(fd); + info->minOutputChannels = value; + + 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::WARNING); + goto capture_probe; + } + info->maxOutputChannels = value; + + snd_pcm_close(handle); capture_probe: // Now try for capture - fd = open(info->name, 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, "RtAudio: OSS capture device (%s) is busy and cannot be probed.", - info->name); + stream = SND_PCM_STREAM_CAPTURE; + snd_pcm_info_set_stream(pcminfo, stream); + + 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, "RtAudio: OSS capture device (%s) open error.", info->name); + 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 @@ -2598,829 +3385,976 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) goto probe_parameters; } - // We have the device open for capture ... 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; + // 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::WARNING); + if (info->maxOutputChannels > 0) + goto probe_parameters; + else + return; } - info->maxInputChannels = i; - // 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; + // 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::WARNING); + if (info->maxOutputChannels > 0) + goto probe_parameters; + else + return; } - info->minInputChannels = i; - close(fd); + info->minInputChannels = value; - if (info->maxOutputChannels == 0 && info->maxInputChannels == 0) { - sprintf(message, "RtAudio: OSS device (%s) reports zero channels for input and output.", - info->name); - error(RtError::DEBUG_WARNING); - return; + 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::WARNING); + if (info->maxOutputChannels > 0) + goto probe_parameters; + else + return; } + info->maxInputChannels = value; + + snd_pcm_close(handle); // 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, 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; - - // Now find the minimum number of channels it can handle - for (i=1; i<=info->maxDuplexChannels; 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); + info->hasDuplexSupport = true; + info->maxDuplexChannels = (info->maxOutputChannels > info->maxInputChannels) ? + info->maxInputChannels : info->maxOutputChannels; + info->minDuplexChannels = (info->minOutputChannels > info->minInputChannels) ? + info->minInputChannels : info->minOutputChannels; 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 + // 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. - if (info->maxOutputChannels >= info->maxInputChannels) { - fd = open(info->name, O_WRONLY | O_NONBLOCK); - channels = info->maxOutputChannels; - } - else { - fd = open(info->name, O_RDONLY | O_NONBLOCK); - channels = info->maxInputChannels; - } + if (info->maxOutputChannels >= info->maxInputChannels) + stream = SND_PCM_STREAM_PLAYBACK; + else + stream = SND_PCM_STREAM_CAPTURE; - if (fd == -1) { - // We've got some sort of conflict ... abort - sprintf(message, "RtAudio: OSS device (%s) won't reopen during probe.", - info->name); - error(RtError::DEBUG_WARNING); + 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::WARNING); return; } - // 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, "RtAudio: OSS device (%s) won't revert to previous channel setting.", - info->name); - error(RtError::DEBUG_WARNING); + // 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::WARNING); return; } - if (ioctl(fd, SNDCTL_DSP_GETFMTS, &mask) == -1) { - close(fd); - sprintf(message, "RtAudio: OSS device (%s) can't get supported audio formats.", - info->name); + // 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; } - // Probe the supported data formats ... we don't care about endian-ness just yet. - int format; + // Probe the supported data formats ... we don't care about endian-ness just yet + snd_pcm_format_t 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; - } -#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; - } -#endif - if (mask & AFMT_S8) { - format = AFMT_S8; + format = SND_PCM_FORMAT_S8; + if (snd_pcm_hw_params_test_format(handle, params, format) == 0) info->nativeFormats |= RTAUDIO_SINT8; - } - if (mask & AFMT_S16_BE) { - format = AFMT_S16_BE; - info->nativeFormats |= RTAUDIO_SINT16; - } - if (mask & AFMT_S16_LE) { - format = AFMT_S16_LE; + 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; // Check that we have at least one supported format if (info->nativeFormats == 0) { - close(fd); - sprintf(message, "RtAudio: OSS device (%s) data format not supported by RtAudio.", - info->name); - error(RtError::DEBUG_WARNING); + snd_pcm_close(handle); + sprintf(message_, "RtApiAlsa: pcm device (%s) data format not supported by RtAudio.", + info->name.c_str()); + error(RtError::WARNING); return; } - // Set the format - i = format; - if (ioctl(fd, SNDCTL_DSP_SETFMT, &format) == -1 || format != i) { - close(fd); - sprintf(message, "RtAudio: OSS device (%s) error setting data format.", - info->name); - error(RtError::DEBUG_WARNING); - return; + // That's all ... close the device and return + snd_pcm_close(handle); + info->probed = true; + return; +} + +bool RtApiAlsa :: probeDeviceOpen( int device, StreamMode mode, int channels, + int sampleRate, RtAudioFormat format, + int *bufferSize, int numberOfBuffers ) +{ +#if defined(__RTAUDIO_DEBUG__) + snd_output_t *out; + snd_output_stdio_attach(&out, stderr, 0); +#endif + + // I'm not using the "plug" interface ... too much inconsistent behavior. + const char *name = devices_[device].name.c_str(); + + 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::WARNING); + return FAILURE; } - // Probe the supported sample rates ... first get lower limit - int speed = 1; - if (ioctl(fd, SNDCTL_DSP_SPEED, &speed) == -1) { - // If we get here, we're probably using an ALSA driver with OSS-emulation, - // which doesn't conform to the OSS specification. In this case, - // we'll probe our predefined list of sample rates for working values. - info->nSampleRates = 0; - for (i=0; isampleRates[info->nSampleRates] = SAMPLE_RATES[i]; - info->nSampleRates++; - } - } - if (info->nSampleRates == 0) { - close(fd); - return; - } - goto finished; + // 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::WARNING); + return FAILURE; } - info->sampleRates[0] = speed; - // Now get upper limit - speed = 1000000; - if (ioctl(fd, SNDCTL_DSP_SPEED, &speed) == -1) { - close(fd); - sprintf(message, "RtAudio: OSS device (%s) error setting sample rate.", - info->name); - error(RtError::DEBUG_WARNING); - return; +#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 + + // 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::WARNING); + return FAILURE; } - info->sampleRates[1] = speed; - info->nSampleRates = -1; - finished: // That's all ... close the device and return - close(fd); - info->probed = true; - return; -} + if (err < 0) { + snd_pcm_close(handle); + sprintf(message_, "RtApiAlsa: error setting access ( (%s): %s.", name, snd_strerror(err)); + error(RtError::WARNING); + return FAILURE; + } -bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, - STREAM_MODE mode, int channels, - int sampleRate, RTAUDIO_FORMAT format, - int *bufferSize, int numberOfBuffers) -{ - int buffers, buffer_bytes, device_channels, device_format; - int srate, temp, fd; + // 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; - const char *name = devices[device].name; + if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) { + stream_.deviceFormat[mode] = format; + goto set_format; + } - 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(stream->handle[0]); - stream->handle[0] = 0; - // First check that the number previously set channels is the same. - if (stream->nUserChannels[0] != channels) { - sprintf(message, "RtAudio: input/output channels must be equal for OSS duplex device (%s).", name); - goto error; - } - fd = open(name, O_RDWR | O_NONBLOCK); - } - else - fd = open(name, O_RDONLY | O_NONBLOCK); + // 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; + } + + 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; + } + + 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; } - if (fd == -1) { - if (errno == EBUSY || errno == EAGAIN) - sprintf(message, "RtAudio: OSS device (%s) is busy and cannot be opened.", - name); - else - sprintf(message, "RtAudio: OSS device (%s) cannot be opened.", name); - goto error; + 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; } - // 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); + 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 (fd == -1) { - sprintf(message, "RtAudio: OSS device (%s) cannot be opened.", name); - goto error; + 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; } - // Get the sample format mask - int mask; - if (ioctl(fd, SNDCTL_DSP_GETFMTS, &mask) == -1) { - close(fd); - sprintf(message, "RtAudio: OSS device (%s) can't get supported audio formats.", - name); - goto error; + // 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::WARNING); + return FAILURE; + + 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::WARNING); + 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; + // 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::WARNING); + return FAILURE; } } - 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 + + // 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::WARNING); + 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 + + // 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::WARNING); + 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; - } + 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::WARNING); + return FAILURE; } + device_channels = value; + if (device_channels < channels) device_channels = channels; + stream_.nDeviceChannels[mode] = device_channels; - if (stream->deviceFormat[mode] == 0) { - // This really shouldn't happen ... - close(fd); - sprintf(message, "RtAudio: OSS device (%s) data format not supported by RtAudio.", - name); - goto error; + // 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::WARNING); + 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; + // 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_get_periods_min(hw_params, &value, &dir); + if (err < 0) { + snd_pcm_close(handle); + sprintf(message_, "RtApiAlsa: error getting min periods on device (%s): %s.", + name, snd_strerror(err)); + error(RtError::WARNING); + 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; - } - else { - if (channels < devices[device].minInputChannels) - device_channels = devices[device].minInputChannels; - } + if (value > periods) periods = value; + err = snd_pcm_hw_params_get_periods_max(hw_params, &value, &dir); + if (err < 0) { + snd_pcm_close(handle); + sprintf(message_, "RtApiAlsa: error getting max periods on device (%s): %s.", + name, snd_strerror(err)); + error(RtError::WARNING); + return FAILURE; } - stream->nDeviceChannels[mode] = device_channels; + if (value < periods) periods = value; - // 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, "RtAudio: OSS error setting fragment size for device (%s).", - name); - goto error; + err = snd_pcm_hw_params_set_periods(handle, hw_params, periods, 0); + if (err < 0) { + snd_pcm_close(handle); + sprintf(message_, "RtApiAlsa: error setting periods (%s): %s.", + name, snd_strerror(err)); + error(RtError::WARNING); + 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, "RtAudio: OSS error setting data format for device (%s).", - name); - goto error; + // Set the buffer (or period) size. + snd_pcm_uframes_t period_size; + err = snd_pcm_hw_params_get_period_size_min(hw_params, &period_size, &dir); + if (err < 0) { + snd_pcm_close(handle); + sprintf(message_, "RtApiAlsa: error getting period size (%s): %s.", + name, snd_strerror(err)); + error(RtError::WARNING); + return FAILURE; } + if (*bufferSize < (int) period_size) *bufferSize = (int) period_size; - // Set the number of channels. - temp = device_channels; - if (ioctl(fd, SNDCTL_DSP_CHANNELS, &device_channels) == -1 || device_channels != temp) { - close(fd); - sprintf(message, "RtAudio: OSS error setting %d channels on device (%s).", - temp, name); - goto error; + err = snd_pcm_hw_params_set_period_size(handle, hw_params, *bufferSize, 0); + if (err < 0) { + snd_pcm_close(handle); + sprintf(message_, "RtApiAlsa: error setting period size (%s): %s.", + name, snd_strerror(err)); + error(RtError::WARNING); + return FAILURE; } - // Set the sample rate. - srate = sampleRate; - temp = srate; - if (ioctl(fd, SNDCTL_DSP_SPEED, &srate) == -1) { - close(fd); - sprintf(message, "RtAudio: OSS error setting sample rate = %d on device (%s).", - temp, name); - goto error; + // 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; } - // Verify the sample rate setup worked. - if (abs(srate - temp) > 100) { - close(fd); - sprintf(message, "RtAudio: OSS error ... audio device (%s) doesn't support sample rate of %d.", - name, temp); - goto error; - } - stream->sampleRate = sampleRate; + stream_.bufferSize = *bufferSize; - if (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &buffer_bytes) == -1) { - close(fd); - sprintf(message, "RtAudio: OSS error getting buffer size for device (%s).", - name); - goto error; + // 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::WARNING); + return FAILURE; } - // Save buffer size (in sample frames). - *bufferSize = buffer_bytes / (formatBytes(stream->deviceFormat[mode]) * device_channels); - stream->bufferSize = *bufferSize; +#if defined(__RTAUDIO_DEBUG__) + fprintf(stderr, "\nRtApiAlsa: dump hardware params after installation:\n\n"); + snd_pcm_hw_params_dump(hw_params, out); +#endif - 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; + // Allocate the stream handle if necessary and then save. + snd_pcm_t **handles; + if ( stream_.apiHandle == 0 ) { + handles = (snd_pcm_t **) calloc(2, sizeof(snd_pcm_t *)); + if ( handle == NULL ) { + sprintf(message_, "RtApiAlsa: error allocating handle memory (%s).", + devices_[device].name.c_str()); + goto error; + } + stream_.apiHandle = (void *) handles; + handles[0] = 0; + handles[1] = 0; + } + else { + handles = (snd_pcm_t **) stream_.apiHandle; } + 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; + 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] ) { + if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { long buffer_bytes; - if (stream->nUserChannels[0] >= stream->nUserChannels[1]) - buffer_bytes = stream->nUserChannels[0]; + 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, "RtAudio: OSS error allocating user buffer memory (%s).", - name); + 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_, "RtApiAlsa: error allocating user buffer memory (%s).", + devices_[device].name.c_str()); goto error; } } - if ( stream->doConvertBuffer[mode] ) { + if ( stream_.doConvertBuffer[mode] ) { long buffer_bytes; bool makeBuffer = true; if ( mode == OUTPUT ) - buffer_bytes = stream->nDeviceChannels[0] * formatBytes(stream->deviceFormat[0]); + 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]); + 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) { - close(fd); - free(stream->userBuffer); - sprintf(message, "RtAudio: OSS error allocating device buffer memory (%s).", - name); + 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; } } } - stream->device[mode] = device; - stream->handle[mode] = fd; - stream->state = STREAM_STOPPED; - if ( stream->mode == OUTPUT && mode == INPUT ) { - stream->mode = DUPLEX; - if (stream->device[0] == device) - stream->handle[0] = fd; - } + 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_.mode = mode; + stream_.nBuffers = periods; + stream_.sampleRate = sampleRate; return SUCCESS; error: - if (stream->handle[0]) { - close(stream->handle[0]); - stream->handle[0] = 0; + if (handles) { + if (handles[0]) + snd_pcm_close(handles[0]); + if (handles[1]) + snd_pcm_close(handles[1]); + free(handles); + stream_.apiHandle = 0; + } + + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; } + error(RtError::WARNING); return FAILURE; } -void RtAudio :: closeStream(int streamId) +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 - // streamId check. - if ( streams.find( streamId ) == streams.end() ) { - sprintf(message, "RtAudio: invalid stream identifier!"); + // stream check. + if ( stream_.mode == UNINITIALIZED ) { + sprintf(message_, "RtApiAlsa::closeStream(): no open stream to close!"); error(RtError::WARNING); return; } - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) streams[streamId]; - - if (stream->callbackInfo.usingCallback) { - pthread_cancel(stream->callbackInfo.thread); - pthread_join(stream->callbackInfo.thread, NULL); + snd_pcm_t **handle = (snd_pcm_t **) stream_.apiHandle; + if (stream_.state == STREAM_RUNNING) { + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) + snd_pcm_drop(handle[0]); + if (stream_.mode == INPUT || stream_.mode == DUPLEX) + snd_pcm_drop(handle[1]); + stream_.state = STREAM_STOPPED; } - if (stream->state == STREAM_RUNNING) { - if (stream->mode == OUTPUT || stream->mode == DUPLEX) - ioctl(stream->handle[0], SNDCTL_DSP_RESET, 0); - if (stream->mode == INPUT || stream->mode == DUPLEX) - ioctl(stream->handle[1], SNDCTL_DSP_RESET, 0); + if (stream_.callbackInfo.usingCallback) { + stream_.callbackInfo.usingCallback = false; + pthread_join(stream_.callbackInfo.thread, NULL); } - pthread_mutex_destroy(&stream->mutex); - - if (stream->handle[0]) - close(stream->handle[0]); - - if (stream->handle[1]) - close(stream->handle[1]); + if (handle) { + if (handle[0]) snd_pcm_close(handle[0]); + if (handle[1]) snd_pcm_close(handle[1]); + free(handle); + handle = 0; + } - if (stream->userBuffer) - free(stream->userBuffer); + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; + } - if (stream->deviceBuffer) - free(stream->deviceBuffer); + if (stream_.deviceBuffer) { + free(stream_.deviceBuffer); + stream_.deviceBuffer = 0; + } - free(stream); - streams.erase(streamId); + stream_.mode = UNINITIALIZED; } -void RtAudio :: startStream(int streamId) +void RtApiAlsa :: startStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + // This method calls snd_pcm_prepare if the device isn't already in that state. - MUTEX_LOCK(&stream->mutex); + verifyStream(); + if (stream_.state == STREAM_RUNNING) return; - stream->state = STREAM_RUNNING; + MUTEX_LOCK(&stream_.mutex); - // No need to do anything else here ... OSS automatically starts - // when fed samples. + int err; + snd_pcm_state_t state; + snd_pcm_t **handle = (snd_pcm_t **) stream_.apiHandle; + 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); + } + } + } + + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + 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); + } + } + } + stream_.state = STREAM_RUNNING; - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: stopStream(int streamId) +void RtApiAlsa :: stopStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - MUTEX_LOCK(&stream->mutex); - - if (stream->state == STREAM_STOPPED) - goto unlock; + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK(&stream_.mutex); int err; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - err = ioctl(stream->handle[0], SNDCTL_DSP_SYNC, 0); - if (err < -1) { - sprintf(message, "RtAudio: OSS error stopping device (%s).", - devices[stream->device[0]].name); + snd_pcm_t **handle = (snd_pcm_t **) stream_.apiHandle; + 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); } } - else { - err = ioctl(stream->handle[1], SNDCTL_DSP_SYNC, 0); - if (err < -1) { - sprintf(message, "RtAudio: OSS error stopping device (%s).", - devices[stream->device[1]].name); + + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + 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); } } - stream->state = STREAM_STOPPED; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: abortStream(int streamId) +void RtApiAlsa :: abortStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - if (stream->state == STREAM_STOPPED) - goto unlock; + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK(&stream_.mutex); int err; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - err = ioctl(stream->handle[0], SNDCTL_DSP_RESET, 0); - if (err < -1) { - sprintf(message, "RtAudio: OSS error aborting device (%s).", - devices[stream->device[0]].name); + snd_pcm_t **handle = (snd_pcm_t **) stream_.apiHandle; + 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); } } - else { - err = ioctl(stream->handle[1], SNDCTL_DSP_RESET, 0); - if (err < -1) { - sprintf(message, "RtAudio: OSS error aborting device (%s).", - devices[stream->device[1]].name); + + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + 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); } } - stream->state = STREAM_STOPPED; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -int RtAudio :: streamWillBlock(int streamId) +int RtApiAlsa :: streamWillBlock() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return 0; - MUTEX_LOCK(&stream->mutex); + MUTEX_LOCK(&stream_.mutex); - int bytes = 0, channels = 0, frames = 0; - if (stream->state == STREAM_STOPPED) - goto unlock; - - audio_buf_info info; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - ioctl(stream->handle[0], SNDCTL_DSP_GETOSPACE, &info); - bytes = info.bytes; - channels = stream->nDeviceChannels[0]; + int err = 0, frames = 0; + snd_pcm_t **handle = (snd_pcm_t **) stream_.apiHandle; + 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); + } } - if (stream->mode == INPUT || stream->mode == DUPLEX) { - ioctl(stream->handle[1], SNDCTL_DSP_GETISPACE, &info); - if (stream->mode == DUPLEX ) { - bytes = (bytes < info.bytes) ? bytes : info.bytes; - channels = stream->nDeviceChannels[0]; - } - else { - bytes = info.bytes; - channels = stream->nDeviceChannels[1]; + 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); } + if (frames > err) frames = err; } - frames = (int) (bytes / (channels * formatBytes(stream->deviceFormat[0]))); - frames -= stream->bufferSize; + frames = stream_.bufferSize - frames; if (frames < 0) frames = 0; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); return frames; } -void RtAudio :: tickStream(int streamId) +void RtApiAlsa :: tickStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); int stopStream = 0; - if (stream->state == STREAM_STOPPED) { - if (stream->callbackInfo.usingCallback) usleep(50000); // sleep 50 milliseconds + if (stream_.state == STREAM_STOPPED) { + if (stream_.callbackInfo.usingCallback) usleep(50000); // sleep 50 milliseconds return; } - else if (stream->callbackInfo.usingCallback) { - RTAUDIO_CALLBACK callback = (RTAUDIO_CALLBACK) stream->callbackInfo.callback; - stopStream = callback(stream->userBuffer, stream->bufferSize, stream->callbackInfo.userData); + else if (stream_.callbackInfo.usingCallback) { + RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; + stopStream = callback(stream_.userBuffer, stream_.bufferSize, 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) + if (stream_.state == STREAM_STOPPED) goto unlock; - int result; + int err; char *buffer; - int samples; - RTAUDIO_FORMAT format; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { + int channels; + snd_pcm_t **handle; + RtAudioFormat format; + handle = (snd_pcm_t **) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { // Setup parameters and do buffer conversion if necessary. - if (stream->doConvertBuffer[0]) { - convertStreamBuffer(stream, OUTPUT); - buffer = stream->deviceBuffer; - samples = stream->bufferSize * stream->nDeviceChannels[0]; - format = stream->deviceFormat[0]; + if (stream_.doConvertBuffer[0]) { + convertStreamBuffer(OUTPUT); + buffer = stream_.deviceBuffer; + channels = stream_.nDeviceChannels[0]; + format = stream_.deviceFormat[0]; } else { - buffer = stream->userBuffer; - samples = stream->bufferSize * stream->nUserChannels[0]; - format = stream->userFormat; + buffer = stream_.userBuffer; + channels = stream_.nUserChannels[0]; + format = stream_.userFormat; } // Do byte swapping if necessary. - if (stream->doByteSwap[0]) - byteSwapBuffer(buffer, samples, format); + if (stream_.doByteSwap[0]) + byteSwapBuffer(buffer, stream_.bufferSize * channels, format); - // Write samples to device. - result = write(stream->handle[0], buffer, samples * formatBytes(format)); + // 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; idevice[0]].name); - error(RtError::DRIVER_ERROR); + 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 (stream->mode == INPUT || stream->mode == DUPLEX) { + 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]; + if (stream_.doConvertBuffer[1]) { + buffer = stream_.deviceBuffer; + channels = stream_.nDeviceChannels[1]; + format = stream_.deviceFormat[1]; } else { - buffer = stream->userBuffer; - samples = stream->bufferSize * stream->nUserChannels[1]; - format = stream->userFormat; + buffer = stream_.userBuffer; + channels = stream_.nUserChannels[1]; + format = stream_.userFormat; } - // Read samples from device. - result = read(stream->handle[1], buffer, samples * formatBytes(format)); + // 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; idevice[1]].name); - error(RtError::DRIVER_ERROR); + 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); + } + } + 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); + } } // Do byte swapping if necessary. - if (stream->doByteSwap[1]) - byteSwapBuffer(buffer, samples, format); + if (stream_.doByteSwap[1]) + byteSwapBuffer(buffer, stream_.bufferSize * channels, format); // Do buffer conversion if necessary. - if (stream->doConvertBuffer[1]) - convertStreamBuffer(stream, INPUT); + if (stream_.doConvertBuffer[1]) + convertStreamBuffer(INPUT); } unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); - if (stream->callbackInfo.usingCallback && stopStream) - this->stopStream(streamId); + if (stream_.callbackInfo.usingCallback && stopStream) + this->stopStream(); } -extern "C" void *callbackHandler(void *ptr) +void RtApiAlsa :: setStreamCallback(RtAudioCallback callback, void *userData) +{ + verifyStream(); + + CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; + if ( info->usingCallback ) { + sprintf(message_, "RtApiAlsa: 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, alsaCallbackHandler, &stream_.callbackInfo); + pthread_attr_destroy(&attr); + if (err) { + info->usingCallback = false; + sprintf(message_, "RtApiAlsa: error starting callback thread!"); + error(RtError::THREAD_ERROR); + } +} + +void RtApiAlsa :: cancelStreamCallback() +{ + verifyStream(); + + if (stream_.callbackInfo.usingCallback) { + + if (stream_.state == STREAM_RUNNING) + stopStream(); + + 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) { - CALLBACK_INFO *info = (CALLBACK_INFO *) ptr; - RtAudio *object = (RtAudio *) info->object; - int stream = info->streamId; + CallbackInfo *info = (CallbackInfo *) ptr; + RtApiAlsa *object = (RtApiAlsa *) info->object; bool *usingCallback = &info->usingCallback; while ( *usingCallback ) { - pthread_testcancel(); try { - object->tickStream(stream); + object->tickStream(); } catch (RtError &exception) { - fprintf(stderr, "\nRtAudio: Callback thread error (%s) ... closing thread.\n\n", - exception.getMessage()); + fprintf(stderr, "\nRtApiAlsa: callback thread error (%s) ... closing thread.\n\n", + exception.getMessageString()); break; } } - return 0; + pthread_exit(NULL); } +//******************** End of __LINUX_ALSA__ *********************// +#endif -//******************** End of __LINUX_OSS__ *********************// - -#elif defined(__WINDOWS_ASIO__) // ASIO API on Windows +#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. 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. +// 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" @@ -3429,60 +4363,72 @@ extern "C" void *callbackHandler(void *ptr) AsioDrivers drivers; ASIOCallbacks asioCallbacks; -CALLBACK_INFO *asioCallbackInfo; ASIODriverInfo driverInfo; +CallbackInfo *asioCallbackInfo; + +struct AsioHandle { + bool stopStream; + ASIOBufferInfo *bufferInfos; + HANDLE condition; + + AsioHandle() + :stopStream(false), bufferInfos(0) {} +}; -void RtAudio :: initialize(void) +RtApiAsio :: RtApiAsio() { - nDevices = drivers.asioGetNumDev(); - if (nDevices <= 0) return; + this->initialize(); - // Allocate the RTAUDIO_DEVICE structures. - devices = (RTAUDIO_DEVICE *) calloc(nDevices, sizeof(RTAUDIO_DEVICE)); - if (devices == NULL) { - sprintf(message, "RtAudio: memory allocation error!"); - error(RtError::MEMORY_ERROR); + if (nDevices_ <= 0) { + sprintf(message_, "RtApiAsio: no Windows ASIO audio drivers found!"); + error(RtError::NO_DEVICES_FOUND); } +} - // Write device driver names to device structures and then probe the - // device capabilities. - for (int i=0; i 0 ) { - sprintf(message, "RtAudio: unable to probe ASIO driver while a stream is open."); + if ( stream_.mode != UNINITIALIZED ) { + sprintf(message_, "RtApiAsio: unable to probe driver while a stream is open."); error(RtError::DEBUG_WARNING); return; } - if ( !drivers.loadDriver( info->name ) ) { - sprintf(message, "RtAudio: ASIO error loading driver (%s).", info->name); + if ( !drivers.loadDriver( (char *)info->name.c_str() ) ) { + sprintf(message_, "RtApiAsio: error loading driver (%s).", info->name.c_str()); error(RtError::DEBUG_WARNING); return; } @@ -3498,7 +4444,7 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) sprintf(details, "driver/hardware not present"); else sprintf(details, "unspecified"); - sprintf(message, "RtAudio: ASIO error (%s) initializing driver (%s).", details, info->name); + sprintf(message_, "RtApiAsio: error (%s) initializing driver (%s).", details, info->name.c_str()); error(RtError::DEBUG_WARNING); return; } @@ -3508,7 +4454,7 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) result = ASIOGetChannels( &inputChannels, &outputChannels ); if ( result != ASE_OK ) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO error getting input/output channel count (%s).", info->name); + sprintf(message_, "RtApiAsio: error getting input/output channel count (%s).", info->name.c_str()); error(RtError::DEBUG_WARNING); return; } @@ -3529,16 +4475,16 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) } // Determine the supported sample rates. - info->nSampleRates = 0; - for (int i=0; isampleRates.clear(); + for (unsigned int i=0; isampleRates[info->nSampleRates++] = SAMPLE_RATES[i]; + info->sampleRates.push_back( SAMPLE_RATES[i] ); } - if (info->nSampleRates == 0) { + if (info->sampleRates.size() == 0) { drivers.removeCurrentDriver(); - sprintf( message, "RtAudio: No supported sample rates found for ASIO driver (%s).", info->name ); + sprintf( message_, "RtApiAsio: No supported sample rates found for driver (%s).", info->name.c_str() ); error(RtError::DEBUG_WARNING); return; } @@ -3551,7 +4497,7 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) result = ASIOGetChannelInfo( &channelInfo ); if ( result != ASE_OK ) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO error getting driver (%s) channel information.", info->name); + sprintf(message_, "RtApiAsio: error getting driver (%s) channel information.", info->name.c_str()); error(RtError::DEBUG_WARNING); return; } @@ -3568,8 +4514,8 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) // Check that we have at least one supported format. if (info->nativeFormats == 0) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO driver (%s) data format not supported by RtAudio.", - info->name); + sprintf(message_, "RtApiAsio: driver (%s) data format not supported by RtAudio.", + info->name.c_str()); error(RtError::DEBUG_WARNING); return; } @@ -3580,12 +4526,12 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) void bufferSwitch(long index, ASIOBool processNow) { - RtAudio *object = (RtAudio *) asioCallbackInfo->object; + RtApiAsio *object = (RtApiAsio *) asioCallbackInfo->object; try { - object->callbackEvent( asioCallbackInfo->streamId, index, (void *)NULL, (void *)NULL ); + object->callbackEvent( index ); } catch (RtError &exception) { - fprintf(stderr, "\nCallback handler error (%s)!\n\n", exception.getMessage()); + fprintf(stderr, "\nRtApiAsio: callback handler error (%s)!\n\n", exception.getMessageString()); return; } @@ -3602,14 +4548,14 @@ void sampleRateChanged(ASIOSampleRate sRate) RtAudio *object = (RtAudio *) asioCallbackInfo->object; try { - object->stopStream( asioCallbackInfo->streamId ); + object->stopStream(); } catch (RtError &exception) { - fprintf(stderr, "\nRtAudio: sampleRateChanged() error (%s)!\n\n", exception.getMessage()); + fprintf(stderr, "\nRtApiAsio: sampleRateChanged() error (%s)!\n\n", exception.getMessageString()); return; } - fprintf(stderr, "\nRtAudio: ASIO driver reports sample rate changed to %d ... stream stopped!!!", (int) sRate); + fprintf(stderr, "\nRtApiAsio: driver reports sample rate changed to %d ... stream stopped!!!", (int) sRate); } long asioMessages(long selector, long value, void* message, double* opt) @@ -3635,7 +4581,7 @@ long asioMessages(long selector, long value, void* message, double* opt) // done by completely destruct is. I.e. ASIOStop(), // ASIODisposeBuffers(), Destruction Afterwards you initialize the // driver again. - fprintf(stderr, "\nRtAudio: ASIO driver reset requested!!!"); + fprintf(stderr, "\nRtApiAsio: driver reset requested!!!"); ret = 1L; break; case kAsioResyncRequest: @@ -3646,7 +4592,7 @@ long asioMessages(long selector, long value, void* message, double* opt) // 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, "\nRtAudio: ASIO driver resync requested!!!"); + fprintf(stderr, "\nRtApiAsio: driver resync requested!!!"); ret = 1L; break; case kAsioLatenciesChanged: @@ -3654,7 +4600,7 @@ long asioMessages(long selector, long value, void* message, double* opt) // latencies changed. Beware, it this does not mean that the // buffer sizes have changed! You might need to update internal // delay data. - fprintf(stderr, "\nRtAudio: ASIO driver latency may have changed!!!"); + fprintf(stderr, "\nRtApiAsio: driver latency may have changed!!!"); ret = 1L; break; case kAsioEngineVersion: @@ -3680,30 +4626,22 @@ long asioMessages(long selector, long value, void* message, double* opt) return ret; } -bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, - STREAM_MODE mode, int channels, - int sampleRate, RTAUDIO_FORMAT format, - int *bufferSize, int numberOfBuffers) +bool RtApiAsio :: probeDeviceOpen(int device, StreamMode mode, int channels, + int sampleRate, RtAudioFormat format, + int *bufferSize, int numberOfBuffers) { - // Don't attempt to load another driver if a stream is already open. - if ( streams.size() > 0 ) { - sprintf(message, "RtAudio: unable to load ASIO driver while a stream is open."); - error(RtError::WARNING); - return FAILURE; - } - // For ASIO, a duplex stream MUST use the same driver. - if ( mode == INPUT && stream->mode == OUTPUT && stream->device[0] != device ) { - sprintf(message, "RtAudio: ASIO duplex stream must use the same device for input and output."); + 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( devices[device].name ) ) { - sprintf(message, "RtAudio: ASIO error loading driver (%s).", devices[device].name); + 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; } @@ -3719,7 +4657,7 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, sprintf(details, "driver/hardware not present"); else sprintf(details, "unspecified"); - sprintf(message, "RtAudio: ASIO error (%s) initializing driver (%s).", details, devices[device].name); + sprintf(message_, "RtApiAsio: error (%s) initializing driver (%s).", details, devices_[device].name.c_str()); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -3730,8 +4668,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = ASIOGetChannels( &inputChannels, &outputChannels ); if ( result != ASE_OK ) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO error getting input/output channel count (%s).", - devices[device].name); + sprintf(message_, "RtApiAsio: error getting input/output channel count (%s).", + devices_[device].name.c_str()); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -3739,20 +4677,20 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, if ( ( mode == OUTPUT && channels > outputChannels) || ( mode == INPUT && channels > inputChannels) ) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO driver (%s) does not support requested channel count (%d).", - devices[device].name, channels); + 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; + 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, "RtAudio: ASIO driver (%s) does not support requested sample rate (%d).", - devices[device].name, sampleRate); + sprintf(message_, "RtApiAsio: driver (%s) does not support requested sample rate (%d).", + devices_[device].name.c_str(), sampleRate); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -3761,8 +4699,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = ASIOSetSampleRate( (ASIOSampleRate) sampleRate ); if ( result != ASE_OK ) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO driver (%s) error setting sample rate (%d).", - devices[device].name, sampleRate); + sprintf(message_, "RtApiAsio: driver (%s) error setting sample rate (%d).", + devices_[device].name.c_str(), sampleRate); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -3775,37 +4713,37 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = ASIOGetChannelInfo( &channelInfo ); if ( result != ASE_OK ) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO driver (%s) error getting data format.", - devices[device].name); + 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; + 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; + 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; + 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; + 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; + stream_.deviceFormat[mode] = RTAUDIO_FLOAT64; + if ( channelInfo.type == ASIOSTFloat64MSB ) stream_.doByteSwap[mode] = true; } - if ( stream->deviceFormat[mode] == 0 ) { + if ( stream_.deviceFormat[mode] == 0 ) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO driver (%s) data format not supported by RtAudio.", - devices[device].name); + sprintf(message_, "RtApiAsio: driver (%s) data format not supported by RtAudio.", + devices_[device].name.c_str()); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -3817,8 +4755,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = ASIOGetBufferSize( &minSize, &maxSize, &preferSize, &granularity ); if ( result != ASE_OK ) { drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO driver (%s) error getting buffer size.", - devices[device].name); + sprintf(message_, "RtApiAsio: driver (%s) error getting buffer size.", + devices_[device].name.c_str()); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -3827,51 +4765,67 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, else if ( *bufferSize > maxSize ) *bufferSize = maxSize; else if ( granularity == -1 ) { // Make sure bufferSize is a power of two. - double power = log10( *bufferSize ) / log10( 2.0 ); - *bufferSize = pow( 2.0, floor(power+0.5) ); + 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; } - if ( mode == INPUT && stream->mode == OUTPUT && stream->bufferSize != *bufferSize ) - cout << "possible input/output buffersize discrepancy" << endl; + if ( mode == INPUT && stream_.mode == OUTPUT && stream_.bufferSize != *bufferSize ) + std::cerr << "Possible input/output buffersize discrepancy!" << std::endl; - stream->bufferSize = *bufferSize; - stream->nBuffers = 2; + stream_.bufferSize = *bufferSize; + stream_.nBuffers = 2; // ASIO always uses deinterleaved channels. - stream->deInterleave[mode] = true; + stream_.deInterleave[mode] = true; - // 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 ) { - free(stream->callbackInfo.buffers); - result = ASIODisposeBuffers(); - if ( result != ASE_OK ) { + // 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, "RtAudio: ASIO driver (%s) error disposing previously allocated buffers.", - devices[device].name); + 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]; - stream->callbackInfo.buffers = 0; - ASIOBufferInfo *bufferInfos = (ASIOBufferInfo *) malloc( nChannels * sizeof(ASIOBufferInfo) ); - stream->callbackInfo.buffers = (void *) bufferInfos; - ASIOBufferInfo *infos = bufferInfos; - for ( i=0; inDeviceChannels[1]; i++, infos++ ) { - infos->isInput = ASIOTrue; + 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; inDeviceChannels[0]; i++, infos++ ) { - infos->isInput = ASIOFalse; + for ( i=0; iisInput = ASIOTrue; infos->channelNum = i; infos->buffers[0] = infos->buffers[1] = 0; } @@ -3881,342 +4835,368 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, asioCallbacks.sampleRateDidChange = &sampleRateChanged; asioCallbacks.asioMessage = &asioMessages; asioCallbacks.bufferSwitchTimeInfo = NULL; - result = ASIOCreateBuffers( bufferInfos, nChannels, stream->bufferSize, &asioCallbacks); + result = ASIOCreateBuffers( handle->bufferInfos, nChannels, stream_.bufferSize, &asioCallbacks); if ( result != ASE_OK ) { - drivers.removeCurrentDriver(); - sprintf(message, "RtAudio: ASIO driver (%s) error creating buffers.", - devices[device].name); - error(RtError::DEBUG_WARNING); - return FAILURE; + sprintf(message_, "RtApiAsio: driver (%s) error creating buffers.", + 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; + 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] ) { + if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { long buffer_bytes; - if (stream->nUserChannels[0] >= stream->nUserChannels[1]) - buffer_bytes = stream->nUserChannels[0]; + 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) - goto memory_error; + 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 allocating user buffer memory (%s).", + devices_[device].name.c_str()); + goto error; + } } - if ( stream->doConvertBuffer[mode] ) { + if ( stream_.doConvertBuffer[mode] ) { long buffer_bytes; bool makeBuffer = true; if ( mode == OUTPUT ) - buffer_bytes = stream->nDeviceChannels[0] * formatBytes(stream->deviceFormat[0]); + 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]); + 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) - goto memory_error; + if (stream_.deviceBuffer) free(stream_.deviceBuffer); + stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1); + if (stream_.deviceBuffer == NULL) { + sprintf(message_, "RtApiAsio: error allocating device buffer memory (%s).", + devices_[device].name.c_str()); + goto error; + } } } - stream->device[mode] = device; - stream->state = STREAM_STOPPED; - if ( stream->mode == OUTPUT && mode == INPUT ) + 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; + stream_.mode = DUPLEX; else - stream->mode = mode; - stream->sampleRate = sampleRate; - asioCallbackInfo = &stream->callbackInfo; - stream->callbackInfo.object = (void *) this; - stream->callbackInfo.waitTime = (unsigned long) (200.0 * stream->bufferSize / stream->sampleRate); + stream_.mode = mode; + stream_.sampleRate = sampleRate; + asioCallbackInfo = &stream_.callbackInfo; + stream_.callbackInfo.object = (void *) this; return SUCCESS; - memory_error: + error: ASIODisposeBuffers(); drivers.removeCurrentDriver(); - if (stream->callbackInfo.buffers) - free(stream->callbackInfo.buffers); - stream->callbackInfo.buffers = 0; + 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_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; } - sprintf(message, "RtAudio: error allocating buffer memory (%s).", - devices[device].name); + error(RtError::WARNING); return FAILURE; } -void RtAudio :: cancelStreamCallback(int streamId) +void RtApiAsio :: closeStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + // 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->callbackInfo.usingCallback) { + if (stream_.state == STREAM_RUNNING) + ASIOStop(); - if (stream->state == STREAM_RUNNING) - stopStream( streamId ); + ASIODisposeBuffers(); + drivers.removeCurrentDriver(); - MUTEX_LOCK(&stream->mutex); + AsioHandle *handle = (AsioHandle *) stream_.apiHandle; + if ( handle ) { + CloseHandle( handle->condition ); + if ( handle->bufferInfos ) + free( handle->bufferInfos ); + free( handle ); + stream_.apiHandle = 0; + } - stream->callbackInfo.usingCallback = false; - stream->callbackInfo.userData = NULL; - stream->state = STREAM_STOPPED; - stream->callbackInfo.callback = NULL; + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; + } - MUTEX_UNLOCK(&stream->mutex); + if (stream_.deviceBuffer) { + free(stream_.deviceBuffer); + stream_.deviceBuffer = 0; } + + stream_.mode = UNINITIALIZED; } -void RtAudio :: closeStream(int streamId) +void RtApiAsio :: setStreamCallback(RtAudioCallback callback, void *userData) { - // 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 ( streams.find( streamId ) == streams.end() ) { - sprintf(message, "RtAudio: invalid stream identifier!"); + verifyStream(); + + if ( stream_.callbackInfo.usingCallback ) { + sprintf(message_, "RtApiAsio: A callback is already set for this stream!"); error(RtError::WARNING); return; } - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) streams[streamId]; - - if (stream->state == STREAM_RUNNING) - ASIOStop(); + stream_.callbackInfo.callback = (void *) callback; + stream_.callbackInfo.userData = userData; + stream_.callbackInfo.usingCallback = true; +} - ASIODisposeBuffers(); - //ASIOExit(); - drivers.removeCurrentDriver(); +void RtApiAsio :: cancelStreamCallback() +{ + verifyStream(); - DeleteCriticalSection(&stream->mutex); + if (stream_.callbackInfo.usingCallback) { - if (stream->callbackInfo.buffers) - free(stream->callbackInfo.buffers); + if (stream_.state == STREAM_RUNNING) + stopStream(); - if (stream->userBuffer) - free(stream->userBuffer); + MUTEX_LOCK(&stream_.mutex); - if (stream->deviceBuffer) - free(stream->deviceBuffer); + stream_.callbackInfo.usingCallback = false; + stream_.callbackInfo.userData = NULL; + stream_.state = STREAM_STOPPED; + stream_.callbackInfo.callback = NULL; - free(stream); - streams.erase(streamId); + MUTEX_UNLOCK(&stream_.mutex); + } } -void RtAudio :: startStream(int streamId) +void RtApiAsio :: startStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); + verifyStream(); + if (stream_.state == STREAM_RUNNING) return; - if (stream->state == STREAM_RUNNING) { - MUTEX_UNLOCK(&stream->mutex); - return; - } + MUTEX_LOCK(&stream_.mutex); - stream->callbackInfo.blockTick = true; - stream->callbackInfo.stopStream = false; - stream->callbackInfo.streamId = streamId; ASIOError result = ASIOStart(); if ( result != ASE_OK ) { - sprintf(message, "RtAudio: ASIO error starting device (%s).", - devices[stream->device[0]].name); - MUTEX_UNLOCK(&stream->mutex); + sprintf(message_, "RtApiAsio: error starting device (%s).", + devices_[stream_.device[0]].name.c_str()); + MUTEX_UNLOCK(&stream_.mutex); error(RtError::DRIVER_ERROR); } - stream->state = STREAM_RUNNING; + AsioHandle *handle = (AsioHandle *) stream_.apiHandle; + handle->stopStream = false; + stream_.state = STREAM_RUNNING; - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: stopStream(int streamId) +void RtApiAsio :: stopStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - MUTEX_LOCK(&stream->mutex); - - if (stream->state == STREAM_STOPPED) { - MUTEX_UNLOCK(&stream->mutex); - 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, "RtAudio: ASIO error stopping device (%s).", - devices[stream->device[0]].name); - MUTEX_UNLOCK(&stream->mutex); + sprintf(message_, "RtApiAsio: error stopping device (%s).", + devices_[stream_.device[0]].name.c_str()); + MUTEX_UNLOCK(&stream_.mutex); error(RtError::DRIVER_ERROR); } - stream->state = STREAM_STOPPED; - - MUTEX_UNLOCK(&stream->mutex); -} -void RtAudio :: abortStream(int streamId) -{ - stopStream( streamId ); + MUTEX_UNLOCK(&stream_.mutex); } -// I don't know how this function can be implemented. -int RtAudio :: streamWillBlock(int streamId) +void RtApiAsio :: abortStream() { - sprintf(message, "RtAudio: streamWillBlock() cannot be implemented for ASIO."); - error(RtError::WARNING); - return 0; + stopStream(); } -void RtAudio :: tickStream(int streamId) +void RtApiAsio :: tickStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); - if (stream->state == STREAM_STOPPED) + if (stream_.state == STREAM_STOPPED) return; - if (stream->callbackInfo.usingCallback) { - sprintf(message, "RtAudio: tickStream() should not be used when a callback function is set!"); + if (stream_.callbackInfo.usingCallback) { + sprintf(message_, "RtApiAsio: tickStream() should not be used when a callback function is set!"); error(RtError::WARNING); return; } - // Block waiting here until the user data is processed in callbackEvent(). - while ( stream->callbackInfo.blockTick ) - Sleep(stream->callbackInfo.waitTime); + AsioHandle *handle = (AsioHandle *) stream_.apiHandle; - MUTEX_LOCK(&stream->mutex); + MUTEX_LOCK(&stream_.mutex); - stream->callbackInfo.blockTick = true; - - MUTEX_UNLOCK(&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 RtAudio :: callbackEvent(int streamId, int bufferIndex, void *inData, void *outData) +void RtApiAsio :: callbackEvent(long bufferIndex) { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + + if (stream_.state == STREAM_STOPPED) return; - CALLBACK_INFO *info = asioCallbackInfo; - if ( !info->usingCallback ) { - // Block waiting here until we get new user data in tickStream(). - while ( !info->blockTick ) - Sleep(info->waitTime); - } - else if ( info->stopStream ) { + 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(asioCallbackInfo->streamId); + this->stopStream(); return; } - MUTEX_LOCK(&stream->mutex); + MUTEX_LOCK(&stream_.mutex); // Invoke user callback first, to get fresh output data. if ( info->usingCallback ) { - RTAUDIO_CALLBACK callback = (RTAUDIO_CALLBACK) info->callback; - if ( callback(stream->userBuffer, stream->bufferSize, info->userData) ) - info->stopStream = true; + RtAudioCallback callback = (RtAudioCallback) info->callback; + if ( callback(stream_.userBuffer, stream_.bufferSize, info->userData) ) + handle->stopStream = true; } - int nChannels = stream->nDeviceChannels[0] + stream->nDeviceChannels[1]; - int bufferBytes; - ASIOBufferInfo *bufferInfos = (ASIOBufferInfo *) info->buffers; - if ( stream->mode == OUTPUT || stream->mode == DUPLEX ) { + 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]) { + bufferBytes = stream_.bufferSize * formatBytes(stream_.deviceFormat[0]); + if (stream_.doConvertBuffer[0]) { - convertStreamBuffer(stream, OUTPUT); - if ( stream->doByteSwap[0] ) - byteSwapBuffer(stream->deviceBuffer, - stream->bufferSize * stream->nDeviceChannels[0], - stream->deviceFormat[0]); + convertStreamBuffer(OUTPUT); + if ( stream_.doByteSwap[0] ) + byteSwapBuffer(stream_.deviceBuffer, + stream_.bufferSize * stream_.nDeviceChannels[0], + stream_.deviceFormat[0]); // Always de-interleave ASIO output data. - for ( int i=0; inDeviceChannels[0]; i++, bufferInfos++ ) { - memcpy(bufferInfos->buffers[bufferIndex], - &stream->deviceBuffer[i*bufferBytes], bufferBytes ); + 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); + if (stream_.doByteSwap[0]) + byteSwapBuffer(stream_.userBuffer, + stream_.bufferSize * stream_.nUserChannels[0], + stream_.userFormat); - memcpy(bufferInfos->buffers[bufferIndex], stream->userBuffer, bufferBytes ); + 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 ) { + if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) { - bufferBytes = stream->bufferSize * formatBytes(stream->deviceFormat[1]); - if (stream->doConvertBuffer[1]) { + bufferBytes = stream_.bufferSize * formatBytes(stream_.deviceFormat[1]); + if (stream_.doConvertBuffer[1]) { // Always interleave ASIO input data. - for ( int i=0; inDeviceChannels[1]; i++, bufferInfos++ ) - memcpy(&stream->deviceBuffer[i*bufferBytes], bufferInfos->buffers[bufferIndex], bufferBytes ); + 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]); - convertStreamBuffer(stream, INPUT); + if ( stream_.doByteSwap[1] ) + byteSwapBuffer(stream_.deviceBuffer, + stream_.bufferSize * stream_.nDeviceChannels[1], + stream_.deviceFormat[1]); + convertStreamBuffer(INPUT); } else { // single channel only - memcpy(stream->userBuffer, bufferInfos->buffers[bufferIndex], bufferBytes ); + 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 (stream_.doByteSwap[1]) + byteSwapBuffer(stream_.userBuffer, + stream_.bufferSize * stream_.nUserChannels[1], + stream_.userFormat); } } if ( !info->usingCallback ) - info->blockTick = false; - - MUTEX_UNLOCK(&stream->mutex); -} + SetEvent( handle->condition ); -void RtAudio :: setStreamCallback(int streamId, RTAUDIO_CALLBACK callback, void *userData) -{ - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - stream->callbackInfo.callback = (void *) callback; - stream->callbackInfo.userData = userData; - stream->callbackInfo.usingCallback = true; + MUTEX_UNLOCK(&stream_.mutex); } //******************** End of __WINDOWS_ASIO__ *********************// +#endif -#elif defined(__WINDOWS_DS__) // Windows DirectSound API +#if defined(__WINDOWS_DS__) // Windows DirectSound API #include +// A structure to hold various information related to the DirectSound +// API implementation. +struct DsHandle { + void *object; + void *buffer; + UINT bufferPointer; +}; + // Declarations for utility functions, callbacks, and structures // specific to the DirectSound implementation. static bool CALLBACK deviceCountCallback(LPGUID lpguid, @@ -4241,6 +5221,8 @@ static bool CALLBACK deviceIdCallback(LPGUID lpguid, static char* getErrorString(int code); +extern "C" unsigned __stdcall callbackHandler(void *ptr); + struct enum_info { char name[64]; LPGUID id; @@ -4248,7 +5230,22 @@ struct enum_info { bool isValid; }; -int RtAudio :: getDefaultInputDevice(void) +RtApiDs :: RtApiDs() +{ + this->initialize(); + + if (nDevices_ <= 0) { + sprintf(message_, "RtApiDs: no Windows DirectSound audio devices found!"); + error(RtError::NO_DEVICES_FOUND); + } +} + +RtApiDs :: ~RtApiDs() +{ + if ( stream_.mode != UNINITIALIZED ) closeStream(); +} + +int RtApiDs :: getDefaultInputDevice(void) { enum_info info; info.name[0] = '\0'; @@ -4256,19 +5253,21 @@ int RtAudio :: getDefaultInputDevice(void) // Enumerate through devices to find the default output. HRESULT result = DirectSoundCaptureEnumerate((LPDSENUMCALLBACK)defaultDeviceCallback, &info); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Error performing default input device enumeration: %s.", + sprintf(message_, "RtApiDs: Error performing default input device enumeration: %s.", getErrorString(result)); error(RtError::WARNING); return 0; } - for ( int i=0; iname, 64 ); + strncpy( dsinfo.name, info->name.c_str(), 64 ); 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, "RtAudio: Error performing input device id enumeration: %s.", + sprintf(message_, "RtApiDs: Error performing input device id enumeration: %s.", getErrorString(result)); error(RtError::WARNING); return; @@ -4386,8 +5375,8 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) LPDIRECTSOUNDCAPTURE input; result = DirectSoundCaptureCreate( dsinfo.id, &input, NULL ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Could not create DirectSound capture object (%s): %s.", - info->name, getErrorString(result)); + sprintf(message_, "RtApiDs: Could not create capture object (%s): %s.", + info->name.c_str(), getErrorString(result)); error(RtError::WARNING); goto playback_probe; } @@ -4397,8 +5386,8 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) result = input->GetCaps( &in_caps ); if ( FAILED(result) ) { input->Release(); - sprintf(message, "RtAudio: Could not get DirectSound capture capabilities (%s): %s.", - info->name, getErrorString(result)); + sprintf(message_, "RtApiDs: Could not get capture capabilities (%s): %s.", + info->name.c_str(), getErrorString(result)); error(RtError::WARNING); goto playback_probe; } @@ -4408,6 +5397,7 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) 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; @@ -4417,14 +5407,14 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) 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[info->nSampleRates++] = 11025; - if( in_caps.dwFormats & WAVE_FORMAT_2S16 ) info->sampleRates[info->nSampleRates++] = 22050; - if( in_caps.dwFormats & WAVE_FORMAT_4S16 ) info->sampleRates[info->nSampleRates++] = 44100; + 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[info->nSampleRates++] = 11025; - if( in_caps.dwFormats & WAVE_FORMAT_2S08 ) info->sampleRates[info->nSampleRates++] = 22050; - if( in_caps.dwFormats & WAVE_FORMAT_4S08 ) info->sampleRates[info->nSampleRates++] = 44100; + 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 ) { @@ -4436,14 +5426,14 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) 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[info->nSampleRates++] = 11025; - if( in_caps.dwFormats & WAVE_FORMAT_2M16 ) info->sampleRates[info->nSampleRates++] = 22050; - if( in_caps.dwFormats & WAVE_FORMAT_4M16 ) info->sampleRates[info->nSampleRates++] = 44100; + 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[info->nSampleRates++] = 11025; - if( in_caps.dwFormats & WAVE_FORMAT_2M08 ) info->sampleRates[info->nSampleRates++] = 22050; - if( in_caps.dwFormats & WAVE_FORMAT_4M08 ) info->sampleRates[info->nSampleRates++] = 44100; + 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 @@ -4457,7 +5447,7 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) // Enumerate through output devices to find the id (if it exists). result = DirectSoundEnumerate((LPDSENUMCALLBACK)deviceIdCallback, &dsinfo); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Error performing output device id enumeration: %s.", + sprintf(message_, "RtApiDs: Error performing output device id enumeration: %s.", getErrorString(result)); error(RtError::WARNING); return; @@ -4471,8 +5461,8 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) DSCAPS out_caps; result = DirectSoundCreate( dsinfo.id, &output, NULL ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Could not create DirectSound playback object (%s): %s.", - info->name, getErrorString(result)); + sprintf(message_, "RtApiDs: Could not create playback object (%s): %s.", + info->name.c_str(), getErrorString(result)); error(RtError::WARNING); goto check_parameters; } @@ -4481,8 +5471,8 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) result = output->GetCaps( &out_caps ); if ( FAILED(result) ) { output->Release(); - sprintf(message, "RtAudio: Could not get DirectSound playback capabilities (%s): %s.", - info->name, getErrorString(result)); + sprintf(message_, "RtApiDs: Could not get playback capabilities (%s): %s.", + info->name.c_str(), getErrorString(result)); error(RtError::WARNING); goto check_parameters; } @@ -4493,49 +5483,19 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) // Get sample rate information. Use capture device rate information // if it exists. - if ( info->nSampleRates == 0 ) { - info->sampleRates[0] = (int) out_caps.dwMinSecondarySampleRate; - info->sampleRates[1] = (int) out_caps.dwMaxSecondarySampleRate; - if ( out_caps.dwFlags & DSCAPS_CONTINUOUSRATE ) - info->nSampleRates = -1; - else if ( out_caps.dwMinSecondarySampleRate == out_caps.dwMaxSecondarySampleRate ) { - if ( out_caps.dwMinSecondarySampleRate == 0 ) { - // This is a bogus driver report ... fake the range and cross - // your fingers. - info->sampleRates[0] = 11025; - info->sampleRates[1] = 48000; - info->nSampleRates = -1; /* continuous range */ - sprintf(message, "RtAudio: bogus sample rates reported by DirectSound driver ... using defaults (%s).", - info->name); - error(RtError::DEBUG_WARNING); - } - else { - info->nSampleRates = 1; - } - } - else if ( (out_caps.dwMinSecondarySampleRate < 1000.0) && - (out_caps.dwMaxSecondarySampleRate > 50000.0) ) { - // This is a bogus driver report ... support for only two - // distant rates. We'll assume this is a range. - info->nSampleRates = -1; - sprintf(message, "RtAudio: bogus sample rates reported by DirectSound driver ... using range (%s).", - info->name); - error(RtError::WARNING); - } - else info->nSampleRates = 2; + if ( info->sampleRates.size() == 0 ) { + info->sampleRates.push_back( (int) out_caps.dwMinSecondarySampleRate ); + info->sampleRates.push_back( (int) out_caps.dwMaxSecondarySampleRate ); } else { - // Check input rates against output rate range - for ( int i=info->nSampleRates-1; i>=0; i-- ) { - if ( info->sampleRates[i] <= out_caps.dwMaxSecondarySampleRate ) - break; - info->nSampleRates--; + // Check input rates against output rate range. + for ( unsigned 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[0] < out_caps.dwMinSecondarySampleRate ) { - info->nSampleRates--; - for ( int i=0; inSampleRates; i++) - info->sampleRates[i] = info->sampleRates[i+1]; - if ( info->nSampleRates <= 0 ) break; + while ( info->sampleRates.size() > 0 && + ((unsigned int) info->sampleRates[0] < out_caps.dwMinSecondarySampleRate) ) { + info->sampleRates.erase( info->sampleRates.begin() ); } } @@ -4546,10 +5506,18 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) output->Release(); check_parameters: - if ( info->maxInputChannels == 0 && info->maxOutputChannels == 0 ) + 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->nSampleRates == 0 || info->nativeFormats == 0 ) + } + 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) @@ -4569,13 +5537,13 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) return; } -bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, - STREAM_MODE mode, int channels, - int sampleRate, RTAUDIO_FORMAT format, - int *bufferSize, int numberOfBuffers) +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 @@ -4603,23 +5571,23 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, waveFormat.nSamplesPerSec = (unsigned long) sampleRate; // Determine the data format. - if ( devices[device].nativeFormats ) { // 8-bit and/or 16-bit support + if ( devices_[device].nativeFormats ) { // 8-bit and/or 16-bit support if ( format == RTAUDIO_SINT8 ) { - if ( devices[device].nativeFormats & RTAUDIO_SINT8 ) + if ( devices_[device].nativeFormats & RTAUDIO_SINT8 ) waveFormat.wBitsPerSample = 8; else waveFormat.wBitsPerSample = 16; } else { - if ( devices[device].nativeFormats & RTAUDIO_SINT16 ) + if ( devices_[device].nativeFormats & RTAUDIO_SINT16 ) waveFormat.wBitsPerSample = 16; else waveFormat.wBitsPerSample = 8; } } else { - sprintf(message, "RtAudio: no reported data formats for DirectSound device (%s).", - devices[device].name); + sprintf(message_, "RtApiDs: no reported data formats for device (%s).", + devices_[device].name.c_str()); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -4628,24 +5596,29 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign; enum_info dsinfo; - strncpy( dsinfo.name, devices[device].name, 64 ); + void *ohandle = 0, *bhandle = 0; + strncpy( dsinfo.name, devices_[device].name.c_str(), 64 ); dsinfo.isValid = false; if ( mode == OUTPUT ) { - if ( devices[device].maxOutputChannels < channels ) + 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; + } // Enumerate through output devices to find the id (if it exists). result = DirectSoundEnumerate((LPDSENUMCALLBACK)deviceIdCallback, &dsinfo); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Error performing output device id enumeration: %s.", + sprintf(message_, "RtApiDs: Error performing output device id enumeration: %s.", getErrorString(result)); error(RtError::DEBUG_WARNING); return FAILURE; } if ( dsinfo.isValid == false ) { - sprintf(message, "RtAudio: DS output device (%s) id not found!", devices[device].name); + sprintf(message_, "RtApiDs: output device (%s) id not found!", devices_[device].name.c_str()); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -4657,8 +5630,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = DirectSoundCreate( id, &object, NULL ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Could not create DirectSound playback object (%s): %s.", - devices[device].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Could not create playback object (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -4667,16 +5640,16 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = object->SetCooperativeLevel(hWnd, DSSCL_EXCLUSIVE); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to set DirectSound cooperative level (%s): %s.", - devices[device].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to set cooperative level (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::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. - // The default is 8-bit, 22 kHz! - // Setup the DS primary buffer description. + // 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; @@ -4684,8 +5657,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = object->CreateSoundBuffer(&bufferDescription, &buffer, NULL); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to access DS primary buffer (%s): %s.", - devices[device].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to access primary buffer (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } @@ -4694,8 +5667,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = buffer->SetFormat(&waveFormat); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to set DS primary buffer format (%s): %s.", - devices[device].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to set primary buffer format (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } @@ -4720,8 +5693,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = object->CreateSoundBuffer(&bufferDescription, &buffer, NULL); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to create secondary DS buffer (%s): %s.", - devices[device].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to create secondary DS buffer (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } @@ -4737,8 +5710,9 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = buffer->Lock(0, buffer_size, &audioPtr, &dataLen, NULL, NULL, 0); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to lock DS buffer (%s): %s.", - devices[device].name, getErrorString(result)); + buffer->Release(); + sprintf(message_, "RtApiDs: Unable to lock buffer (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } @@ -4750,33 +5724,34 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = buffer->Unlock(audioPtr, dataLen, NULL, 0); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to unlock DS buffer(%s): %s.", - devices[device].name, getErrorString(result)); + buffer->Release(); + sprintf(message_, "RtApiDs: Unable to unlock buffer(%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } - stream->handle[0].object = (void *) object; - stream->handle[0].buffer = (void *) buffer; - stream->nDeviceChannels[0] = channels; + ohandle = (void *) object; + bhandle = (void *) buffer; + stream_.nDeviceChannels[0] = channels; } if ( mode == INPUT ) { - if ( devices[device].maxInputChannels < channels ) + if ( devices_[device].maxInputChannels < channels ) return FAILURE; // Enumerate through input devices to find the id (if it exists). result = DirectSoundCaptureEnumerate((LPDSENUMCALLBACK)deviceIdCallback, &dsinfo); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Error performing input device id enumeration: %s.", + sprintf(message_, "RtApiDs: Error performing input device id enumeration: %s.", getErrorString(result)); error(RtError::DEBUG_WARNING); return FAILURE; } if ( dsinfo.isValid == false ) { - sprintf(message, "RtAudio: DS input device (%s) id not found!", devices[device].name); + sprintf(message_, "RtAudioDS: input device (%s) id not found!", devices_[device].name.c_str()); error(RtError::DEBUG_WARNING); return FAILURE; } @@ -4788,8 +5763,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = DirectSoundCaptureCreate( id, &object, NULL ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Could not create DirectSound capture object (%s): %s.", - devices[device].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Could not create capture object (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } @@ -4807,8 +5782,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = object->CreateCaptureBuffer(&bufferDescription, &buffer, NULL); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to create DS capture buffer (%s): %s.", - devices[device].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to create capture buffer (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } @@ -4817,8 +5792,9 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = buffer->Lock(0, buffer_size, &audioPtr, &dataLen, NULL, NULL, 0); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to lock DS capture buffer (%s): %s.", - devices[device].name, getErrorString(result)); + buffer->Release(); + sprintf(message_, "RtApiDs: Unable to lock capture buffer (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } @@ -4830,233 +5806,285 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = buffer->Unlock(audioPtr, dataLen, NULL, 0); if ( FAILED(result) ) { object->Release(); - sprintf(message, "RtAudio: Unable to unlock DS capture buffer (%s): %s.", - devices[device].name, getErrorString(result)); + buffer->Release(); + sprintf(message_, "RtApiDs: Unable to unlock capture buffer (%s): %s.", + devices_[device].name.c_str(), getErrorString(result)); error(RtError::WARNING); return FAILURE; } - stream->handle[1].object = (void *) object; - stream->handle[1].buffer = (void *) buffer; - stream->nDeviceChannels[1] = channels; + ohandle = (void *) object; + bhandle = (void *) buffer; + stream_.nDeviceChannels[1] = channels; } - stream->userFormat = format; + stream_.userFormat = format; if ( waveFormat.wBitsPerSample == 8 ) - stream->deviceFormat[mode] = RTAUDIO_SINT8; + stream_.deviceFormat[mode] = RTAUDIO_SINT8; else - stream->deviceFormat[mode] = RTAUDIO_SINT16; - stream->nUserChannels[mode] = channels; + stream_.deviceFormat[mode] = RTAUDIO_SINT16; + stream_.nUserChannels[mode] = channels; *bufferSize = buffer_size / (channels * nBuffers * waveFormat.wBitsPerSample / 8); - stream->bufferSize = *bufferSize; + stream_.bufferSize = *bufferSize; // 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; + 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; // Allocate necessary internal buffers - if ( stream->nUserChannels[0] != stream->nUserChannels[1] ) { + if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { long buffer_bytes; - if (stream->nUserChannels[0] >= stream->nUserChannels[1]) - buffer_bytes = stream->nUserChannels[0]; + 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) - goto memory_error; + 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 ( stream->doConvertBuffer[mode] ) { + if ( stream_.doConvertBuffer[mode] ) { long buffer_bytes; bool makeBuffer = true; if ( mode == OUTPUT ) - buffer_bytes = stream->nDeviceChannels[0] * formatBytes(stream->deviceFormat[0]); + 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]); + 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) - goto memory_error; + 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; + } } } - stream->device[mode] = device; - stream->state = STREAM_STOPPED; - if ( stream->mode == OUTPUT && mode == INPUT ) + // 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; + } + 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; + + 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; + stream_.mode = DUPLEX; else - stream->mode = mode; - stream->nBuffers = nBuffers; - stream->sampleRate = sampleRate; + stream_.mode = mode; + stream_.nBuffers = nBuffers; + stream_.sampleRate = sampleRate; return SUCCESS; - memory_error: - if (stream->handle[0].object) { - LPDIRECTSOUND object = (LPDIRECTSOUND) stream->handle[0].object; - LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) stream->handle[0].buffer; - if (buffer) { - buffer->Release(); - stream->handle[0].buffer = NULL; + 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(); } - object->Release(); - stream->handle[0].object = NULL; - } - if (stream->handle[1].object) { - LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) stream->handle[1].object; - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) stream->handle[1].buffer; - if (buffer) { - buffer->Release(); - stream->handle[1].buffer = NULL; + if (handles[1].object) { + LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handles[1].object; + LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; + if (buffer) buffer->Release(); + object->Release(); } - object->Release(); - stream->handle[1].object = NULL; + free(handles); + stream_.apiHandle = 0; } - if (stream->userBuffer) { - free(stream->userBuffer); - stream->userBuffer = 0; + + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; } - sprintf(message, "RtAudio: error allocating buffer memory (%s).", - devices[device].name); + error(RtError::WARNING); return FAILURE; } -void RtAudio :: cancelStreamCallback(int streamId) +void RtApiDs :: setStreamCallback(RtAudioCallback callback, void *userData) +{ + verifyStream(); + + CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo; + if ( info->usingCallback ) { + sprintf(message_, "RtApiDs: 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; + + 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); + } + + // When spawning multiple threads in quick succession, it appears to be + // necessary to wait a bit for each to initialize ... another windoism! + Sleep(1); +} + +void RtApiDs :: cancelStreamCallback() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); - if (stream->callbackInfo.usingCallback) { + if (stream_.callbackInfo.usingCallback) { - if (stream->state == STREAM_RUNNING) - stopStream( streamId ); + if (stream_.state == STREAM_RUNNING) + stopStream(); - MUTEX_LOCK(&stream->mutex); + MUTEX_LOCK(&stream_.mutex); - 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; + 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; - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } } -void RtAudio :: closeStream(int streamId) +void RtApiDs :: 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 ( streams.find( streamId ) == streams.end() ) { - sprintf(message, "RtAudio: invalid stream identifier!"); + if ( stream_.mode == UNINITIALIZED ) { + sprintf(message_, "RtApiDs::closeStream(): no open stream to close!"); error(RtError::WARNING); return; } - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) streams[streamId]; - - if (stream->callbackInfo.usingCallback) { - stream->callbackInfo.usingCallback = false; - WaitForSingleObject( (HANDLE)stream->callbackInfo.thread, INFINITE ); - CloseHandle( (HANDLE)stream->callbackInfo.thread ); + if (stream_.callbackInfo.usingCallback) { + stream_.callbackInfo.usingCallback = false; + WaitForSingleObject( (HANDLE)stream_.callbackInfo.thread, INFINITE ); + CloseHandle( (HANDLE)stream_.callbackInfo.thread ); } - DeleteCriticalSection(&stream->mutex); - - if (stream->handle[0].object) { - LPDIRECTSOUND object = (LPDIRECTSOUND) stream->handle[0].object; - LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) stream->handle[0].buffer; - if (buffer) { - buffer->Stop(); - buffer->Release(); + 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(); } - object->Release(); - } - if (stream->handle[1].object) { - LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) stream->handle[1].object; - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) stream->handle[1].buffer; - if (buffer) { - buffer->Stop(); - buffer->Release(); + if (handles[1].object) { + LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handles[1].object; + LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; + if (buffer) { + buffer->Stop(); + buffer->Release(); + } + object->Release(); } - object->Release(); + free(handles); + stream_.apiHandle = 0; + } + + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; } - if (stream->userBuffer) - free(stream->userBuffer); - - if (stream->deviceBuffer) - free(stream->deviceBuffer); + if (stream_.deviceBuffer) { + free(stream_.deviceBuffer); + stream_.deviceBuffer = 0; + } - free(stream); - streams.erase(streamId); + stream_.mode = UNINITIALIZED; } -void RtAudio :: startStream(int streamId) +void RtApiDs :: startStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_RUNNING) return; - MUTEX_LOCK(&stream->mutex); - - if (stream->state == STREAM_RUNNING) - goto unlock; + MUTEX_LOCK(&stream_.mutex); HRESULT result; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) stream->handle[0].buffer; + DsHandle *handles = (DsHandle *) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { + LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; result = buffer->Play(0, 0, DSBPLAY_LOOPING ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to start DS buffer (%s): %s.", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to start buffer (%s): %s.", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } } - if (stream->mode == INPUT || stream->mode == DUPLEX) { - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) stream->handle[1].buffer; + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; result = buffer->Start(DSCBSTART_LOOPING ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to start DS capture buffer (%s): %s.", - devices[stream->device[1]].name, getErrorString(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; + stream_.state = STREAM_RUNNING; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: stopStream(int streamId) +void RtApiDs :: stopStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - if (stream->state == STREAM_STOPPED) { - MUTEX_UNLOCK(&stream->mutex); - return; - } + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK(&stream_.mutex); // There is no specific DirectSound API call to "drain" a buffer // before stopping. We can hack this for playback by writing zeroes @@ -5069,24 +6097,25 @@ void RtAudio :: stopStream(int streamId) LPVOID buffer2 = NULL; DWORD bufferSize1 = 0; DWORD bufferSize2 = 0; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { + DsHandle *handles = (DsHandle *) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { DWORD currentPos, safePos; - long buffer_bytes = stream->bufferSize * stream->nDeviceChannels[0]; - buffer_bytes *= formatBytes(stream->deviceFormat[0]); + long buffer_bytes = stream_.bufferSize * stream_.nDeviceChannels[0]; + buffer_bytes *= formatBytes(stream_.deviceFormat[0]); - LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) stream->handle[0].buffer; - UINT nextWritePos = stream->handle[0].bufferPointer; - dsBufferSize = buffer_bytes * stream->nBuffers; + LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; + UINT nextWritePos = handles[0].bufferPointer; + dsBufferSize = buffer_bytes * stream_.nBuffers; // Write zeroes for nBuffer counts. - for (int i=0; inBuffers; i++) { + for (int i=0; iGetCurrentPosition(¤tPos, &safePos); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to get current DS position (%s): %s.", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } @@ -5095,16 +6124,16 @@ void RtAudio :: stopStream(int streamId) // Check whether the entire write region is behind the play pointer. while ( currentPos < endWrite ) { - float millis = (endWrite - currentPos) * 900.0; - millis /= ( formatBytes(stream->deviceFormat[0]) * stream->sampleRate); + double millis = (endWrite - currentPos) * 900.0; + millis /= ( formatBytes(stream_.deviceFormat[0]) * stream_.sampleRate); if ( millis < 1.0 ) millis = 1.0; Sleep( (DWORD) millis ); // Wake up, find out where we are now result = dsBuffer->GetCurrentPosition( ¤tPos, &safePos ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to get current DS position (%s): %s.", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } if ( currentPos < nextWritePos ) currentPos += dsBufferSize; // unwrap offset @@ -5114,8 +6143,8 @@ void RtAudio :: stopStream(int streamId) result = dsBuffer->Lock (nextWritePos, buffer_bytes, &buffer1, &bufferSize1, &buffer2, &bufferSize2, 0); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to lock DS buffer during playback (%s): %s.", - devices[stream->device[0]].name, getErrorString(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); } @@ -5126,39 +6155,39 @@ void RtAudio :: stopStream(int streamId) // Update our buffer offset and unlock sound buffer dsBuffer->Unlock (buffer1, bufferSize1, buffer2, bufferSize2); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to unlock DS buffer during playback (%s): %s.", - devices[stream->device[0]].name, getErrorString(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; - stream->handle[0].bufferPointer = nextWritePos; + handles[0].bufferPointer = nextWritePos; } // If we play again, start at the beginning of the buffer. - stream->handle[0].bufferPointer = 0; + handles[0].bufferPointer = 0; } - if (stream->mode == INPUT || stream->mode == DUPLEX) { - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) stream->handle[1].buffer; + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; buffer1 = NULL; bufferSize1 = 0; result = buffer->Stop(); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to stop DS capture buffer (%s): %s", - devices[stream->device[1]].name, getErrorString(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 = stream->bufferSize * stream->nDeviceChannels[1]; - dsBufferSize *= formatBytes(stream->deviceFormat[1]) * stream->nBuffers; + dsBufferSize = stream_.bufferSize * stream_.nDeviceChannels[1]; + dsBufferSize *= formatBytes(stream_.deviceFormat[1]) * stream_.nBuffers; // 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, "RtAudio: Unable to lock DS capture buffer (%s): %s.", - devices[stream->device[1]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to lock capture buffer (%s): %s.", + devices_[stream_.device[1]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } @@ -5168,50 +6197,51 @@ void RtAudio :: stopStream(int streamId) // Unlock the DS buffer result = buffer->Unlock(buffer1, bufferSize1, NULL, 0); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to unlock DS capture buffer (%s): %s.", - devices[stream->device[1]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to unlock capture buffer (%s): %s.", + devices_[stream_.device[1]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } // If we start recording again, we must begin at beginning of buffer. - stream->handle[1].bufferPointer = 0; + handles[1].bufferPointer = 0; } - stream->state = STREAM_STOPPED; - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: abortStream(int streamId) +void RtApiDs :: abortStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - MUTEX_LOCK(&stream->mutex); - - if (stream->state == STREAM_STOPPED) - goto unlock; + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK(&stream_.mutex); HRESULT result; long dsBufferSize; LPVOID audioPtr; DWORD dataLen; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) stream->handle[0].buffer; + 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, "RtAudio: Unable to stop DS buffer (%s): %s", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to stop buffer (%s): %s", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } - dsBufferSize = stream->bufferSize * stream->nDeviceChannels[0]; - dsBufferSize *= formatBytes(stream->deviceFormat[0]) * stream->nBuffers; + dsBufferSize = stream_.bufferSize * stream_.nDeviceChannels[0]; + dsBufferSize *= formatBytes(stream_.deviceFormat[0]) * stream_.nBuffers; // 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, "RtAudio: Unable to lock DS buffer (%s): %s.", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to lock buffer (%s): %s.", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } @@ -5221,36 +6251,36 @@ void RtAudio :: abortStream(int streamId) // Unlock the DS buffer result = buffer->Unlock(audioPtr, dataLen, NULL, 0); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to unlock DS buffer (%s): %s.", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to unlock buffer (%s): %s.", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } // If we start playing again, we must begin at beginning of buffer. - stream->handle[0].bufferPointer = 0; + handles[0].bufferPointer = 0; } - if (stream->mode == INPUT || stream->mode == DUPLEX) { - LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) stream->handle[1].buffer; + 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, "RtAudio: Unable to stop DS capture buffer (%s): %s", - devices[stream->device[1]].name, getErrorString(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 = stream->bufferSize * stream->nDeviceChannels[1]; - dsBufferSize *= formatBytes(stream->deviceFormat[1]) * stream->nBuffers; + dsBufferSize = stream_.bufferSize * stream_.nDeviceChannels[1]; + dsBufferSize *= formatBytes(stream_.deviceFormat[1]) * stream_.nBuffers; // 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, "RtAudio: Unable to lock DS capture buffer (%s): %s.", - devices[stream->device[1]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to lock capture buffer (%s): %s.", + devices_[stream_.device[1]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } @@ -5260,112 +6290,108 @@ void RtAudio :: abortStream(int streamId) // Unlock the DS buffer result = buffer->Unlock(audioPtr, dataLen, NULL, 0); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to unlock DS capture buffer (%s): %s.", - devices[stream->device[1]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to unlock capture buffer (%s): %s.", + devices_[stream_.device[1]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } // If we start recording again, we must begin at beginning of buffer. - stream->handle[1].bufferPointer = 0; + handles[1].bufferPointer = 0; } - stream->state = STREAM_STOPPED; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -int RtAudio :: streamWillBlock(int streamId) +int RtApiDs :: streamWillBlock() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return 0; - MUTEX_LOCK(&stream->mutex); + MUTEX_LOCK(&stream_.mutex); int channels; int frames = 0; - if (stream->state == STREAM_STOPPED) - goto unlock; - HRESULT result; DWORD currentPos, safePos; channels = 1; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { + DsHandle *handles = (DsHandle *) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) stream->handle[0].buffer; - UINT nextWritePos = stream->handle[0].bufferPointer; - channels = stream->nDeviceChannels[0]; - DWORD dsBufferSize = stream->bufferSize * channels; - dsBufferSize *= formatBytes(stream->deviceFormat[0]) * stream->nBuffers; + LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; + UINT nextWritePos = handles[0].bufferPointer; + channels = stream_.nDeviceChannels[0]; + DWORD dsBufferSize = stream_.bufferSize * channels; + dsBufferSize *= formatBytes(stream_.deviceFormat[0]) * stream_.nBuffers; // Find out where the read and "safe write" pointers are. result = dsBuffer->GetCurrentPosition(¤tPos, &safePos); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to get current DS position (%s): %s.", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } if ( currentPos < nextWritePos ) currentPos += dsBufferSize; // unwrap offset frames = currentPos - nextWritePos; - frames /= channels * formatBytes(stream->deviceFormat[0]); + frames /= channels * formatBytes(stream_.deviceFormat[0]); } - if (stream->mode == INPUT || stream->mode == DUPLEX) { + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { - LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) stream->handle[1].buffer; - UINT nextReadPos = stream->handle[1].bufferPointer; - channels = stream->nDeviceChannels[1]; - DWORD dsBufferSize = stream->bufferSize * channels; - dsBufferSize *= formatBytes(stream->deviceFormat[1]) * stream->nBuffers; + LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; + UINT nextReadPos = handles[1].bufferPointer; + channels = stream_.nDeviceChannels[1]; + DWORD dsBufferSize = stream_.bufferSize * channels; + dsBufferSize *= formatBytes(stream_.deviceFormat[1]) * stream_.nBuffers; // Find out where the write and "safe read" pointers are. result = dsBuffer->GetCurrentPosition(¤tPos, &safePos); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to get current DS capture position (%s): %s.", - devices[stream->device[1]].name, getErrorString(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 ( safePos < nextReadPos ) safePos += dsBufferSize; // unwrap offset - if (stream->mode == DUPLEX ) { + if (stream_.mode == DUPLEX ) { // Take largest value of the two. int temp = safePos - nextReadPos; - temp /= channels * formatBytes(stream->deviceFormat[1]); + temp /= channels * formatBytes(stream_.deviceFormat[1]); frames = ( temp > frames ) ? temp : frames; } else { frames = safePos - nextReadPos; - frames /= channels * formatBytes(stream->deviceFormat[1]); + frames /= channels * formatBytes(stream_.deviceFormat[1]); } } - frames = stream->bufferSize - frames; + frames = stream_.bufferSize - frames; if (frames < 0) frames = 0; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); return frames; } -void RtAudio :: tickStream(int streamId) +void RtApiDs :: tickStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); int stopStream = 0; - if (stream->state == STREAM_STOPPED) { - if (stream->callbackInfo.usingCallback) Sleep(50); // sleep 50 milliseconds + if (stream_.state == STREAM_STOPPED) { + if (stream_.callbackInfo.usingCallback) Sleep(50); // sleep 50 milliseconds return; } - else if (stream->callbackInfo.usingCallback) { - RTAUDIO_CALLBACK callback = (RTAUDIO_CALLBACK) stream->callbackInfo.callback; - stopStream = callback(stream->userBuffer, stream->bufferSize, stream->callbackInfo.userData); + else if (stream_.callbackInfo.usingCallback) { + RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; + stopStream = callback(stream_.userBuffer, stream_.bufferSize, 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) { - MUTEX_UNLOCK(&stream->mutex); + if (stream_.state == STREAM_STOPPED) { + MUTEX_UNLOCK(&stream_.mutex); return; } @@ -5377,32 +6403,33 @@ void RtAudio :: tickStream(int streamId) DWORD bufferSize2 = 0; char *buffer; long buffer_bytes; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { + DsHandle *handles = (DsHandle *) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { // Setup parameters and do buffer conversion if necessary. - if (stream->doConvertBuffer[0]) { - convertStreamBuffer(stream, OUTPUT); - buffer = stream->deviceBuffer; - buffer_bytes = stream->bufferSize * stream->nDeviceChannels[0]; - buffer_bytes *= formatBytes(stream->deviceFormat[0]); + if (stream_.doConvertBuffer[0]) { + convertStreamBuffer(OUTPUT); + buffer = stream_.deviceBuffer; + 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); + buffer = stream_.userBuffer; + buffer_bytes = stream_.bufferSize * stream_.nUserChannels[0]; + buffer_bytes *= formatBytes(stream_.userFormat); } // No byte swapping necessary in DirectSound implementation. - LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) stream->handle[0].buffer; - UINT nextWritePos = stream->handle[0].bufferPointer; - DWORD dsBufferSize = buffer_bytes * stream->nBuffers; + LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handles[0].buffer; + UINT nextWritePos = handles[0].bufferPointer; + DWORD dsBufferSize = buffer_bytes * stream_.nBuffers; // Find out where the read and "safe write" pointers are. result = dsBuffer->GetCurrentPosition(¤tPos, &safePos); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to get current DS position (%s): %s.", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } @@ -5420,16 +6447,16 @@ void RtAudio :: tickStream(int streamId) // A "fudgefactor" less than 1 is used because it was found // that sleeping too long was MUCH worse than sleeping for // several shorter periods. - float millis = (endWrite - currentPos) * 900.0; - millis /= ( formatBytes(stream->deviceFormat[0]) * stream->sampleRate); + double millis = (endWrite - currentPos) * 900.0; + millis /= ( formatBytes(stream_.deviceFormat[0]) * stream_.sampleRate); if ( millis < 1.0 ) millis = 1.0; Sleep( (DWORD) millis ); // Wake up, find out where we are now result = dsBuffer->GetCurrentPosition( ¤tPos, &safePos ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to get current DS position (%s): %s.", - devices[stream->device[0]].name, getErrorString(result)); + sprintf(message_, "RtApiDs: Unable to get current position (%s): %s.", + devices_[stream_.device[0]].name.c_str(), getErrorString(result)); error(RtError::DRIVER_ERROR); } if ( currentPos < nextWritePos ) currentPos += dsBufferSize; // unwrap offset @@ -5439,8 +6466,8 @@ void RtAudio :: tickStream(int streamId) result = dsBuffer->Lock (nextWritePos, buffer_bytes, &buffer1, &bufferSize1, &buffer2, &bufferSize2, 0); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to lock DS buffer during playback (%s): %s.", - devices[stream->device[0]].name, getErrorString(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); } @@ -5451,37 +6478,37 @@ void RtAudio :: tickStream(int streamId) // Update our buffer offset and unlock sound buffer dsBuffer->Unlock (buffer1, bufferSize1, buffer2, bufferSize2); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to unlock DS buffer during playback (%s): %s.", - devices[stream->device[0]].name, getErrorString(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; - stream->handle[0].bufferPointer = nextWritePos; + handles[0].bufferPointer = nextWritePos; } - if (stream->mode == INPUT || stream->mode == DUPLEX) { + 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]); + 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); + buffer = stream_.userBuffer; + buffer_bytes = stream_.bufferSize * stream_.nUserChannels[1]; + buffer_bytes *= formatBytes(stream_.userFormat); } - LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) stream->handle[1].buffer; - UINT nextReadPos = stream->handle[1].bufferPointer; - DWORD dsBufferSize = buffer_bytes * stream->nBuffers; + LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handles[1].buffer; + UINT nextReadPos = handles[1].bufferPointer; + DWORD dsBufferSize = buffer_bytes * stream_.nBuffers; // Find out where the write and "safe read" pointers are. result = dsBuffer->GetCurrentPosition(¤tPos, &safePos); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to get current DS capture position (%s): %s.", - devices[stream->device[1]].name, getErrorString(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); } @@ -5491,16 +6518,16 @@ void RtAudio :: tickStream(int streamId) // Check whether the entire write region is behind the play pointer. while ( safePos < endRead ) { // See comments for playback. - float millis = (endRead - safePos) * 900.0; - millis /= ( formatBytes(stream->deviceFormat[1]) * stream->sampleRate); + double millis = (endRead - safePos) * 900.0; + millis /= ( formatBytes(stream_.deviceFormat[1]) * stream_.sampleRate); if ( millis < 1.0 ) millis = 1.0; Sleep( (DWORD) millis ); // Wake up, find out where we are now result = dsBuffer->GetCurrentPosition( ¤tPos, &safePos ); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to get current DS capture position (%s): %s.", - devices[stream->device[1]].name, getErrorString(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); } @@ -5511,8 +6538,8 @@ void RtAudio :: tickStream(int streamId) result = dsBuffer->Lock (nextReadPos, buffer_bytes, &buffer1, &bufferSize1, &buffer2, &bufferSize2, 0); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to lock DS buffer during capture (%s): %s.", - devices[stream->device[1]].name, getErrorString(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); } @@ -5524,23 +6551,23 @@ void RtAudio :: tickStream(int streamId) nextReadPos = (nextReadPos + bufferSize1 + bufferSize2) % dsBufferSize; dsBuffer->Unlock (buffer1, bufferSize1, buffer2, bufferSize2); if ( FAILED(result) ) { - sprintf(message, "RtAudio: Unable to unlock DS buffer during capture (%s): %s.", - devices[stream->device[1]].name, getErrorString(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); } - stream->handle[1].bufferPointer = nextReadPos; + handles[1].bufferPointer = nextReadPos; // No byte swapping necessary in DirectSound implementation. // Do buffer conversion if necessary. - if (stream->doConvertBuffer[1]) - convertStreamBuffer(stream, INPUT); + if (stream_.doConvertBuffer[1]) + convertStreamBuffer(INPUT); } - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); - if (stream->callbackInfo.usingCallback && stopStream) - this->stopStream(streamId); + if (stream_.callbackInfo.usingCallback && stopStream) + this->stopStream(); } // Definitions for utility functions and callbacks @@ -5548,18 +6575,17 @@ void RtAudio :: tickStream(int streamId) extern "C" unsigned __stdcall callbackHandler(void *ptr) { - CALLBACK_INFO *info = (CALLBACK_INFO *) ptr; - RtAudio *object = (RtAudio *) info->object; - int stream = info->streamId; + CallbackInfo *info = (CallbackInfo *) ptr; + RtApiDs *object = (RtApiDs *) info->object; bool *usingCallback = &info->usingCallback; while ( *usingCallback ) { try { - object->tickStream(stream); + object->tickStream(); } catch (RtError &exception) { - fprintf(stderr, "\nRtAudio: Callback thread error (%s) ... closing thread.\n\n", - exception.getMessage()); + fprintf(stderr, "\nRtApiDs: callback thread error (%s) ... closing thread.\n\n", + exception.getMessageString()); break; } } @@ -5568,37 +6594,6 @@ extern "C" unsigned __stdcall callbackHandler(void *ptr) return 0; } -void RtAudio :: setStreamCallback(int streamId, RTAUDIO_CALLBACK callback, void *userData) -{ - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - CALLBACK_INFO *info = (CALLBACK_INFO *) &stream->callbackInfo; - if ( info->usingCallback ) { - sprintf(message, "RtAudio: 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; - info->streamId = streamId; - - unsigned thread_id; - info->thread = _beginthreadex(NULL, 0, &callbackHandler, - &stream->callbackInfo, 0, &thread_id); - if (info->thread == 0) { - info->usingCallback = false; - sprintf(message, "RtAudio: error starting callback thread!"); - error(RtError::THREAD_ERROR); - } - - // When spawning multiple threads in quick succession, it appears to be - // necessary to wait a bit for each to initialize ... another windoism! - Sleep(1); -} - static bool CALLBACK deviceCountCallback(LPGUID lpguid, LPCSTR lpcstrDescription, LPCSTR lpcstrModule, @@ -5742,133 +6737,174 @@ static char* getErrorString(int code) } //******************** End of __WINDOWS_DS__ *********************// +#endif -#elif defined(__IRIX_AL__) // SGI's AL API for IRIX +#if defined(__IRIX_AL__) // SGI's AL API for IRIX +#include #include #include -void RtAudio :: initialize(void) +extern "C" void *callbackHandler(void * ptr); + +RtApiAl :: RtApiAl() +{ + this->initialize(); + + if (nDevices_ <= 0) { + sprintf(message_, "RtApiAl: no Irix AL audio devices found!"); + error(RtError::NO_DEVICES_FOUND); + } +} + +RtApiAl :: ~RtApiAl() +{ + // The subclass destructor gets called before the base class + // destructor, so close any existing streams before deallocating + // apiDeviceId memory. + if ( stream_.mode != UNINITIALIZED ) closeStream(); + + // Free our allocated apiDeviceId memory. + long *id; + for ( unsigned int i=0; iid[0]; + long *id = (long *) info->apiDeviceId; + resource = id[0]; if (resource > 0) { // Probe output device parameters. result = alQueryValues(resource, AL_CHANNELS, &value, 1, 0, 0); if (result < 0) { - sprintf(message, "RtAudio: AL error getting device (%s) channels: %s.", - info->name, alGetErrorString(oserror())); + sprintf(message_, "RtApiAl: error getting device (%s) channels: %s.", + info->name.c_str(), alGetErrorString(oserror())); error(RtError::WARNING); } else { @@ -5878,33 +6914,31 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) result = alGetParamInfo(resource, AL_RATE, &pinfo); if (result < 0) { - sprintf(message, "RtAudio: AL error getting device (%s) rates: %s.", - info->name, alGetErrorString(oserror())); + sprintf(message_, "RtApiAl: error getting device (%s) rates: %s.", + info->name.c_str(), alGetErrorString(oserror())); error(RtError::WARNING); } else { - info->nSampleRates = 0; - for (i=0; i= pinfo.min.i && SAMPLE_RATES[i] <= pinfo.max.i ) { - info->sampleRates[info->nSampleRates] = SAMPLE_RATES[i]; - info->nSampleRates++; - } + 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] ); } } // The AL library supports all our formats, except 24-bit and 32-bit ints. - info->nativeFormats = (RTAUDIO_FORMAT) 51; + info->nativeFormats = (RtAudioFormat) 51; } // Now get input resource ID if it exists. - resource = info->id[1]; + resource = id[1]; if (resource > 0) { // Probe input device parameters. result = alQueryValues(resource, AL_CHANNELS, &value, 1, 0, 0); if (result < 0) { - sprintf(message, "RtAudio: AL error getting device (%s) channels: %s.", - info->name, alGetErrorString(oserror())); + sprintf(message_, "RtApiAl: error getting device (%s) channels: %s.", + info->name.c_str(), alGetErrorString(oserror())); error(RtError::WARNING); } else { @@ -5914,8 +6948,8 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) result = alGetParamInfo(resource, AL_RATE, &pinfo); if (result < 0) { - sprintf(message, "RtAudio: AL error getting device (%s) rates: %s.", - info->name, alGetErrorString(oserror())); + sprintf(message_, "RtApiAl: error getting device (%s) rates: %s.", + info->name.c_str(), alGetErrorString(oserror())); error(RtError::WARNING); } else { @@ -5923,22 +6957,20 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) // 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->nSampleRates = 0; - for (i=0; i= pinfo.min.i && SAMPLE_RATES[i] <= pinfo.max.i ) { - info->sampleRates[info->nSampleRates] = SAMPLE_RATES[i]; - info->nSampleRates++; - } + 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] ); } } // The AL library supports all our formats, except 24-bit and 32-bit ints. - info->nativeFormats = (RTAUDIO_FORMAT) 51; + info->nativeFormats = (RtAudioFormat) 51; } if ( info->maxInputChannels == 0 && info->maxOutputChannels == 0 ) return; - if ( info->nSampleRates == 0 ) + if ( info->sampleRates.size() == 0 ) return; // Determine duplex status. @@ -5959,20 +6991,21 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info) return; } -bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, - STREAM_MODE mode, int channels, - int sampleRate, RTAUDIO_FORMAT format, +bool RtApiAl :: probeDeviceOpen(int device, StreamMode mode, int channels, + int sampleRate, RtAudioFormat format, int *bufferSize, int numberOfBuffers) { - int result, resource, nBuffers; + 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,"RtAudio: can't get AL config: %s.", + sprintf(message_,"RtApiAl: can't get AL config: %s.", alGetErrorString(oserror())); error(RtError::WARNING); return FAILURE; @@ -5981,7 +7014,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, // Set the channels. result = alSetChannels(al_config, channels); if ( result < 0 ) { - sprintf(message,"RtAudio: can't set %d channels in AL config: %s.", + alFreeConfig(al_config); + sprintf(message_,"RtApiAl: can't set %d channels in AL config: %s.", channels, alGetErrorString(oserror())); error(RtError::WARNING); return FAILURE; @@ -6002,7 +7036,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, buffer_size = alGetQueueSize(al_config); result = alSetQueueSize(al_config, buffer_size); if ( result < 0 ) { - sprintf(message,"RtAudio: can't set buffer size (%ld) in AL config: %s.", + alFreeConfig(al_config); + sprintf(message_,"RtApiAl: can't set buffer size (%ld) in AL config: %s.", buffer_size, alGetErrorString(oserror())); error(RtError::WARNING); return FAILURE; @@ -6011,8 +7046,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, } // Set the data format. - stream->userFormat = format; - stream->deviceFormat[mode] = 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); @@ -6026,13 +7061,13 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, // 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; + stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; } 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; + stream_.deviceFormat[mode] = RTAUDIO_FLOAT32; } else if (format == RTAUDIO_FLOAT32) result = alSetSampFmt(al_config, AL_SAMPFMT_FLOAT); @@ -6040,7 +7075,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = alSetSampFmt(al_config, AL_SAMPFMT_DOUBLE); if ( result == -1 ) { - sprintf(message,"RtAudio: AL error setting sample format in AL config: %s.", + alFreeConfig(al_config); + sprintf(message_,"RtApiAl: error setting sample format in AL config: %s.", alGetErrorString(oserror())); error(RtError::WARNING); return FAILURE; @@ -6052,19 +7088,21 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, if (device == 0) resource = AL_DEFAULT_OUTPUT; else - resource = devices[device].id[0]; + resource = id[0]; result = alSetDevice(al_config, resource); if ( result == -1 ) { - sprintf(message,"RtAudio: AL error setting device (%s) in AL config: %s.", - devices[device].name, alGetErrorString(oserror())); + alFreeConfig(al_config); + sprintf(message_,"RtApiAl: error setting device (%s) in AL config: %s.", + devices_[device].name.c_str(), alGetErrorString(oserror())); error(RtError::WARNING); return FAILURE; } // Open the port. - port = alOpenPort("RtAudio Output Port", "w", al_config); + port = alOpenPort("RtApiAl Output Port", "w", al_config); if( !port ) { - sprintf(message,"RtAudio: AL error opening output port: %s.", + alFreeConfig(al_config); + sprintf(message_,"RtApiAl: error opening output port: %s.", alGetErrorString(oserror())); error(RtError::WARNING); return FAILURE; @@ -6078,8 +7116,9 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = alSetParams(resource, pvs, 2); if ( result < 0 ) { alClosePort(port); - sprintf(message,"RtAudio: AL error setting sample rate (%d) for device (%s): %s.", - sampleRate, devices[device].name, alGetErrorString(oserror())); + 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::WARNING); return FAILURE; } @@ -6090,19 +7129,21 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, if (device == 0) resource = AL_DEFAULT_INPUT; else - resource = devices[device].id[1]; + resource = id[1]; result = alSetDevice(al_config, resource); if ( result == -1 ) { - sprintf(message,"RtAudio: AL error setting device (%s) in AL config: %s.", - devices[device].name, alGetErrorString(oserror())); + alFreeConfig(al_config); + sprintf(message_,"RtApiAl: error setting device (%s) in AL config: %s.", + devices_[device].name.c_str(), alGetErrorString(oserror())); error(RtError::WARNING); return FAILURE; } // Open the port. - port = alOpenPort("RtAudio Output Port", "r", al_config); + port = alOpenPort("RtApiAl Input Port", "r", al_config); if( !port ) { - sprintf(message,"RtAudio: AL error opening input port: %s.", + alFreeConfig(al_config); + sprintf(message_,"RtApiAl: error opening input port: %s.", alGetErrorString(oserror())); error(RtError::WARNING); return FAILURE; @@ -6116,8 +7157,9 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, result = alSetParams(resource, pvs, 2); if ( result < 0 ) { alClosePort(port); - sprintf(message,"RtAudio: AL error setting sample rate (%d) for device (%s): %s.", - sampleRate, devices[device].name, alGetErrorString(oserror())); + 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::WARNING); return FAILURE; } @@ -6125,324 +7167,407 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream, alFreeConfig(al_config); - stream->nUserChannels[mode] = channels; - stream->nDeviceChannels[mode] = channels; + stream_.nUserChannels[mode] = channels; + stream_.nDeviceChannels[mode] = channels; + + // 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; + } + handle[mode] = port; - // Set handle and flags for buffer conversion - stream->handle[mode] = port; - stream->doConvertBuffer[mode] = false; - if (stream->userFormat != stream->deviceFormat[mode]) - stream->doConvertBuffer[mode] = true; + // Set flags for buffer conversion + stream_.doConvertBuffer[mode] = false; + if (stream_.userFormat != stream_.deviceFormat[mode]) + stream_.doConvertBuffer[mode] = true; // Allocate necessary internal buffers - if ( stream->nUserChannels[0] != stream->nUserChannels[1] ) { + if ( stream_.nUserChannels[0] != stream_.nUserChannels[1] ) { long buffer_bytes; - if (stream->nUserChannels[0] >= stream->nUserChannels[1]) - buffer_bytes = stream->nUserChannels[0]; + 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) - goto memory_error; + 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()); + goto error; + } } - if ( stream->doConvertBuffer[mode] ) { + if ( stream_.doConvertBuffer[mode] ) { long buffer_bytes; bool makeBuffer = true; if ( mode == OUTPUT ) - buffer_bytes = stream->nDeviceChannels[0] * formatBytes(stream->deviceFormat[0]); + 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]); + 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) - goto memory_error; + 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()); + goto error; + } } } - stream->device[mode] = device; - stream->state = STREAM_STOPPED; - if ( stream->mode == OUTPUT && mode == INPUT ) + 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; + stream_.mode = DUPLEX; else - stream->mode = mode; - stream->nBuffers = nBuffers; - stream->bufferSize = *bufferSize; - stream->sampleRate = sampleRate; + stream_.mode = mode; + stream_.nBuffers = nBuffers; + stream_.bufferSize = *bufferSize; + stream_.sampleRate = sampleRate; return SUCCESS; - memory_error: - if (stream->handle[0]) { - alClosePort(stream->handle[0]); - stream->handle[0] = 0; - } - if (stream->handle[1]) { - alClosePort(stream->handle[1]); - stream->handle[1] = 0; + error: + if (handle) { + if (handle[0]) + alClosePort(handle[0]); + if (handle[1]) + alClosePort(handle[1]); + free(handle); + stream_.apiHandle = 0; } - if (stream->userBuffer) { - free(stream->userBuffer); - stream->userBuffer = 0; + + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; } - sprintf(message, "RtAudio: ALSA error allocating buffer memory for device (%s).", - devices[device].name); + error(RtError::WARNING); return FAILURE; } -void RtAudio :: closeStream(int streamId) +void RtApiAl :: 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 ( streams.find( streamId ) == streams.end() ) { - sprintf(message, "RtAudio: invalid stream identifier!"); + if ( stream_.mode == UNINITIALIZED ) { + sprintf(message_, "RtApiAl::closeStream(): no open stream to close!"); error(RtError::WARNING); return; } - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) streams[streamId]; - - if (stream->callbackInfo.usingCallback) { - pthread_cancel(stream->callbackInfo.thread); - pthread_join(stream->callbackInfo.thread, NULL); + 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; } - pthread_mutex_destroy(&stream->mutex); - - if (stream->handle[0]) - alClosePort(stream->handle[0]); + if (stream_.callbackInfo.usingCallback) { + stream_.callbackInfo.usingCallback = false; + pthread_join(stream_.callbackInfo.thread, NULL); + } - if (stream->handle[1]) - alClosePort(stream->handle[1]); + if (handle) { + if (handle[0]) alClosePort(handle[0]); + if (handle[1]) alClosePort(handle[1]); + free(handle); + stream_.apiHandle = 0; + } - if (stream->userBuffer) - free(stream->userBuffer); + if (stream_.userBuffer) { + free(stream_.userBuffer); + stream_.userBuffer = 0; + } - if (stream->deviceBuffer) - free(stream->deviceBuffer); + if (stream_.deviceBuffer) { + free(stream_.deviceBuffer); + stream_.deviceBuffer = 0; + } - free(stream); - streams.erase(streamId); + stream_.mode = UNINITIALIZED; } -void RtAudio :: startStream(int streamId) +void RtApiAl :: startStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); + if (stream_.state == STREAM_RUNNING) return; - if (stream->state == STREAM_RUNNING) - return; + MUTEX_LOCK(&stream_.mutex); // The AL port is ready as soon as it is opened. - stream->state = STREAM_RUNNING; + stream_.state = STREAM_RUNNING; + + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: stopStream(int streamId) +void RtApiAl :: stopStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - if (stream->state == STREAM_STOPPED) - goto unlock; + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK(&stream_.mutex); - int result; - int buffer_size = stream->bufferSize * stream->nBuffers; + int result, buffer_size = stream_.bufferSize * stream_.nBuffers; + ALport *handle = (ALport *) stream_.apiHandle; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) - alZeroFrames(stream->handle[0], buffer_size); + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) + alZeroFrames(handle[0], buffer_size); - if (stream->mode == INPUT || stream->mode == DUPLEX) { - result = alDiscardFrames(stream->handle[1], buffer_size); + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + result = alDiscardFrames(handle[1], buffer_size); if (result == -1) { - sprintf(message, "RtAudio: AL error draining stream device (%s): %s.", - devices[stream->device[1]].name, alGetErrorString(oserror())); + sprintf(message_, "RtApiAl: error draining stream device (%s): %s.", + devices_[stream_.device[1]].name.c_str(), alGetErrorString(oserror())); error(RtError::DRIVER_ERROR); } } - stream->state = STREAM_STOPPED; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -void RtAudio :: abortStream(int streamId) +void RtApiAl :: abortStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); - - MUTEX_LOCK(&stream->mutex); + verifyStream(); + if (stream_.state == STREAM_STOPPED) return; - if (stream->state == STREAM_STOPPED) - goto unlock; + // Change the state before the lock to improve shutdown response + // when using a callback. + stream_.state = STREAM_STOPPED; + MUTEX_LOCK(&stream_.mutex); - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { + ALport *handle = (ALport *) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { - int buffer_size = stream->bufferSize * stream->nBuffers; - int result = alDiscardFrames(stream->handle[0], buffer_size); + int buffer_size = stream_.bufferSize * stream_.nBuffers; + int result = alDiscardFrames(handle[0], buffer_size); if (result == -1) { - sprintf(message, "RtAudio: AL error aborting stream device (%s): %s.", - devices[stream->device[0]].name, alGetErrorString(oserror())); + sprintf(message_, "RtApiAl: error aborting stream device (%s): %s.", + devices_[stream_.device[0]].name.c_str(), alGetErrorString(oserror())); error(RtError::DRIVER_ERROR); } } // There is no clear action to take on the input stream, since the // port will continue to run in any event. - stream->state = STREAM_STOPPED; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); } -int RtAudio :: streamWillBlock(int streamId) +int RtApiAl :: streamWillBlock() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); - MUTEX_LOCK(&stream->mutex); + if (stream_.state == STREAM_STOPPED) return 0; - int frames = 0; - if (stream->state == STREAM_STOPPED) - goto unlock; + MUTEX_LOCK(&stream_.mutex); + int frames = 0; int err = 0; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { - err = alGetFillable(stream->handle[0]); + ALport *handle = (ALport *) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { + err = alGetFillable(handle[0]); if (err < 0) { - sprintf(message, "RtAudio: AL error getting available frames for stream (%s): %s.", - devices[stream->device[0]].name, alGetErrorString(oserror())); + sprintf(message_, "RtApiAl: error getting available frames for stream (%s): %s.", + devices_[stream_.device[0]].name.c_str(), alGetErrorString(oserror())); error(RtError::DRIVER_ERROR); } } frames = err; - if (stream->mode == INPUT || stream->mode == DUPLEX) { - err = alGetFilled(stream->handle[1]); + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { + err = alGetFilled(handle[1]); if (err < 0) { - sprintf(message, "RtAudio: AL error getting available frames for stream (%s): %s.", - devices[stream->device[1]].name, alGetErrorString(oserror())); + 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 (frames > err) frames = err; } - frames = stream->bufferSize - frames; + frames = stream_.bufferSize - frames; if (frames < 0) frames = 0; - unlock: - MUTEX_UNLOCK(&stream->mutex); + MUTEX_UNLOCK(&stream_.mutex); return frames; } -void RtAudio :: tickStream(int streamId) +void RtApiAl :: tickStream() { - RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId); + verifyStream(); int stopStream = 0; - if (stream->state == STREAM_STOPPED) { - if (stream->callbackInfo.usingCallback) usleep(50000); // sleep 50 milliseconds + if (stream_.state == STREAM_STOPPED) { + if (stream_.callbackInfo.usingCallback) usleep(50000); // sleep 50 milliseconds return; } - else if (stream->callbackInfo.usingCallback) { - RTAUDIO_CALLBACK callback = (RTAUDIO_CALLBACK) stream->callbackInfo.callback; - stopStream = callback(stream->userBuffer, stream->bufferSize, stream->callbackInfo.userData); + else if (stream_.callbackInfo.usingCallback) { + RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback; + stopStream = callback(stream_.userBuffer, stream_.bufferSize, 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) + if (stream_.state == STREAM_STOPPED) goto unlock; char *buffer; int channels; - RTAUDIO_FORMAT format; - if (stream->mode == OUTPUT || stream->mode == DUPLEX) { + RtAudioFormat format; + ALport *handle = (ALport *) stream_.apiHandle; + if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) { // Setup parameters and do buffer conversion if necessary. - if (stream->doConvertBuffer[0]) { - convertStreamBuffer(stream, OUTPUT); - buffer = stream->deviceBuffer; - channels = stream->nDeviceChannels[0]; - format = stream->deviceFormat[0]; + if (stream_.doConvertBuffer[0]) { + convertStreamBuffer(OUTPUT); + buffer = stream_.deviceBuffer; + channels = stream_.nDeviceChannels[0]; + format = stream_.deviceFormat[0]; } else { - buffer = stream->userBuffer; - channels = stream->nUserChannels[0]; - format = stream->userFormat; + buffer = stream_.userBuffer; + channels = 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, stream_.bufferSize * channels, format); // Write interleaved samples to device. - alWriteFrames(stream->handle[0], buffer, stream->bufferSize); + alWriteFrames(handle[0], buffer, stream_.bufferSize); } - if (stream->mode == INPUT || stream->mode == DUPLEX) { + if (stream_.mode == INPUT || stream_.mode == DUPLEX) { // Setup parameters. - if (stream->doConvertBuffer[1]) { - buffer = stream->deviceBuffer; - channels = stream->nDeviceChannels[1]; - format = stream->deviceFormat[1]; + if (stream_.doConvertBuffer[1]) { + buffer = stream_.deviceBuffer; + channels = stream_.nDeviceChannels[1]; + format = stream_.deviceFormat[1]; } else { - buffer = stream->userBuffer; - channels = stream->nUserChannels[1]; - format = stream->userFormat; + buffer = stream_.userBuffer; + channels = stream_.nUserChannels[1]; + format = stream_.userFormat; } // Read interleaved samples from device. - alReadFrames(stream->handle[1], buffer, stream->bufferSize); + alReadFrames(handle[1], buffer, stream_.bufferSize); // Do byte swapping if necessary. - if (stream->doByteSwap[1]) - byteSwapBuffer(buffer, stream->bufferSize * channels, format); + if (stream_.doByteSwap[1]) + byteSwapBuffer(buffer, stream_.bufferSize * channels, format); // Do buffer conversion if necessary. - if (stream->doConvertBuffer[1]) - convertStreamBuffer(stream, INPUT); + if (stream_.doConvertBuffer[1]) + convertStreamBuffer(INPUT); } unlock: - MUTEX_UNLOCK(&stream->mutex); + 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->callbackInfo.usingCallback && stopStream) - this->stopStream(streamId); + if (stream_.state == STREAM_RUNNING) + stopStream(); + + 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 *callbackHandler(void *ptr) { - CALLBACK_INFO *info = (CALLBACK_INFO *) ptr; - RtAudio *object = (RtAudio *) info->object; - int stream = info->streamId; + CallbackInfo *info = (CallbackInfo *) ptr; + RtApiAl *object = (RtApiAl *) info->object; bool *usingCallback = &info->usingCallback; while ( *usingCallback ) { - pthread_testcancel(); try { - object->tickStream(stream); + object->tickStream(); } catch (RtError &exception) { - fprintf(stderr, "\nRtAudio: Callback thread error (%s) ... closing thread.\n\n", - exception.getMessage()); + fprintf(stderr, "\nRtApiAl: callback thread error (%s) ... closing thread.\n\n", + exception.getMessageString()); break; } } @@ -6451,46 +7576,44 @@ extern "C" void *callbackHandler(void *ptr) } //******************** End of __IRIX_AL__ *********************// - #endif // *************************************************** // // -// Private common (OS-independent) RtAudio methods. +// Protected common (OS-independent) RtAudio methods. // // *************************************************** // // This method can be modified to control the behavior of error // message reporting and throwing. -void RtAudio :: error(RtError::TYPE type) +void RtApi :: error(RtError::Type type) { if (type == RtError::WARNING) { - fprintf(stderr, "\n%s\n\n", message); + fprintf(stderr, "\n%s\n\n", message_); } else if (type == RtError::DEBUG_WARNING) { #if defined(__RTAUDIO_DEBUG__) - fprintf(stderr, "\n%s\n\n", message); + fprintf(stderr, "\n%s\n\n", message_); #endif } else { - fprintf(stderr, "\n%s\n\n", message); - throw RtError(message, type); +#if defined(__RTAUDIO_DEBUG__) + fprintf(stderr, "\n%s\n\n", message_); +#endif + throw RtError(std::string(message_), type); } } -void *RtAudio :: verifyStream(int streamId) +void RtApi :: verifyStream() { - // Verify the stream key. - if ( streams.find( streamId ) == streams.end() ) { - sprintf(message, "RtAudio: invalid stream identifier!"); + if ( stream_.mode == UNINITIALIZED ) { + sprintf(message_, "RtAudio: a stream was not previously opened!"); error(RtError::INVALID_STREAM); } - - return streams[streamId]; } -void RtAudio :: clearDeviceInfo(RTAUDIO_DEVICE *info) +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. @@ -6502,13 +7625,30 @@ void RtAudio :: clearDeviceInfo(RTAUDIO_DEVICE *info) info->minInputChannels = 0; info->minDuplexChannels = 0; info->hasDuplexSupport = false; - info->nSampleRates = 0; - for (int i=0; isampleRates[i] = 0; + info->sampleRates.clear(); info->nativeFormats = 0; } -int RtAudio :: formatBytes(RTAUDIO_FORMAT format) +void RtApi :: clearStreamInfo() +{ + stream_.mode = UNINITIALIZED; + stream_.state = STREAM_STOPPED; + stream_.sampleRate = 0; + stream_.bufferSize = 0; + stream_.nBuffers = 0; + stream_.userFormat = 0; + for ( int i=0; i<2; i++ ) { + stream_.device[i] = 0; + stream_.doConvertBuffer[i] = false; + stream_.deInterleave[i] = false; + stream_.doByteSwap[i] = false; + stream_.nUserChannels[i] = 0; + stream_.nDeviceChannels[i] = 0; + stream_.deviceFormat[i] = 0; + } +} + +int RtApi :: formatBytes(RtAudioFormat format) { if (format == RTAUDIO_SINT16) return 2; @@ -6520,42 +7660,42 @@ int RtAudio :: formatBytes(RTAUDIO_FORMAT format) else if (format == RTAUDIO_SINT8) return 1; - sprintf(message,"RtAudio: undefined format in formatBytes()."); + sprintf(message_,"RtApi: undefined format in formatBytes()."); error(RtError::WARNING); return 0; } -void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode) +void RtApi :: convertStreamBuffer( StreamMode mode ) { // This method does format conversion, input/output channel compensation, and // data interleaving/deinterleaving. 24-bit integers are assumed to occupy // the upper three bytes of a 32-bit integer. int j, jump_in, jump_out, channels; - RTAUDIO_FORMAT format_in, format_out; + RtAudioFormat format_in, format_out; char *input, *output; if (mode == INPUT) { // convert device to user buffer - input = stream->deviceBuffer; - output = stream->userBuffer; - jump_in = stream->nDeviceChannels[1]; - jump_out = stream->nUserChannels[1]; - format_in = stream->deviceFormat[1]; - format_out = stream->userFormat; + input = stream_.deviceBuffer; + output = stream_.userBuffer; + jump_in = stream_.nDeviceChannels[1]; + jump_out = stream_.nUserChannels[1]; + format_in = stream_.deviceFormat[1]; + format_out = stream_.userFormat; } else { // convert user to device buffer - input = stream->userBuffer; - output = stream->deviceBuffer; - jump_in = stream->nUserChannels[0]; - jump_out = stream->nDeviceChannels[0]; - format_in = stream->userFormat; - format_out = stream->deviceFormat[0]; + input = stream_.userBuffer; + output = stream_.deviceBuffer; + jump_in = stream_.nUserChannels[0]; + jump_out = stream_.nDeviceChannels[0]; + format_in = stream_.userFormat; + format_out = stream_.deviceFormat[0]; // clear our device buffer when in/out duplex device channels are different - if ( stream->mode == DUPLEX && - stream->nDeviceChannels[0] != stream->nDeviceChannels[1] ) - memset(output, 0, stream->bufferSize * jump_out * formatBytes(format_out)); + if ( stream_.mode == DUPLEX && + stream_.nDeviceChannels[0] != stream_.nDeviceChannels[1] ) + memset(output, 0, stream_.bufferSize * jump_out * formatBytes(format_out)); } channels = (jump_in < jump_out) ? jump_in : jump_out; @@ -6563,17 +7703,17 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode) // Set up the interleave/deinterleave offsets std::vector offset_in(channels); std::vector offset_out(channels); - if (mode == INPUT && stream->deInterleave[1]) { + if (mode == INPUT && stream_.deInterleave[1]) { for (int k=0; kbufferSize; + offset_in[k] = k * stream_.bufferSize; offset_out[k] = k; jump_in = 1; } } - else if (mode == OUTPUT && stream->deInterleave[0]) { + else if (mode == OUTPUT && stream_.deInterleave[0]) { for (int k=0; kbufferSize; + offset_out[k] = k * stream_.bufferSize; jump_out = 1; } } @@ -6585,15 +7725,15 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode) } if (format_out == RTAUDIO_FLOAT64) { - FLOAT64 scale; - FLOAT64 *out = (FLOAT64 *)output; + Float64 scale; + Float64 *out = (Float64 *)output; if (format_in == RTAUDIO_SINT8) { signed char *in = (signed char *)input; scale = 1.0 / 128.0; - for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + Float32 *in = (Float32 *)input; + for (int i=0; ibufferSize; i++) { + Float64 *in = (Float64 *)input; + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + Float32 *in = (Float32 *)input; + for (int i=0; ibufferSize; i++) { + Float64 *in = (Float64 *)input; + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + Int16 *in = (Int16 *)input; + for (int i=0; ibufferSize; i++) { + Int32 *in = (Int32 *)input; + for (int i=0; ibufferSize; i++) { + Int32 *in = (Int32 *)input; + for (int i=0; ibufferSize; i++) { + Float32 *in = (Float32 *)input; + for (int i=0; ibufferSize; i++) { + Float64 *in = (Float64 *)input; + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + Int16 *in = (Int16 *)input; + for (int i=0; ibufferSize; i++) { + Int32 *in = (Int32 *)input; + for (int i=0; ibufferSize; i++) { + Int32 *in = (Int32 *)input; + for (int i=0; ibufferSize; i++) { + Float32 *in = (Float32 *)input; + for (int i=0; ibufferSize; i++) { + Float64 *in = (Float64 *)input; + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + Int16 *in = (Int16 *)input; + for (int i=0; ibufferSize; i++) { + Int32 *in = (Int32 *)input; + for (int i=0; i> 16) & 0x0000ffff); + out[offset_out[j]] = (Int16) ((in[offset_in[j]] >> 16) & 0x0000ffff); } in += jump_in; out += jump_out; } } else if (format_in == RTAUDIO_SINT32) { - INT32 *in = (INT32 *)input; - for (int i=0; ibufferSize; i++) { + Int32 *in = (Int32 *)input; + for (int i=0; i> 16) & 0x0000ffff); + out[offset_out[j]] = (Int16) ((in[offset_in[j]] >> 16) & 0x0000ffff); } in += jump_in; out += jump_out; } } else if (format_in == RTAUDIO_FLOAT32) { - FLOAT32 *in = (FLOAT32 *)input; - for (int i=0; ibufferSize; i++) { + Float32 *in = (Float32 *)input; + for (int i=0; ibufferSize; i++) { + Float64 *in = (Float64 *)input; + for (int i=0; ibufferSize; i++) { + for (int i=0; ibufferSize; i++) { + Int16 *in = (Int16 *)input; + for (int i=0; i> 8) & 0x00ff); } @@ -6953,8 +8093,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode) } } else if (format_in == RTAUDIO_SINT24) { - INT32 *in = (INT32 *)input; - for (int i=0; ibufferSize; i++) { + Int32 *in = (Int32 *)input; + for (int i=0; i> 24) & 0x000000ff); } @@ -6963,8 +8103,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode) } } else if (format_in == RTAUDIO_SINT32) { - INT32 *in = (INT32 *)input; - for (int i=0; ibufferSize; i++) { + Int32 *in = (Int32 *)input; + for (int i=0; i> 24) & 0x000000ff); } @@ -6973,8 +8113,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode) } } else if (format_in == RTAUDIO_FLOAT32) { - FLOAT32 *in = (FLOAT32 *)input; - for (int i=0; ibufferSize; i++) { + Float32 *in = (Float32 *)input; + for (int i=0; ibufferSize; i++) { + Float64 *in = (Float64 *)input; + for (int i=0; i