Version 3.0

1 files changed, 4232 insertions, 3114 deletions

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 <vector>
-#include <stdio.h>
-#include <iostream.h>
+#include <iostream>
 
 // 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<nDevices; i++) {
-      if (i >= 0 ) { 
+    for ( int i=-1; i<nDevices_; i++ ) {
+      if ( 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,111 +308,1084 @@ int RtAudio :: openStream(int outputDevice, int outputChannels,
     else
       device = inputDevice - 1;
 
-    for (int i=-1; i<nDevices; i++) {
+    for (int i=-1; i<nDevices_; i++) {
       if (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];
+  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; i<devices_[deviceIndex].sampleRates.size(); i++)
+      info.sampleRates.push_back( devices_[deviceIndex].sampleRates[i] );
+    info.nativeFormats = devices_[deviceIndex].nativeFormats;
+    if ( (deviceIndex == getDefaultOutputDevice()) ||
+         (deviceIndex == getDefaultInputDevice()) )
+      info.isDefault = true;
+  }
+
+  return info;
+}
+
+char * const RtApi :: getStreamBuffer(void)
+{
+  verifyStream();
+  return stream_.userBuffer;
+}
+
+int RtApi :: getDefaultInputDevice(void)
+{
+  // Should be implemented in subclasses if appropriate.
+  return 0;
+}
+
+int RtApi :: getDefaultOutputDevice(void)
+{
+  // Should be implemented in subclasses if appropriate.
+  return 0;
+}
+
+void RtApi :: closeStream(void)
+{
+  // MUST be implemented in subclasses!
+}
+
+void RtApi :: probeDeviceInfo( RtApiDevice *info )
+{
+  // MUST be implemented in subclasses!
+}
+
+bool RtApi :: probeDeviceOpen( int device, StreamMode mode, int channels, 
+                               int sampleRate, RtAudioFormat format,
+                               int *bufferSize, int numberOfBuffers )
+{
+  // MUST be implemented in subclasses!
+  return FAILURE;
+}
+
+
+// *************************************************** //
+//
+// OS/API-specific methods.
+//
+// *************************************************** //
+
+#if defined(__LINUX_OSS__)
+
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+#include <errno.h>
+#include <math.h>
+
+#define DAC_NAME "/dev/dsp"
+#define MAX_DEVICES 16
+#define MAX_CHANNELS 16
+
+extern "C" void *ossCallbackHandler(void * ptr);
+
+RtApiOss :: RtApiOss()
+{
+  this->initialize();
+
+  if (nDevices_ <= 0) {
+    sprintf(message_, "RtApiOss: no Linux OSS audio devices found!");
+    error(RtError::NO_DEVICES_FOUND);
+ }
+}
+
+RtApiOss :: ~RtApiOss()
+{
+  if ( stream_.mode != UNINITIALIZED )
+    closeStream();
+}
+
+void RtApiOss :: initialize(void)
+{
+  // Count cards and devices
+  nDevices_ = 0;
+
+  // We check /dev/dsp before probing devices.  /dev/dsp is supposed to
+  // be a link to the "default" audio device, of the form /dev/dsp0,
+  // /dev/dsp1, etc...  However, I've seen many cases where /dev/dsp was a
+  // real device, so we need to check for that.  Also, sometimes the
+  // link is to /dev/dspx and other times just dspx.  I'm not sure how
+  // the latter works, but it does.
+  char device_name[16];
+  struct stat dspstat;
+  int dsplink = -1;
+  int i = 0;
+  if (lstat(DAC_NAME, &dspstat) == 0) {
+    if (S_ISLNK(dspstat.st_mode)) {
+      i = readlink(DAC_NAME, device_name, sizeof(device_name));
+      if (i > 0) {
+        device_name[i] = '\0';
+        if (i > 8) { // check for "/dev/dspx"
+          if (!strncmp(DAC_NAME, device_name, 8))
+            dsplink = atoi(&device_name[8]);
+        }
+        else if (i > 3) { // check for "dspx"
+          if (!strncmp("dsp", device_name, 3))
+            dsplink = atoi(&device_name[3]);
+        }
+      }
+      else {
+        sprintf(message_, "RtApiOss: cannot read value of symbolic link %s.", DAC_NAME);
+        error(RtError::SYSTEM_ERROR);
+      }
     }
-    else {
-      for (int i=0; i<info->nSampleRates; i++)
-        info->sampleRates[i] = devices[deviceIndex].sampleRates[i];
+  }
+  else {
+    sprintf(message_, "RtApiOss: cannot stat %s.", DAC_NAME);
+    error(RtError::SYSTEM_ERROR);
+  }
+
+  // The OSS API doesn't provide a routine for determining the number
+  // of devices.  Thus, we'll just pursue a brute force method.  The
+  // idea is to start with /dev/dsp(0) and continue with higher device
+  // numbers until we reach MAX_DSP_DEVICES.  This should tell us how
+  // many devices we have ... it is not a fullproof scheme, but hopefully
+  // it will work most of the time.
+  int fd = 0;
+  RtApiDevice device;
+  for (i=-1; i<MAX_DEVICES; i++) {
+
+    // 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);
+
+    // 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_, "RtApiOss: OSS record device (%s) is busy.", device_name);
+            error(RtError::WARNING);
+            // still count it for now
+          }
+        }
+      }
+      else {
+        sprintf(message_, "RtApiOss: OSS playback device (%s) is busy.", device_name);
+        error(RtError::WARNING);
+        // still count it for now
+      }
+    }
+
+    if (fd >= 0) close(fd);
+    device.name.erase();
+    device.name.append( (const char *)device_name, strlen(device_name)+1);
+    devices_.push_back(device);
+    nDevices_++;
+  }
+}
+
+void RtApiOss :: probeDeviceInfo(RtApiDevice *info)
+{
+  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->nativeFormats = devices[deviceIndex].nativeFormats;
-    if ( deviceIndex == getDefaultOutputDevice() ||
-         deviceIndex == getDefaultInputDevice() )
-      info->isDefault = true;
+    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; k<MAX_SAMPLE_RATES; k++) {
+    int speed = SAMPLE_RATES[k];
+    if (ioctl(fd, SNDCTL_DSP_SPEED, &speed) != -1 && speed == (int)SAMPLE_RATES[k])
+      info->sampleRates.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;
 }
 
-char * const RtAudio :: getStreamBuffer(int streamId)
+bool RtApiOss :: probeDeviceOpen(int device, StreamMode mode, int channels, 
+                                int sampleRate, RtAudioFormat format,
+                                int *bufferSize, int numberOfBuffers)
 {
-  RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId);
+  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;
 
-  return stream->userBuffer;
+  // 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;
 }
 
-#if defined(__LINUX_ALSA__) || defined(__LINUX_OSS__) || defined(__IRIX_AL__)
+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;
+  }
 
-extern "C" void *callbackHandler(void * ptr);
+  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);
 
-void RtAudio :: setStreamCallback(int streamId, RTAUDIO_CALLBACK callback, void *userData)
+    // 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)
 {
-  RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId);
+  verifyStream();
 
-  CALLBACK_INFO *info = (CALLBACK_INFO *) &stream->callbackInfo;
+  CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
   if ( info->usingCallback ) {
-    sprintf(message, "RtAudio: A callback is already set for this stream!");
+    sprintf(message_, "RtApiOss: A callback is already set for this stream!");
     error(RtError::WARNING);
     return;
   }
@@ -316,49 +1394,72 @@ void RtAudio :: setStreamCallback(int streamId, RTAUDIO_CALLBACK callback, void
   info->userData = userData;
   info->usingCallback = true;
   info->object = (void *) this;
-  info->streamId = streamId;
 
-  int err = pthread_create(&info->thread, NULL, callbackHandler, &stream->callbackInfo);
+  // 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, "RtAudio: error starting callback thread!");
+    sprintf(message_, "RtApiOss: error starting callback thread!");
     error(RtError::THREAD_ERROR);
   }
 }
 
-void RtAudio :: cancelStreamCallback(int streamId)
+void RtApiOss :: 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;
-    pthread_cancel(stream->callbackInfo.thread);
-    pthread_join(stream->callbackInfo.thread, NULL);
-    stream->callbackInfo.thread = 0;
-    stream->callbackInfo.callback = NULL;
-    stream->callbackInfo.userData = NULL;
+    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);
+    MUTEX_UNLOCK(&stream_.mutex);
   }
 }
 
-#endif
+extern "C" void *ossCallbackHandler(void *ptr)
+{
+  CallbackInfo *info = (CallbackInfo *) ptr;
+  RtApiOss *object = (RtApiOss *) info->object;
+  bool *usingCallback = &info->usingCallback;
 
-// *************************************************** //
-//
-// OS/API-specific methods.
-//
-// *************************************************** //
+  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
@@ -367,49 +1468,73 @@ void RtAudio :: cancelStreamCallback(int streamId)
 // 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
+// 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.  Some initial listener code is
-// commented out.
+// 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) {}
+};
 
-void RtAudio :: initialize(void)
+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; i<devices_.size(); i++ ) {
+    id = (AudioDeviceID *) devices_[i].apiDeviceId;
+    if (id) free(id);
+  }
+}
+
+void RtApiCore :: initialize(void)
 {
   OSStatus err = noErr;
   UInt32 dataSize;
   AudioDeviceID	*deviceList = NULL;
-  nDevices = 0;
+  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!");
+    sprintf(message_, "RtApiCore: OS-X error getting device info!");
     error(RtError::SYSTEM_ERROR);
   }
 
-  nDevices = dataSize / sizeof(AudioDeviceID);
-  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);
-  }
+  nDevices_ = dataSize / sizeof(AudioDeviceID);
+  if (nDevices_ == 0) return;
 
   // Make space for the devices we are about to get.
   deviceList = (AudioDeviceID	*) malloc( dataSize );
   if (deviceList == NULL) {
-    sprintf(message, "RtAudio: memory allocation error!");
+    sprintf(message_, "RtApiCore: memory allocation error during initialization!");
     error(RtError::MEMORY_ERROR);
   }
 
@@ -417,57 +1542,62 @@ void RtAudio :: initialize(void)
   err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &dataSize, (void *) deviceList);
   if (err != noErr) {
     free(deviceList);
-    sprintf(message, "RtAudio: OSX error getting device properties!");
+    sprintf(message_, "RtApiCore: OS-X error getting device properties!");
     error(RtError::SYSTEM_ERROR);
   }
 
-  // Write device identifiers to device structures and then
-  // probe the device capabilities.
-  for (int i=0; i<nDevices; i++) {
-    devices[i].id[0] = deviceList[i];
-    //probeDeviceInfo(&devices[i]);
+  // Create list of device structures and write device identifiers.
+  RtApiDevice device;
+  AudioDeviceID *id;
+  for (int i=0; i<nDevices_; i++) {
+    devices_.push_back(device);
+    id = (AudioDeviceID *) malloc( sizeof(AudioDeviceID) );
+    *id = deviceList[i];
+    devices_[i].apiDeviceId = (void *) id;
   }
 
   free(deviceList);
 }
 
-int RtAudio :: getDefaultInputDevice(void)
+int RtApiCore :: getDefaultInputDevice(void)
 {
-  AudioDeviceID id;
+  AudioDeviceID id, *deviceId;
   UInt32 dataSize = sizeof( AudioDeviceID );
 
   OSStatus result = AudioHardwareGetProperty( kAudioHardwarePropertyDefaultInputDevice,
                                               &dataSize, &id );
 
   if (result != noErr) {
-    sprintf( message, "RtAudio: OSX error getting default input device." );
+    sprintf( message_, "RtApiCore: OS-X error getting default input device." );
     error(RtError::WARNING);
     return 0;
   }
 
-  for ( int i=0; i<nDevices; i++ ) {
-    if ( id == devices[i].id[0] ) return i;
+  for ( int i=0; i<nDevices_; i++ ) {
+    deviceId = (AudioDeviceID *) devices_[i].apiDeviceId;
+    if ( id == *deviceId ) return i;
   }
 
   return 0;
 }
 
-int RtAudio :: getDefaultOutputDevice(void)
+int RtApiCore :: getDefaultOutputDevice(void)
 {
-  AudioDeviceID id;
+  AudioDeviceID id, *deviceId;
   UInt32 dataSize = sizeof( AudioDeviceID );
 
   OSStatus result = AudioHardwareGetProperty( kAudioHardwarePropertyDefaultOutputDevice,
                                               &dataSize, &id );
 
   if (result != noErr) {
-    sprintf( message, "RtAudio: OSX error getting default output device." );
+    sprintf( message_, "RtApiCore: OS-X error getting default output device." );
     error(RtError::WARNING);
     return 0;
   }
 
-  for ( int i=0; i<nDevices; i++ ) {
-    if ( id == devices[i].id[0] ) return i;
+  for ( int i=0; i<nDevices_; i++ ) {
+    deviceId = (AudioDeviceID *) devices_[i].apiDeviceId;
+    if ( id == *deviceId ) return i;
   }
 
   return 0;
@@ -499,7 +1629,7 @@ static bool deviceSupportsFormat( AudioDeviceID id, bool isInput,
   return false;
 }
 
-void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
+void RtApiCore :: probeDeviceInfo( RtApiDevice *info )
 {
   OSStatus err = noErr;
 
@@ -507,11 +1637,12 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
   char	name[256];
   char	fullname[512];
   UInt32 dataSize = 256;
-  err = AudioDeviceGetProperty( info->id[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; i<MAX_SAMPLE_RATES; i++) {
-    description.mSampleRate = (double) SAMPLE_RATES[i];
-    if ( deviceSupportsFormat( info->id[0], isInput, &description, isDuplex ) )
-      info->sampleRates[info->nSampleRates++] = SAMPLE_RATES[i];
+  info->sampleRates.clear();
+  for (unsigned int k=0; k<MAX_SAMPLE_RATES; k++) {
+    description.mSampleRate = (double) SAMPLE_RATES[k];
+    if ( deviceSupportsFormat( *id, isInput, &description, isDuplex ) )
+      info->sampleRates.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<int, void *>::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; iStream<nStreams; iStream++ ) {
         if ( bufferList->mBuffers[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; i<nStreams; i++, iChannel++ ) {
 
@@ -922,7 +2036,8 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
                                   kAudioDevicePropertyStreamFormat,
                                   &dataSize, &description );
     if (err != noErr) {
-      sprintf( message, "RtAudio: OSX error getting stream format for device (%s).", devices[device].name );
+      sprintf( message_, "RtApiCore: OS-X error getting stream format for device (%s).",
+               devices_[device].name.c_str() );
       error(RtError::DEBUG_WARNING);
       return FAILURE;
     }
@@ -934,515 +2049,1215 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
                                   kAudioDevicePropertyStreamFormat,
                                   dataSize, &description );
     if (err != noErr) {
-      sprintf( message, "RtAudio: OSX error setting sample rate or data format for device (%s).", devices[device].name );
+      sprintf( message_, "RtApiCore: OS-X error setting sample rate or data format for device (%s).",
+               devices_[device].name.c_str() );
       error(RtError::DEBUG_WARNING);
       return FAILURE;
     }
   }
 
-  // Check whether we need byte-swapping (assuming OS X host is big-endian).
+  // Check whether we need byte-swapping (assuming OS-X host is big-endian).
   iChannel -= nStreams;
   err = AudioDeviceGetProperty( id, iChannel, isInput,
                                 kAudioDevicePropertyStreamFormat,
                                 &dataSize, &description );
   if (err != noErr) {
-    sprintf( message, "RtAudio: OSX error getting stream format for device (%s).", devices[device].name );
+    sprintf( message_, "RtApiCore: OS-X error getting stream format for device (%s).", devices_[device].name.c_str() );
     error(RtError::DEBUG_WARNING);
     return FAILURE;
   }
 
-  stream->doByteSwap[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 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;
+    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
+     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->userBuffer)
-    free(stream->userBuffer);
+  if ( stream_.deInterleave[0] || stream_.deInterleave[1] ) {
+    free(stream_.deviceBuffer);
+    stream_.deviceBuffer = 0;
+  }
 
-  if ( stream->deInterleave[0] || stream->deInterleave[1] )
-    free(stream->callbackInfo.buffers);
+  CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
 
-  free(stream);
-  streams.erase(streamId);
+  // Destroy pthread condition variable and free the CoreHandle structure.
+  if ( handle ) {
+    pthread_cond_destroy(&handle->condition);
+    free( handle );
+    stream_.apiHandle = 0;
+  }
+
+  stream_.mode = UNINITIALIZED;
 }
 
-void RtAudio :: startStream(int streamId)
+void RtApiCore :: startStream()
 {
-  RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId);
-
-  MUTEX_LOCK(&stream->mutex);
+  verifyStream();
+  if (stream_.state == STREAM_RUNNING) return;
 
-  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);
+  MUTEX_UNLOCK(&stream_.mutex);
 }
 
-void RtAudio :: abortStream(int streamId)
+void RtApiCore :: abortStream()
 {
-  stopStream( streamId );
+  stopStream();
 }
 
-// I don't know how this function can be implemented.
-int RtAudio :: streamWillBlock(int streamId)
+void RtApiCore :: tickStream()
 {
-  sprintf(message, "RtAudio: streamWillBlock() cannot be implemented for OS X.");
-  error(RtError::WARNING);
-  return 0;
-}
+  verifyStream();
 
-void RtAudio :: tickStream(int streamId)
-{
-  RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId);
+  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();
 
-  CALLBACK_INFO *info;
+  if (stream_.state == STREAM_STOPPED) return;
+
+  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; i<stream->nDeviceChannels[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; i<stream_.nDeviceChannels[0]; i++ ) {
+          memcpy(outBufferList->mBuffers[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; i<stream->nDeviceChannels[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; i<stream_.nDeviceChannels[1]; i++ ) {
+          memcpy(&stream_.deviceBuffer[i*bufferBytes],
+                 inBufferList->mBuffers[handle->index[1]+i].mData, bufferBytes );
         }
       }
       else
-        stream->deviceBuffer = (char *) inBufferList->mBuffers[stream->handle[1]].mData;
+        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(stream, INPUT);
+      if ( stream_.doByteSwap[1] )
+        byteSwapBuffer(stream_.deviceBuffer,
+                       stream_.bufferSize * stream_.nDeviceChannels[1],
+                       stream_.deviceFormat[1]);
+      convertStreamBuffer(INPUT);
 
     }
     else {
-      memcpy(stream->userBuffer,
-             inBufferList->mBuffers[stream->handle[1]].mData,
-             inBufferList->mBuffers[stream->handle[1]].mDataByteSize );
+      memcpy(stream_.userBuffer,
+             inBufferList->mBuffers[handle->index[1]].mData,
+             inBufferList->mBuffers[handle->index[1]].mDataByteSize );
 
-      if (stream->doByteSwap[1])
-        byteSwapBuffer(stream->userBuffer,
-                       stream->bufferSize * stream->nUserChannels[1],
-                       stream->userFormat);
+      if (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;
+  if ( !info->usingCallback && (stream_.mode != DUPLEX || deviceId == id ) )
+    pthread_cond_signal(&handle->condition);
 
-  MUTEX_UNLOCK(&stream->mutex);
+  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;
+  }
+
+  stream_.callbackInfo.callback = (void *) callback;
+  stream_.callbackInfo.userData = userData;
+  stream_.callbackInfo.usingCallback = true;
 }
 
-void RtAudio :: setStreamCallback(int streamId, RTAUDIO_CALLBACK callback, void *userData)
+void RtApiCore :: cancelStreamCallback()
 {
-  RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId);
+  verifyStream();
+
+  if (stream_.callbackInfo.usingCallback) {
+
+    if (stream_.state == STREAM_RUNNING)
+      stopStream();
+
+    MUTEX_LOCK(&stream_.mutex);
+
+    stream_.callbackInfo.usingCallback = false;
+    stream_.callbackInfo.userData = NULL;
+    stream_.state = STREAM_STOPPED;
+    stream_.callbackInfo.callback = NULL;
 
-  stream->callbackInfo.callback = (void *) callback;
-  stream->callbackInfo.userData = userData;
-  stream->callbackInfo.usingCallback = true;
+    MUTEX_UNLOCK(&stream_.mutex);
+  }
 }
 
+
 //******************** End of __MACOSX_CORE__ *********************//
+#endif
 
-#elif defined(__LINUX_ALSA__)
+#if defined(__LINUX_JACK__)
 
-#define MAX_DEVICES 16
+// 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.
+
+#include <jack/jack.h>
+#include <unistd.h>
+
+// 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) {}
+};
+
+std::string jackmsg;
+
+static void jackerror (const char *desc)
+{
+  jackmsg.erase();
+  jackmsg.append( desc, strlen(desc)+1 );
+}
+
+RtApiJack :: RtApiJack()
+{
+  this->initialize();
+
+  if (nDevices_ <= 0) {
+    sprintf(message_, "RtApiJack: no Linux Jack server found or connection error (jack: %s)!",
+            jackmsg.c_str());
+    error(RtError::NO_DEVICES_FOUND);
+  }
+}
+
+RtApiJack :: ~RtApiJack()
+{
+  if ( stream_.mode != UNINITIALIZED ) closeStream();
+}
+
+void RtApiJack :: initialize(void)
+{
+  nDevices_ = 0;
+
+  // 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 );
+
+  // Look for jack server and try to become a client.
+  jack_client_t *client;
+  if ( (client = jack_client_new( "RtApiJack" )) == 0)
+    return;
+
+  RtApiDevice device;
+  // Determine the name of the device.
+  device.name = "Jack Server";
+  devices_.push_back(device);
+  nDevices_++;
+
+  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;
+  }
+
+  // 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;
+  }
+
+  if (info->maxOutputChannels == 0 && info->maxInputChannels == 0) {
+    jack_client_close(client);
+    sprintf(message_, "RtApiJack: error determining jack input/output channels!");
+    error(RtError::WARNING);
+    return;
+  }
+
+  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;
+  }
+
+  // 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;
+
+  // 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;
+  }
+
+  jack_client_close(client);
+  info->probed = true;
+}
+
+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;
+  }
 
-void RtAudio :: initialize(void)
+  return 0;
+}
+
+void jackShutdown(void *infoPointer)
 {
-  int card, result, device;
-  char name[32];
+  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;
+  }
+
+  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;
+  }
+
+  JackHandle *handle = (JackHandle *) stream_.apiHandle;
+
+  // 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;
+  }
+
+  // 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;
+  }
+  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] ) {
+
+    long buffer_bytes;
+    if (stream_.nUserChannels[0] >= stream_.nUserChannels[1])
+      buffer_bytes = stream_.nUserChannels[0];
+    else
+      buffer_bytes = stream_.nUserChannels[1];
+
+    buffer_bytes *= *bufferSize * formatBytes(stream_.userFormat);
+    if (stream_.userBuffer) free(stream_.userBuffer);
+    stream_.userBuffer = (char *) calloc(buffer_bytes, 1);
+    if (stream_.userBuffer == NULL) {
+      sprintf(message_, "RtApiJack: error allocating user buffer memory (%s).",
+              devices_[device].name.c_str());
+      goto error;
+    }
+  }
+
+  if ( stream_.doConvertBuffer[mode] ) {
+
+    long buffer_bytes;
+    bool makeBuffer = true;
+    if ( mode == OUTPUT )
+      buffer_bytes = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]);
+    else { // mode == INPUT
+      buffer_bytes = stream_.nDeviceChannels[1] * formatBytes(stream_.deviceFormat[1]);
+      if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
+        long bytes_out = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]);
+        if ( buffer_bytes < bytes_out ) makeBuffer = false;
+      }
+    }
+
+    if ( makeBuffer ) {
+      buffer_bytes *= *bufferSize;
+      if (stream_.deviceBuffer) free(stream_.deviceBuffer);
+      stream_.deviceBuffer = (char *) calloc(buffer_bytes, 1);
+      if (stream_.deviceBuffer == NULL) {
+        sprintf(message_, "RtApiJack: error allocating device buffer memory (%s).",
+                devices_[device].name.c_str());
+        goto error;
+      }
+    }
+  }
+
+  // Allocate memory for the Jack ports (channels) identifiers.
+  handle->ports[mode] = (jack_port_t **) malloc (sizeof (jack_port_t *) * channels);
+  if ( handle->ports[mode] == NULL )  {
+    sprintf(message_, "RtApiJack: error allocating port handle memory (%s).",
+            devices_[device].name.c_str());
+    goto error;
+  }
+
+  stream_.device[mode] = device;
+  stream_.state = STREAM_STOPPED;
+  stream_.callbackInfo.usingCallback = false;
+  stream_.callbackInfo.object = (void *) this;
+  stream_.callbackInfo.apiInfo = (void *) handle;
+
+  if ( stream_.mode == OUTPUT && mode == INPUT )
+    // We had already set up the stream for output.
+    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 );
+  }
+
+  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;
+  }
+
+  error(RtError::WARNING);
+  return FAILURE;
+}
+
+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
+  // stream check.
+  if ( stream_.mode == UNINITIALIZED ) {
+    sprintf(message_, "RtApiJack::closeStream(): no open stream to close!");
+    error(RtError::WARNING);
+    return;
+  }
+
+  JackHandle *handle = (JackHandle *) stream_.apiHandle;
+  if ( handle && handle->clientOpen == true ) {
+    if (stream_.state == STREAM_RUNNING)
+      jack_deactivate(handle->client);
+
+    jack_client_close(handle->client);
+  }
+
+  if ( 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;
+  }
+
+  if (stream_.userBuffer) {
+    free(stream_.userBuffer);
+    stream_.userBuffer = 0;
+  }
+
+  if (stream_.deviceBuffer) {
+    free(stream_.deviceBuffer);
+    stream_.deviceBuffer = 0;
+  }
+
+  stream_.mode = UNINITIALIZED;
+}
+
+
+void RtApiJack :: startStream()
+{
+  verifyStream();
+  if (stream_.state == STREAM_RUNNING) return;
+
+  MUTEX_LOCK(&stream_.mutex);
+
+  char label[64];
+  JackHandle *handle = (JackHandle *) stream_.apiHandle;
+  if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+    for ( int i=0; i<stream_.nUserChannels[0]; i++ ) {
+      snprintf(label, 64, "outport %d", i);
+      handle->ports[0][i] = jack_port_register(handle->client, (const char *)label,
+                                               JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+    }
+  }
+
+  if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+    for ( int i=0; i<stream_.nUserChannels[1]; i++ ) {
+      snprintf(label, 64, "inport %d", i);
+      handle->ports[1][i] = jack_port_register(handle->client, (const char *)label,
+                                               JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
+    }
+  }
+
+  if (jack_activate(handle->client)) {
+    sprintf(message_, "RtApiJack: unable to activate JACK client!");
+    error(RtError::SYSTEM_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; i<stream_.nUserChannels[0]; i++ ) {
+      result = 1;
+      if ( ports[i] )
+        result = jack_connect( handle->client, jack_port_name(handle->ports[0][i]), ports[i] );
+      if ( result ) {
+        free(ports);
+        sprintf(message_, "RtApiJack: error connecting output ports!");
+        error(RtError::SYSTEM_ERROR);
+      }
+    }
+    free(ports);
+  }
+
+  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);
+    }
+
+    // Now make the port connections.  See note above.
+    for ( int i=0; i<stream_.nUserChannels[1]; i++ ) {
+      result = 1;
+      if ( ports[i] )
+        result = jack_connect( handle->client, 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);
+  }
+
+  handle->stopStream = false;
+  stream_.state = STREAM_RUNNING;
+
+  MUTEX_UNLOCK(&stream_.mutex);
+}
+
+void RtApiJack :: 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);
+
+  JackHandle *handle = (JackHandle *) stream_.apiHandle;
+  jack_deactivate(handle->client);
+
+  MUTEX_UNLOCK(&stream_.mutex);
+}
+
+void RtApiJack :: abortStream()
+{
+  stopStream();
+}
+
+void RtApiJack :: tickStream()
+{
+  verifyStream();
+
+  if (stream_.state == STREAM_STOPPED) return;
+
+  if (stream_.callbackInfo.usingCallback) {
+    sprintf(message_, "RtApiJack: tickStream() should not be used when a callback function is set!");
+    error(RtError::WARNING);
+    return;
+  }
+
+  JackHandle *handle = (JackHandle *) stream_.apiHandle;
+
+  MUTEX_LOCK(&stream_.mutex);
+
+  pthread_cond_wait(&handle->condition, &stream_.mutex);
+
+  MUTEX_UNLOCK(&stream_.mutex);
+}
+
+void RtApiJack :: callbackEvent( unsigned long nframes )
+{
+  verifyStream();
+
+  if (stream_.state == STREAM_STOPPED) return;
+
+  CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
+  JackHandle *handle = (JackHandle *) stream_.apiHandle;
+  if ( info->usingCallback && handle->stopStream ) {
+    // Check if the stream should be stopped (via the previous user
+    // callback return value).  We stop the stream here, rather than
+    // after the function call, so that output data can first be
+    // processed.
+    this->stopStream();
+    return;
+  }
+
+  MUTEX_LOCK(&stream_.mutex);
+
+  // Invoke user callback first, to get fresh output data.
+  if ( info->usingCallback ) {
+    RtAudioCallback callback = (RtAudioCallback) info->callback;
+    handle->stopStream = callback(stream_.userBuffer, stream_.bufferSize, info->userData);
+  }
+
+  jack_default_audio_sample_t *jackbuffer;
+  long bufferBytes = nframes * sizeof (jack_default_audio_sample_t);
+  if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+    if (stream_.doConvertBuffer[0]) {
+      convertStreamBuffer(OUTPUT);
+
+      for ( int i=0; i<stream_.nDeviceChannels[0]; i++ ) {
+        jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer(handle->ports[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 ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+
+    if (stream_.doConvertBuffer[1]) {
+    for ( int i=0; i<stream_.nDeviceChannels[1]; i++ ) {
+      jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer(handle->ports[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 ( !info->usingCallback )
+    pthread_cond_signal(&handle->condition);
+
+  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;
+  }
+
+  stream_.callbackInfo.callback = (void *) callback;
+  stream_.callbackInfo.userData = userData;
+  stream_.callbackInfo.usingCallback = true;
+}
+
+void RtApiJack :: cancelStreamCallback()
+{
+  verifyStream();
+
+  if (stream_.callbackInfo.usingCallback) {
+
+    if (stream_.state == STREAM_RUNNING)
+      stopStream();
+
+    MUTEX_LOCK(&stream_.mutex);
+
+    stream_.callbackInfo.usingCallback = false;
+    stream_.callbackInfo.userData = NULL;
+    stream_.state = STREAM_STOPPED;
+    stream_.callbackInfo.callback = NULL;
+
+    MUTEX_UNLOCK(&stream_.mutex);
+  }
+}
+
+#endif
+
+#if defined(__LINUX_ALSA__)
+
+#include <alsa/asoundlib.h>
+#include <unistd.h>
+#include <ctype.h>
+
+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);
+  }
+}
+
+RtApiAlsa :: ~RtApiAlsa()
+{
+  if ( stream_.mode != UNINITIALIZED )
+    closeStream();
+}
+
+void RtApiAlsa :: initialize(void)
+{
+  int card, subdevice, result;
+  char name[64];
   const char *cardId;
-  char deviceNames[MAX_DEVICES][32];
   snd_ctl_t *handle;
   snd_ctl_card_info_t *info;
   snd_ctl_card_info_alloca(&info);
+  RtApiDevice device;
 
   // Count cards and devices
-  nDevices = 0;
+  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));
+      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, "RtAudio: ALSA control hardware info (%i): %s.", card, snd_strerror(result));
+      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);
-		device = -1;
+		subdevice = -1;
 		while (1) {
-      result = snd_ctl_pcm_next_device(handle, &device);
+      result = snd_ctl_pcm_next_device(handle, &subdevice);
 			if (result < 0) {
-        sprintf(message, "RtAudio: ALSA control next device (%i): %s.", card, snd_strerror(result));
+        sprintf(message_, "RtApiAlsa: control next device (%i): %s.", card, snd_strerror(result));
         error(RtError::DEBUG_WARNING);
         break;
       }
-			if (device < 0)
+			if (subdevice < 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;
+      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; i<strlen(cardId); i++ ) {
+        if ( !isdigit( cardId[i] ) ) {
+          sprintf( name, "hw:%s,%d", cardId, subdevice );
+          break;
+        }
+      }
+      device.name.erase();
+      device.name.append( (const char *)name, strlen(name)+1 );
+      devices_.push_back(device);
+      nDevices_++;
     }
-    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; i<nDevices; i++) {
-    strncpy(devices[i].name, deviceNames[i], 32);
-    //probeDeviceInfo(&devices[i]);
-  }
 }
 
-int RtAudio :: getDefaultInputDevice(void)
-{
-  // No ALSA API functions for default devices.
-  return 0;
-}
-
-int RtAudio :: getDefaultOutputDevice(void)
-{
-  // No ALSA API functions for default devices.
-  return 0;
-}
-
-void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
+void RtApiAlsa :: probeDeviceInfo(RtApiDevice *info)
 {
   int err;
   int open_mode = SND_PCM_ASYNC;
@@ -1453,15 +3268,15 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
 	snd_pcm_info_alloca(&pcminfo);
   snd_pcm_hw_params_t *params;
   snd_pcm_hw_params_alloca(&params);
-  char name[32];
+  char name[64];
   char *card;
 
   // Open the control interface for this card.
-  strncpy( name, info->name, 32 );
+  strncpy( name, info->name.c_str(), 64 );
   card = strtok(name, ",");
-  err = snd_ctl_open(&chandle, card, 0);
+  err = snd_ctl_open(&chandle, card, SND_CTL_NONBLOCK);
   if (err < 0) {
-    sprintf(message, "RtAudio: ALSA control open (%s): %s.", card, snd_strerror(err));
+    sprintf(message_, "RtApiAlsa: control open (%s): %s.", card, snd_strerror(err));
     error(RtError::DEBUG_WARNING);
     return;
   }
@@ -1475,25 +3290,25 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
 
   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);
+      sprintf(message_, "RtApiAlsa: pcm device (%s) doesn't handle output!", info->name.c_str());
       error(RtError::DEBUG_WARNING);
     }
     else {
-      sprintf(message, "RtAudio: ALSA snd_ctl_pcm_info error for device (%s) output: %s",
-              info->name, snd_strerror(err));
+      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, stream, open_mode | SND_PCM_NONBLOCK );
+  err = snd_pcm_open(&handle, info->name.c_str(), 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));
+      sprintf(message_, "RtApiAlsa: pcm playback device (%s) is busy: %s.",
+              info->name.c_str(), snd_strerror(err));
     else
-      sprintf(message, "RtAudio: ALSA pcm playback open (%s) error: %s.",
-              info->name, snd_strerror(err));
+      sprintf(message_, "RtApiAlsa: pcm playback open (%s) error: %s.",
+              info->name.c_str(), snd_strerror(err));
     error(RtError::DEBUG_WARNING);
     goto capture_probe;
   }
@@ -1502,15 +3317,33 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
   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));
+    sprintf(message_, "RtApiAlsa: hardware probe error (%s): %s.",
+            info->name.c_str(), 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);
+  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 = 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);
 
@@ -1523,12 +3356,12 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
   snd_ctl_close(chandle);
   if ( err < 0 ) {
     if (err == -ENOENT) {
-      sprintf(message, "RtAudio: ALSA pcm device (%s) doesn't handle input!", info->name);
+      sprintf(message_, "RtApiAlsa: pcm device (%s) doesn't handle input!", info->name.c_str());
       error(RtError::DEBUG_WARNING);
     }
     else {
-      sprintf(message, "RtAudio: ALSA snd_ctl_pcm_info error for device (%s) input: %s",
-              info->name, snd_strerror(err));
+      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)
@@ -1537,14 +3370,14 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
     goto probe_parameters;
   }
 
-  err = snd_pcm_open(&handle, info->name, stream, open_mode | SND_PCM_NONBLOCK);
+  err = snd_pcm_open(&handle, info->name.c_str(), 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));
+      sprintf(message_, "RtApiAlsa: pcm capture device (%s) is busy: %s.",
+              info->name.c_str(), snd_strerror(err));
     else
-      sprintf(message, "RtAudio: ALSA pcm capture open (%s) error: %s.",
-              info->name, snd_strerror(err));
+      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
@@ -1556,8 +3389,8 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
   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));
+    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;
@@ -1566,8 +3399,31 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
   }
 
   // Get input channel information.
-  info->minInputChannels = snd_pcm_hw_params_get_channels_min(params);
-  info->maxInputChannels = snd_pcm_hw_params_get_channels_max(params);
+  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 = value;
+
+  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);
 
@@ -1593,10 +3449,10 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
   else
     stream = SND_PCM_STREAM_CAPTURE;
 
-  err = snd_pcm_open(&handle, info->name, stream, open_mode);
+  err = snd_pcm_open(&handle, info->name.c_str(), stream, open_mode);
   if (err < 0) {
-    sprintf(message, "RtAudio: ALSA pcm (%s) won't reopen during probe: %s.",
-            info->name, snd_strerror(err));
+    sprintf(message_, "RtApiAlsa: pcm (%s) won't reopen during probe: %s.",
+            info->name.c_str(), snd_strerror(err));
     error(RtError::WARNING);
     return;
   }
@@ -1605,33 +3461,25 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
   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));
+    sprintf(message_, "RtApiAlsa: hardware reopen probe error (%s): %s.",
+            info->name.c_str(), snd_strerror(err));
     error(RtError::WARNING);
     return;
   }
 
-  // Test a non-standard sample rate to see if continuous rate is supported.
+  // Test our discrete set of sample rate values.
   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);
+  info->sampleRates.clear();
+  for (unsigned int i=0; i<MAX_SAMPLE_RATES; i++) {
+    if (snd_pcm_hw_params_test_rate(handle, params, SAMPLE_RATES[i], dir) == 0)
+      info->sampleRates.push_back(SAMPLE_RATES[i]);
   }
-  else {
-    // No continuous rate support ... test our discrete set of sample rate values.
-    info->nSampleRates = 0;
-    for (int i=0; i<MAX_SAMPLE_RATES; i++) {
-      if (snd_pcm_hw_params_test_rate(handle, params, SAMPLE_RATES[i], dir) == 0) {
-        info->sampleRates[info->nSampleRates] = SAMPLE_RATES[i];
-        info->nSampleRates++;
-      }
-    }
-    if (info->nSampleRates == 0) {
-      snd_pcm_close(handle);
-      return;
-    }
+  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
@@ -1659,8 +3507,8 @@ void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
   // 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);
+    sprintf(message_, "RtApiAlsa: pcm device (%s) data format not supported by RtAudio.",
+            info->name.c_str());
     error(RtError::WARNING);
     return;
   }
@@ -1671,10 +3519,9 @@ 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 RtApiAlsa :: probeDeviceOpen( int device, StreamMode mode, int channels, 
+                                   int sampleRate, RtAudioFormat format,
+                                   int *bufferSize, int numberOfBuffers )
 {
 #if defined(__RTAUDIO_DEBUG__)
   snd_output_t *out;
@@ -1682,7 +3529,7 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
 #endif
 
   // I'm not using the "plug" interface ... too much inconsistent behavior.
-  const char *name = devices[device].name;
+  const char *name = devices_[device].name.c_str();
 
   snd_pcm_stream_t alsa_stream;
   if (mode == OUTPUT)
@@ -1695,7 +3542,7 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
   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.",
+    sprintf(message_,"RtApiAlsa: pcm device (%s) won't open: %s.",
             name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
@@ -1707,43 +3554,42 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
   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.",
+    sprintf(message_, "RtApiAlsa: error getting parameter handle (%s): %s.",
             name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
   }
 
 #if defined(__RTAUDIO_DEBUG__)
-  fprintf(stderr, "\nRtAudio: ALSA dump hardware params just after device open:\n\n");
+  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;
+    stream_.deInterleave[mode] = true;
   }
   else {
     snd_pcm_close(handle);
-    sprintf(message, "RtAudio: ALSA device (%s) access not supported by RtAudio.", name);
+    sprintf(message_, "RtApiAlsa: device (%s) access not supported by RtAudio.", name);
     error(RtError::WARNING);
     return FAILURE;
   }
 
   if (err < 0) {
     snd_pcm_close(handle);
-    sprintf(message, "RtAudio: ALSA error setting access ( (%s): %s.", name, snd_strerror(err));
+    sprintf(message_, "RtApiAlsa: error setting access ( (%s): %s.", name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
   }
 
   // Determine how to set the device format.
-  stream->userFormat = format;
-  snd_pcm_format_t 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;
@@ -1759,49 +3605,49 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
     device_format = SND_PCM_FORMAT_FLOAT64;
 
   if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) {
-    stream->deviceFormat[mode] = format;
+    stream_.deviceFormat[mode] = format;
     goto set_format;
   }
 
   // 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;
+    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;
+    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;
+    stream_.deviceFormat[mode] = RTAUDIO_SINT32;
     goto set_format;
   }
 
   device_format = SND_PCM_FORMAT_S24;
   if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) {
-    stream->deviceFormat[mode] = RTAUDIO_SINT24;
+    stream_.deviceFormat[mode] = RTAUDIO_SINT24;
     goto set_format;
   }
 
   device_format = SND_PCM_FORMAT_S16;
   if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) {
-    stream->deviceFormat[mode] = RTAUDIO_SINT16;
+    stream_.deviceFormat[mode] = RTAUDIO_SINT16;
     goto set_format;
   }
 
   device_format = SND_PCM_FORMAT_S8;
   if (snd_pcm_hw_params_test_format(handle, hw_params, device_format) == 0) {
-    stream->deviceFormat[mode] = RTAUDIO_SINT8;
+    stream_.deviceFormat[mode] = RTAUDIO_SINT8;
     goto set_format;
   }
 
   // If we get here, no supported format was found.
-  sprintf(message,"RtAudio: ALSA pcm device (%s) data format not supported by RtAudio.", name);
+  sprintf(message_,"RtApiAlsa: pcm device (%s) data format not supported by RtAudio.", name);
   snd_pcm_close(handle);
   error(RtError::WARNING);
   return FAILURE;
@@ -1810,21 +3656,21 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
   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.",
+    sprintf(message_, "RtApiAlsa: error setting format (%s): %s.",
             name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
   }
 
   // Determine whether byte-swaping is necessary.
-  stream->doByteSwap[mode] = false;
+  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;
+      stream_.doByteSwap[mode] = true;
     else if (err < 0) {
       snd_pcm_close(handle);
-      sprintf(message, "RtAudio: ALSA error getting format endian-ness (%s): %s.",
+      sprintf(message_, "RtApiAlsa: error getting format endian-ness (%s): %s.",
               name, snd_strerror(err));
       error(RtError::WARNING);
       return FAILURE;
@@ -1835,7 +3681,7 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
   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.",
+    sprintf(message_, "RtApiAlsa: error setting sample rate (%d) on device (%s): %s.",
             sampleRate, name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
@@ -1843,25 +3689,34 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
 
   // 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) {
+  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, "RtAudio: channels (%d) not supported by device (%s).",
+    sprintf(message_, "RtApiAlsa: channels (%d) not supported by device (%s).",
             channels, name);
     error(RtError::WARNING);
     return FAILURE;
   }
 
-  device_channels = snd_pcm_hw_params_get_channels_min(hw_params);
+  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;
+  stream_.nDeviceChannels[mode] = device_channels;
 
   // Set the device channels.
   err = snd_pcm_hw_params_set_channels(handle, hw_params, device_channels);
   if (err < 0) {
     snd_pcm_close(handle);
-    sprintf(message, "RtAudio: ALSA error setting channels (%d) on device (%s): %s.",
+    sprintf(message_, "RtApiAlsa: error setting channels (%d) on device (%s): %s.",
             device_channels, name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
@@ -1869,31 +3724,53 @@ bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
 
   // Set the buffer number, which in ALSA is referred to as the "period".
   int dir;
-  int periods = numberOfBuffers;
+  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, &dir);
-  if (err > periods) periods = err;
-  err = snd_pcm_hw_params_get_periods_max(hw_params, &dir);
-  if (err < periods) periods = err;
+  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;
+  }
+  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;
+  }
+  if (value < periods) periods = value;
 
   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.",
+    sprintf(message_, "RtApiAlsa: error setting periods (%s): %s.",
             name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
   }
 
   // Set the buffer (or period) size.
-  err = snd_pcm_hw_params_get_period_size_min(hw_params, &dir);
-  if (err > *bufferSize) *bufferSize = err;
+  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;
 
   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.",
+    sprintf(message_, "RtApiAlsa: error setting period size (%s): %s.",
             name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
@@ -1901,1526 +3778,583 @@ 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!
-  if ( stream->mode == OUTPUT && mode == INPUT && *bufferSize != stream->bufferSize ) {
-    sprintf( message, "RtAudio: ALSA error setting buffer size for duplex stream on device (%s).",
+  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;
   }
 
-  stream->bufferSize = *bufferSize;
+  stream_.bufferSize = *bufferSize;
 
   // 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.",
+    sprintf(message_, "RtApiAlsa: error installing hardware configuration (%s): %s.",
             name, snd_strerror(err));
     error(RtError::WARNING);
     return FAILURE;
   }
 
 #if defined(__RTAUDIO_DEBUG__)
-  fprintf(stderr, "\nRtAudio: ALSA dump hardware params after installation:\n\n");
+  fprintf(stderr, "\nRtApiAlsa: 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);
-    return FAILURE;
+  // 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 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;
+  // Set flags for buffer conversion
+  stream_.doConvertBuffer[mode] = false;
+  if (stream_.userFormat != stream_.deviceFormat[mode])
+    stream_.doConvertBuffer[mode] = true;
+  if (stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode])
+    stream_.doConvertBuffer[mode] = true;
+  if (stream_.nUserChannels[mode] > 1 && stream_.deInterleave[mode])
+    stream_.doConvertBuffer[mode] = true;
 
   // Allocate necessary internal buffers
-  if ( stream->nUserChannels[0] != stream->nUserChannels[1] ) {
+  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_, "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)
-        goto memory_error;
+      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->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 = periods;
-  stream->sampleRate = sampleRate;
+    stream_.mode = mode;
+  stream_.nBuffers = periods;
+  stream_.sampleRate = sampleRate;
 
   return SUCCESS;
 
- memory_error:
-  if (stream->handle[0]) {
-    snd_pcm_close(stream->handle[0]);
-    stream->handle[0] = 0;
-  }
-  if (stream->handle[1]) {
-    snd_pcm_close(stream->handle[1]);
-    stream->handle[1] = 0;
+ error:
+  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;
+
+  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 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)
-      snd_pcm_drop(stream->handle[0]);
-    if (stream->mode == INPUT || stream->mode == DUPLEX)
-      snd_pcm_drop(stream->handle[1]);
+  if (stream_.callbackInfo.usingCallback) {
+    stream_.callbackInfo.usingCallback = false;
+    pthread_join(stream_.callbackInfo.thread, NULL);
   }
 
-  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 (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()
 {
   // 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);
+  verifyStream();
+  if (stream_.state == STREAM_RUNNING) return;
 
-  if (stream->state == STREAM_RUNNING)
-    goto unlock;
+  MUTEX_LOCK(&stream_.mutex);
 
   int err;
   snd_pcm_state_t state;
-  if (stream->mode == OUTPUT || stream->mode == DUPLEX) {
-    state = snd_pcm_state(stream->handle[0]);
+  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(stream->handle[0]);
+      err = snd_pcm_prepare(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);
+        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(stream->handle[1]);
+  if (stream_.mode == INPUT || stream_.mode == DUPLEX) {
+    state = snd_pcm_state(handle[1]);
     if (state != SND_PCM_STATE_PREPARED) {
-      err = snd_pcm_prepare(stream->handle[1]);
+      err = snd_pcm_prepare(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);
+        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;
+  stream_.state = STREAM_RUNNING;
 
- unlock:
-  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 = snd_pcm_drain(stream->handle[0]);
+  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, "RtAudio: ALSA error draining pcm device (%s): %s.",
-              devices[stream->device[0]].name, snd_strerror(err));
-      MUTEX_UNLOCK(&stream->mutex);
+      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);
     }
   }
 
-  if (stream->mode == INPUT || stream->mode == DUPLEX) {
-    err = snd_pcm_drain(stream->handle[1]);
+  if (stream_.mode == INPUT || stream_.mode == DUPLEX) {
+    err = snd_pcm_drain(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);
+      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);
+  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 = snd_pcm_drop(stream->handle[0]);
+  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, "RtAudio: ALSA error draining pcm device (%s): %s.",
-              devices[stream->device[0]].name, snd_strerror(err));
-      MUTEX_UNLOCK(&stream->mutex);
+      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);
     }
   }
 
-  if (stream->mode == INPUT || stream->mode == DUPLEX) {
-    err = snd_pcm_drop(stream->handle[1]);
+  if (stream_.mode == INPUT || stream_.mode == DUPLEX) {
+    err = snd_pcm_drop(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);
+      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 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]);
+  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, "RtAudio: ALSA error getting available frames for device (%s): %s.",
-              devices[stream->device[0]].name, snd_strerror(err));
-      MUTEX_UNLOCK(&stream->mutex);
+      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);
     }
   }
 
   frames = err;
 
-  if (stream->mode == INPUT || stream->mode == DUPLEX) {
-    err = snd_pcm_avail_update(stream->handle[1]);
+  if (stream_.mode == INPUT || stream_.mode == DUPLEX) {
+    err = snd_pcm_avail_update(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);
+      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 = 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 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 err;
   char *buffer;
   int channels;
-  RTAUDIO_FORMAT format;
-  if (stream->mode == OUTPUT || stream->mode == DUPLEX) {
+  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;
-      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 samples to device in interleaved/non-interleaved format.
-    if (stream->deInterleave[0]) {
+    if (stream_.deInterleave[0]) {
       void *bufs[channels];
-      size_t offset = stream->bufferSize * formatBytes(format);
+      size_t offset = stream_.bufferSize * formatBytes(format);
       for (int i=0; i<channels; i++)
         bufs[i] = (void *) (buffer + (i * offset));
-      err = snd_pcm_writen(stream->handle[0], bufs, stream->bufferSize);
+      err = snd_pcm_writen(handle[0], bufs, stream_.bufferSize);
     }
     else
-      err = snd_pcm_writei(stream->handle[0], buffer, stream->bufferSize);
+      err = snd_pcm_writei(handle[0], buffer, stream_.bufferSize);
 
-    if (err < 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]);
+        snd_pcm_state_t state = snd_pcm_state(handle[0]);
         if (state == SND_PCM_STATE_XRUN) {
-          sprintf(message, "RtAudio: ALSA underrun detected.");
+          sprintf(message_, "RtApiAlsa: underrun detected.");
           error(RtError::WARNING);
-          err = snd_pcm_prepare(stream->handle[0]);
+          err = snd_pcm_prepare(handle[0]);
           if (err < 0) {
-            sprintf(message, "RtAudio: ALSA error preparing handle after underrun: %s.",
+            sprintf(message_, "RtApiAlsa: error preparing handle after underrun: %s.",
                     snd_strerror(err));
-            MUTEX_UNLOCK(&stream->mutex);
+            MUTEX_UNLOCK(&stream_.mutex);
             error(RtError::DRIVER_ERROR);
           }
         }
         else {
-          sprintf(message, "RtAudio: ALSA error, current state is %s.",
+          sprintf(message_, "RtApiAlsa: tickStream() error, current state is %s.",
                   snd_pcm_state_name(state));
-          MUTEX_UNLOCK(&stream->mutex);
+          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);
+        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;
-      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 samples from device in interleaved/non-interleaved format.
-    if (stream->deInterleave[1]) {
+    if (stream_.deInterleave[1]) {
       void *bufs[channels];
-      size_t offset = stream->bufferSize * formatBytes(format);
+      size_t offset = stream_.bufferSize * formatBytes(format);
       for (int i=0; i<channels; i++)
         bufs[i] = (void *) (buffer + (i * offset));
-      err = snd_pcm_readn(stream->handle[1], bufs, stream->bufferSize);
+      err = snd_pcm_readn(handle[1], bufs, stream_.bufferSize);
     }
     else
-      err = snd_pcm_readi(stream->handle[1], buffer, stream->bufferSize);
+      err = snd_pcm_readi(handle[1], buffer, stream_.bufferSize);
 
-    if (err < 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[1]);
+        snd_pcm_state_t state = snd_pcm_state(handle[1]);
         if (state == SND_PCM_STATE_XRUN) {
-          sprintf(message, "RtAudio: ALSA overrun detected.");
+          sprintf(message_, "RtApiAlsa: overrun detected.");
           error(RtError::WARNING);
-          err = snd_pcm_prepare(stream->handle[1]);
+          err = snd_pcm_prepare(handle[1]);
           if (err < 0) {
-            sprintf(message, "RtAudio: ALSA error preparing handle after overrun: %s.",
+            sprintf(message_, "RtApiAlsa: error preparing handle after overrun: %s.",
                     snd_strerror(err));
-            MUTEX_UNLOCK(&stream->mutex);
+            MUTEX_UNLOCK(&stream_.mutex);
             error(RtError::DRIVER_ERROR);
           }
         }
         else {
-          sprintf(message, "RtAudio: ALSA error, current state is %s.",
+          sprintf(message_, "RtApiAlsa: tickStream() error, current state is %s.",
                   snd_pcm_state_name(state));
-          MUTEX_UNLOCK(&stream->mutex);
+          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);
+        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, 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);
-
-  if (stream->callbackInfo.usingCallback && stopStream)
-    this->stopStream(streamId);
-}
-
-extern "C" void *callbackHandler(void *ptr)
-{
-  CALLBACK_INFO *info = (CALLBACK_INFO *) ptr;
-  RtAudio *object = (RtAudio *) info->object;
-  int stream = info->streamId;
-  bool *usingCallback = &info->usingCallback;
-
-  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;
-    }
-  }
-
-  return 0;
-}
-
-//******************** End of __LINUX_ALSA__ *********************//
-
-#elif defined(__LINUX_OSS__)
-
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/soundcard.h>
-#include <errno.h>
-#include <math.h>
-
-#define DAC_NAME "/dev/dsp"
-#define MAX_DEVICES 16
-#define MAX_CHANNELS 16
-
-void RtAudio :: initialize(void)
-{
-  // Count cards and devices
-  nDevices = 0;
-
-  // We check /dev/dsp before probing devices.  /dev/dsp is supposed to
-  // be a link to the "default" audio device, of the form /dev/dsp0,
-  // /dev/dsp1, etc...  However, I've seen many cases where /dev/dsp was a
-  // real device, so we need to check for that.  Also, sometimes the
-  // link is to /dev/dspx and other times just dspx.  I'm not sure how
-  // the latter works, but it does.
-  char device_name[16];
-  struct stat dspstat;
-  int dsplink = -1;
-  int i = 0;
-  if (lstat(DAC_NAME, &dspstat) == 0) {
-    if (S_ISLNK(dspstat.st_mode)) {
-      i = readlink(DAC_NAME, device_name, sizeof(device_name));
-      if (i > 0) {
-        device_name[i] = '\0';
-        if (i > 8) { // check for "/dev/dspx"
-          if (!strncmp(DAC_NAME, device_name, 8))
-            dsplink = atoi(&device_name[8]);
-        }
-        else if (i > 3) { // check for "dspx"
-          if (!strncmp("dsp", device_name, 3))
-            dsplink = atoi(&device_name[3]);
-        }
-      }
-      else {
-        sprintf(message, "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);
-  }
-
-  // The OSS API doesn't provide a routine for determining the number
-  // of devices.  Thus, we'll just pursue a brute force method.  The
-  // idea is to start with /dev/dsp(0) and continue with higher device
-  // numbers until we reach MAX_DSP_DEVICES.  This should tell us how
-  // many devices we have ... it is not a fullproof scheme, but hopefully
-  // it will work most of the time.
-
-  int fd = 0;
-  char names[MAX_DEVICES][16];
-  for (i=-1; i<MAX_DEVICES; i++) {
-
-    // 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);
-
-    // 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 (fd >= 0) close(fd);
-    strncpy(names[nDevices], device_name, 16);
-    nDevices++;
-  }
-
-  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 control structure and then probe capabilities.
-  for (i=0; i<nDevices; i++) {
-    strncpy(devices[i].name, names[i], 16);
-    //probeDeviceInfo(&devices[i]);
-  }
-
-  return;
-}
-
-int RtAudio :: getDefaultInputDevice(void)
-{
-  // No OSS API functions for default devices.
-  return 0;
-}
-
-int RtAudio :: getDefaultOutputDevice(void)
-{
-  // No OSS API functions for default devices.
-  return 0;
-}
-
-void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
-{
-  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, 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);
-    else
-      sprintf(message, "RtAudio: OSS playback device (%s) open error.", info->name);
-    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, 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);
-    else
-      sprintf(message, "RtAudio: OSS capture device (%s) open error.", info->name);
-    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, "RtAudio: OSS device (%s) reports zero channels for input and output.",
-            info->name);
-    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, 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, O_WRONLY | O_NONBLOCK);
-    channels = info->maxOutputChannels;
-  }
-  else {
-    fd = open(info->name, O_RDONLY | O_NONBLOCK);
-    channels = info->maxInputChannels;
-  }
-
-  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);
-    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);
-    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);
-    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, "RtAudio: OSS device (%s) data format not supported by RtAudio.",
-            info->name);
-    error(RtError::DEBUG_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;
-  }
-
-  // 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; i<MAX_SAMPLE_RATES; i++) {
-      speed = SAMPLE_RATES[i];
-      if (ioctl(fd, SNDCTL_DSP_SPEED, &speed) != -1) {
-        info->sampleRates[info->nSampleRates] = SAMPLE_RATES[i];
-        info->nSampleRates++;
-      }
-    }
-    if (info->nSampleRates == 0) {
-      close(fd);
-      return;
-    }
-    goto finished;
-  }
-  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;
-  }
-  info->sampleRates[1] = speed;
-  info->nSampleRates = -1;
+  MUTEX_UNLOCK(&stream_.mutex);
 
- finished: // That's all ... close the device and return
-  close(fd);
-  info->probed = true;
-  return;
+  if (stream_.callbackInfo.usingCallback && stopStream)
+    this->stopStream();
 }
 
-bool RtAudio :: probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
-                                STREAM_MODE mode, int channels, 
-                                int sampleRate, RTAUDIO_FORMAT format,
-                                int *bufferSize, int numberOfBuffers)
+void RtApiAlsa :: setStreamCallback(RtAudioCallback callback, void *userData)
 {
-  int buffers, buffer_bytes, device_channels, device_format;
-  int srate, temp, fd;
-
-  const char *name = devices[device].name;
-
-  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);
-  }
-
-  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;
-  }
-
-  // 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, "RtAudio: OSS 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, "RtAudio: OSS 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, "RtAudio: OSS 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;
+  verifyStream();
 
-  // 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;
-  }
-  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 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;
-  }
-
-  // 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;
-  }
-
-  // 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;
-
-  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;
-  }
-
-  // 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;
-  }
-
-  // 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, "RtAudio: OSS 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);
-        free(stream->userBuffer);
-        sprintf(message, "RtAudio: OSS error allocating device buffer memory (%s).",
-                name);
-        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;
-  }
-  else
-    stream->mode = mode;
-
-  return SUCCESS;
-
- error:
-  if (stream->handle[0]) {
-    close(stream->handle[0]);
-    stream->handle[0] = 0;
-  }
-  error(RtError::WARNING);
-  return FAILURE;
-}
-
-void RtAudio :: closeStream(int 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 ( streams.find( streamId ) == streams.end() ) {
-    sprintf(message, "RtAudio: invalid stream identifier!");
+  CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
+  if ( info->usingCallback ) {
+    sprintf(message_, "RtApiAlsa: A callback is already set for this stream!");
     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);
-  }
-
-  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);
-  }
-
-  pthread_mutex_destroy(&stream->mutex);
-
-  if (stream->handle[0])
-    close(stream->handle[0]);
-
-  if (stream->handle[1])
-    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)
-{
-  RTAUDIO_STREAM *stream = (RTAUDIO_STREAM *) verifyStream(streamId);
-
-  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 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 = ioctl(stream->handle[0], SNDCTL_DSP_SYNC, 0);
-    if (err < -1) {
-      sprintf(message, "RtAudio: OSS error stopping device (%s).",
-              devices[stream->device[0]].name);
-      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);
-      error(RtError::DRIVER_ERROR);
-    }
-  }
-  stream->state = STREAM_STOPPED;
-
- unlock:
-  MUTEX_UNLOCK(&stream->mutex);
-}
-
-void RtAudio :: abortStream(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 = ioctl(stream->handle[0], SNDCTL_DSP_RESET, 0);
-    if (err < -1) {
-      sprintf(message, "RtAudio: OSS error aborting device (%s).",
-              devices[stream->device[0]].name);
-      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);
-      error(RtError::DRIVER_ERROR);
-    }
-  }
-  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 bytes = 0, channels = 0, frames = 0;
-  if (stream->state == STREAM_STOPPED)
-    goto unlock;
+  info->callback = (void *) callback;
+  info->userData = userData;
+  info->usingCallback = true;
+  info->object = (void *) this;
 
-  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];
-  }
+  // 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);
 
-  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];
-    }
+  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);
   }
-
-  frames = (int) (bytes / (channels * formatBytes(stream->deviceFormat[0])));
-  frames -= stream->bufferSize;
-  if (frames < 0) frames = 0;
-
- unlock:
-  MUTEX_UNLOCK(&stream->mutex);
-  return frames;
 }
 
-void RtAudio :: tickStream(int streamId)
+void RtApiAlsa :: cancelStreamCallback()
 {
-  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);
-  }
-
-  MUTEX_LOCK(&stream->mutex);
-
-  // The state might change while waiting on a mutex.
-  if (stream->state == STREAM_STOPPED)
-    goto unlock;
-
-  int result;
-  char *buffer;
-  int samples;
-  RTAUDIO_FORMAT format;
-  if (stream->mode == OUTPUT || stream->mode == DUPLEX) {
+  verifyStream();
 
-    // 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];
-    }
-    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(stream->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, "RtAudio: OSS audio write error for device (%s).",
-              devices[stream->device[0]].name);
-      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;
-    }
+  if (stream_.callbackInfo.usingCallback) {
 
-    // Read samples from device.
-    result = read(stream->handle[1], buffer, samples * formatBytes(format));
+    if (stream_.state == STREAM_RUNNING)
+      stopStream();
 
-    if (result == -1) {
-      // This could be an overrun, but the basic OSS API doesn't provide a means for determining that.
-      sprintf(message, "RtAudio: OSS audio read error for device (%s).",
-              devices[stream->device[1]].name);
-      error(RtError::DRIVER_ERROR);
-    }
+    MUTEX_LOCK(&stream_.mutex);
 
-    // Do byte swapping if necessary.
-    if (stream->doByteSwap[1])
-      byteSwapBuffer(buffer, samples, format);
+    stream_.callbackInfo.usingCallback = false;
+    pthread_join(stream_.callbackInfo.thread, NULL);
+    stream_.callbackInfo.thread = 0;
+    stream_.callbackInfo.callback = NULL;
+    stream_.callbackInfo.userData = NULL;
 
-    // Do buffer conversion if necessary.
-    if (stream->doConvertBuffer[1])
-      convertStreamBuffer(stream, INPUT);
+    MUTEX_UNLOCK(&stream_.mutex);
   }
-
- unlock:
-  MUTEX_UNLOCK(&stream->mutex);
-
-  if (stream->callbackInfo.usingCallback && stopStream)
-    this->stopStream(streamId);
 }
 
-extern "C" void *callbackHandler(void *ptr)
+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;
 
-void RtAudio :: initialize(void)
+struct AsioHandle {
+  bool stopStream;
+  ASIOBufferInfo *bufferInfos;
+  HANDLE condition;
+
+  AsioHandle()
+    :stopStream(false), bufferInfos(0) {}
+};
+
+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<nDevices; i++) {
-    if ( drivers.asioGetDriverName( i, devices[i].name, 128 ) == 0 )
-      //probeDeviceInfo(&devices[i]);
-      ;
+RtApiAsio :: ~RtApiAsio()
+{
+  if ( stream_.mode != UNINITIALIZED ) closeStream();
+}
+
+void RtApiAsio :: initialize(void)
+{
+  nDevices_ = drivers.asioGetNumDev();
+  if (nDevices_ <= 0) return;
+
+  // Create device structures and write device driver names to each.
+  RtApiDevice device;
+  char name[128];
+  for (int i=0; i<nDevices_; i++) {
+    if ( drivers.asioGetDriverName( i, name, 128 ) == 0 ) {
+      device.name.erase();
+      device.name.append( (const char *)name, strlen(name)+1);
+      devices_.push_back(device);
+    }
     else {
-      sprintf(message, "RtAudio: error getting ASIO driver name for device index %d!", i);
+      sprintf(message_, "RtApiAsio: error getting driver name for device index %d!", i);
       error(RtError::WARNING);
     }
   }
 
+  nDevices_ = (int) devices_.size();
+
   drivers.removeCurrentDriver();
   driverInfo.asioVersion = 2;
   // See note in DirectSound implementation about GetDesktopWindow().
   driverInfo.sysRef = GetForegroundWindow();
 }
 
-int RtAudio :: getDefaultInputDevice(void)
-{
-  return 0;
-}
-
-int RtAudio :: getDefaultOutputDevice(void)
-{
-  return 0;
-}
-
-void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
+void RtApiAsio :: probeDeviceInfo(RtApiDevice *info)
 {
   // Don't probe if a stream is already open.
-  if ( streams.size() > 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; i<MAX_SAMPLE_RATES; i++) {
+  info->sampleRates.clear();
+  for (unsigned int i=0; i<MAX_SAMPLE_RATES; i++) {
     result = ASIOCanSampleRate( (ASIOSampleRate) SAMPLE_RATES[i] );
     if ( result == ASE_OK )
-      info->sampleRates[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; i<stream->nDeviceChannels[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; i<stream_.nDeviceChannels[0]; i++, infos++ ) {
+    infos->isInput = ASIOFalse;
     infos->channelNum = i;
     infos->buffers[0] = infos->buffers[1] = 0;
   }
-
-  for ( i=0; i<stream->nDeviceChannels[0]; i++, infos++ ) {
-    infos->isInput = ASIOFalse;
+  for ( i=0; i<stream_.nDeviceChannels[1]; i++, infos++ ) {
+    infos->isInput = 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);
+  verifyStream();
+  if (stream_.state == STREAM_RUNNING) return;
 
-  MUTEX_LOCK(&stream->mutex);
-
-  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);
+  MUTEX_UNLOCK(&stream_.mutex);
 }
 
-void RtAudio :: abortStream(int streamId)
+void RtApiAsio :: abortStream()
 {
-  stopStream( streamId );
-}
-
-// I don't know how this function can be implemented.
-int RtAudio :: streamWillBlock(int streamId)
-{
-  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();
 
-  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 ) {
+  if (stream_.state == STREAM_STOPPED) return;
+
+  CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
+  AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
+  if ( info->usingCallback && handle->stopStream ) {
     // Check if the stream should be stopped (via the previous user
     // callback return value).  We stop the stream here, rather than
     // after the function call, so that output data can first be
     // processed.
-    this->stopStream(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; i<stream->nDeviceChannels[0]; i++, bufferInfos++ ) {
-        memcpy(bufferInfos->buffers[bufferIndex],
-               &stream->deviceBuffer[i*bufferBytes], bufferBytes );
+      j = 0;
+      for ( int i=0; i<nChannels; i++ ) {
+        if ( handle->bufferInfos[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; i<nChannels; i++ ) {
+        if ( handle->bufferInfos[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; i<stream->nDeviceChannels[1]; i++, bufferInfos++ )
-        memcpy(&stream->deviceBuffer[i*bufferBytes], bufferInfos->buffers[bufferIndex], bufferBytes );
+      j = 0;
+      for ( int i=0; i<nChannels; i++ ) {
+        if ( handle->bufferInfos[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; i<nChannels; i++ ) {
+        if ( handle->bufferInfos[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;
+    SetEvent( handle->condition );
 
-  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;
+  MUTEX_UNLOCK(&stream_.mutex);
 }
 
 //******************** End of __WINDOWS_ASIO__ *********************//
+#endif
 
-#elif defined(__WINDOWS_DS__) // Windows DirectSound API
+#if defined(__WINDOWS_DS__) // Windows DirectSound API
 
 #include <dsound.h>
 
+// 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; i<nDevices; i++ )
-    if ( strncmp( devices[i].name, info.name, 64 ) == 0 ) return i;
+  for ( int i=0; i<nDevices_; i++ ) {
+    if ( strncmp( info.name, devices_[i].name.c_str(), 64 ) == 0 ) return i;
+  }
+
 
   return 0;
 }
 
-int RtAudio :: getDefaultOutputDevice(void)
+int RtApiDs :: getDefaultOutputDevice(void)
 {
   enum_info info;
   info.name[0] = '\0';
@@ -4276,28 +5275,28 @@ int RtAudio :: getDefaultOutputDevice(void)
   // Enumerate through devices to find the default output.
   HRESULT result = DirectSoundEnumerate((LPDSENUMCALLBACK)defaultDeviceCallback, &info);
   if ( FAILED(result) ) {
-    sprintf(message, "RtAudio: Error performing default output device enumeration: %s.",
+    sprintf(message_, "RtApiDs: Error performing default output device enumeration: %s.",
             getErrorString(result));
     error(RtError::WARNING);
     return 0;
   }
 
-  for ( int i=0; i<nDevices; i++ )
-    if ( strncmp(devices[i].name, info.name, 64 ) == 0 ) return i;
+  for ( int i=0; i<nDevices_; i++ )
+    if ( strncmp( info.name, devices_[i].name.c_str(), 64 ) == 0 ) return i;
 
   return 0;
 }
 
-void RtAudio :: initialize(void)
+void RtApiDs :: initialize(void)
 {
   int i, ins = 0, outs = 0, count = 0;
   HRESULT result;
-  nDevices = 0;
+  nDevices_ = 0;
 
   // Count DirectSound devices.
   result = DirectSoundEnumerate((LPDSENUMCALLBACK)deviceCountCallback, &outs);
   if ( FAILED(result) ) {
-    sprintf(message, "RtAudio: Unable to enumerate through sound playback devices: %s.",
+    sprintf(message_, "RtApiDs: Unable to enumerate through sound playback devices: %s.",
             getErrorString(result));
     error(RtError::DRIVER_ERROR);
   }
@@ -4305,7 +5304,7 @@ void RtAudio :: initialize(void)
   // Count DirectSoundCapture devices.
   result = DirectSoundCaptureEnumerate((LPDSENUMCALLBACK)deviceCountCallback, &ins);
   if ( FAILED(result) ) {
-    sprintf(message, "RtAudio: Unable to enumerate through sound capture devices: %s.",
+    sprintf(message_, "RtApiDs: Unable to enumerate through sound capture devices: %s.",
             getErrorString(result));
     error(RtError::DRIVER_ERROR);
   }
@@ -4323,7 +5322,7 @@ void RtAudio :: initialize(void)
   // Get playback device info and check capabilities.
   result = DirectSoundEnumerate((LPDSENUMCALLBACK)deviceInfoCallback, &info[0]);
   if ( FAILED(result) ) {
-    sprintf(message, "RtAudio: Unable to enumerate through sound playback devices: %s.",
+    sprintf(message_, "RtApiDs: Unable to enumerate through sound playback devices: %s.",
             getErrorString(result));
     error(RtError::DRIVER_ERROR);
   }
@@ -4331,49 +5330,39 @@ void RtAudio :: initialize(void)
   // Get capture device info and check capabilities.
   result = DirectSoundCaptureEnumerate((LPDSENUMCALLBACK)deviceInfoCallback, &info[0]);
   if ( FAILED(result) ) {
-    sprintf(message, "RtAudio: Unable to enumerate through sound capture devices: %s.",
+    sprintf(message_, "RtApiDs: Unable to enumerate through sound capture devices: %s.",
             getErrorString(result));
     error(RtError::DRIVER_ERROR);
   }
 
-  // Parse the devices and check validity.  Devices are considered
-  // invalid if they cannot be opened, they report < 1 supported
-  // channels, or they report no supported data (capture only).
-  for (i=0; i<count; i++)
-    if ( info[i].isValid ) nDevices++;
-
-  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);
-  }
-
-  // Copy the names to our devices structures.
+  // Create device structures for valid devices and write device names
+  // to each.  Devices are considered invalid if they cannot be
+  // opened, they report < 1 supported channels, or they report no
+  // supported data (capture only).
+  RtApiDevice device;
   int index = 0;
   for (i=0; i<count; i++) {
-    if ( info[i].isValid )
-      strncpy(devices[index++].name, info[i].name, 64);
+    if ( info[i].isValid ) {
+      device.name.erase();
+      device.name.append( (const char *)info[i].name, strlen(info[i].name)+1);
+      devices_.push_back(device);
+    }
   }
 
-  //for (i=0;i<nDevices; i++)
-  //probeDeviceInfo(&devices[i]);
-
+  nDevices_ = devices_.size();
   return;
 }
 
-void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
+void RtApiDs :: probeDeviceInfo(RtApiDevice *info)
 {
   enum_info dsinfo;
-  strncpy( dsinfo.name, info->name, 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; i<info->nSampleRates; 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);
-
-  MUTEX_LOCK(&stream->mutex);
+  verifyStream();
+  if (stream_.state == STREAM_RUNNING) return;
 
-  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; i<stream->nBuffers; i++) {
+    for (int i=0; i<stream_.nBuffers; i++) {
 
       // Find out where the read and "safe write" pointers are.
       result = dsBuffer->GetCurrentPosition(&currentPos, &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( &currentPos, &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(&currentPos, &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(&currentPos, &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(&currentPos, &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( &currentPos, &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(&currentPos, &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( &currentPos, &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 <dmedia/audio.h>
 #include <unistd.h>
 #include <errno.h>
 
-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; i<devices_.size(); i++ ) {
+    id = (long *) devices_[i].apiDeviceId;
+    if (id) free(id);
+  }
+}
+
+void RtApiAl :: initialize(void)
 {
   // Count cards and devices
-  nDevices = 0;
+  nDevices_ = 0;
 
   // Determine the total number of input and output devices.
-  nDevices = alQueryValues(AL_SYSTEM, AL_DEVICES, 0, 0, 0, 0);
-  if (nDevices < 0) {
-    sprintf(message, "RtAudio: AL error counting devices: %s.",
+  nDevices_ = alQueryValues(AL_SYSTEM, AL_DEVICES, 0, 0, 0, 0);
+  if (nDevices_ < 0) {
+    sprintf(message_, "RtApiAl: error counting devices: %s.",
             alGetErrorString(oserror()));
     error(RtError::DRIVER_ERROR);
   }
 
-  if (nDevices <= 0) return;
+  if (nDevices_ <= 0) return;
 
-  ALvalue *vls = (ALvalue *) new ALvalue[nDevices];
+  ALvalue *vls = (ALvalue *) new ALvalue[nDevices_];
 
-  //  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 and resource ids to device info
-  // structure.
-  char name[32];
+  // Create our list of devices and write their ascii identifiers and resource ids.
+  char name[64];
   int outs, ins, i;
   ALpv pvs[1];
   pvs[0].param = AL_NAME;
   pvs[0].value.ptr = name;
-  pvs[0].sizeIn = 32;
+  pvs[0].sizeIn = 64;
+  RtApiDevice device;
+  long *id;
 
-  outs = alQueryValues(AL_SYSTEM, AL_DEFAULT_OUTPUT, vls, nDevices, 0, 0);
+  outs = alQueryValues(AL_SYSTEM, AL_DEFAULT_OUTPUT, vls, nDevices_, 0, 0);
   if (outs < 0) {
-    sprintf(message, "RtAudio: AL error getting output devices: %s.",
+    delete [] vls;
+    sprintf(message_, "RtApiAl: error getting output devices: %s.",
             alGetErrorString(oserror()));
     error(RtError::DRIVER_ERROR);
   }
 
   for (i=0; i<outs; i++) {
     if (alGetParams(vls[i].i, pvs, 1) < 0) {
-      sprintf(message, "RtAudio: AL error querying output devices: %s.",
+      delete [] vls;
+      sprintf(message_, "RtApiAl: error querying output devices: %s.",
               alGetErrorString(oserror()));
       error(RtError::DRIVER_ERROR);
     }
-    strncpy(devices[i].name, name, 32);
-    devices[i].id[0] = vls[i].i;
+    device.name.erase();
+    device.name.append( (const char *)name, strlen(name)+1);
+    devices_.push_back(device);
+    id = (long *) calloc(2, sizeof(long));
+    id[0] = vls[i].i;
+    devices_[i].apiDeviceId = (void *) id;
   }
 
-  ins = alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, &vls[outs], nDevices-outs, 0, 0);
+  ins = alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, &vls[outs], nDevices_-outs, 0, 0);
   if (ins < 0) {
-    sprintf(message, "RtAudio: AL error getting input devices: %s.",
+    delete [] vls;
+    sprintf(message_, "RtApiAl: error getting input devices: %s.",
             alGetErrorString(oserror()));
     error(RtError::DRIVER_ERROR);
   }
 
   for (i=outs; i<ins+outs; i++) {
     if (alGetParams(vls[i].i, pvs, 1) < 0) {
-      sprintf(message, "RtAudio: AL error querying input devices: %s.",
+      delete [] vls;
+      sprintf(message_, "RtApiAl: error querying input devices: %s.",
               alGetErrorString(oserror()));
       error(RtError::DRIVER_ERROR);
     }
-    strncpy(devices[i].name, name, 32);
-    devices[i].id[1] = vls[i].i;
+    device.name.erase();
+    device.name.append( (const char *)name, strlen(name)+1);
+    devices_.push_back(device);
+    id = (long *) calloc(2, sizeof(long));
+    id[1] = vls[i].i;
+    devices_[i].apiDeviceId = (void *) id;
   }
 
   delete [] vls;
-
-  return;
 }
 
-int RtAudio :: getDefaultInputDevice(void)
+int RtApiAl :: getDefaultInputDevice(void)
 {
   ALvalue value;
+  long *id;
   int result = alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, &value, 1, 0, 0);
   if (result < 0) {
-    sprintf(message, "RtAudio: AL error getting default input device id: %s.",
+    sprintf(message_, "RtApiAl: error getting default input device id: %s.",
             alGetErrorString(oserror()));
     error(RtError::WARNING);
   }
   else {
-    for ( int i=0; i<nDevices; i++ )
-      if ( devices[i].id[1] == value.i ) return i;
+    for ( unsigned int i=0; i<devices_.size(); i++ ) {
+      id = (long *) devices_[i].apiDeviceId;
+      if ( id[1] == value.i ) return i;
+    }
   }
 
   return 0;
 }
 
-int RtAudio :: getDefaultOutputDevice(void)
+int RtApiAl :: getDefaultOutputDevice(void)
 {
   ALvalue value;
+  long *id;
   int result = alQueryValues(AL_SYSTEM, AL_DEFAULT_OUTPUT, &value, 1, 0, 0);
   if (result < 0) {
-    sprintf(message, "RtAudio: AL error getting default output device id: %s.",
+    sprintf(message_, "RtApiAl: error getting default output device id: %s.",
             alGetErrorString(oserror()));
     error(RtError::WARNING);
   }
   else {
-    for ( int i=0; i<nDevices; i++ )
-      if ( devices[i].id[0] == value.i ) return i;
+    for ( unsigned int i=0; i<devices_.size(); i++ ) {
+      id = (long *) devices_[i].apiDeviceId;
+      if ( id[0] == value.i ) return i;
+    }
   }
 
   return 0;
 }
 
-void RtAudio :: probeDeviceInfo(RTAUDIO_DEVICE *info)
+void RtApiAl :: probeDeviceInfo(RtApiDevice *info)
 {
-  int resource, result, i;
+  int result;
+  long resource;
   ALvalue value;
   ALparamInfo pinfo;
 
   // Get output resource ID if it exists.
-  resource = info->id[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<MAX_SAMPLE_RATES; i++) {
-        if ( SAMPLE_RATES[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<MAX_SAMPLE_RATES; k++) {
+        if ( SAMPLE_RATES[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<MAX_SAMPLE_RATES; i++) {
-        if ( SAMPLE_RATES[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<MAX_SAMPLE_RATES; k++) {
+        if ( SAMPLE_RATES[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);
+  verifyStream();
+  if (stream_.state == STREAM_STOPPED) return;
 
-  MUTEX_LOCK(&stream->mutex);
+  // Change the state before the lock to improve shutdown response
+  // when using a callback.
+  stream_.state = STREAM_STOPPED;
+  MUTEX_LOCK(&stream_.mutex);
 
-  if (stream->state == STREAM_STOPPED)
-    goto unlock;
-
-  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);
+  verifyStream();
+  if (stream_.state == STREAM_STOPPED) return;
 
-  MUTEX_LOCK(&stream->mutex);
+  // Change the state before the lock to improve shutdown response
+  // when using a callback.
+  stream_.state = STREAM_STOPPED;
+  MUTEX_LOCK(&stream_.mutex);
 
-  if (stream->state == STREAM_STOPPED)
-    goto unlock;
+  ALport *handle = (ALport *) stream_.apiHandle;
+  if (stream_.mode == OUTPUT || stream_.mode == DUPLEX) {
 
-  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(streamId);
+  if (stream_.callbackInfo.usingCallback && stopStream)
+    this->stopStream();
+}
+
+void RtApiAl :: setStreamCallback(RtAudioCallback callback, void *userData)
+{
+  verifyStream();
+
+  CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
+  if ( info->usingCallback ) {
+    sprintf(message_, "RtApiAl: A callback is already set for this stream!");
+    error(RtError::WARNING);
+    return;
+  }
+
+  info->callback = (void *) callback;
+  info->userData = userData;
+  info->usingCallback = true;
+  info->object = (void *) this;
+
+  // Set the thread attributes for joinable and realtime scheduling
+  // priority.  The higher priority will only take affect if the
+  // program is run as root or suid.
+  pthread_attr_t attr;
+  pthread_attr_init(&attr);
+  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+  pthread_attr_setschedpolicy(&attr, SCHED_RR);
+
+  int err = pthread_create(&info->thread, &attr, callbackHandler, &stream_.callbackInfo);
+  pthread_attr_destroy(&attr);
+  if (err) {
+    info->usingCallback = false;
+    sprintf(message_, "RtApiAl: error starting callback thread!");
+    error(RtError::THREAD_ERROR);
+  }
+}
+
+void RtApiAl :: cancelStreamCallback()
+{
+  verifyStream();
+
+  if (stream_.callbackInfo.usingCallback) {
+
+    if (stream_.state == STREAM_RUNNING)
+      stopStream();
+
+    MUTEX_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; i<MAX_SAMPLE_RATES; i++)
-    info->sampleRates[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<int> offset_in(channels);
   std::vector<int> offset_out(channels);
-  if (mode == INPUT && stream->deInterleave[1]) {
+  if (mode == INPUT && stream_.deInterleave[1]) {
     for (int k=0; k<channels; k++) {
-      offset_in[k] = k * stream->bufferSize;
+      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; k<channels; k++) {
       offset_in[k] = k;
-      offset_out[k] = k * stream->bufferSize;
+      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; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT64) in[offset_in[j]];
+          out[offset_out[j]] = (Float64) in[offset_in[j]];
           out[offset_out[j]] *= scale;
         }
         in += jump_in;
@@ -6601,11 +7741,11 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT16) {
-      INT16 *in = (INT16 *)input;
+      Int16 *in = (Int16 *)input;
       scale = 1.0 / 32768.0;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT64) in[offset_in[j]];
+          out[offset_out[j]] = (Float64) in[offset_in[j]];
           out[offset_out[j]] *= scale;
         }
         in += jump_in;
@@ -6613,11 +7753,11 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT24) {
-      INT32 *in = (INT32 *)input;
+      Int32 *in = (Int32 *)input;
       scale = 1.0 / 2147483648.0;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT64) (in[offset_in[j]] & 0xffffff00);
+          out[offset_out[j]] = (Float64) (in[offset_in[j]] & 0xffffff00);
           out[offset_out[j]] *= scale;
         }
         in += jump_in;
@@ -6625,11 +7765,11 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT32) {
-      INT32 *in = (INT32 *)input;
+      Int32 *in = (Int32 *)input;
       scale = 1.0 / 2147483648.0;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT64) in[offset_in[j]];
+          out[offset_out[j]] = (Float64) in[offset_in[j]];
           out[offset_out[j]] *= scale;
         }
         in += jump_in;
@@ -6637,10 +7777,10 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_FLOAT32) {
-      FLOAT32 *in = (FLOAT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float32 *in = (Float32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT64) in[offset_in[j]];
+          out[offset_out[j]] = (Float64) in[offset_in[j]];
         }
         in += jump_in;
         out += jump_out;
@@ -6648,8 +7788,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
     else if (format_in == RTAUDIO_FLOAT64) {
       // Channel compensation and/or (de)interleaving only.
-      FLOAT64 *in = (FLOAT64 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float64 *in = (Float64 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = in[offset_in[j]];
         }
@@ -6659,15 +7799,15 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
   }
   else if (format_out == RTAUDIO_FLOAT32) {
-    FLOAT32 scale;
-    FLOAT32 *out = (FLOAT32 *)output;
+    Float32 scale;
+    Float32 *out = (Float32 *)output;
 
     if (format_in == RTAUDIO_SINT8) {
       signed char *in = (signed char *)input;
       scale = 1.0 / 128.0;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT32) in[offset_in[j]];
+          out[offset_out[j]] = (Float32) in[offset_in[j]];
           out[offset_out[j]] *= scale;
         }
         in += jump_in;
@@ -6675,11 +7815,11 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT16) {
-      INT16 *in = (INT16 *)input;
+      Int16 *in = (Int16 *)input;
       scale = 1.0 / 32768.0;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT32) in[offset_in[j]];
+          out[offset_out[j]] = (Float32) in[offset_in[j]];
           out[offset_out[j]] *= scale;
         }
         in += jump_in;
@@ -6687,11 +7827,11 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT24) {
-      INT32 *in = (INT32 *)input;
+      Int32 *in = (Int32 *)input;
       scale = 1.0 / 2147483648.0;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT32) (in[offset_in[j]] & 0xffffff00);
+          out[offset_out[j]] = (Float32) (in[offset_in[j]] & 0xffffff00);
           out[offset_out[j]] *= scale;
         }
         in += jump_in;
@@ -6699,11 +7839,11 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT32) {
-      INT32 *in = (INT32 *)input;
+      Int32 *in = (Int32 *)input;
       scale = 1.0 / 2147483648.0;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT32) in[offset_in[j]];
+          out[offset_out[j]] = (Float32) in[offset_in[j]];
           out[offset_out[j]] *= scale;
         }
         in += jump_in;
@@ -6712,8 +7852,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
     else if (format_in == RTAUDIO_FLOAT32) {
       // Channel compensation and/or (de)interleaving only.
-      FLOAT32 *in = (FLOAT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float32 *in = (Float32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = in[offset_in[j]];
         }
@@ -6722,10 +7862,10 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_FLOAT64) {
-      FLOAT64 *in = (FLOAT64 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float64 *in = (Float64 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (FLOAT32) in[offset_in[j]];
+          out[offset_out[j]] = (Float32) in[offset_in[j]];
         }
         in += jump_in;
         out += jump_out;
@@ -6733,12 +7873,12 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
   }
   else if (format_out == RTAUDIO_SINT32) {
-    INT32 *out = (INT32 *)output;
+    Int32 *out = (Int32 *)output;
     if (format_in == RTAUDIO_SINT8) {
       signed char *in = (signed char *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) in[offset_in[j]];
+          out[offset_out[j]] = (Int32) in[offset_in[j]];
           out[offset_out[j]] <<= 24;
         }
         in += jump_in;
@@ -6746,10 +7886,10 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT16) {
-      INT16 *in = (INT16 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int16 *in = (Int16 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) in[offset_in[j]];
+          out[offset_out[j]] = (Int32) in[offset_in[j]];
           out[offset_out[j]] <<= 16;
         }
         in += jump_in;
@@ -6757,10 +7897,10 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT24) {
-      INT32 *in = (INT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int32 *in = (Int32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) in[offset_in[j]];
+          out[offset_out[j]] = (Int32) in[offset_in[j]];
         }
         in += jump_in;
         out += jump_out;
@@ -6768,8 +7908,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
     else if (format_in == RTAUDIO_SINT32) {
       // Channel compensation and/or (de)interleaving only.
-      INT32 *in = (INT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int32 *in = (Int32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = in[offset_in[j]];
         }
@@ -6778,20 +7918,20 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_FLOAT32) {
-      FLOAT32 *in = (FLOAT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float32 *in = (Float32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) (in[offset_in[j]] * 2147483647.0);
+          out[offset_out[j]] = (Int32) (in[offset_in[j]] * 2147483647.0);
         }
         in += jump_in;
         out += jump_out;
       }
     }
     else if (format_in == RTAUDIO_FLOAT64) {
-      FLOAT64 *in = (FLOAT64 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float64 *in = (Float64 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) (in[offset_in[j]] * 2147483647.0);
+          out[offset_out[j]] = (Int32) (in[offset_in[j]] * 2147483647.0);
         }
         in += jump_in;
         out += jump_out;
@@ -6799,12 +7939,12 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
   }
   else if (format_out == RTAUDIO_SINT24) {
-    INT32 *out = (INT32 *)output;
+    Int32 *out = (Int32 *)output;
     if (format_in == RTAUDIO_SINT8) {
       signed char *in = (signed char *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) in[offset_in[j]];
+          out[offset_out[j]] = (Int32) in[offset_in[j]];
           out[offset_out[j]] <<= 24;
         }
         in += jump_in;
@@ -6812,10 +7952,10 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT16) {
-      INT16 *in = (INT16 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int16 *in = (Int16 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) in[offset_in[j]];
+          out[offset_out[j]] = (Int32) in[offset_in[j]];
           out[offset_out[j]] <<= 16;
         }
         in += jump_in;
@@ -6824,8 +7964,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
     else if (format_in == RTAUDIO_SINT24) {
       // Channel compensation and/or (de)interleaving only.
-      INT32 *in = (INT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int32 *in = (Int32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = in[offset_in[j]];
         }
@@ -6834,30 +7974,30 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT32) {
-      INT32 *in = (INT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int32 *in = (Int32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) (in[offset_in[j]] & 0xffffff00);
+          out[offset_out[j]] = (Int32) (in[offset_in[j]] & 0xffffff00);
         }
         in += jump_in;
         out += jump_out;
       }
     }
     else if (format_in == RTAUDIO_FLOAT32) {
-      FLOAT32 *in = (FLOAT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float32 *in = (Float32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) (in[offset_in[j]] * 2147483647.0);
+          out[offset_out[j]] = (Int32) (in[offset_in[j]] * 2147483647.0);
         }
         in += jump_in;
         out += jump_out;
       }
     }
     else if (format_in == RTAUDIO_FLOAT64) {
-      FLOAT64 *in = (FLOAT64 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float64 *in = (Float64 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT32) (in[offset_in[j]] * 2147483647.0);
+          out[offset_out[j]] = (Int32) (in[offset_in[j]] * 2147483647.0);
         }
         in += jump_in;
         out += jump_out;
@@ -6865,12 +8005,12 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
   }
   else if (format_out == RTAUDIO_SINT16) {
-    INT16 *out = (INT16 *)output;
+    Int16 *out = (Int16 *)output;
     if (format_in == RTAUDIO_SINT8) {
       signed char *in = (signed char *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT16) in[offset_in[j]];
+          out[offset_out[j]] = (Int16) in[offset_in[j]];
           out[offset_out[j]] <<= 8;
         }
         in += jump_in;
@@ -6879,8 +8019,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     }
     else if (format_in == RTAUDIO_SINT16) {
       // Channel compensation and/or (de)interleaving only.
-      INT16 *in = (INT16 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int16 *in = (Int16 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = in[offset_in[j]];
         }
@@ -6889,40 +8029,40 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_SINT24) {
-      INT32 *in = (INT32 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int32 *in = (Int32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT16) ((in[offset_in[j]] >> 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; i<stream->bufferSize; i++) {
+      Int32 *in = (Int32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT16) ((in[offset_in[j]] >> 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; i<stream->bufferSize; i++) {
+      Float32 *in = (Float32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT16) (in[offset_in[j]] * 32767.0);
+          out[offset_out[j]] = (Int16) (in[offset_in[j]] * 32767.0);
         }
         in += jump_in;
         out += jump_out;
       }
     }
     else if (format_in == RTAUDIO_FLOAT64) {
-      FLOAT64 *in = (FLOAT64 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float64 *in = (Float64 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
-          out[offset_out[j]] = (INT16) (in[offset_in[j]] * 32767.0);
+          out[offset_out[j]] = (Int16) (in[offset_in[j]] * 32767.0);
         }
         in += jump_in;
         out += jump_out;
@@ -6934,7 +8074,7 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
     if (format_in == RTAUDIO_SINT8) {
       // Channel compensation and/or (de)interleaving only.
       signed char *in = (signed char *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = in[offset_in[j]];
         }
@@ -6943,8 +8083,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     if (format_in == RTAUDIO_SINT16) {
-      INT16 *in = (INT16 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Int16 *in = (Int16 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = (signed char) ((in[offset_in[j]] >> 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; i<stream->bufferSize; i++) {
+      Int32 *in = (Int32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = (signed char) ((in[offset_in[j]] >> 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; i<stream->bufferSize; i++) {
+      Int32 *in = (Int32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = (signed char) ((in[offset_in[j]] >> 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; i<stream->bufferSize; i++) {
+      Float32 *in = (Float32 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = (signed char) (in[offset_in[j]] * 127.0);
         }
@@ -6983,8 +8123,8 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
       }
     }
     else if (format_in == RTAUDIO_FLOAT64) {
-      FLOAT64 *in = (FLOAT64 *)input;
-      for (int i=0; i<stream->bufferSize; i++) {
+      Float64 *in = (Float64 *)input;
+      for (int i=0; i<stream_.bufferSize; i++) {
         for (j=0; j<channels; j++) {
           out[offset_out[j]] = (signed char) (in[offset_in[j]] * 127.0);
         }
@@ -6995,7 +8135,7 @@ void RtAudio :: convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode)
   }
 }
 
-void RtAudio :: byteSwapBuffer(char *buffer, int samples, RTAUDIO_FORMAT format)
+void RtApi :: byteSwapBuffer( char *buffer, int samples, RtAudioFormat format )
 {
   register char val;
   register char *ptr;
@@ -7061,25 +8201,3 @@ void RtAudio :: byteSwapBuffer(char *buffer, int samples, RTAUDIO_FORMAT format)
     }
   }
 }
-
-
-// *************************************************** //
-//
-// RtError class definition.
-//
-// *************************************************** //
-
-RtError :: RtError(const char *p, TYPE tipe)
-{
-  type = tipe;
-  strncpy(error_message, p, 256);
-}
-
-RtError :: ~RtError()
-{
-}
-
-void RtError :: printMessage()
-{
-  printf("\n%s\n\n", error_message);
-}