RtAudio.cpp

   1 /************************************************************************/
   2 /*! \class RtAudio
   3     \brief Realtime audio i/o C++ classes.
   4
   5     RtAudio provides a common API (Application Programming Interface)
   6     for realtime audio input/output across Linux (native ALSA, Jack,
   7     and OSS), Macintosh OS X (CoreAudio and Jack), and Windows
   8     (DirectSound, ASIO and WASAPI) operating systems.
   9
  10     RtAudio WWW site: http://www.music.mcgill.ca/~gary/rtaudio/
  11
  12     RtAudio: realtime audio i/o C++ classes
  13     Copyright (c) 2001-2017 Gary P. Scavone
  14
  15     Permission is hereby granted, free of charge, to any person
  16     obtaining a copy of this software and associated documentation files
  17     (the "Software"), to deal in the Software without restriction,
  18     including without limitation the rights to use, copy, modify, merge,
  19     publish, distribute, sublicense, and/or sell copies of the Software,
  20     and to permit persons to whom the Software is furnished to do so,
  21     subject to the following conditions:
  22
  23     The above copyright notice and this permission notice shall be
  24     included in all copies or substantial portions of the Software.
  25
  26     Any person wishing to distribute modifications to the Software is
  27     asked to send the modifications to the original developer so that
  28     they can be incorporated into the canonical version.  This is,
  29     however, not a binding provision of this license.
  30
  31     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  34     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  35     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  36     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38 */
  39 /************************************************************************/
  40
  41 // RtAudio: Version 5.0.0
  42
  43 #include "RtAudio.h"
  44 #include <iostream>
  45 #include <cstdlib>
  46 #include <cstring>
  47 #include <climits>
  48 #include <cmath>
  49 #include <algorithm>
  50
  51 // Static variable definitions.
  52 const unsigned int RtApi::MAX_SAMPLE_RATES = 14;
  53 const unsigned int RtApi::SAMPLE_RATES[] = {
  54   4000, 5512, 8000, 9600, 11025, 16000, 22050,
  55   32000, 44100, 48000, 88200, 96000, 176400, 192000
  56 };
  57
  58 #if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_WASAPI__)
  59   #define MUTEX_INITIALIZE(A) InitializeCriticalSection(A)
  60   #define MUTEX_DESTROY(A)    DeleteCriticalSection(A)
  61   #define MUTEX_LOCK(A)       EnterCriticalSection(A)
  62   #define MUTEX_UNLOCK(A)     LeaveCriticalSection(A)
  63
  64   #include "tchar.h"
  65
  66   static std::string convertCharPointerToStdString(const char *text)
  67   {
  68     return std::string(text);
  69   }
  70
  71   static std::string convertCharPointerToStdString(const wchar_t *text)
  72   {
  73     int length = WideCharToMultiByte(CP_UTF8, 0, text, -1, NULL, 0, NULL, NULL);
  74     std::string s( length-1, '\0' );
  75     WideCharToMultiByte(CP_UTF8, 0, text, -1, &s[0], length, NULL, NULL);
  76     return s;
  77   }
  78
  79 #elif defined(__LINUX_ALSA__) || defined(__LINUX_PULSE__) || defined(__UNIX_JACK__) || defined(__LINUX_OSS__) || defined(__MACOSX_CORE__)
  80   // pthread API
  81   #define MUTEX_INITIALIZE(A) pthread_mutex_init(A, NULL)
  82   #define MUTEX_DESTROY(A)    pthread_mutex_destroy(A)
  83   #define MUTEX_LOCK(A)       pthread_mutex_lock(A)
  84   #define MUTEX_UNLOCK(A)     pthread_mutex_unlock(A)
  85 #else
  86   #define MUTEX_INITIALIZE(A) abs(*A) // dummy definitions
  87   #define MUTEX_DESTROY(A)    abs(*A) // dummy definitions
  88 #endif
  89
  90 // *************************************************** //
  91 //
  92 // RtAudio definitions.
  93 //
  94 // *************************************************** //
  95
  96 std::string RtAudio :: getVersion( void )
  97 {
  98   return RTAUDIO_VERSION;
  99 }
 100
 101 // Define API names and display names.
 102 // Must be in same order as API enum.
 103 extern "C" {
 104 const char* rtaudio_api_names[][2] = {
 105   { "unspecified" , "Unknown" },
 106   { "alsa"        , "ALSA" },
 107   { "pulse"       , "Pulse" },
 108   { "oss"         , "OpenSoundSystem" },
 109   { "jack"        , "Jack" },
 110   { "core"        , "CoreAudio" },
 111   { "wasapi"      , "WASAPI" },
 112   { "asio"        , "ASIO" },
 113   { "ds"          , "DirectSound" },
 114   { "dummy"       , "Dummy" },
 115 };
 116 const unsigned int rtaudio_num_api_names =
 117   sizeof(rtaudio_api_names)/sizeof(rtaudio_api_names[0]);
 118
 119 // The order here will control the order of RtAudio's API search in
 120 // the constructor.
 121 extern "C" const RtAudio::Api rtaudio_compiled_apis[] = {
 122 #if defined(__UNIX_JACK__)
 123   RtAudio::UNIX_JACK,
 124 #endif
 125 #if defined(__LINUX_PULSE__)
 126   RtAudio::LINUX_PULSE,
 127 #endif
 128 #if defined(__LINUX_ALSA__)
 129   RtAudio::LINUX_ALSA,
 130 #endif
 131 #if defined(__LINUX_OSS__)
 132   RtAudio::LINUX_OSS,
 133 #endif
 134 #if defined(__WINDOWS_ASIO__)
 135   RtAudio::WINDOWS_ASIO,
 136 #endif
 137 #if defined(__WINDOWS_WASAPI__)
 138   RtAudio::WINDOWS_WASAPI,
 139 #endif
 140 #if defined(__WINDOWS_DS__)
 141   RtAudio::WINDOWS_DS,
 142 #endif
 143 #if defined(__MACOSX_CORE__)
 144   RtAudio::MACOSX_CORE,
 145 #endif
 146 #if defined(__RTAUDIO_DUMMY__)
 147   RtAudio::RTAUDIO_DUMMY,
 148 #endif
 149   RtAudio::UNSPECIFIED,
 150 };
 151 extern "C" const unsigned int rtaudio_num_compiled_apis =
 152   sizeof(rtaudio_compiled_apis)/sizeof(rtaudio_compiled_apis[0])-1;
 153 }
 154
 155 // This is a compile-time check that rtaudio_num_api_names == RtAudio::NUM_APIS.
 156 // If the build breaks here, check that they match.
 157 template<bool b> class StaticAssert { private: StaticAssert() {} };
 158 template<> class StaticAssert<true>{ public: StaticAssert() {} };
 159 class StaticAssertions { StaticAssertions() {
 160   StaticAssert<rtaudio_num_api_names == RtAudio::NUM_APIS>();
 161 }};
 162
 163 void RtAudio :: getCompiledApi( std::vector<RtAudio::Api> &apis )
 164 {
 165   apis = std::vector<RtAudio::Api>(rtaudio_compiled_apis,
 166                                    rtaudio_compiled_apis + rtaudio_num_compiled_apis);
 167 }
 168
 169 std::string RtAudio :: getApiName( RtAudio::Api api )
 170 {
 171   if (api < 0 || api >= RtAudio::NUM_APIS)
 172     return "";
 173   return rtaudio_api_names[api][0];
 174 }
 175
 176 std::string RtAudio :: getApiDisplayName( RtAudio::Api api )
 177 {
 178   if (api < 0 || api >= RtAudio::NUM_APIS)
 179     return "Unknown";
 180   return rtaudio_api_names[api][1];
 181 }
 182
 183 RtAudio::Api RtAudio :: getCompiledApiByName( const std::string &name )
 184 {
 185   unsigned int i=0;
 186   for (i = 0; i < rtaudio_num_compiled_apis; ++i)
 187     if (name == rtaudio_api_names[rtaudio_compiled_apis[i]][0])
 188       return rtaudio_compiled_apis[i];
 189   return RtAudio::UNSPECIFIED;
 190 }
 191
 192 void RtAudio :: openRtApi( RtAudio::Api api )
 193 {
 194   if ( rtapi_ )
 195     delete rtapi_;
 196   rtapi_ = 0;
 197
 198 #if defined(__UNIX_JACK__)
 199   if ( api == UNIX_JACK )
 200     rtapi_ = new RtApiJack();
 201 #endif
 202 #if defined(__LINUX_ALSA__)
 203   if ( api == LINUX_ALSA )
 204     rtapi_ = new RtApiAlsa();
 205 #endif
 206 #if defined(__LINUX_PULSE__)
 207   if ( api == LINUX_PULSE )
 208     rtapi_ = new RtApiPulse();
 209 #endif
 210 #if defined(__LINUX_OSS__)
 211   if ( api == LINUX_OSS )
 212     rtapi_ = new RtApiOss();
 213 #endif
 214 #if defined(__WINDOWS_ASIO__)
 215   if ( api == WINDOWS_ASIO )
 216     rtapi_ = new RtApiAsio();
 217 #endif
 218 #if defined(__WINDOWS_WASAPI__)
 219   if ( api == WINDOWS_WASAPI )
 220     rtapi_ = new RtApiWasapi();
 221 #endif
 222 #if defined(__WINDOWS_DS__)
 223   if ( api == WINDOWS_DS )
 224     rtapi_ = new RtApiDs();
 225 #endif
 226 #if defined(__MACOSX_CORE__)
 227   if ( api == MACOSX_CORE )
 228     rtapi_ = new RtApiCore();
 229 #endif
 230 #if defined(__RTAUDIO_DUMMY__)
 231   if ( api == RTAUDIO_DUMMY )
 232     rtapi_ = new RtApiDummy();
 233 #endif
 234 }
 235
 236 RtAudio :: RtAudio( RtAudio::Api api )
 237 {
 238   rtapi_ = 0;
 239
 240   if ( api != UNSPECIFIED ) {
 241     // Attempt to open the specified API.
 242     openRtApi( api );
 243     if ( rtapi_ ) return;
 244
 245     // No compiled support for specified API value.  Issue a debug
 246     // warning and continue as if no API was specified.
 247     std::cerr << "\nRtAudio: no compiled support for specified API argument!\n" << std::endl;
 248   }
 249
 250   // Iterate through the compiled APIs and return as soon as we find
 251   // one with at least one device or we reach the end of the list.
 252   std::vector< RtAudio::Api > apis;
 253   getCompiledApi( apis );
 254   for ( unsigned int i=0; i<apis.size(); i++ ) {
 255     openRtApi( apis[i] );
 256     if ( rtapi_ && rtapi_->getDeviceCount() ) break;
 257   }
 258
 259   if ( rtapi_ ) return;
 260
 261   // It should not be possible to get here because the preprocessor
 262   // definition __RTAUDIO_DUMMY__ is automatically defined if no
 263   // API-specific definitions are passed to the compiler. But just in
 264   // case something weird happens, we'll thow an error.
 265   std::string errorText = "\nRtAudio: no compiled API support found ... critical error!!\n\n";
 266   throw( RtAudioError( errorText, RtAudioError::UNSPECIFIED ) );
 267 }
 268
 269 RtAudio :: ~RtAudio()
 270 {
 271   if ( rtapi_ )
 272     delete rtapi_;
 273 }
 274
 275 void RtAudio :: openStream( RtAudio::StreamParameters *outputParameters,
 276                             RtAudio::StreamParameters *inputParameters,
 277                             RtAudioFormat format, unsigned int sampleRate,
 278                             unsigned int *bufferFrames,
 279                             RtAudioCallback callback, void *userData,
 280                             RtAudio::StreamOptions *options,
 281                             RtAudioErrorCallback errorCallback )
 282 {
 283   return rtapi_->openStream( outputParameters, inputParameters, format,
 284                              sampleRate, bufferFrames, callback,
 285                              userData, options, errorCallback );
 286 }
 287
 288 // *************************************************** //
 289 //
 290 // Public RtApi definitions (see end of file for
 291 // private or protected utility functions).
 292 //
 293 // *************************************************** //
 294
 295 RtApi :: RtApi()
 296 {
 297   stream_.state = STREAM_CLOSED;
 298   stream_.mode = UNINITIALIZED;
 299   stream_.apiHandle = 0;
 300   stream_.userBuffer[0] = 0;
 301   stream_.userBuffer[1] = 0;
 302   MUTEX_INITIALIZE( &stream_.mutex );
 303   showWarnings_ = true;
 304   firstErrorOccurred_ = false;
 305 }
 306
 307 RtApi :: ~RtApi()
 308 {
 309   MUTEX_DESTROY( &stream_.mutex );
 310 }
 311
 312 void RtApi :: openStream( RtAudio::StreamParameters *oParams,
 313                           RtAudio::StreamParameters *iParams,
 314                           RtAudioFormat format, unsigned int sampleRate,
 315                           unsigned int *bufferFrames,
 316                           RtAudioCallback callback, void *userData,
 317                           RtAudio::StreamOptions *options,
 318                           RtAudioErrorCallback errorCallback )
 319 {
 320   if ( stream_.state != STREAM_CLOSED ) {
 321     errorText_ = "RtApi::openStream: a stream is already open!";
 322     error( RtAudioError::INVALID_USE );
 323     return;
 324   }
 325
 326   // Clear stream information potentially left from a previously open stream.
 327   clearStreamInfo();
 328
 329   if ( oParams && oParams->nChannels < 1 ) {
 330     errorText_ = "RtApi::openStream: a non-NULL output StreamParameters structure cannot have an nChannels value less than one.";
 331     error( RtAudioError::INVALID_USE );
 332     return;
 333   }
 334
 335   if ( iParams && iParams->nChannels < 1 ) {
 336     errorText_ = "RtApi::openStream: a non-NULL input StreamParameters structure cannot have an nChannels value less than one.";
 337     error( RtAudioError::INVALID_USE );
 338     return;
 339   }
 340
 341   if ( oParams == NULL && iParams == NULL ) {
 342     errorText_ = "RtApi::openStream: input and output StreamParameters structures are both NULL!";
 343     error( RtAudioError::INVALID_USE );
 344     return;
 345   }
 346
 347   if ( formatBytes(format) == 0 ) {
 348     errorText_ = "RtApi::openStream: 'format' parameter value is undefined.";
 349     error( RtAudioError::INVALID_USE );
 350     return;
 351   }
 352
 353   unsigned int nDevices = getDeviceCount();
 354   unsigned int oChannels = 0;
 355   if ( oParams ) {
 356     oChannels = oParams->nChannels;
 357     if ( oParams->deviceId >= nDevices ) {
 358       errorText_ = "RtApi::openStream: output device parameter value is invalid.";
 359       error( RtAudioError::INVALID_USE );
 360       return;
 361     }
 362   }
 363
 364   unsigned int iChannels = 0;
 365   if ( iParams ) {
 366     iChannels = iParams->nChannels;
 367     if ( iParams->deviceId >= nDevices ) {
 368       errorText_ = "RtApi::openStream: input device parameter value is invalid.";
 369       error( RtAudioError::INVALID_USE );
 370       return;
 371     }
 372   }
 373
 374   bool result;
 375
 376   if ( oChannels > 0 ) {
 377
 378     result = probeDeviceOpen( oParams->deviceId, OUTPUT, oChannels, oParams->firstChannel,
 379                               sampleRate, format, bufferFrames, options );
 380     if ( result == false ) {
 381       error( RtAudioError::SYSTEM_ERROR );
 382       return;
 383     }
 384   }
 385
 386   if ( iChannels > 0 ) {
 387
 388     result = probeDeviceOpen( iParams->deviceId, INPUT, iChannels, iParams->firstChannel,
 389                               sampleRate, format, bufferFrames, options );
 390     if ( result == false ) {
 391       if ( oChannels > 0 ) closeStream();
 392       error( RtAudioError::SYSTEM_ERROR );
 393       return;
 394     }
 395   }
 396
 397   stream_.callbackInfo.callback = (void *) callback;
 398   stream_.callbackInfo.userData = userData;
 399   stream_.callbackInfo.errorCallback = (void *) errorCallback;
 400
 401   if ( options ) options->numberOfBuffers = stream_.nBuffers;
 402   stream_.state = STREAM_STOPPED;
 403 }
 404
 405 unsigned int RtApi :: getDefaultInputDevice( void )
 406 {
 407   // Should be implemented in subclasses if possible.
 408   return 0;
 409 }
 410
 411 unsigned int RtApi :: getDefaultOutputDevice( void )
 412 {
 413   // Should be implemented in subclasses if possible.
 414   return 0;
 415 }
 416
 417 void RtApi :: closeStream( void )
 418 {
 419   // MUST be implemented in subclasses!
 420   return;
 421 }
 422
 423 bool RtApi :: probeDeviceOpen( unsigned int /*device*/, StreamMode /*mode*/, unsigned int /*channels*/,
 424                                unsigned int /*firstChannel*/, unsigned int /*sampleRate*/,
 425                                RtAudioFormat /*format*/, unsigned int * /*bufferSize*/,
 426                                RtAudio::StreamOptions * /*options*/ )
 427 {
 428   // MUST be implemented in subclasses!
 429   return FAILURE;
 430 }
 431
 432 void RtApi :: tickStreamTime( void )
 433 {
 434   // Subclasses that do not provide their own implementation of
 435   // getStreamTime should call this function once per buffer I/O to
 436   // provide basic stream time support.
 437
 438   stream_.streamTime += ( stream_.bufferSize * 1.0 / stream_.sampleRate );
 439
 440 #if defined( HAVE_GETTIMEOFDAY )
 441   gettimeofday( &stream_.lastTickTimestamp, NULL );
 442 #endif
 443 }
 444
 445 long RtApi :: getStreamLatency( void )
 446 {
 447   verifyStream();
 448
 449   long totalLatency = 0;
 450   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX )
 451     totalLatency = stream_.latency[0];
 452   if ( stream_.mode == INPUT || stream_.mode == DUPLEX )
 453     totalLatency += stream_.latency[1];
 454
 455   return totalLatency;
 456 }
 457
 458 double RtApi :: getStreamTime( void )
 459 {
 460   verifyStream();
 461
 462 #if defined( HAVE_GETTIMEOFDAY )
 463   // Return a very accurate estimate of the stream time by
 464   // adding in the elapsed time since the last tick.
 465   struct timeval then;
 466   struct timeval now;
 467
 468   if ( stream_.state != STREAM_RUNNING || stream_.streamTime == 0.0 )
 469     return stream_.streamTime;
 470
 471   gettimeofday( &now, NULL );
 472   then = stream_.lastTickTimestamp;
 473   return stream_.streamTime +
 474     ((now.tv_sec + 0.000001 * now.tv_usec) -
 475      (then.tv_sec + 0.000001 * then.tv_usec));
 476 #else
 477   return stream_.streamTime;
 478 #endif
 479 }
 480
 481 void RtApi :: setStreamTime( double time )
 482 {
 483   verifyStream();
 484
 485   if ( time >= 0.0 )
 486     stream_.streamTime = time;
 487 #if defined( HAVE_GETTIMEOFDAY )
 488   gettimeofday( &stream_.lastTickTimestamp, NULL );
 489 #endif
 490 }
 491
 492 unsigned int RtApi :: getStreamSampleRate( void )
 493 {
 494  verifyStream();
 495
 496  return stream_.sampleRate;
 497 }
 498
 499
 500 // *************************************************** //
 501 //
 502 // OS/API-specific methods.
 503 //
 504 // *************************************************** //
 505
 506 #if defined(__MACOSX_CORE__)
 507
 508 // The OS X CoreAudio API is designed to use a separate callback
 509 // procedure for each of its audio devices.  A single RtAudio duplex
 510 // stream using two different devices is supported here, though it
 511 // cannot be guaranteed to always behave correctly because we cannot
 512 // synchronize these two callbacks.
 513 //
 514 // A property listener is installed for over/underrun information.
 515 // However, no functionality is currently provided to allow property
 516 // listeners to trigger user handlers because it is unclear what could
 517 // be done if a critical stream parameter (buffer size, sample rate,
 518 // device disconnect) notification arrived.  The listeners entail
 519 // quite a bit of extra code and most likely, a user program wouldn't
 520 // be prepared for the result anyway.  However, we do provide a flag
 521 // to the client callback function to inform of an over/underrun.
 522
 523 // A structure to hold various information related to the CoreAudio API
 524 // implementation.
 525 struct CoreHandle {
 526   AudioDeviceID id[2];    // device ids
 527 #if defined( MAC_OS_X_VERSION_10_5 ) && ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
 528   AudioDeviceIOProcID procId[2];
 529 #endif
 530   UInt32 iStream[2];      // device stream index (or first if using multiple)
 531   UInt32 nStreams[2];     // number of streams to use
 532   bool xrun[2];
 533   char *deviceBuffer;
 534   pthread_cond_t condition;
 535   int drainCounter;       // Tracks callback counts when draining
 536   bool internalDrain;     // Indicates if stop is initiated from callback or not.
 537
 538   CoreHandle()
 539     :deviceBuffer(0), drainCounter(0), internalDrain(false) { nStreams[0] = 1; nStreams[1] = 1; id[0] = 0; id[1] = 0; xrun[0] = false; xrun[1] = false; }
 540 };
 541
 542 RtApiCore:: RtApiCore()
 543 {
 544 #if defined( AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER )
 545   // This is a largely undocumented but absolutely necessary
 546   // requirement starting with OS-X 10.6.  If not called, queries and
 547   // updates to various audio device properties are not handled
 548   // correctly.
 549   CFRunLoopRef theRunLoop = NULL;
 550   AudioObjectPropertyAddress property = { kAudioHardwarePropertyRunLoop,
 551                                           kAudioObjectPropertyScopeGlobal,
 552                                           kAudioObjectPropertyElementMaster };
 553   OSStatus result = AudioObjectSetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);
 554   if ( result != noErr ) {
 555     errorText_ = "RtApiCore::RtApiCore: error setting run loop property!";
 556     error( RtAudioError::WARNING );
 557   }
 558 #endif
 559 }
 560
 561 RtApiCore :: ~RtApiCore()
 562 {
 563   // The subclass destructor gets called before the base class
 564   // destructor, so close an existing stream before deallocating
 565   // apiDeviceId memory.
 566   if ( stream_.state != STREAM_CLOSED ) closeStream();
 567 }
 568
 569 unsigned int RtApiCore :: getDeviceCount( void )
 570 {
 571   // Find out how many audio devices there are, if any.
 572   UInt32 dataSize;
 573   AudioObjectPropertyAddress propertyAddress = { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
 574   OSStatus result = AudioObjectGetPropertyDataSize( kAudioObjectSystemObject, &propertyAddress, 0, NULL, &dataSize );
 575   if ( result != noErr ) {
 576     errorText_ = "RtApiCore::getDeviceCount: OS-X error getting device info!";
 577     error( RtAudioError::WARNING );
 578     return 0;
 579   }
 580
 581   return dataSize / sizeof( AudioDeviceID );
 582 }
 583
 584 unsigned int RtApiCore :: getDefaultInputDevice( void )
 585 {
 586   unsigned int nDevices = getDeviceCount();
 587   if ( nDevices <= 1 ) return 0;
 588
 589   AudioDeviceID id;
 590   UInt32 dataSize = sizeof( AudioDeviceID );
 591   AudioObjectPropertyAddress property = { kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
 592   OSStatus result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, &dataSize, &id );
 593   if ( result != noErr ) {
 594     errorText_ = "RtApiCore::getDefaultInputDevice: OS-X system error getting device.";
 595     error( RtAudioError::WARNING );
 596     return 0;
 597   }
 598
 599   dataSize *= nDevices;
 600   AudioDeviceID deviceList[ nDevices ];
 601   property.mSelector = kAudioHardwarePropertyDevices;
 602   result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, &dataSize, (void *) &deviceList );
 603   if ( result != noErr ) {
 604     errorText_ = "RtApiCore::getDefaultInputDevice: OS-X system error getting device IDs.";
 605     error( RtAudioError::WARNING );
 606     return 0;
 607   }
 608
 609   for ( unsigned int i=0; i<nDevices; i++ )
 610     if ( id == deviceList[i] ) return i;
 611
 612   errorText_ = "RtApiCore::getDefaultInputDevice: No default device found!";
 613   error( RtAudioError::WARNING );
 614   return 0;
 615 }
 616
 617 unsigned int RtApiCore :: getDefaultOutputDevice( void )
 618 {
 619   unsigned int nDevices = getDeviceCount();
 620   if ( nDevices <= 1 ) return 0;
 621
 622   AudioDeviceID id;
 623   UInt32 dataSize = sizeof( AudioDeviceID );
 624   AudioObjectPropertyAddress property = { kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
 625   OSStatus result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, &dataSize, &id );
 626   if ( result != noErr ) {
 627     errorText_ = "RtApiCore::getDefaultOutputDevice: OS-X system error getting device.";
 628     error( RtAudioError::WARNING );
 629     return 0;
 630   }
 631
 632   dataSize = sizeof( AudioDeviceID ) * nDevices;
 633   AudioDeviceID deviceList[ nDevices ];
 634   property.mSelector = kAudioHardwarePropertyDevices;
 635   result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, &dataSize, (void *) &deviceList );
 636   if ( result != noErr ) {
 637     errorText_ = "RtApiCore::getDefaultOutputDevice: OS-X system error getting device IDs.";
 638     error( RtAudioError::WARNING );
 639     return 0;
 640   }
 641
 642   for ( unsigned int i=0; i<nDevices; i++ )
 643     if ( id == deviceList[i] ) return i;
 644
 645   errorText_ = "RtApiCore::getDefaultOutputDevice: No default device found!";
 646   error( RtAudioError::WARNING );
 647   return 0;
 648 }
 649
 650 RtAudio::DeviceInfo RtApiCore :: getDeviceInfo( unsigned int device )
 651 {
 652   RtAudio::DeviceInfo info;
 653   info.probed = false;
 654
 655   // Get device ID
 656   unsigned int nDevices = getDeviceCount();
 657   if ( nDevices == 0 ) {
 658     errorText_ = "RtApiCore::getDeviceInfo: no devices found!";
 659     error( RtAudioError::INVALID_USE );
 660     return info;
 661   }
 662
 663   if ( device >= nDevices ) {
 664     errorText_ = "RtApiCore::getDeviceInfo: device ID is invalid!";
 665     error( RtAudioError::INVALID_USE );
 666     return info;
 667   }
 668
 669   AudioDeviceID deviceList[ nDevices ];
 670   UInt32 dataSize = sizeof( AudioDeviceID ) * nDevices;
 671   AudioObjectPropertyAddress property = { kAudioHardwarePropertyDevices,
 672                                           kAudioObjectPropertyScopeGlobal,
 673                                           kAudioObjectPropertyElementMaster };
 674   OSStatus result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property,
 675                                                 0, NULL, &dataSize, (void *) &deviceList );
 676   if ( result != noErr ) {
 677     errorText_ = "RtApiCore::getDeviceInfo: OS-X system error getting device IDs.";
 678     error( RtAudioError::WARNING );
 679     return info;
 680   }
 681
 682   AudioDeviceID id = deviceList[ device ];
 683
 684   // Get the device name.
 685   info.name.erase();
 686   CFStringRef cfname;
 687   dataSize = sizeof( CFStringRef );
 688   property.mSelector = kAudioObjectPropertyManufacturer;
 689   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &cfname );
 690   if ( result != noErr ) {
 691     errorStream_ << "RtApiCore::probeDeviceInfo: system error (" << getErrorCode( result ) << ") getting device manufacturer.";
 692     errorText_ = errorStream_.str();
 693     error( RtAudioError::WARNING );
 694     return info;
 695   }
 696
 697   //const char *mname = CFStringGetCStringPtr( cfname, CFStringGetSystemEncoding() );
 698   int length = CFStringGetLength(cfname);
 699   char *mname = (char *)malloc(length * 3 + 1);
 700 #if defined( UNICODE ) || defined( _UNICODE )
 701   CFStringGetCString(cfname, mname, length * 3 + 1, kCFStringEncodingUTF8);
 702 #else
 703   CFStringGetCString(cfname, mname, length * 3 + 1, CFStringGetSystemEncoding());
 704 #endif
 705   info.name.append( (const char *)mname, strlen(mname) );
 706   info.name.append( ": " );
 707   CFRelease( cfname );
 708   free(mname);
 709
 710   property.mSelector = kAudioObjectPropertyName;
 711   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &cfname );
 712   if ( result != noErr ) {
 713     errorStream_ << "RtApiCore::probeDeviceInfo: system error (" << getErrorCode( result ) << ") getting device name.";
 714     errorText_ = errorStream_.str();
 715     error( RtAudioError::WARNING );
 716     return info;
 717   }
 718
 719   //const char *name = CFStringGetCStringPtr( cfname, CFStringGetSystemEncoding() );
 720   length = CFStringGetLength(cfname);
 721   char *name = (char *)malloc(length * 3 + 1);
 722 #if defined( UNICODE ) || defined( _UNICODE )
 723   CFStringGetCString(cfname, name, length * 3 + 1, kCFStringEncodingUTF8);
 724 #else
 725   CFStringGetCString(cfname, name, length * 3 + 1, CFStringGetSystemEncoding());
 726 #endif
 727   info.name.append( (const char *)name, strlen(name) );
 728   CFRelease( cfname );
 729   free(name);
 730
 731   // Get the output stream "configuration".
 732   AudioBufferList       *bufferList = nil;
 733   property.mSelector = kAudioDevicePropertyStreamConfiguration;
 734   property.mScope = kAudioDevicePropertyScopeOutput;
 735   //  property.mElement = kAudioObjectPropertyElementWildcard;
 736   dataSize = 0;
 737   result = AudioObjectGetPropertyDataSize( id, &property, 0, NULL, &dataSize );
 738   if ( result != noErr || dataSize == 0 ) {
 739     errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting output stream configuration info for device (" << device << ").";
 740     errorText_ = errorStream_.str();
 741     error( RtAudioError::WARNING );
 742     return info;
 743   }
 744
 745   // Allocate the AudioBufferList.
 746   bufferList = (AudioBufferList *) malloc( dataSize );
 747   if ( bufferList == NULL ) {
 748     errorText_ = "RtApiCore::getDeviceInfo: memory error allocating output AudioBufferList.";
 749     error( RtAudioError::WARNING );
 750     return info;
 751   }
 752
 753   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, bufferList );
 754   if ( result != noErr || dataSize == 0 ) {
 755     free( bufferList );
 756     errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting output stream configuration for device (" << device << ").";
 757     errorText_ = errorStream_.str();
 758     error( RtAudioError::WARNING );
 759     return info;
 760   }
 761
 762   // Get output channel information.
 763   unsigned int i, nStreams = bufferList->mNumberBuffers;
 764   for ( i=0; i<nStreams; i++ )
 765     info.outputChannels += bufferList->mBuffers[i].mNumberChannels;
 766   free( bufferList );
 767
 768   // Get the input stream "configuration".
 769   property.mScope = kAudioDevicePropertyScopeInput;
 770   result = AudioObjectGetPropertyDataSize( id, &property, 0, NULL, &dataSize );
 771   if ( result != noErr || dataSize == 0 ) {
 772     errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting input stream configuration info for device (" << device << ").";
 773     errorText_ = errorStream_.str();
 774     error( RtAudioError::WARNING );
 775     return info;
 776   }
 777
 778   // Allocate the AudioBufferList.
 779   bufferList = (AudioBufferList *) malloc( dataSize );
 780   if ( bufferList == NULL ) {
 781     errorText_ = "RtApiCore::getDeviceInfo: memory error allocating input AudioBufferList.";
 782     error( RtAudioError::WARNING );
 783     return info;
 784   }
 785
 786   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, bufferList );
 787   if (result != noErr || dataSize == 0) {
 788     free( bufferList );
 789     errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting input stream configuration for device (" << device << ").";
 790     errorText_ = errorStream_.str();
 791     error( RtAudioError::WARNING );
 792     return info;
 793   }
 794
 795   // Get input channel information.
 796   nStreams = bufferList->mNumberBuffers;
 797   for ( i=0; i<nStreams; i++ )
 798     info.inputChannels += bufferList->mBuffers[i].mNumberChannels;
 799   free( bufferList );
 800
 801   // If device opens for both playback and capture, we determine the channels.
 802   if ( info.outputChannels > 0 && info.inputChannels > 0 )
 803     info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
 804
 805   // Probe the device sample rates.
 806   bool isInput = false;
 807   if ( info.outputChannels == 0 ) isInput = true;
 808
 809   // Determine the supported sample rates.
 810   property.mSelector = kAudioDevicePropertyAvailableNominalSampleRates;
 811   if ( isInput == false ) property.mScope = kAudioDevicePropertyScopeOutput;
 812   result = AudioObjectGetPropertyDataSize( id, &property, 0, NULL, &dataSize );
 813   if ( result != kAudioHardwareNoError || dataSize == 0 ) {
 814     errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting sample rate info.";
 815     errorText_ = errorStream_.str();
 816     error( RtAudioError::WARNING );
 817     return info;
 818   }
 819
 820   UInt32 nRanges = dataSize / sizeof( AudioValueRange );
 821   AudioValueRange rangeList[ nRanges ];
 822   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &rangeList );
 823   if ( result != kAudioHardwareNoError ) {
 824     errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting sample rates.";
 825     errorText_ = errorStream_.str();
 826     error( RtAudioError::WARNING );
 827     return info;
 828   }
 829
 830   // The sample rate reporting mechanism is a bit of a mystery.  It
 831   // seems that it can either return individual rates or a range of
 832   // rates.  I assume that if the min / max range values are the same,
 833   // then that represents a single supported rate and if the min / max
 834   // range values are different, the device supports an arbitrary
 835   // range of values (though there might be multiple ranges, so we'll
 836   // use the most conservative range).
 837   Float64 minimumRate = 1.0, maximumRate = 10000000000.0;
 838   bool haveValueRange = false;
 839   info.sampleRates.clear();
 840   for ( UInt32 i=0; i<nRanges; i++ ) {
 841     if ( rangeList[i].mMinimum == rangeList[i].mMaximum ) {
 842       unsigned int tmpSr = (unsigned int) rangeList[i].mMinimum;
 843       info.sampleRates.push_back( tmpSr );
 844
 845       if ( !info.preferredSampleRate || ( tmpSr <= 48000 && tmpSr > info.preferredSampleRate ) )
 846         info.preferredSampleRate = tmpSr;
 847
 848     } else {
 849       haveValueRange = true;
 850       if ( rangeList[i].mMinimum > minimumRate ) minimumRate = rangeList[i].mMinimum;
 851       if ( rangeList[i].mMaximum < maximumRate ) maximumRate = rangeList[i].mMaximum;
 852     }
 853   }
 854
 855   if ( haveValueRange ) {
 856     for ( unsigned int k=0; k<MAX_SAMPLE_RATES; k++ ) {
 857       if ( SAMPLE_RATES[k] >= (unsigned int) minimumRate && SAMPLE_RATES[k] <= (unsigned int) maximumRate ) {
 858         info.sampleRates.push_back( SAMPLE_RATES[k] );
 859
 860         if ( !info.preferredSampleRate || ( SAMPLE_RATES[k] <= 48000 && SAMPLE_RATES[k] > info.preferredSampleRate ) )
 861           info.preferredSampleRate = SAMPLE_RATES[k];
 862       }
 863     }
 864   }
 865
 866   // Sort and remove any redundant values
 867   std::sort( info.sampleRates.begin(), info.sampleRates.end() );
 868   info.sampleRates.erase( unique( info.sampleRates.begin(), info.sampleRates.end() ), info.sampleRates.end() );
 869
 870   if ( info.sampleRates.size() == 0 ) {
 871     errorStream_ << "RtApiCore::probeDeviceInfo: No supported sample rates found for device (" << device << ").";
 872     errorText_ = errorStream_.str();
 873     error( RtAudioError::WARNING );
 874     return info;
 875   }
 876
 877   // CoreAudio always uses 32-bit floating point data for PCM streams.
 878   // Thus, any other "physical" formats supported by the device are of
 879   // no interest to the client.
 880   info.nativeFormats = RTAUDIO_FLOAT32;
 881
 882   if ( info.outputChannels > 0 )
 883     if ( getDefaultOutputDevice() == device ) info.isDefaultOutput = true;
 884   if ( info.inputChannels > 0 )
 885     if ( getDefaultInputDevice() == device ) info.isDefaultInput = true;
 886
 887   info.probed = true;
 888   return info;
 889 }
 890
 891 static OSStatus callbackHandler( AudioDeviceID inDevice,
 892                                  const AudioTimeStamp* /*inNow*/,
 893                                  const AudioBufferList* inInputData,
 894                                  const AudioTimeStamp* /*inInputTime*/,
 895                                  AudioBufferList* outOutputData,
 896                                  const AudioTimeStamp* /*inOutputTime*/,
 897                                  void* infoPointer )
 898 {
 899   CallbackInfo *info = (CallbackInfo *) infoPointer;
 900
 901   RtApiCore *object = (RtApiCore *) info->object;
 902   if ( object->callbackEvent( inDevice, inInputData, outOutputData ) == false )
 903     return kAudioHardwareUnspecifiedError;
 904   else
 905     return kAudioHardwareNoError;
 906 }
 907
 908 static OSStatus xrunListener( AudioObjectID /*inDevice*/,
 909                               UInt32 nAddresses,
 910                               const AudioObjectPropertyAddress properties[],
 911                               void* handlePointer )
 912 {
 913   CoreHandle *handle = (CoreHandle *) handlePointer;
 914   for ( UInt32 i=0; i<nAddresses; i++ ) {
 915     if ( properties[i].mSelector == kAudioDeviceProcessorOverload ) {
 916       if ( properties[i].mScope == kAudioDevicePropertyScopeInput )
 917         handle->xrun[1] = true;
 918       else
 919         handle->xrun[0] = true;
 920     }
 921   }
 922
 923   return kAudioHardwareNoError;
 924 }
 925
 926 static OSStatus rateListener( AudioObjectID inDevice,
 927                               UInt32 /*nAddresses*/,
 928                               const AudioObjectPropertyAddress /*properties*/[],
 929                               void* ratePointer )
 930 {
 931   Float64 *rate = (Float64 *) ratePointer;
 932   UInt32 dataSize = sizeof( Float64 );
 933   AudioObjectPropertyAddress property = { kAudioDevicePropertyNominalSampleRate,
 934                                           kAudioObjectPropertyScopeGlobal,
 935                                           kAudioObjectPropertyElementMaster };
 936   AudioObjectGetPropertyData( inDevice, &property, 0, NULL, &dataSize, rate );
 937   return kAudioHardwareNoError;
 938 }
 939
 940 bool RtApiCore :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
 941                                    unsigned int firstChannel, unsigned int sampleRate,
 942                                    RtAudioFormat format, unsigned int *bufferSize,
 943                                    RtAudio::StreamOptions *options )
 944 {
 945   // Get device ID
 946   unsigned int nDevices = getDeviceCount();
 947   if ( nDevices == 0 ) {
 948     // This should not happen because a check is made before this function is called.
 949     errorText_ = "RtApiCore::probeDeviceOpen: no devices found!";
 950     return FAILURE;
 951   }
 952
 953   if ( device >= nDevices ) {
 954     // This should not happen because a check is made before this function is called.
 955     errorText_ = "RtApiCore::probeDeviceOpen: device ID is invalid!";
 956     return FAILURE;
 957   }
 958
 959   AudioDeviceID deviceList[ nDevices ];
 960   UInt32 dataSize = sizeof( AudioDeviceID ) * nDevices;
 961   AudioObjectPropertyAddress property = { kAudioHardwarePropertyDevices,
 962                                           kAudioObjectPropertyScopeGlobal,
 963                                           kAudioObjectPropertyElementMaster };
 964   OSStatus result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property,
 965                                                 0, NULL, &dataSize, (void *) &deviceList );
 966   if ( result != noErr ) {
 967     errorText_ = "RtApiCore::probeDeviceOpen: OS-X system error getting device IDs.";
 968     return FAILURE;
 969   }
 970
 971   AudioDeviceID id = deviceList[ device ];
 972
 973   // Setup for stream mode.
 974   bool isInput = false;
 975   if ( mode == INPUT ) {
 976     isInput = true;
 977     property.mScope = kAudioDevicePropertyScopeInput;
 978   }
 979   else
 980     property.mScope = kAudioDevicePropertyScopeOutput;
 981
 982   // Get the stream "configuration".
 983   AudioBufferList       *bufferList = nil;
 984   dataSize = 0;
 985   property.mSelector = kAudioDevicePropertyStreamConfiguration;
 986   result = AudioObjectGetPropertyDataSize( id, &property, 0, NULL, &dataSize );
 987   if ( result != noErr || dataSize == 0 ) {
 988     errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream configuration info for device (" << device << ").";
 989     errorText_ = errorStream_.str();
 990     return FAILURE;
 991   }
 992
 993   // Allocate the AudioBufferList.
 994   bufferList = (AudioBufferList *) malloc( dataSize );
 995   if ( bufferList == NULL ) {
 996     errorText_ = "RtApiCore::probeDeviceOpen: memory error allocating AudioBufferList.";
 997     return FAILURE;
 998   }
 999
1000   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, bufferList );
1001   if (result != noErr || dataSize == 0) {
1002     free( bufferList );
1003     errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream configuration for device (" << device << ").";
1004     errorText_ = errorStream_.str();
1005     return FAILURE;
1006   }
1007
1008   // Search for one or more streams that contain the desired number of
1009   // channels. CoreAudio devices can have an arbitrary number of
1010   // streams and each stream can have an arbitrary number of channels.
1011   // For each stream, a single buffer of interleaved samples is
1012   // provided.  RtAudio prefers the use of one stream of interleaved
1013   // data or multiple consecutive single-channel streams.  However, we
1014   // now support multiple consecutive multi-channel streams of
1015   // interleaved data as well.
1016   UInt32 iStream, offsetCounter = firstChannel;
1017   UInt32 nStreams = bufferList->mNumberBuffers;
1018   bool monoMode = false;
1019   bool foundStream = false;
1020
1021   // First check that the device supports the requested number of
1022   // channels.
1023   UInt32 deviceChannels = 0;
1024   for ( iStream=0; iStream<nStreams; iStream++ )
1025     deviceChannels += bufferList->mBuffers[iStream].mNumberChannels;
1026
1027   if ( deviceChannels < ( channels + firstChannel ) ) {
1028     free( bufferList );
1029     errorStream_ << "RtApiCore::probeDeviceOpen: the device (" << device << ") does not support the requested channel count.";
1030     errorText_ = errorStream_.str();
1031     return FAILURE;
1032   }
1033
1034   // Look for a single stream meeting our needs.
1035   UInt32 firstStream, streamCount = 1, streamChannels = 0, channelOffset = 0;
1036   for ( iStream=0; iStream<nStreams; iStream++ ) {
1037     streamChannels = bufferList->mBuffers[iStream].mNumberChannels;
1038     if ( streamChannels >= channels + offsetCounter ) {
1039       firstStream = iStream;
1040       channelOffset = offsetCounter;
1041       foundStream = true;
1042       break;
1043     }
1044     if ( streamChannels > offsetCounter ) break;
1045     offsetCounter -= streamChannels;
1046   }
1047
1048   // If we didn't find a single stream above, then we should be able
1049   // to meet the channel specification with multiple streams.
1050   if ( foundStream == false ) {
1051     monoMode = true;
1052     offsetCounter = firstChannel;
1053     for ( iStream=0; iStream<nStreams; iStream++ ) {
1054       streamChannels = bufferList->mBuffers[iStream].mNumberChannels;
1055       if ( streamChannels > offsetCounter ) break;
1056       offsetCounter -= streamChannels;
1057     }
1058
1059     firstStream = iStream;
1060     channelOffset = offsetCounter;
1061     Int32 channelCounter = channels + offsetCounter - streamChannels;
1062
1063     if ( streamChannels > 1 ) monoMode = false;
1064     while ( channelCounter > 0 ) {
1065       streamChannels = bufferList->mBuffers[++iStream].mNumberChannels;
1066       if ( streamChannels > 1 ) monoMode = false;
1067       channelCounter -= streamChannels;
1068       streamCount++;
1069     }
1070   }
1071
1072   free( bufferList );
1073
1074   // Determine the buffer size.
1075   AudioValueRange       bufferRange;
1076   dataSize = sizeof( AudioValueRange );
1077   property.mSelector = kAudioDevicePropertyBufferFrameSizeRange;
1078   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &bufferRange );
1079
1080   if ( result != noErr ) {
1081     errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting buffer size range for device (" << device << ").";
1082     errorText_ = errorStream_.str();
1083     return FAILURE;
1084   }
1085
1086   if ( bufferRange.mMinimum > *bufferSize ) *bufferSize = (unsigned long) bufferRange.mMinimum;
1087   else if ( bufferRange.mMaximum < *bufferSize ) *bufferSize = (unsigned long) bufferRange.mMaximum;
1088   if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) *bufferSize = (unsigned long) bufferRange.mMinimum;
1089
1090   // Set the buffer size.  For multiple streams, I'm assuming we only
1091   // need to make this setting for the master channel.
1092   UInt32 theSize = (UInt32) *bufferSize;
1093   dataSize = sizeof( UInt32 );
1094   property.mSelector = kAudioDevicePropertyBufferFrameSize;
1095   result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &theSize );
1096
1097   if ( result != noErr ) {
1098     errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting the buffer size for device (" << device << ").";
1099     errorText_ = errorStream_.str();
1100     return FAILURE;
1101   }
1102
1103   // If attempting to setup a duplex stream, the bufferSize parameter
1104   // MUST be the same in both directions!
1105   *bufferSize = theSize;
1106   if ( stream_.mode == OUTPUT && mode == INPUT && *bufferSize != stream_.bufferSize ) {
1107     errorStream_ << "RtApiCore::probeDeviceOpen: system error setting buffer size for duplex stream on device (" << device << ").";
1108     errorText_ = errorStream_.str();
1109     return FAILURE;
1110   }
1111
1112   stream_.bufferSize = *bufferSize;
1113   stream_.nBuffers = 1;
1114
1115   // Try to set "hog" mode ... it's not clear to me this is working.
1116   if ( options && options->flags & RTAUDIO_HOG_DEVICE ) {
1117     pid_t hog_pid;
1118     dataSize = sizeof( hog_pid );
1119     property.mSelector = kAudioDevicePropertyHogMode;
1120     result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &hog_pid );
1121     if ( result != noErr ) {
1122       errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting 'hog' state!";
1123       errorText_ = errorStream_.str();
1124       return FAILURE;
1125     }
1126
1127     if ( hog_pid != getpid() ) {
1128       hog_pid = getpid();
1129       result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &hog_pid );
1130       if ( result != noErr ) {
1131         errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting 'hog' state!";
1132         errorText_ = errorStream_.str();
1133         return FAILURE;
1134       }
1135     }
1136   }
1137
1138   // Check and if necessary, change the sample rate for the device.
1139   Float64 nominalRate;
1140   dataSize = sizeof( Float64 );
1141   property.mSelector = kAudioDevicePropertyNominalSampleRate;
1142   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &nominalRate );
1143   if ( result != noErr ) {
1144     errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting current sample rate.";
1145     errorText_ = errorStream_.str();
1146     return FAILURE;
1147   }
1148
1149   // Only change the sample rate if off by more than 1 Hz.
1150   if ( fabs( nominalRate - (double)sampleRate ) > 1.0 ) {
1151
1152     // Set a property listener for the sample rate change
1153     Float64 reportedRate = 0.0;
1154     AudioObjectPropertyAddress tmp = { kAudioDevicePropertyNominalSampleRate, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
1155     result = AudioObjectAddPropertyListener( id, &tmp, rateListener, (void *) &reportedRate );
1156     if ( result != noErr ) {
1157       errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting sample rate property listener for device (" << device << ").";
1158       errorText_ = errorStream_.str();
1159       return FAILURE;
1160     }
1161
1162     nominalRate = (Float64) sampleRate;
1163     result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &nominalRate );
1164     if ( result != noErr ) {
1165       AudioObjectRemovePropertyListener( id, &tmp, rateListener, (void *) &reportedRate );
1166       errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting sample rate for device (" << device << ").";
1167       errorText_ = errorStream_.str();
1168       return FAILURE;
1169     }
1170
1171     // Now wait until the reported nominal rate is what we just set.
1172     UInt32 microCounter = 0;
1173     while ( reportedRate != nominalRate ) {
1174       microCounter += 5000;
1175       if ( microCounter > 5000000 ) break;
1176       usleep( 5000 );
1177     }
1178
1179     // Remove the property listener.
1180     AudioObjectRemovePropertyListener( id, &tmp, rateListener, (void *) &reportedRate );
1181
1182     if ( microCounter > 5000000 ) {
1183       errorStream_ << "RtApiCore::probeDeviceOpen: timeout waiting for sample rate update for device (" << device << ").";
1184       errorText_ = errorStream_.str();
1185       return FAILURE;
1186     }
1187   }
1188
1189   // Now set the stream format for all streams.  Also, check the
1190   // physical format of the device and change that if necessary.
1191   AudioStreamBasicDescription   description;
1192   dataSize = sizeof( AudioStreamBasicDescription );
1193   property.mSelector = kAudioStreamPropertyVirtualFormat;
1194   result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &description );
1195   if ( result != noErr ) {
1196     errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream format for device (" << device << ").";
1197     errorText_ = errorStream_.str();
1198     return FAILURE;
1199   }
1200
1201   // Set the sample rate and data format id.  However, only make the
1202   // change if the sample rate is not within 1.0 of the desired
1203   // rate and the format is not linear pcm.
1204   bool updateFormat = false;
1205   if ( fabs( description.mSampleRate - (Float64)sampleRate ) > 1.0 ) {
1206     description.mSampleRate = (Float64) sampleRate;
1207     updateFormat = true;
1208   }
1209
1210   if ( description.mFormatID != kAudioFormatLinearPCM ) {
1211     description.mFormatID = kAudioFormatLinearPCM;
1212     updateFormat = true;
1213   }
1214
1215   if ( updateFormat ) {
1216     result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &description );
1217     if ( result != noErr ) {
1218       errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting sample rate or data format for device (" << device << ").";
1219       errorText_ = errorStream_.str();
1220       return FAILURE;
1221     }
1222   }
1223
1224   // Now check the physical format.
1225   property.mSelector = kAudioStreamPropertyPhysicalFormat;
1226   result = AudioObjectGetPropertyData( id, &property, 0, NULL,  &dataSize, &description );
1227   if ( result != noErr ) {
1228     errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream physical format for device (" << device << ").";
1229     errorText_ = errorStream_.str();
1230     return FAILURE;
1231   }
1232
1233   //std::cout << "Current physical stream format:" << std::endl;
1234   //std::cout << "   mBitsPerChan = " << description.mBitsPerChannel << std::endl;
1235   //std::cout << "   aligned high = " << (description.mFormatFlags & kAudioFormatFlagIsAlignedHigh) << ", isPacked = " << (description.mFormatFlags & kAudioFormatFlagIsPacked) << std::endl;
1236   //std::cout << "   bytesPerFrame = " << description.mBytesPerFrame << std::endl;
1237   //std::cout << "   sample rate = " << description.mSampleRate << std::endl;
1238
1239   if ( description.mFormatID != kAudioFormatLinearPCM || description.mBitsPerChannel < 16 ) {
1240     description.mFormatID = kAudioFormatLinearPCM;
1241     //description.mSampleRate = (Float64) sampleRate;
1242     AudioStreamBasicDescription testDescription = description;
1243     UInt32 formatFlags;
1244
1245     // We'll try higher bit rates first and then work our way down.
1246     std::vector< std::pair<UInt32, UInt32>  > physicalFormats;
1247     formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsFloat) & ~kLinearPCMFormatFlagIsSignedInteger;
1248     physicalFormats.push_back( std::pair<Float32, UInt32>( 32, formatFlags ) );
1249     formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked) & ~kLinearPCMFormatFlagIsFloat;
1250     physicalFormats.push_back( std::pair<Float32, UInt32>( 32, formatFlags ) );
1251     physicalFormats.push_back( std::pair<Float32, UInt32>( 24, formatFlags ) );   // 24-bit packed
1252     formatFlags &= ~( kAudioFormatFlagIsPacked | kAudioFormatFlagIsAlignedHigh );
1253     physicalFormats.push_back( std::pair<Float32, UInt32>( 24.2, formatFlags ) ); // 24-bit in 4 bytes, aligned low
1254     formatFlags |= kAudioFormatFlagIsAlignedHigh;
1255     physicalFormats.push_back( std::pair<Float32, UInt32>( 24.4, formatFlags ) ); // 24-bit in 4 bytes, aligned high
1256     formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked) & ~kLinearPCMFormatFlagIsFloat;
1257     physicalFormats.push_back( std::pair<Float32, UInt32>( 16, formatFlags ) );
1258     physicalFormats.push_back( std::pair<Float32, UInt32>( 8, formatFlags ) );
1259
1260     bool setPhysicalFormat = false;
1261     for( unsigned int i=0; i<physicalFormats.size(); i++ ) {
1262       testDescription = description;
1263       testDescription.mBitsPerChannel = (UInt32) physicalFormats[i].first;
1264       testDescription.mFormatFlags = physicalFormats[i].second;
1265       if ( (24 == (UInt32)physicalFormats[i].first) && ~( physicalFormats[i].second & kAudioFormatFlagIsPacked ) )
1266         testDescription.mBytesPerFrame =  4 * testDescription.mChannelsPerFrame;
1267       else
1268         testDescription.mBytesPerFrame =  testDescription.mBitsPerChannel/8 * testDescription.mChannelsPerFrame;
1269       testDescription.mBytesPerPacket = testDescription.mBytesPerFrame * testDescription.mFramesPerPacket;
1270       result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &testDescription );
1271       if ( result == noErr ) {
1272         setPhysicalFormat = true;
1273         //std::cout << "Updated physical stream format:" << std::endl;
1274         //std::cout << "   mBitsPerChan = " << testDescription.mBitsPerChannel << std::endl;
1275         //std::cout << "   aligned high = " << (testDescription.mFormatFlags & kAudioFormatFlagIsAlignedHigh) << ", isPacked = " << (testDescription.mFormatFlags & kAudioFormatFlagIsPacked) << std::endl;
1276         //std::cout << "   bytesPerFrame = " << testDescription.mBytesPerFrame << std::endl;
1277         //std::cout << "   sample rate = " << testDescription.mSampleRate << std::endl;
1278         break;
1279       }
1280     }
1281
1282     if ( !setPhysicalFormat ) {
1283       errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting physical data format for device (" << device << ").";
1284       errorText_ = errorStream_.str();
1285       return FAILURE;
1286     }
1287   } // done setting virtual/physical formats.
1288
1289   // Get the stream / device latency.
1290   UInt32 latency;
1291   dataSize = sizeof( UInt32 );
1292   property.mSelector = kAudioDevicePropertyLatency;
1293   if ( AudioObjectHasProperty( id, &property ) == true ) {
1294     result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &latency );
1295     if ( result == kAudioHardwareNoError ) stream_.latency[ mode ] = latency;
1296     else {
1297       errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting device latency for device (" << device << ").";
1298       errorText_ = errorStream_.str();
1299       error( RtAudioError::WARNING );
1300     }
1301   }
1302
1303   // Byte-swapping: According to AudioHardware.h, the stream data will
1304   // always be presented in native-endian format, so we should never
1305   // need to byte swap.
1306   stream_.doByteSwap[mode] = false;
1307
1308   // From the CoreAudio documentation, PCM data must be supplied as
1309   // 32-bit floats.
1310   stream_.userFormat = format;
1311   stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
1312
1313   if ( streamCount == 1 )
1314     stream_.nDeviceChannels[mode] = description.mChannelsPerFrame;
1315   else // multiple streams
1316     stream_.nDeviceChannels[mode] = channels;
1317   stream_.nUserChannels[mode] = channels;
1318   stream_.channelOffset[mode] = channelOffset;  // offset within a CoreAudio stream
1319   if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
1320   else stream_.userInterleaved = true;
1321   stream_.deviceInterleaved[mode] = true;
1322   if ( monoMode == true ) stream_.deviceInterleaved[mode] = false;
1323
1324   // Set flags for buffer conversion.
1325   stream_.doConvertBuffer[mode] = false;
1326   if ( stream_.userFormat != stream_.deviceFormat[mode] )
1327     stream_.doConvertBuffer[mode] = true;
1328   if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] )
1329     stream_.doConvertBuffer[mode] = true;
1330   if ( streamCount == 1 ) {
1331     if ( stream_.nUserChannels[mode] > 1 &&
1332          stream_.userInterleaved != stream_.deviceInterleaved[mode] )
1333       stream_.doConvertBuffer[mode] = true;
1334   }
1335   else if ( monoMode && stream_.userInterleaved )
1336     stream_.doConvertBuffer[mode] = true;
1337
1338   // Allocate our CoreHandle structure for the stream.
1339   CoreHandle *handle = 0;
1340   if ( stream_.apiHandle == 0 ) {
1341     try {
1342       handle = new CoreHandle;
1343     }
1344     catch ( std::bad_alloc& ) {
1345       errorText_ = "RtApiCore::probeDeviceOpen: error allocating CoreHandle memory.";
1346       goto error;
1347     }
1348
1349     if ( pthread_cond_init( &handle->condition, NULL ) ) {
1350       errorText_ = "RtApiCore::probeDeviceOpen: error initializing pthread condition variable.";
1351       goto error;
1352     }
1353     stream_.apiHandle = (void *) handle;
1354   }
1355   else
1356     handle = (CoreHandle *) stream_.apiHandle;
1357   handle->iStream[mode] = firstStream;
1358   handle->nStreams[mode] = streamCount;
1359   handle->id[mode] = id;
1360
1361   // Allocate necessary internal buffers.
1362   unsigned long bufferBytes;
1363   bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
1364   //  stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
1365   stream_.userBuffer[mode] = (char *) malloc( bufferBytes * sizeof(char) );
1366   memset( stream_.userBuffer[mode], 0, bufferBytes * sizeof(char) );
1367   if ( stream_.userBuffer[mode] == NULL ) {
1368     errorText_ = "RtApiCore::probeDeviceOpen: error allocating user buffer memory.";
1369     goto error;
1370   }
1371
1372   // If possible, we will make use of the CoreAudio stream buffers as
1373   // "device buffers".  However, we can't do this if using multiple
1374   // streams.
1375   if ( stream_.doConvertBuffer[mode] && handle->nStreams[mode] > 1 ) {
1376
1377     bool makeBuffer = true;
1378     bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
1379     if ( mode == INPUT ) {
1380       if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
1381         unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
1382         if ( bufferBytes <= bytesOut ) makeBuffer = false;
1383       }
1384     }
1385
1386     if ( makeBuffer ) {
1387       bufferBytes *= *bufferSize;
1388       if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
1389       stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
1390       if ( stream_.deviceBuffer == NULL ) {
1391         errorText_ = "RtApiCore::probeDeviceOpen: error allocating device buffer memory.";
1392         goto error;
1393       }
1394     }
1395   }
1396
1397   stream_.sampleRate = sampleRate;
1398   stream_.device[mode] = device;
1399   stream_.state = STREAM_STOPPED;
1400   stream_.callbackInfo.object = (void *) this;
1401
1402   // Setup the buffer conversion information structure.
1403   if ( stream_.doConvertBuffer[mode] ) {
1404     if ( streamCount > 1 ) setConvertInfo( mode, 0 );
1405     else setConvertInfo( mode, channelOffset );
1406   }
1407
1408   if ( mode == INPUT && stream_.mode == OUTPUT && stream_.device[0] == device )
1409     // Only one callback procedure per device.
1410     stream_.mode = DUPLEX;
1411   else {
1412 #if defined( MAC_OS_X_VERSION_10_5 ) && ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
1413     result = AudioDeviceCreateIOProcID( id, callbackHandler, (void *) &stream_.callbackInfo, &handle->procId[mode] );
1414 #else
1415     // deprecated in favor of AudioDeviceCreateIOProcID()
1416     result = AudioDeviceAddIOProc( id, callbackHandler, (void *) &stream_.callbackInfo );
1417 #endif
1418     if ( result != noErr ) {
1419       errorStream_ << "RtApiCore::probeDeviceOpen: system error setting callback for device (" << device << ").";
1420       errorText_ = errorStream_.str();
1421       goto error;
1422     }
1423     if ( stream_.mode == OUTPUT && mode == INPUT )
1424       stream_.mode = DUPLEX;
1425     else
1426       stream_.mode = mode;
1427   }
1428
1429   // Setup the device property listener for over/underload.
1430   property.mSelector = kAudioDeviceProcessorOverload;
1431   property.mScope = kAudioObjectPropertyScopeGlobal;
1432   result = AudioObjectAddPropertyListener( id, &property, xrunListener, (void *) handle );
1433
1434   return SUCCESS;
1435
1436  error:
1437   if ( handle ) {
1438     pthread_cond_destroy( &handle->condition );
1439     delete handle;
1440     stream_.apiHandle = 0;
1441   }
1442
1443   for ( int i=0; i<2; i++ ) {
1444     if ( stream_.userBuffer[i] ) {
1445       free( stream_.userBuffer[i] );
1446       stream_.userBuffer[i] = 0;
1447     }
1448   }
1449
1450   if ( stream_.deviceBuffer ) {
1451     free( stream_.deviceBuffer );
1452     stream_.deviceBuffer = 0;
1453   }
1454
1455   stream_.state = STREAM_CLOSED;
1456   return FAILURE;
1457 }
1458
1459 void RtApiCore :: closeStream( void )
1460 {
1461   if ( stream_.state == STREAM_CLOSED ) {
1462     errorText_ = "RtApiCore::closeStream(): no open stream to close!";
1463     error( RtAudioError::WARNING );
1464     return;
1465   }
1466
1467   CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
1468   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
1469     if (handle) {
1470       AudioObjectPropertyAddress property = { kAudioHardwarePropertyDevices,
1471         kAudioObjectPropertyScopeGlobal,
1472         kAudioObjectPropertyElementMaster };
1473
1474       property.mSelector = kAudioDeviceProcessorOverload;
1475       property.mScope = kAudioObjectPropertyScopeGlobal;
1476       if (AudioObjectRemovePropertyListener( handle->id[0], &property, xrunListener, (void *) handle ) != noErr) {
1477         errorText_ = "RtApiCore::closeStream(): error removing property listener!";
1478         error( RtAudioError::WARNING );
1479       }
1480     }
1481     if ( stream_.state == STREAM_RUNNING )
1482       AudioDeviceStop( handle->id[0], callbackHandler );
1483 #if defined( MAC_OS_X_VERSION_10_5 ) && ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
1484     AudioDeviceDestroyIOProcID( handle->id[0], handle->procId[0] );
1485 #else
1486     // deprecated in favor of AudioDeviceDestroyIOProcID()
1487     AudioDeviceRemoveIOProc( handle->id[0], callbackHandler );
1488 #endif
1489   }
1490
1491   if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) {
1492     if (handle) {
1493       AudioObjectPropertyAddress property = { kAudioHardwarePropertyDevices,
1494         kAudioObjectPropertyScopeGlobal,
1495         kAudioObjectPropertyElementMaster };
1496
1497       property.mSelector = kAudioDeviceProcessorOverload;
1498       property.mScope = kAudioObjectPropertyScopeGlobal;
1499       if (AudioObjectRemovePropertyListener( handle->id[1], &property, xrunListener, (void *) handle ) != noErr) {
1500         errorText_ = "RtApiCore::closeStream(): error removing property listener!";
1501         error( RtAudioError::WARNING );
1502       }
1503     }
1504     if ( stream_.state == STREAM_RUNNING )
1505       AudioDeviceStop( handle->id[1], callbackHandler );
1506 #if defined( MAC_OS_X_VERSION_10_5 ) && ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
1507     AudioDeviceDestroyIOProcID( handle->id[1], handle->procId[1] );
1508 #else
1509     // deprecated in favor of AudioDeviceDestroyIOProcID()
1510     AudioDeviceRemoveIOProc( handle->id[1], callbackHandler );
1511 #endif
1512   }
1513
1514   for ( int i=0; i<2; i++ ) {
1515     if ( stream_.userBuffer[i] ) {
1516       free( stream_.userBuffer[i] );
1517       stream_.userBuffer[i] = 0;
1518     }
1519   }
1520
1521   if ( stream_.deviceBuffer ) {
1522     free( stream_.deviceBuffer );
1523     stream_.deviceBuffer = 0;
1524   }
1525
1526   // Destroy pthread condition variable.
1527   pthread_cond_destroy( &handle->condition );
1528   delete handle;
1529   stream_.apiHandle = 0;
1530
1531   stream_.mode = UNINITIALIZED;
1532   stream_.state = STREAM_CLOSED;
1533 }
1534
1535 void RtApiCore :: startStream( void )
1536 {
1537   verifyStream();
1538   if ( stream_.state == STREAM_RUNNING ) {
1539     errorText_ = "RtApiCore::startStream(): the stream is already running!";
1540     error( RtAudioError::WARNING );
1541     return;
1542   }
1543
1544   OSStatus result = noErr;
1545   CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
1546   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
1547
1548     result = AudioDeviceStart( handle->id[0], callbackHandler );
1549     if ( result != noErr ) {
1550       errorStream_ << "RtApiCore::startStream: system error (" << getErrorCode( result ) << ") starting callback procedure on device (" << stream_.device[0] << ").";
1551       errorText_ = errorStream_.str();
1552       goto unlock;
1553     }
1554   }
1555
1556   if ( stream_.mode == INPUT ||
1557        ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) {
1558
1559     result = AudioDeviceStart( handle->id[1], callbackHandler );
1560     if ( result != noErr ) {
1561       errorStream_ << "RtApiCore::startStream: system error starting input callback procedure on device (" << stream_.device[1] << ").";
1562       errorText_ = errorStream_.str();
1563       goto unlock;
1564     }
1565   }
1566
1567   handle->drainCounter = 0;
1568   handle->internalDrain = false;
1569   stream_.state = STREAM_RUNNING;
1570
1571  unlock:
1572   if ( result == noErr ) return;
1573   error( RtAudioError::SYSTEM_ERROR );
1574 }
1575
1576 void RtApiCore :: stopStream( void )
1577 {
1578   verifyStream();
1579   if ( stream_.state == STREAM_STOPPED ) {
1580     errorText_ = "RtApiCore::stopStream(): the stream is already stopped!";
1581     error( RtAudioError::WARNING );
1582     return;
1583   }
1584
1585   OSStatus result = noErr;
1586   CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
1587   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
1588
1589     if ( handle->drainCounter == 0 ) {
1590       handle->drainCounter = 2;
1591       pthread_cond_wait( &handle->condition, &stream_.mutex ); // block until signaled
1592     }
1593
1594     result = AudioDeviceStop( handle->id[0], callbackHandler );
1595     if ( result != noErr ) {
1596       errorStream_ << "RtApiCore::stopStream: system error (" << getErrorCode( result ) << ") stopping callback procedure on device (" << stream_.device[0] << ").";
1597       errorText_ = errorStream_.str();
1598       goto unlock;
1599     }
1600   }
1601
1602   if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) {
1603
1604     result = AudioDeviceStop( handle->id[1], callbackHandler );
1605     if ( result != noErr ) {
1606       errorStream_ << "RtApiCore::stopStream: system error (" << getErrorCode( result ) << ") stopping input callback procedure on device (" << stream_.device[1] << ").";
1607       errorText_ = errorStream_.str();
1608       goto unlock;
1609     }
1610   }
1611
1612   stream_.state = STREAM_STOPPED;
1613
1614  unlock:
1615   if ( result == noErr ) return;
1616   error( RtAudioError::SYSTEM_ERROR );
1617 }
1618
1619 void RtApiCore :: abortStream( void )
1620 {
1621   verifyStream();
1622   if ( stream_.state == STREAM_STOPPED ) {
1623     errorText_ = "RtApiCore::abortStream(): the stream is already stopped!";
1624     error( RtAudioError::WARNING );
1625     return;
1626   }
1627
1628   CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
1629   handle->drainCounter = 2;
1630
1631   stopStream();
1632 }
1633
1634 // This function will be called by a spawned thread when the user
1635 // callback function signals that the stream should be stopped or
1636 // aborted.  It is better to handle it this way because the
1637 // callbackEvent() function probably should return before the AudioDeviceStop()
1638 // function is called.
1639 static void *coreStopStream( void *ptr )
1640 {
1641   CallbackInfo *info = (CallbackInfo *) ptr;
1642   RtApiCore *object = (RtApiCore *) info->object;
1643
1644   object->stopStream();
1645   pthread_exit( NULL );
1646 }
1647
1648 bool RtApiCore :: callbackEvent( AudioDeviceID deviceId,
1649                                  const AudioBufferList *inBufferList,
1650                                  const AudioBufferList *outBufferList )
1651 {
1652   if ( stream_.state == STREAM_STOPPED || stream_.state == STREAM_STOPPING ) return SUCCESS;
1653   if ( stream_.state == STREAM_CLOSED ) {
1654     errorText_ = "RtApiCore::callbackEvent(): the stream is closed ... this shouldn't happen!";
1655     error( RtAudioError::WARNING );
1656     return FAILURE;
1657   }
1658
1659   CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
1660   CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
1661
1662   // Check if we were draining the stream and signal is finished.
1663   if ( handle->drainCounter > 3 ) {
1664     ThreadHandle threadId;
1665
1666     stream_.state = STREAM_STOPPING;
1667     if ( handle->internalDrain == true )
1668       pthread_create( &threadId, NULL, coreStopStream, info );
1669     else // external call to stopStream()
1670       pthread_cond_signal( &handle->condition );
1671     return SUCCESS;
1672   }
1673
1674   AudioDeviceID outputDevice = handle->id[0];
1675
1676   // Invoke user callback to get fresh output data UNLESS we are
1677   // draining stream or duplex mode AND the input/output devices are
1678   // different AND this function is called for the input device.
1679   if ( handle->drainCounter == 0 && ( stream_.mode != DUPLEX || deviceId == outputDevice ) ) {
1680     RtAudioCallback callback = (RtAudioCallback) info->callback;
1681     double streamTime = getStreamTime();
1682     RtAudioStreamStatus status = 0;
1683     if ( stream_.mode != INPUT && handle->xrun[0] == true ) {
1684       status |= RTAUDIO_OUTPUT_UNDERFLOW;
1685       handle->xrun[0] = false;
1686     }
1687     if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) {
1688       status |= RTAUDIO_INPUT_OVERFLOW;
1689       handle->xrun[1] = false;
1690     }
1691
1692     int cbReturnValue = callback( stream_.userBuffer[0], stream_.userBuffer[1],
1693                                   stream_.bufferSize, streamTime, status, info->userData );
1694     if ( cbReturnValue == 2 ) {
1695       stream_.state = STREAM_STOPPING;
1696       handle->drainCounter = 2;
1697       abortStream();
1698       return SUCCESS;
1699     }
1700     else if ( cbReturnValue == 1 ) {
1701       handle->drainCounter = 1;
1702       handle->internalDrain = true;
1703     }
1704   }
1705
1706   if ( stream_.mode == OUTPUT || ( stream_.mode == DUPLEX && deviceId == outputDevice ) ) {
1707
1708     if ( handle->drainCounter > 1 ) { // write zeros to the output stream
1709
1710       if ( handle->nStreams[0] == 1 ) {
1711         memset( outBufferList->mBuffers[handle->iStream[0]].mData,
1712                 0,
1713                 outBufferList->mBuffers[handle->iStream[0]].mDataByteSize );
1714       }
1715       else { // fill multiple streams with zeros
1716         for ( unsigned int i=0; i<handle->nStreams[0]; i++ ) {
1717           memset( outBufferList->mBuffers[handle->iStream[0]+i].mData,
1718                   0,
1719                   outBufferList->mBuffers[handle->iStream[0]+i].mDataByteSize );
1720         }
1721       }
1722     }
1723     else if ( handle->nStreams[0] == 1 ) {
1724       if ( stream_.doConvertBuffer[0] ) { // convert directly to CoreAudio stream buffer
1725         convertBuffer( (char *) outBufferList->mBuffers[handle->iStream[0]].mData,
1726                        stream_.userBuffer[0], stream_.convertInfo[0] );
1727       }
1728       else { // copy from user buffer
1729         memcpy( outBufferList->mBuffers[handle->iStream[0]].mData,
1730                 stream_.userBuffer[0],
1731                 outBufferList->mBuffers[handle->iStream[0]].mDataByteSize );
1732       }
1733     }
1734     else { // fill multiple streams
1735       Float32 *inBuffer = (Float32 *) stream_.userBuffer[0];
1736       if ( stream_.doConvertBuffer[0] ) {
1737         convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] );
1738         inBuffer = (Float32 *) stream_.deviceBuffer;
1739       }
1740
1741       if ( stream_.deviceInterleaved[0] == false ) { // mono mode
1742         UInt32 bufferBytes = outBufferList->mBuffers[handle->iStream[0]].mDataByteSize;
1743         for ( unsigned int i=0; i<stream_.nUserChannels[0]; i++ ) {
1744           memcpy( outBufferList->mBuffers[handle->iStream[0]+i].mData,
1745                   (void *)&inBuffer[i*stream_.bufferSize], bufferBytes );
1746         }
1747       }
1748       else { // fill multiple multi-channel streams with interleaved data
1749         UInt32 streamChannels, channelsLeft, inJump, outJump, inOffset;
1750         Float32 *out, *in;
1751
1752         bool inInterleaved = ( stream_.userInterleaved ) ? true : false;
1753         UInt32 inChannels = stream_.nUserChannels[0];
1754         if ( stream_.doConvertBuffer[0] ) {
1755           inInterleaved = true; // device buffer will always be interleaved for nStreams > 1 and not mono mode
1756           inChannels = stream_.nDeviceChannels[0];
1757         }
1758
1759         if ( inInterleaved ) inOffset = 1;
1760         else inOffset = stream_.bufferSize;
1761
1762         channelsLeft = inChannels;
1763         for ( unsigned int i=0; i<handle->nStreams[0]; i++ ) {
1764           in = inBuffer;
1765           out = (Float32 *) outBufferList->mBuffers[handle->iStream[0]+i].mData;
1766           streamChannels = outBufferList->mBuffers[handle->iStream[0]+i].mNumberChannels;
1767
1768           outJump = 0;
1769           // Account for possible channel offset in first stream
1770           if ( i == 0 && stream_.channelOffset[0] > 0 ) {
1771             streamChannels -= stream_.channelOffset[0];
1772             outJump = stream_.channelOffset[0];
1773             out += outJump;
1774           }
1775
1776           // Account for possible unfilled channels at end of the last stream
1777           if ( streamChannels > channelsLeft ) {
1778             outJump = streamChannels - channelsLeft;
1779             streamChannels = channelsLeft;
1780           }
1781
1782           // Determine input buffer offsets and skips
1783           if ( inInterleaved ) {
1784             inJump = inChannels;
1785             in += inChannels - channelsLeft;
1786           }
1787           else {
1788             inJump = 1;
1789             in += (inChannels - channelsLeft) * inOffset;
1790           }
1791
1792           for ( unsigned int i=0; i<stream_.bufferSize; i++ ) {
1793             for ( unsigned int j=0; j<streamChannels; j++ ) {
1794               *out++ = in[j*inOffset];
1795             }
1796             out += outJump;
1797             in += inJump;
1798           }
1799           channelsLeft -= streamChannels;
1800         }
1801       }
1802     }
1803   }
1804
1805   // Don't bother draining input
1806   if ( handle->drainCounter ) {
1807     handle->drainCounter++;
1808     goto unlock;
1809   }
1810
1811   AudioDeviceID inputDevice;
1812   inputDevice = handle->id[1];
1813   if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && deviceId == inputDevice ) ) {
1814
1815     if ( handle->nStreams[1] == 1 ) {
1816       if ( stream_.doConvertBuffer[1] ) { // convert directly from CoreAudio stream buffer
1817         convertBuffer( stream_.userBuffer[1],
1818                        (char *) inBufferList->mBuffers[handle->iStream[1]].mData,
1819                        stream_.convertInfo[1] );
1820       }
1821       else { // copy to user buffer
1822         memcpy( stream_.userBuffer[1],
1823                 inBufferList->mBuffers[handle->iStream[1]].mData,
1824                 inBufferList->mBuffers[handle->iStream[1]].mDataByteSize );
1825       }
1826     }
1827     else { // read from multiple streams
1828       Float32 *outBuffer = (Float32 *) stream_.userBuffer[1];
1829       if ( stream_.doConvertBuffer[1] ) outBuffer = (Float32 *) stream_.deviceBuffer;
1830
1831       if ( stream_.deviceInterleaved[1] == false ) { // mono mode
1832         UInt32 bufferBytes = inBufferList->mBuffers[handle->iStream[1]].mDataByteSize;
1833         for ( unsigned int i=0; i<stream_.nUserChannels[1]; i++ ) {
1834           memcpy( (void *)&outBuffer[i*stream_.bufferSize],
1835                   inBufferList->mBuffers[handle->iStream[1]+i].mData, bufferBytes );
1836         }
1837       }
1838       else { // read from multiple multi-channel streams
1839         UInt32 streamChannels, channelsLeft, inJump, outJump, outOffset;
1840         Float32 *out, *in;
1841
1842         bool outInterleaved = ( stream_.userInterleaved ) ? true : false;
1843         UInt32 outChannels = stream_.nUserChannels[1];
1844         if ( stream_.doConvertBuffer[1] ) {
1845           outInterleaved = true; // device buffer will always be interleaved for nStreams > 1 and not mono mode
1846           outChannels = stream_.nDeviceChannels[1];
1847         }
1848
1849         if ( outInterleaved ) outOffset = 1;
1850         else outOffset = stream_.bufferSize;
1851
1852         channelsLeft = outChannels;
1853         for ( unsigned int i=0; i<handle->nStreams[1]; i++ ) {
1854           out = outBuffer;
1855           in = (Float32 *) inBufferList->mBuffers[handle->iStream[1]+i].mData;
1856           streamChannels = inBufferList->mBuffers[handle->iStream[1]+i].mNumberChannels;
1857
1858           inJump = 0;
1859           // Account for possible channel offset in first stream
1860           if ( i == 0 && stream_.channelOffset[1] > 0 ) {
1861             streamChannels -= stream_.channelOffset[1];
1862             inJump = stream_.channelOffset[1];
1863             in += inJump;
1864           }
1865
1866           // Account for possible unread channels at end of the last stream
1867           if ( streamChannels > channelsLeft ) {
1868             inJump = streamChannels - channelsLeft;
1869             streamChannels = channelsLeft;
1870           }
1871
1872           // Determine output buffer offsets and skips
1873           if ( outInterleaved ) {
1874             outJump = outChannels;
1875             out += outChannels - channelsLeft;
1876           }
1877           else {
1878             outJump = 1;
1879             out += (outChannels - channelsLeft) * outOffset;
1880           }
1881
1882           for ( unsigned int i=0; i<stream_.bufferSize; i++ ) {
1883             for ( unsigned int j=0; j<streamChannels; j++ ) {
1884               out[j*outOffset] = *in++;
1885             }
1886             out += outJump;
1887             in += inJump;
1888           }
1889           channelsLeft -= streamChannels;
1890         }
1891       }
1892
1893       if ( stream_.doConvertBuffer[1] ) { // convert from our internal "device" buffer
1894         convertBuffer( stream_.userBuffer[1],
1895                        stream_.deviceBuffer,
1896                        stream_.convertInfo[1] );
1897       }
1898     }
1899   }
1900
1901  unlock:
1902   //MUTEX_UNLOCK( &stream_.mutex );
1903
1904   RtApi::tickStreamTime();
1905   return SUCCESS;
1906 }
1907
1908 const char* RtApiCore :: getErrorCode( OSStatus code )
1909 {
1910   switch( code ) {
1911
1912   case kAudioHardwareNotRunningError:
1913     return "kAudioHardwareNotRunningError";
1914
1915   case kAudioHardwareUnspecifiedError:
1916     return "kAudioHardwareUnspecifiedError";
1917
1918   case kAudioHardwareUnknownPropertyError:
1919     return "kAudioHardwareUnknownPropertyError";
1920
1921   case kAudioHardwareBadPropertySizeError:
1922     return "kAudioHardwareBadPropertySizeError";
1923
1924   case kAudioHardwareIllegalOperationError:
1925     return "kAudioHardwareIllegalOperationError";
1926
1927   case kAudioHardwareBadObjectError:
1928     return "kAudioHardwareBadObjectError";
1929
1930   case kAudioHardwareBadDeviceError:
1931     return "kAudioHardwareBadDeviceError";
1932
1933   case kAudioHardwareBadStreamError:
1934     return "kAudioHardwareBadStreamError";
1935
1936   case kAudioHardwareUnsupportedOperationError:
1937     return "kAudioHardwareUnsupportedOperationError";
1938
1939   case kAudioDeviceUnsupportedFormatError:
1940     return "kAudioDeviceUnsupportedFormatError";
1941
1942   case kAudioDevicePermissionsError:
1943     return "kAudioDevicePermissionsError";
1944
1945   default:
1946     return "CoreAudio unknown error";
1947   }
1948 }
1949
1950   //******************** End of __MACOSX_CORE__ *********************//
1951 #endif
1952
1953 #if defined(__UNIX_JACK__)
1954
1955 // JACK is a low-latency audio server, originally written for the
1956 // GNU/Linux operating system and now also ported to OS-X. It can
1957 // connect a number of different applications to an audio device, as
1958 // well as allowing them to share audio between themselves.
1959 //
1960 // When using JACK with RtAudio, "devices" refer to JACK clients that
1961 // have ports connected to the server.  The JACK server is typically
1962 // started in a terminal as follows:
1963 //
1964 // .jackd -d alsa -d hw:0
1965 //
1966 // or through an interface program such as qjackctl.  Many of the
1967 // parameters normally set for a stream are fixed by the JACK server
1968 // and can be specified when the JACK server is started.  In
1969 // particular,
1970 //
1971 // .jackd -d alsa -d hw:0 -r 44100 -p 512 -n 4
1972 //
1973 // specifies a sample rate of 44100 Hz, a buffer size of 512 sample
1974 // frames, and number of buffers = 4.  Once the server is running, it
1975 // is not possible to override these values.  If the values are not
1976 // specified in the command-line, the JACK server uses default values.
1977 //
1978 // The JACK server does not have to be running when an instance of
1979 // RtApiJack is created, though the function getDeviceCount() will
1980 // report 0 devices found until JACK has been started.  When no
1981 // devices are available (i.e., the JACK server is not running), a
1982 // stream cannot be opened.
1983
1984 #include <jack/jack.h>
1985 #include <unistd.h>
1986 #include <cstdio>
1987
1988 // A structure to hold various information related to the Jack API
1989 // implementation.
1990 struct JackHandle {
1991   jack_client_t *client;
1992   jack_port_t **ports[2];
1993   std::string deviceName[2];
1994   bool xrun[2];
1995   pthread_cond_t condition;
1996   int drainCounter;       // Tracks callback counts when draining
1997   bool internalDrain;     // Indicates if stop is initiated from callback or not.
1998
1999   JackHandle()
2000     :client(0), drainCounter(0), internalDrain(false) { ports[0] = 0; ports[1] = 0; xrun[0] = false; xrun[1] = false; }
2001 };
2002
2003 #if !defined(__RTAUDIO_DEBUG__)
2004 static void jackSilentError( const char * ) {};
2005 #endif
2006
2007 RtApiJack :: RtApiJack()
2008     :shouldAutoconnect_(true) {
2009   // Nothing to do here.
2010 #if !defined(__RTAUDIO_DEBUG__)
2011   // Turn off Jack's internal error reporting.
2012   jack_set_error_function( &jackSilentError );
2013 #endif
2014 }
2015
2016 RtApiJack :: ~RtApiJack()
2017 {
2018   if ( stream_.state != STREAM_CLOSED ) closeStream();
2019 }
2020
2021 unsigned int RtApiJack :: getDeviceCount( void )
2022 {
2023   // See if we can become a jack client.
2024   jack_options_t options = (jack_options_t) ( JackNoStartServer ); //JackNullOption;
2025   jack_status_t *status = NULL;
2026   jack_client_t *client = jack_client_open( "RtApiJackCount", options, status );
2027   if ( client == 0 ) return 0;
2028
2029   const char **ports;
2030   std::string port, previousPort;
2031   unsigned int nChannels = 0, nDevices = 0;
2032   ports = jack_get_ports( client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0 );
2033   if ( ports ) {
2034     // Parse the port names up to the first colon (:).
2035     size_t iColon = 0;
2036     do {
2037       port = (char *) ports[ nChannels ];
2038       iColon = port.find(":");
2039       if ( iColon != std::string::npos ) {
2040         port = port.substr( 0, iColon + 1 );
2041         if ( port != previousPort ) {
2042           nDevices++;
2043           previousPort = port;
2044         }
2045       }
2046     } while ( ports[++nChannels] );
2047     free( ports );
2048   }
2049
2050   jack_client_close( client );
2051   return nDevices;
2052 }
2053
2054 RtAudio::DeviceInfo RtApiJack :: getDeviceInfo( unsigned int device )
2055 {
2056   RtAudio::DeviceInfo info;
2057   info.probed = false;
2058
2059   jack_options_t options = (jack_options_t) ( JackNoStartServer ); //JackNullOption
2060   jack_status_t *status = NULL;
2061   jack_client_t *client = jack_client_open( "RtApiJackInfo", options, status );
2062   if ( client == 0 ) {
2063     errorText_ = "RtApiJack::getDeviceInfo: Jack server not found or connection error!";
2064     error( RtAudioError::WARNING );
2065     return info;
2066   }
2067
2068   const char **ports;
2069   std::string port, previousPort;
2070   unsigned int nPorts = 0, nDevices = 0;
2071   ports = jack_get_ports( client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0 );
2072   if ( ports ) {
2073     // Parse the port names up to the first colon (:).
2074     size_t iColon = 0;
2075     do {
2076       port = (char *) ports[ nPorts ];
2077       iColon = port.find(":");
2078       if ( iColon != std::string::npos ) {
2079         port = port.substr( 0, iColon );
2080         if ( port != previousPort ) {
2081           if ( nDevices == device ) info.name = port;
2082           nDevices++;
2083           previousPort = port;
2084         }
2085       }
2086     } while ( ports[++nPorts] );
2087     free( ports );
2088   }
2089
2090   if ( device >= nDevices ) {
2091     jack_client_close( client );
2092     errorText_ = "RtApiJack::getDeviceInfo: device ID is invalid!";
2093     error( RtAudioError::INVALID_USE );
2094     return info;
2095   }
2096
2097   // Get the current jack server sample rate.
2098   info.sampleRates.clear();
2099
2100   info.preferredSampleRate = jack_get_sample_rate( client );
2101   info.sampleRates.push_back( info.preferredSampleRate );
2102
2103   // Count the available ports containing the client name as device
2104   // channels.  Jack "input ports" equal RtAudio output channels.
2105   unsigned int nChannels = 0;
2106   ports = jack_get_ports( client, info.name.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput );
2107   if ( ports ) {
2108     while ( ports[ nChannels ] ) nChannels++;
2109     free( ports );
2110     info.outputChannels = nChannels;
2111   }
2112
2113   // Jack "output ports" equal RtAudio input channels.
2114   nChannels = 0;
2115   ports = jack_get_ports( client, info.name.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput );
2116   if ( ports ) {
2117     while ( ports[ nChannels ] ) nChannels++;
2118     free( ports );
2119     info.inputChannels = nChannels;
2120   }
2121
2122   if ( info.outputChannels == 0 && info.inputChannels == 0 ) {
2123     jack_client_close(client);
2124     errorText_ = "RtApiJack::getDeviceInfo: error determining Jack input/output channels!";
2125     error( RtAudioError::WARNING );
2126     return info;
2127   }
2128
2129   // If device opens for both playback and capture, we determine the channels.
2130   if ( info.outputChannels > 0 && info.inputChannels > 0 )
2131     info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
2132
2133   // Jack always uses 32-bit floats.
2134   info.nativeFormats = RTAUDIO_FLOAT32;
2135
2136   // Jack doesn't provide default devices so we'll use the first available one.
2137   if ( device == 0 && info.outputChannels > 0 )
2138     info.isDefaultOutput = true;
2139   if ( device == 0 && info.inputChannels > 0 )
2140     info.isDefaultInput = true;
2141
2142   jack_client_close(client);
2143   info.probed = true;
2144   return info;
2145 }
2146
2147 static int jackCallbackHandler( jack_nframes_t nframes, void *infoPointer )
2148 {
2149   CallbackInfo *info = (CallbackInfo *) infoPointer;
2150
2151   RtApiJack *object = (RtApiJack *) info->object;
2152   if ( object->callbackEvent( (unsigned long) nframes ) == false ) return 1;
2153
2154   return 0;
2155 }
2156
2157 // This function will be called by a spawned thread when the Jack
2158 // server signals that it is shutting down.  It is necessary to handle
2159 // it this way because the jackShutdown() function must return before
2160 // the jack_deactivate() function (in closeStream()) will return.
2161 static void *jackCloseStream( void *ptr )
2162 {
2163   CallbackInfo *info = (CallbackInfo *) ptr;
2164   RtApiJack *object = (RtApiJack *) info->object;
2165
2166   object->closeStream();
2167
2168   pthread_exit( NULL );
2169 }
2170 static void jackShutdown( void *infoPointer )
2171 {
2172   CallbackInfo *info = (CallbackInfo *) infoPointer;
2173   RtApiJack *object = (RtApiJack *) info->object;
2174
2175   // Check current stream state.  If stopped, then we'll assume this
2176   // was called as a result of a call to RtApiJack::stopStream (the
2177   // deactivation of a client handle causes this function to be called).
2178   // If not, we'll assume the Jack server is shutting down or some
2179   // other problem occurred and we should close the stream.
2180   if ( object->isStreamRunning() == false ) return;
2181
2182   ThreadHandle threadId;
2183   pthread_create( &threadId, NULL, jackCloseStream, info );
2184   std::cerr << "\nRtApiJack: the Jack server is shutting down this client ... stream stopped and closed!!\n" << std::endl;
2185 }
2186
2187 static int jackXrun( void *infoPointer )
2188 {
2189   JackHandle *handle = *((JackHandle **) infoPointer);
2190
2191   if ( handle->ports[0] ) handle->xrun[0] = true;
2192   if ( handle->ports[1] ) handle->xrun[1] = true;
2193
2194   return 0;
2195 }
2196
2197 bool RtApiJack :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
2198                                    unsigned int firstChannel, unsigned int sampleRate,
2199                                    RtAudioFormat format, unsigned int *bufferSize,
2200                                    RtAudio::StreamOptions *options )
2201 {
2202   JackHandle *handle = (JackHandle *) stream_.apiHandle;
2203
2204   // Look for jack server and try to become a client (only do once per stream).
2205   jack_client_t *client = 0;
2206   if ( mode == OUTPUT || ( mode == INPUT && stream_.mode != OUTPUT ) ) {
2207     jack_options_t jackoptions = (jack_options_t) ( JackNoStartServer ); //JackNullOption;
2208     jack_status_t *status = NULL;
2209     if ( options && !options->streamName.empty() )
2210       client = jack_client_open( options->streamName.c_str(), jackoptions, status );
2211     else
2212       client = jack_client_open( "RtApiJack", jackoptions, status );
2213     if ( client == 0 ) {
2214       errorText_ = "RtApiJack::probeDeviceOpen: Jack server not found or connection error!";
2215       error( RtAudioError::WARNING );
2216       return FAILURE;
2217     }
2218   }
2219   else {
2220     // The handle must have been created on an earlier pass.
2221     client = handle->client;
2222   }
2223
2224   const char **ports;
2225   std::string port, previousPort, deviceName;
2226   unsigned int nPorts = 0, nDevices = 0;
2227   ports = jack_get_ports( client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0 );
2228   if ( ports ) {
2229     // Parse the port names up to the first colon (:).
2230     size_t iColon = 0;
2231     do {
2232       port = (char *) ports[ nPorts ];
2233       iColon = port.find(":");
2234       if ( iColon != std::string::npos ) {
2235         port = port.substr( 0, iColon );
2236         if ( port != previousPort ) {
2237           if ( nDevices == device ) deviceName = port;
2238           nDevices++;
2239           previousPort = port;
2240         }
2241       }
2242     } while ( ports[++nPorts] );
2243     free( ports );
2244   }
2245
2246   if ( device >= nDevices ) {
2247     errorText_ = "RtApiJack::probeDeviceOpen: device ID is invalid!";
2248     return FAILURE;
2249   }
2250
2251   unsigned long flag = JackPortIsInput;
2252   if ( mode == INPUT ) flag = JackPortIsOutput;
2253
2254   if ( ! (options && (options->flags & RTAUDIO_JACK_DONT_CONNECT)) ) {
2255     // Count the available ports containing the client name as device
2256     // channels.  Jack "input ports" equal RtAudio output channels.
2257     unsigned int nChannels = 0;
2258     ports = jack_get_ports( client, deviceName.c_str(), JACK_DEFAULT_AUDIO_TYPE, flag );
2259     if ( ports ) {
2260       while ( ports[ nChannels ] ) nChannels++;
2261       free( ports );
2262     }
2263     // Compare the jack ports for specified client to the requested number of channels.
2264     if ( nChannels < (channels + firstChannel) ) {
2265       errorStream_ << "RtApiJack::probeDeviceOpen: requested number of channels (" << channels << ") + offset (" << firstChannel << ") not found for specified device (" << device << ":" << deviceName << ").";
2266       errorText_ = errorStream_.str();
2267       return FAILURE;
2268     }
2269   }
2270
2271   // Check the jack server sample rate.
2272   unsigned int jackRate = jack_get_sample_rate( client );
2273   if ( sampleRate != jackRate ) {
2274     jack_client_close( client );
2275     errorStream_ << "RtApiJack::probeDeviceOpen: the requested sample rate (" << sampleRate << ") is different than the JACK server rate (" << jackRate << ").";
2276     errorText_ = errorStream_.str();
2277     return FAILURE;
2278   }
2279   stream_.sampleRate = jackRate;
2280
2281   // Get the latency of the JACK port.
2282   ports = jack_get_ports( client, deviceName.c_str(), JACK_DEFAULT_AUDIO_TYPE, flag );
2283   if ( ports[ firstChannel ] ) {
2284     // Added by Ge Wang
2285     jack_latency_callback_mode_t cbmode = (mode == INPUT ? JackCaptureLatency : JackPlaybackLatency);
2286     // the range (usually the min and max are equal)
2287     jack_latency_range_t latrange; latrange.min = latrange.max = 0;
2288     // get the latency range
2289     jack_port_get_latency_range( jack_port_by_name( client, ports[firstChannel] ), cbmode, &latrange );
2290     // be optimistic, use the min!
2291     stream_.latency[mode] = latrange.min;
2292     //stream_.latency[mode] = jack_port_get_latency( jack_port_by_name( client, ports[ firstChannel ] ) );
2293   }
2294   free( ports );
2295
2296   // The jack server always uses 32-bit floating-point data.
2297   stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
2298   stream_.userFormat = format;
2299
2300   if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
2301   else stream_.userInterleaved = true;
2302
2303   // Jack always uses non-interleaved buffers.
2304   stream_.deviceInterleaved[mode] = false;
2305
2306   // Jack always provides host byte-ordered data.
2307   stream_.doByteSwap[mode] = false;
2308
2309   // Get the buffer size.  The buffer size and number of buffers
2310   // (periods) is set when the jack server is started.
2311   stream_.bufferSize = (int) jack_get_buffer_size( client );
2312   *bufferSize = stream_.bufferSize;
2313
2314   stream_.nDeviceChannels[mode] = channels;
2315   stream_.nUserChannels[mode] = channels;
2316
2317   // Set flags for buffer conversion.
2318   stream_.doConvertBuffer[mode] = false;
2319   if ( stream_.userFormat != stream_.deviceFormat[mode] )
2320     stream_.doConvertBuffer[mode] = true;
2321   if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
2322        stream_.nUserChannels[mode] > 1 )
2323     stream_.doConvertBuffer[mode] = true;
2324
2325   // Allocate our JackHandle structure for the stream.
2326   if ( handle == 0 ) {
2327     try {
2328       handle = new JackHandle;
2329     }
2330     catch ( std::bad_alloc& ) {
2331       errorText_ = "RtApiJack::probeDeviceOpen: error allocating JackHandle memory.";
2332       goto error;
2333     }
2334
2335     if ( pthread_cond_init(&handle->condition, NULL) ) {
2336       errorText_ = "RtApiJack::probeDeviceOpen: error initializing pthread condition variable.";
2337       goto error;
2338     }
2339     stream_.apiHandle = (void *) handle;
2340     handle->client = client;
2341   }
2342   handle->deviceName[mode] = deviceName;
2343
2344   // Allocate necessary internal buffers.
2345   unsigned long bufferBytes;
2346   bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
2347   stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
2348   if ( stream_.userBuffer[mode] == NULL ) {
2349     errorText_ = "RtApiJack::probeDeviceOpen: error allocating user buffer memory.";
2350     goto error;
2351   }
2352
2353   if ( stream_.doConvertBuffer[mode] ) {
2354
2355     bool makeBuffer = true;
2356     if ( mode == OUTPUT )
2357       bufferBytes = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
2358     else { // mode == INPUT
2359       bufferBytes = stream_.nDeviceChannels[1] * formatBytes( stream_.deviceFormat[1] );
2360       if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
2361         unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]);
2362         if ( bufferBytes < bytesOut ) makeBuffer = false;
2363       }
2364     }
2365
2366     if ( makeBuffer ) {
2367       bufferBytes *= *bufferSize;
2368       if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
2369       stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
2370       if ( stream_.deviceBuffer == NULL ) {
2371         errorText_ = "RtApiJack::probeDeviceOpen: error allocating device buffer memory.";
2372         goto error;
2373       }
2374     }
2375   }
2376
2377   // Allocate memory for the Jack ports (channels) identifiers.
2378   handle->ports[mode] = (jack_port_t **) malloc ( sizeof (jack_port_t *) * channels );
2379   if ( handle->ports[mode] == NULL )  {
2380     errorText_ = "RtApiJack::probeDeviceOpen: error allocating port memory.";
2381     goto error;
2382   }
2383
2384   stream_.device[mode] = device;
2385   stream_.channelOffset[mode] = firstChannel;
2386   stream_.state = STREAM_STOPPED;
2387   stream_.callbackInfo.object = (void *) this;
2388
2389   if ( stream_.mode == OUTPUT && mode == INPUT )
2390     // We had already set up the stream for output.
2391     stream_.mode = DUPLEX;
2392   else {
2393     stream_.mode = mode;
2394     jack_set_process_callback( handle->client, jackCallbackHandler, (void *) &stream_.callbackInfo );
2395     jack_set_xrun_callback( handle->client, jackXrun, (void *) &stream_.apiHandle );
2396     jack_on_shutdown( handle->client, jackShutdown, (void *) &stream_.callbackInfo );
2397   }
2398
2399   // Register our ports.
2400   char label[64];
2401   if ( mode == OUTPUT ) {
2402     for ( unsigned int i=0; i<stream_.nUserChannels[0]; i++ ) {
2403       snprintf( label, 64, "outport %d", i );
2404       handle->ports[0][i] = jack_port_register( handle->client, (const char *)label,
2405                                                 JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 );
2406     }
2407   }
2408   else {
2409     for ( unsigned int i=0; i<stream_.nUserChannels[1]; i++ ) {
2410       snprintf( label, 64, "inport %d", i );
2411       handle->ports[1][i] = jack_port_register( handle->client, (const char *)label,
2412                                                 JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 );
2413     }
2414   }
2415
2416   // Setup the buffer conversion information structure.  We don't use
2417   // buffers to do channel offsets, so we override that parameter
2418   // here.
2419   if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, 0 );
2420
2421   if ( options && options->flags & RTAUDIO_JACK_DONT_CONNECT ) shouldAutoconnect_ = false;
2422
2423   return SUCCESS;
2424
2425  error:
2426   if ( handle ) {
2427     pthread_cond_destroy( &handle->condition );
2428     jack_client_close( handle->client );
2429
2430     if ( handle->ports[0] ) free( handle->ports[0] );
2431     if ( handle->ports[1] ) free( handle->ports[1] );
2432
2433     delete handle;
2434     stream_.apiHandle = 0;
2435   }
2436
2437   for ( int i=0; i<2; i++ ) {
2438     if ( stream_.userBuffer[i] ) {
2439       free( stream_.userBuffer[i] );
2440       stream_.userBuffer[i] = 0;
2441     }
2442   }
2443
2444   if ( stream_.deviceBuffer ) {
2445     free( stream_.deviceBuffer );
2446     stream_.deviceBuffer = 0;
2447   }
2448
2449   return FAILURE;
2450 }
2451
2452 void RtApiJack :: closeStream( void )
2453 {
2454   if ( stream_.state == STREAM_CLOSED ) {
2455     errorText_ = "RtApiJack::closeStream(): no open stream to close!";
2456     error( RtAudioError::WARNING );
2457     return;
2458   }
2459
2460   JackHandle *handle = (JackHandle *) stream_.apiHandle;
2461   if ( handle ) {
2462
2463     if ( stream_.state == STREAM_RUNNING )
2464       jack_deactivate( handle->client );
2465
2466     jack_client_close( handle->client );
2467   }
2468
2469   if ( handle ) {
2470     if ( handle->ports[0] ) free( handle->ports[0] );
2471     if ( handle->ports[1] ) free( handle->ports[1] );
2472     pthread_cond_destroy( &handle->condition );
2473     delete handle;
2474     stream_.apiHandle = 0;
2475   }
2476
2477   for ( int i=0; i<2; i++ ) {
2478     if ( stream_.userBuffer[i] ) {
2479       free( stream_.userBuffer[i] );
2480       stream_.userBuffer[i] = 0;
2481     }
2482   }
2483
2484   if ( stream_.deviceBuffer ) {
2485     free( stream_.deviceBuffer );
2486     stream_.deviceBuffer = 0;
2487   }
2488
2489   stream_.mode = UNINITIALIZED;
2490   stream_.state = STREAM_CLOSED;
2491 }
2492
2493 void RtApiJack :: startStream( void )
2494 {
2495   verifyStream();
2496   if ( stream_.state == STREAM_RUNNING ) {
2497     errorText_ = "RtApiJack::startStream(): the stream is already running!";
2498     error( RtAudioError::WARNING );
2499     return;
2500   }
2501
2502   JackHandle *handle = (JackHandle *) stream_.apiHandle;
2503   int result = jack_activate( handle->client );
2504   if ( result ) {
2505     errorText_ = "RtApiJack::startStream(): unable to activate JACK client!";
2506     goto unlock;
2507   }
2508
2509   const char **ports;
2510
2511   // Get the list of available ports.
2512   if ( shouldAutoconnect_ && (stream_.mode == OUTPUT || stream_.mode == DUPLEX) ) {
2513     result = 1;
2514     ports = jack_get_ports( handle->client, handle->deviceName[0].c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput);
2515     if ( ports == NULL) {
2516       errorText_ = "RtApiJack::startStream(): error determining available JACK input ports!";
2517       goto unlock;
2518     }
2519
2520     // Now make the port connections.  Since RtAudio wasn't designed to
2521     // allow the user to select particular channels of a device, we'll
2522     // just open the first "nChannels" ports with offset.
2523     for ( unsigned int i=0; i<stream_.nUserChannels[0]; i++ ) {
2524       result = 1;
2525       if ( ports[ stream_.channelOffset[0] + i ] )
2526         result = jack_connect( handle->client, jack_port_name( handle->ports[0][i] ), ports[ stream_.channelOffset[0] + i ] );
2527       if ( result ) {
2528         free( ports );
2529         errorText_ = "RtApiJack::startStream(): error connecting output ports!";
2530         goto unlock;
2531       }
2532     }
2533     free(ports);
2534   }
2535
2536   if ( shouldAutoconnect_ && (stream_.mode == INPUT || stream_.mode == DUPLEX) ) {
2537     result = 1;
2538     ports = jack_get_ports( handle->client, handle->deviceName[1].c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput );
2539     if ( ports == NULL) {
2540       errorText_ = "RtApiJack::startStream(): error determining available JACK output ports!";
2541       goto unlock;
2542     }
2543
2544     // Now make the port connections.  See note above.
2545     for ( unsigned int i=0; i<stream_.nUserChannels[1]; i++ ) {
2546       result = 1;
2547       if ( ports[ stream_.channelOffset[1] + i ] )
2548         result = jack_connect( handle->client, ports[ stream_.channelOffset[1] + i ], jack_port_name( handle->ports[1][i] ) );
2549       if ( result ) {
2550         free( ports );
2551         errorText_ = "RtApiJack::startStream(): error connecting input ports!";
2552         goto unlock;
2553       }
2554     }
2555     free(ports);
2556   }
2557
2558   handle->drainCounter = 0;
2559   handle->internalDrain = false;
2560   stream_.state = STREAM_RUNNING;
2561
2562  unlock:
2563   if ( result == 0 ) return;
2564   error( RtAudioError::SYSTEM_ERROR );
2565 }
2566
2567 void RtApiJack :: stopStream( void )
2568 {
2569   verifyStream();
2570   if ( stream_.state == STREAM_STOPPED ) {
2571     errorText_ = "RtApiJack::stopStream(): the stream is already stopped!";
2572     error( RtAudioError::WARNING );
2573     return;
2574   }
2575
2576   JackHandle *handle = (JackHandle *) stream_.apiHandle;
2577   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
2578
2579     if ( handle->drainCounter == 0 ) {
2580       handle->drainCounter = 2;
2581       pthread_cond_wait( &handle->condition, &stream_.mutex ); // block until signaled
2582     }
2583   }
2584
2585   jack_deactivate( handle->client );
2586   stream_.state = STREAM_STOPPED;
2587 }
2588
2589 void RtApiJack :: abortStream( void )
2590 {
2591   verifyStream();
2592   if ( stream_.state == STREAM_STOPPED ) {
2593     errorText_ = "RtApiJack::abortStream(): the stream is already stopped!";
2594     error( RtAudioError::WARNING );
2595     return;
2596   }
2597
2598   JackHandle *handle = (JackHandle *) stream_.apiHandle;
2599   handle->drainCounter = 2;
2600
2601   stopStream();
2602 }
2603
2604 // This function will be called by a spawned thread when the user
2605 // callback function signals that the stream should be stopped or
2606 // aborted.  It is necessary to handle it this way because the
2607 // callbackEvent() function must return before the jack_deactivate()
2608 // function will return.
2609 static void *jackStopStream( void *ptr )
2610 {
2611   CallbackInfo *info = (CallbackInfo *) ptr;
2612   RtApiJack *object = (RtApiJack *) info->object;
2613
2614   object->stopStream();
2615   pthread_exit( NULL );
2616 }
2617
2618 bool RtApiJack :: callbackEvent( unsigned long nframes )
2619 {
2620   if ( stream_.state == STREAM_STOPPED || stream_.state == STREAM_STOPPING ) return SUCCESS;
2621   if ( stream_.state == STREAM_CLOSED ) {
2622     errorText_ = "RtApiCore::callbackEvent(): the stream is closed ... this shouldn't happen!";
2623     error( RtAudioError::WARNING );
2624     return FAILURE;
2625   }
2626   if ( stream_.bufferSize != nframes ) {
2627     errorText_ = "RtApiCore::callbackEvent(): the JACK buffer size has changed ... cannot process!";
2628     error( RtAudioError::WARNING );
2629     return FAILURE;
2630   }
2631
2632   CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
2633   JackHandle *handle = (JackHandle *) stream_.apiHandle;
2634
2635   // Check if we were draining the stream and signal is finished.
2636   if ( handle->drainCounter > 3 ) {
2637     ThreadHandle threadId;
2638
2639     stream_.state = STREAM_STOPPING;
2640     if ( handle->internalDrain == true )
2641       pthread_create( &threadId, NULL, jackStopStream, info );
2642     else
2643       pthread_cond_signal( &handle->condition );
2644     return SUCCESS;
2645   }
2646
2647   // Invoke user callback first, to get fresh output data.
2648   if ( handle->drainCounter == 0 ) {
2649     RtAudioCallback callback = (RtAudioCallback) info->callback;
2650     double streamTime = getStreamTime();
2651     RtAudioStreamStatus status = 0;
2652     if ( stream_.mode != INPUT && handle->xrun[0] == true ) {
2653       status |= RTAUDIO_OUTPUT_UNDERFLOW;
2654       handle->xrun[0] = false;
2655     }
2656     if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) {
2657       status |= RTAUDIO_INPUT_OVERFLOW;
2658       handle->xrun[1] = false;
2659     }
2660     int cbReturnValue = callback( stream_.userBuffer[0], stream_.userBuffer[1],
2661                                   stream_.bufferSize, streamTime, status, info->userData );
2662     if ( cbReturnValue == 2 ) {
2663       stream_.state = STREAM_STOPPING;
2664       handle->drainCounter = 2;
2665       ThreadHandle id;
2666       pthread_create( &id, NULL, jackStopStream, info );
2667       return SUCCESS;
2668     }
2669     else if ( cbReturnValue == 1 ) {
2670       handle->drainCounter = 1;
2671       handle->internalDrain = true;
2672     }
2673   }
2674
2675   jack_default_audio_sample_t *jackbuffer;
2676   unsigned long bufferBytes = nframes * sizeof( jack_default_audio_sample_t );
2677   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
2678
2679     if ( handle->drainCounter > 1 ) { // write zeros to the output stream
2680
2681       for ( unsigned int i=0; i<stream_.nDeviceChannels[0]; i++ ) {
2682         jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[0][i], (jack_nframes_t) nframes );
2683         memset( jackbuffer, 0, bufferBytes );
2684       }
2685
2686     }
2687     else if ( stream_.doConvertBuffer[0] ) {
2688
2689       convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] );
2690
2691       for ( unsigned int i=0; i<stream_.nDeviceChannels[0]; i++ ) {
2692         jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[0][i], (jack_nframes_t) nframes );
2693         memcpy( jackbuffer, &stream_.deviceBuffer[i*bufferBytes], bufferBytes );
2694       }
2695     }
2696     else { // no buffer conversion
2697       for ( unsigned int i=0; i<stream_.nUserChannels[0]; i++ ) {
2698         jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[0][i], (jack_nframes_t) nframes );
2699         memcpy( jackbuffer, &stream_.userBuffer[0][i*bufferBytes], bufferBytes );
2700       }
2701     }
2702   }
2703
2704   // Don't bother draining input
2705   if ( handle->drainCounter ) {
2706     handle->drainCounter++;
2707     goto unlock;
2708   }
2709
2710   if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
2711
2712     if ( stream_.doConvertBuffer[1] ) {
2713       for ( unsigned int i=0; i<stream_.nDeviceChannels[1]; i++ ) {
2714         jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[1][i], (jack_nframes_t) nframes );
2715         memcpy( &stream_.deviceBuffer[i*bufferBytes], jackbuffer, bufferBytes );
2716       }
2717       convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
2718     }
2719     else { // no buffer conversion
2720       for ( unsigned int i=0; i<stream_.nUserChannels[1]; i++ ) {
2721         jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[1][i], (jack_nframes_t) nframes );
2722         memcpy( &stream_.userBuffer[1][i*bufferBytes], jackbuffer, bufferBytes );
2723       }
2724     }
2725   }
2726
2727  unlock:
2728   RtApi::tickStreamTime();
2729   return SUCCESS;
2730 }
2731   //******************** End of __UNIX_JACK__ *********************//
2732 #endif
2733
2734 #if defined(__WINDOWS_ASIO__) // ASIO API on Windows
2735
2736 // The ASIO API is designed around a callback scheme, so this
2737 // implementation is similar to that used for OS-X CoreAudio and Linux
2738 // Jack.  The primary constraint with ASIO is that it only allows
2739 // access to a single driver at a time.  Thus, it is not possible to
2740 // have more than one simultaneous RtAudio stream.
2741 //
2742 // This implementation also requires a number of external ASIO files
2743 // and a few global variables.  The ASIO callback scheme does not
2744 // allow for the passing of user data, so we must create a global
2745 // pointer to our callbackInfo structure.
2746 //
2747 // On unix systems, we make use of a pthread condition variable.
2748 // Since there is no equivalent in Windows, I hacked something based
2749 // on information found in
2750 // http://www.cs.wustl.edu/~schmidt/win32-cv-1.html.
2751
2752 #include "asiosys.h"
2753 #include "asio.h"
2754 #include "iasiothiscallresolver.h"
2755 #include "asiodrivers.h"
2756 #include <cmath>
2757
2758 static AsioDrivers drivers;
2759 static ASIOCallbacks asioCallbacks;
2760 static ASIODriverInfo driverInfo;
2761 static CallbackInfo *asioCallbackInfo;
2762 static bool asioXRun;
2763
2764 struct AsioHandle {
2765   int drainCounter;       // Tracks callback counts when draining
2766   bool internalDrain;     // Indicates if stop is initiated from callback or not.
2767   ASIOBufferInfo *bufferInfos;
2768   HANDLE condition;
2769
2770   AsioHandle()
2771     :drainCounter(0), internalDrain(false), bufferInfos(0) {}
2772 };
2773
2774 // Function declarations (definitions at end of section)
2775 static const char* getAsioErrorString( ASIOError result );
2776 static void sampleRateChanged( ASIOSampleRate sRate );
2777 static long asioMessages( long selector, long value, void* message, double* opt );
2778
2779 RtApiAsio :: RtApiAsio()
2780 {
2781   // ASIO cannot run on a multi-threaded appartment. You can call
2782   // CoInitialize beforehand, but it must be for appartment threading
2783   // (in which case, CoInitilialize will return S_FALSE here).
2784   coInitialized_ = false;
2785   HRESULT hr = CoInitialize( NULL );
2786   if ( FAILED(hr) ) {
2787     errorText_ = "RtApiAsio::ASIO requires a single-threaded appartment. Call CoInitializeEx(0,COINIT_APARTMENTTHREADED)";
2788     error( RtAudioError::WARNING );
2789   }
2790   coInitialized_ = true;
2791
2792   drivers.removeCurrentDriver();
2793   driverInfo.asioVersion = 2;
2794
2795   // See note in DirectSound implementation about GetDesktopWindow().
2796   driverInfo.sysRef = GetForegroundWindow();
2797 }
2798
2799 RtApiAsio :: ~RtApiAsio()
2800 {
2801   if ( stream_.state != STREAM_CLOSED ) closeStream();
2802   if ( coInitialized_ ) CoUninitialize();
2803 }
2804
2805 unsigned int RtApiAsio :: getDeviceCount( void )
2806 {
2807   return (unsigned int) drivers.asioGetNumDev();
2808 }
2809
2810 RtAudio::DeviceInfo RtApiAsio :: getDeviceInfo( unsigned int device )
2811 {
2812   RtAudio::DeviceInfo info;
2813   info.probed = false;
2814
2815   // Get device ID
2816   unsigned int nDevices = getDeviceCount();
2817   if ( nDevices == 0 ) {
2818     errorText_ = "RtApiAsio::getDeviceInfo: no devices found!";
2819     error( RtAudioError::INVALID_USE );
2820     return info;
2821   }
2822
2823   if ( device >= nDevices ) {
2824     errorText_ = "RtApiAsio::getDeviceInfo: device ID is invalid!";
2825     error( RtAudioError::INVALID_USE );
2826     return info;
2827   }
2828
2829   // If a stream is already open, we cannot probe other devices.  Thus, use the saved results.
2830   if ( stream_.state != STREAM_CLOSED ) {
2831     if ( device >= devices_.size() ) {
2832       errorText_ = "RtApiAsio::getDeviceInfo: device ID was not present before stream was opened.";
2833       error( RtAudioError::WARNING );
2834       return info;
2835     }
2836     return devices_[ device ];
2837   }
2838
2839   char driverName[32];
2840   ASIOError result = drivers.asioGetDriverName( (int) device, driverName, 32 );
2841   if ( result != ASE_OK ) {
2842     errorStream_ << "RtApiAsio::getDeviceInfo: unable to get driver name (" << getAsioErrorString( result ) << ").";
2843     errorText_ = errorStream_.str();
2844     error( RtAudioError::WARNING );
2845     return info;
2846   }
2847
2848   info.name = driverName;
2849
2850   if ( !drivers.loadDriver( driverName ) ) {
2851     errorStream_ << "RtApiAsio::getDeviceInfo: unable to load driver (" << driverName << ").";
2852     errorText_ = errorStream_.str();
2853     error( RtAudioError::WARNING );
2854     return info;
2855   }
2856
2857   result = ASIOInit( &driverInfo );
2858   if ( result != ASE_OK ) {
2859     errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") initializing driver (" << driverName << ").";
2860     errorText_ = errorStream_.str();
2861     error( RtAudioError::WARNING );
2862     return info;
2863   }
2864
2865   // Determine the device channel information.
2866   long inputChannels, outputChannels;
2867   result = ASIOGetChannels( &inputChannels, &outputChannels );
2868   if ( result != ASE_OK ) {
2869     drivers.removeCurrentDriver();
2870     errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") getting channel count (" << driverName << ").";
2871     errorText_ = errorStream_.str();
2872     error( RtAudioError::WARNING );
2873     return info;
2874   }
2875
2876   info.outputChannels = outputChannels;
2877   info.inputChannels = inputChannels;
2878   if ( info.outputChannels > 0 && info.inputChannels > 0 )
2879     info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
2880
2881   // Determine the supported sample rates.
2882   info.sampleRates.clear();
2883   for ( unsigned int i=0; i<MAX_SAMPLE_RATES; i++ ) {
2884     result = ASIOCanSampleRate( (ASIOSampleRate) SAMPLE_RATES[i] );
2885     if ( result == ASE_OK ) {
2886       info.sampleRates.push_back( SAMPLE_RATES[i] );
2887
2888       if ( !info.preferredSampleRate || ( SAMPLE_RATES[i] <= 48000 && SAMPLE_RATES[i] > info.preferredSampleRate ) )
2889         info.preferredSampleRate = SAMPLE_RATES[i];
2890     }
2891   }
2892
2893   // Determine supported data types ... just check first channel and assume rest are the same.
2894   ASIOChannelInfo channelInfo;
2895   channelInfo.channel = 0;
2896   channelInfo.isInput = true;
2897   if ( info.inputChannels <= 0 ) channelInfo.isInput = false;
2898   result = ASIOGetChannelInfo( &channelInfo );
2899   if ( result != ASE_OK ) {
2900     drivers.removeCurrentDriver();
2901     errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") getting driver channel info (" << driverName << ").";
2902     errorText_ = errorStream_.str();
2903     error( RtAudioError::WARNING );
2904     return info;
2905   }
2906
2907   info.nativeFormats = 0;
2908   if ( channelInfo.type == ASIOSTInt16MSB || channelInfo.type == ASIOSTInt16LSB )
2909     info.nativeFormats |= RTAUDIO_SINT16;
2910   else if ( channelInfo.type == ASIOSTInt32MSB || channelInfo.type == ASIOSTInt32LSB )
2911     info.nativeFormats |= RTAUDIO_SINT32;
2912   else if ( channelInfo.type == ASIOSTFloat32MSB || channelInfo.type == ASIOSTFloat32LSB )
2913     info.nativeFormats |= RTAUDIO_FLOAT32;
2914   else if ( channelInfo.type == ASIOSTFloat64MSB || channelInfo.type == ASIOSTFloat64LSB )
2915     info.nativeFormats |= RTAUDIO_FLOAT64;
2916   else if ( channelInfo.type == ASIOSTInt24MSB || channelInfo.type == ASIOSTInt24LSB )
2917     info.nativeFormats |= RTAUDIO_SINT24;
2918
2919   if ( info.outputChannels > 0 )
2920     if ( getDefaultOutputDevice() == device ) info.isDefaultOutput = true;
2921   if ( info.inputChannels > 0 )
2922     if ( getDefaultInputDevice() == device ) info.isDefaultInput = true;
2923
2924   info.probed = true;
2925   drivers.removeCurrentDriver();
2926   return info;
2927 }
2928
2929 static void bufferSwitch( long index, ASIOBool /*processNow*/ )
2930 {
2931   RtApiAsio *object = (RtApiAsio *) asioCallbackInfo->object;
2932   object->callbackEvent( index );
2933 }
2934
2935 void RtApiAsio :: saveDeviceInfo( void )
2936 {
2937   devices_.clear();
2938
2939   unsigned int nDevices = getDeviceCount();
2940   devices_.resize( nDevices );
2941   for ( unsigned int i=0; i<nDevices; i++ )
2942     devices_[i] = getDeviceInfo( i );
2943 }
2944
2945 bool RtApiAsio :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
2946                                    unsigned int firstChannel, unsigned int sampleRate,
2947                                    RtAudioFormat format, unsigned int *bufferSize,
2948                                    RtAudio::StreamOptions *options )
2949 {////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2950
2951   bool isDuplexInput =  mode == INPUT && stream_.mode == OUTPUT;
2952
2953   // For ASIO, a duplex stream MUST use the same driver.
2954   if ( isDuplexInput && stream_.device[0] != device ) {
2955     errorText_ = "RtApiAsio::probeDeviceOpen: an ASIO duplex stream must use the same device for input and output!";
2956     return FAILURE;
2957   }
2958
2959   char driverName[32];
2960   ASIOError result = drivers.asioGetDriverName( (int) device, driverName, 32 );
2961   if ( result != ASE_OK ) {
2962     errorStream_ << "RtApiAsio::probeDeviceOpen: unable to get driver name (" << getAsioErrorString( result ) << ").";
2963     errorText_ = errorStream_.str();
2964     return FAILURE;
2965   }
2966
2967   // Only load the driver once for duplex stream.
2968   if ( !isDuplexInput ) {
2969     // The getDeviceInfo() function will not work when a stream is open
2970     // because ASIO does not allow multiple devices to run at the same
2971     // time.  Thus, we'll probe the system before opening a stream and
2972     // save the results for use by getDeviceInfo().
2973     this->saveDeviceInfo();
2974
2975     if ( !drivers.loadDriver( driverName ) ) {
2976       errorStream_ << "RtApiAsio::probeDeviceOpen: unable to load driver (" << driverName << ").";
2977       errorText_ = errorStream_.str();
2978       return FAILURE;
2979     }
2980
2981     result = ASIOInit( &driverInfo );
2982     if ( result != ASE_OK ) {
2983       errorStream_ << "RtApiAsio::probeDeviceOpen: error (" << getAsioErrorString( result ) << ") initializing driver (" << driverName << ").";
2984       errorText_ = errorStream_.str();
2985       return FAILURE;
2986     }
2987   }
2988
2989   // keep them before any "goto error", they are used for error cleanup + goto device boundary checks
2990   bool buffersAllocated = false;
2991   AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
2992   unsigned int nChannels;
2993
2994
2995   // Check the device channel count.
2996   long inputChannels, outputChannels;
2997   result = ASIOGetChannels( &inputChannels, &outputChannels );
2998   if ( result != ASE_OK ) {
2999     errorStream_ << "RtApiAsio::probeDeviceOpen: error (" << getAsioErrorString( result ) << ") getting channel count (" << driverName << ").";
3000     errorText_ = errorStream_.str();
3001     goto error;
3002   }
3003
3004   if ( ( mode == OUTPUT && (channels+firstChannel) > (unsigned int) outputChannels) ||
3005        ( mode == INPUT && (channels+firstChannel) > (unsigned int) inputChannels) ) {
3006     errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") does not support requested channel count (" << channels << ") + offset (" << firstChannel << ").";
3007     errorText_ = errorStream_.str();
3008     goto error;
3009   }
3010   stream_.nDeviceChannels[mode] = channels;
3011   stream_.nUserChannels[mode] = channels;
3012   stream_.channelOffset[mode] = firstChannel;
3013
3014   // Verify the sample rate is supported.
3015   result = ASIOCanSampleRate( (ASIOSampleRate) sampleRate );
3016   if ( result != ASE_OK ) {
3017     errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") does not support requested sample rate (" << sampleRate << ").";
3018     errorText_ = errorStream_.str();
3019     goto error;
3020   }
3021
3022   // Get the current sample rate
3023   ASIOSampleRate currentRate;
3024   result = ASIOGetSampleRate( &currentRate );
3025   if ( result != ASE_OK ) {
3026     errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error getting sample rate.";
3027     errorText_ = errorStream_.str();
3028     goto error;
3029   }
3030
3031   // Set the sample rate only if necessary
3032   if ( currentRate != sampleRate ) {
3033     result = ASIOSetSampleRate( (ASIOSampleRate) sampleRate );
3034     if ( result != ASE_OK ) {
3035       errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error setting sample rate (" << sampleRate << ").";
3036       errorText_ = errorStream_.str();
3037       goto error;
3038     }
3039   }
3040
3041   // Determine the driver data type.
3042   ASIOChannelInfo channelInfo;
3043   channelInfo.channel = 0;
3044   if ( mode == OUTPUT ) channelInfo.isInput = false;
3045   else channelInfo.isInput = true;
3046   result = ASIOGetChannelInfo( &channelInfo );
3047   if ( result != ASE_OK ) {
3048     errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") getting data format.";
3049     errorText_ = errorStream_.str();
3050     goto error;
3051   }
3052
3053   // Assuming WINDOWS host is always little-endian.
3054   stream_.doByteSwap[mode] = false;
3055   stream_.userFormat = format;
3056   stream_.deviceFormat[mode] = 0;
3057   if ( channelInfo.type == ASIOSTInt16MSB || channelInfo.type == ASIOSTInt16LSB ) {
3058     stream_.deviceFormat[mode] = RTAUDIO_SINT16;
3059     if ( channelInfo.type == ASIOSTInt16MSB ) stream_.doByteSwap[mode] = true;
3060   }
3061   else if ( channelInfo.type == ASIOSTInt32MSB || channelInfo.type == ASIOSTInt32LSB ) {
3062     stream_.deviceFormat[mode] = RTAUDIO_SINT32;
3063     if ( channelInfo.type == ASIOSTInt32MSB ) stream_.doByteSwap[mode] = true;
3064   }
3065   else if ( channelInfo.type == ASIOSTFloat32MSB || channelInfo.type == ASIOSTFloat32LSB ) {
3066     stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
3067     if ( channelInfo.type == ASIOSTFloat32MSB ) stream_.doByteSwap[mode] = true;
3068   }
3069   else if ( channelInfo.type == ASIOSTFloat64MSB || channelInfo.type == ASIOSTFloat64LSB ) {
3070     stream_.deviceFormat[mode] = RTAUDIO_FLOAT64;
3071     if ( channelInfo.type == ASIOSTFloat64MSB ) stream_.doByteSwap[mode] = true;
3072   }
3073   else if ( channelInfo.type == ASIOSTInt24MSB || channelInfo.type == ASIOSTInt24LSB ) {
3074     stream_.deviceFormat[mode] = RTAUDIO_SINT24;
3075     if ( channelInfo.type == ASIOSTInt24MSB ) stream_.doByteSwap[mode] = true;
3076   }
3077
3078   if ( stream_.deviceFormat[mode] == 0 ) {
3079     errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") data format not supported by RtAudio.";
3080     errorText_ = errorStream_.str();
3081     goto error;
3082   }
3083
3084   // Set the buffer size.  For a duplex stream, this will end up
3085   // setting the buffer size based on the input constraints, which
3086   // should be ok.
3087   long minSize, maxSize, preferSize, granularity;
3088   result = ASIOGetBufferSize( &minSize, &maxSize, &preferSize, &granularity );
3089   if ( result != ASE_OK ) {
3090     errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") getting buffer size.";
3091     errorText_ = errorStream_.str();
3092     goto error;
3093   }
3094
3095   if ( isDuplexInput ) {
3096     // When this is the duplex input (output was opened before), then we have to use the same
3097     // buffersize as the output, because it might use the preferred buffer size, which most
3098     // likely wasn't passed as input to this. The buffer sizes have to be identically anyway,
3099     // So instead of throwing an error, make them equal. The caller uses the reference
3100     // to the "bufferSize" param as usual to set up processing buffers.
3101
3102     *bufferSize = stream_.bufferSize;
3103
3104   } else {
3105     if ( *bufferSize == 0 ) *bufferSize = preferSize;
3106     else if ( *bufferSize < (unsigned int) minSize ) *bufferSize = (unsigned int) minSize;
3107     else if ( *bufferSize > (unsigned int) maxSize ) *bufferSize = (unsigned int) maxSize;
3108     else if ( granularity == -1 ) {
3109       // Make sure bufferSize is a power of two.
3110       int log2_of_min_size = 0;
3111       int log2_of_max_size = 0;
3112
3113       for ( unsigned int i = 0; i < sizeof(long) * 8; i++ ) {
3114         if ( minSize & ((long)1 << i) ) log2_of_min_size = i;
3115         if ( maxSize & ((long)1 << i) ) log2_of_max_size = i;
3116       }
3117
3118       long min_delta = std::abs( (long)*bufferSize - ((long)1 << log2_of_min_size) );
3119       int min_delta_num = log2_of_min_size;
3120
3121       for (int i = log2_of_min_size + 1; i <= log2_of_max_size; i++) {
3122         long current_delta = std::abs( (long)*bufferSize - ((long)1 << i) );
3123         if (current_delta < min_delta) {
3124           min_delta = current_delta;
3125           min_delta_num = i;
3126         }
3127       }
3128
3129       *bufferSize = ( (unsigned int)1 << min_delta_num );
3130       if ( *bufferSize < (unsigned int) minSize ) *bufferSize = (unsigned int) minSize;
3131       else if ( *bufferSize > (unsigned int) maxSize ) *bufferSize = (unsigned int) maxSize;
3132     }
3133     else if ( granularity != 0 ) {
3134       // Set to an even multiple of granularity, rounding up.
3135       *bufferSize = (*bufferSize + granularity-1) / granularity * granularity;
3136     }
3137   }
3138
3139   /*
3140   // we don't use it anymore, see above!
3141   // Just left it here for the case...
3142   if ( isDuplexInput && stream_.bufferSize != *bufferSize ) {
3143     errorText_ = "RtApiAsio::probeDeviceOpen: input/output buffersize discrepancy!";
3144     goto error;
3145   }
3146   */
3147
3148   stream_.bufferSize = *bufferSize;
3149   stream_.nBuffers = 2;
3150
3151   if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
3152   else stream_.userInterleaved = true;
3153
3154   // ASIO always uses non-interleaved buffers.
3155   stream_.deviceInterleaved[mode] = false;
3156
3157   // Allocate, if necessary, our AsioHandle structure for the stream.
3158   if ( handle == 0 ) {
3159     try {
3160       handle = new AsioHandle;
3161     }
3162     catch ( std::bad_alloc& ) {
3163       errorText_ = "RtApiAsio::probeDeviceOpen: error allocating AsioHandle memory.";
3164       goto error;
3165     }
3166     handle->bufferInfos = 0;
3167
3168     // Create a manual-reset event.
3169     handle->condition = CreateEvent( NULL,   // no security
3170                                      TRUE,   // manual-reset
3171                                      FALSE,  // non-signaled initially
3172                                      NULL ); // unnamed
3173     stream_.apiHandle = (void *) handle;
3174   }
3175
3176   // Create the ASIO internal buffers.  Since RtAudio sets up input
3177   // and output separately, we'll have to dispose of previously
3178   // created output buffers for a duplex stream.
3179   if ( mode == INPUT && stream_.mode == OUTPUT ) {
3180     ASIODisposeBuffers();
3181     if ( handle->bufferInfos ) free( handle->bufferInfos );
3182   }
3183
3184   // Allocate, initialize, and save the bufferInfos in our stream callbackInfo structure.
3185   unsigned int i;
3186   nChannels = stream_.nDeviceChannels[0] + stream_.nDeviceChannels[1];
3187   handle->bufferInfos = (ASIOBufferInfo *) malloc( nChannels * sizeof(ASIOBufferInfo) );
3188   if ( handle->bufferInfos == NULL ) {
3189     errorStream_ << "RtApiAsio::probeDeviceOpen: error allocating bufferInfo memory for driver (" << driverName << ").";
3190     errorText_ = errorStream_.str();
3191     goto error;
3192   }
3193
3194   ASIOBufferInfo *infos;
3195   infos = handle->bufferInfos;
3196   for ( i=0; i<stream_.nDeviceChannels[0]; i++, infos++ ) {
3197     infos->isInput = ASIOFalse;
3198     infos->channelNum = i + stream_.channelOffset[0];
3199     infos->buffers[0] = infos->buffers[1] = 0;
3200   }
3201   for ( i=0; i<stream_.nDeviceChannels[1]; i++, infos++ ) {
3202     infos->isInput = ASIOTrue;
3203     infos->channelNum = i + stream_.channelOffset[1];
3204     infos->buffers[0] = infos->buffers[1] = 0;
3205   }
3206
3207   // prepare for callbacks
3208   stream_.sampleRate = sampleRate;
3209   stream_.device[mode] = device;
3210   stream_.mode = isDuplexInput ? DUPLEX : mode;
3211
3212   // store this class instance before registering callbacks, that are going to use it
3213   asioCallbackInfo = &stream_.callbackInfo;
3214   stream_.callbackInfo.object = (void *) this;
3215
3216   // Set up the ASIO callback structure and create the ASIO data buffers.
3217   asioCallbacks.bufferSwitch = &bufferSwitch;
3218   asioCallbacks.sampleRateDidChange = &sampleRateChanged;
3219   asioCallbacks.asioMessage = &asioMessages;
3220   asioCallbacks.bufferSwitchTimeInfo = NULL;
3221   result = ASIOCreateBuffers( handle->bufferInfos, nChannels, stream_.bufferSize, &asioCallbacks );
3222   if ( result != ASE_OK ) {
3223     // Standard method failed. This can happen with strict/misbehaving drivers that return valid buffer size ranges
3224     // but only accept the preferred buffer size as parameter for ASIOCreateBuffers (e.g. Creative's ASIO driver).
3225     // In that case, let's be naïve and try that instead.
3226     *bufferSize = preferSize;
3227     stream_.bufferSize = *bufferSize;
3228     result = ASIOCreateBuffers( handle->bufferInfos, nChannels, stream_.bufferSize, &asioCallbacks );
3229   }
3230
3231   if ( result != ASE_OK ) {
3232     errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") creating buffers.";
3233     errorText_ = errorStream_.str();
3234     goto error;
3235   }
3236   buffersAllocated = true;
3237   stream_.state = STREAM_STOPPED;
3238
3239   // Set flags for buffer conversion.
3240   stream_.doConvertBuffer[mode] = false;
3241   if ( stream_.userFormat != stream_.deviceFormat[mode] )
3242     stream_.doConvertBuffer[mode] = true;
3243   if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
3244        stream_.nUserChannels[mode] > 1 )
3245     stream_.doConvertBuffer[mode] = true;
3246
3247   // Allocate necessary internal buffers
3248   unsigned long bufferBytes;
3249   bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
3250   stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
3251   if ( stream_.userBuffer[mode] == NULL ) {
3252     errorText_ = "RtApiAsio::probeDeviceOpen: error allocating user buffer memory.";
3253     goto error;
3254   }
3255
3256   if ( stream_.doConvertBuffer[mode] ) {
3257
3258     bool makeBuffer = true;
3259     bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
3260     if ( isDuplexInput && stream_.deviceBuffer ) {
3261       unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
3262       if ( bufferBytes <= bytesOut ) makeBuffer = false;
3263     }
3264
3265     if ( makeBuffer ) {
3266       bufferBytes *= *bufferSize;
3267       if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
3268       stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
3269       if ( stream_.deviceBuffer == NULL ) {
3270         errorText_ = "RtApiAsio::probeDeviceOpen: error allocating device buffer memory.";
3271         goto error;
3272       }
3273     }
3274   }
3275
3276   // Determine device latencies
3277   long inputLatency, outputLatency;
3278   result = ASIOGetLatencies( &inputLatency, &outputLatency );
3279   if ( result != ASE_OK ) {
3280     errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") getting latency.";
3281     errorText_ = errorStream_.str();
3282     error( RtAudioError::WARNING); // warn but don't fail
3283   }
3284   else {
3285     stream_.latency[0] = outputLatency;
3286     stream_.latency[1] = inputLatency;
3287   }
3288
3289   // Setup the buffer conversion information structure.  We don't use
3290   // buffers to do channel offsets, so we override that parameter
3291   // here.
3292   if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, 0 );
3293
3294   return SUCCESS;
3295
3296  error:
3297   if ( !isDuplexInput ) {
3298     // the cleanup for error in the duplex input, is done by RtApi::openStream
3299     // So we clean up for single channel only
3300
3301     if ( buffersAllocated )
3302       ASIODisposeBuffers();
3303
3304     drivers.removeCurrentDriver();
3305
3306     if ( handle ) {
3307       CloseHandle( handle->condition );
3308       if ( handle->bufferInfos )
3309         free( handle->bufferInfos );
3310
3311       delete handle;
3312       stream_.apiHandle = 0;
3313     }
3314
3315
3316     if ( stream_.userBuffer[mode] ) {
3317       free( stream_.userBuffer[mode] );
3318       stream_.userBuffer[mode] = 0;
3319     }
3320
3321     if ( stream_.deviceBuffer ) {
3322       free( stream_.deviceBuffer );
3323       stream_.deviceBuffer = 0;
3324     }
3325   }
3326
3327   return FAILURE;
3328 }////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3329
3330 void RtApiAsio :: closeStream()
3331 {
3332   if ( stream_.state == STREAM_CLOSED ) {
3333     errorText_ = "RtApiAsio::closeStream(): no open stream to close!";
3334     error( RtAudioError::WARNING );
3335     return;
3336   }
3337
3338   if ( stream_.state == STREAM_RUNNING ) {
3339     stream_.state = STREAM_STOPPED;
3340     ASIOStop();
3341   }
3342   ASIODisposeBuffers();
3343   drivers.removeCurrentDriver();
3344
3345   AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
3346   if ( handle ) {
3347     CloseHandle( handle->condition );
3348     if ( handle->bufferInfos )
3349       free( handle->bufferInfos );
3350     delete handle;
3351     stream_.apiHandle = 0;
3352   }
3353
3354   for ( int i=0; i<2; i++ ) {
3355     if ( stream_.userBuffer[i] ) {
3356       free( stream_.userBuffer[i] );
3357       stream_.userBuffer[i] = 0;
3358     }
3359   }
3360
3361   if ( stream_.deviceBuffer ) {
3362     free( stream_.deviceBuffer );
3363     stream_.deviceBuffer = 0;
3364   }
3365
3366   stream_.mode = UNINITIALIZED;
3367   stream_.state = STREAM_CLOSED;
3368 }
3369
3370 bool stopThreadCalled = false;
3371
3372 void RtApiAsio :: startStream()
3373 {
3374   verifyStream();
3375   if ( stream_.state == STREAM_RUNNING ) {
3376     errorText_ = "RtApiAsio::startStream(): the stream is already running!";
3377     error( RtAudioError::WARNING );
3378     return;
3379   }
3380
3381   AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
3382   ASIOError result = ASIOStart();
3383   if ( result != ASE_OK ) {
3384     errorStream_ << "RtApiAsio::startStream: error (" << getAsioErrorString( result ) << ") starting device.";
3385     errorText_ = errorStream_.str();
3386     goto unlock;
3387   }
3388
3389   handle->drainCounter = 0;
3390   handle->internalDrain = false;
3391   ResetEvent( handle->condition );
3392   stream_.state = STREAM_RUNNING;
3393   asioXRun = false;
3394
3395  unlock:
3396   stopThreadCalled = false;
3397
3398   if ( result == ASE_OK ) return;
3399   error( RtAudioError::SYSTEM_ERROR );
3400 }
3401
3402 void RtApiAsio :: stopStream()
3403 {
3404   verifyStream();
3405   if ( stream_.state == STREAM_STOPPED ) {
3406     errorText_ = "RtApiAsio::stopStream(): the stream is already stopped!";
3407     error( RtAudioError::WARNING );
3408     return;
3409   }
3410
3411   AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
3412   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
3413     if ( handle->drainCounter == 0 ) {
3414       handle->drainCounter = 2;
3415       WaitForSingleObject( handle->condition, INFINITE );  // block until signaled
3416     }
3417   }
3418
3419   stream_.state = STREAM_STOPPED;
3420
3421   ASIOError result = ASIOStop();
3422   if ( result != ASE_OK ) {
3423     errorStream_ << "RtApiAsio::stopStream: error (" << getAsioErrorString( result ) << ") stopping device.";
3424     errorText_ = errorStream_.str();
3425   }
3426
3427   if ( result == ASE_OK ) return;
3428   error( RtAudioError::SYSTEM_ERROR );
3429 }
3430
3431 void RtApiAsio :: abortStream()
3432 {
3433   verifyStream();
3434   if ( stream_.state == STREAM_STOPPED ) {
3435     errorText_ = "RtApiAsio::abortStream(): the stream is already stopped!";
3436     error( RtAudioError::WARNING );
3437     return;
3438   }
3439
3440   // The following lines were commented-out because some behavior was
3441   // noted where the device buffers need to be zeroed to avoid
3442   // continuing sound, even when the device buffers are completely
3443   // disposed.  So now, calling abort is the same as calling stop.
3444   // AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
3445   // handle->drainCounter = 2;
3446   stopStream();
3447 }
3448
3449 // This function will be called by a spawned thread when the user
3450 // callback function signals that the stream should be stopped or
3451 // aborted.  It is necessary to handle it this way because the
3452 // callbackEvent() function must return before the ASIOStop()
3453 // function will return.
3454 static unsigned __stdcall asioStopStream( void *ptr )
3455 {
3456   CallbackInfo *info = (CallbackInfo *) ptr;
3457   RtApiAsio *object = (RtApiAsio *) info->object;
3458
3459   object->stopStream();
3460   _endthreadex( 0 );
3461   return 0;
3462 }
3463
3464 bool RtApiAsio :: callbackEvent( long bufferIndex )
3465 {
3466   if ( stream_.state == STREAM_STOPPED || stream_.state == STREAM_STOPPING ) return SUCCESS;
3467   if ( stream_.state == STREAM_CLOSED ) {
3468     errorText_ = "RtApiAsio::callbackEvent(): the stream is closed ... this shouldn't happen!";
3469     error( RtAudioError::WARNING );
3470     return FAILURE;
3471   }
3472
3473   CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
3474   AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
3475
3476   // Check if we were draining the stream and signal if finished.
3477   if ( handle->drainCounter > 3 ) {
3478
3479     stream_.state = STREAM_STOPPING;
3480     if ( handle->internalDrain == false )
3481       SetEvent( handle->condition );
3482     else { // spawn a thread to stop the stream
3483       unsigned threadId;
3484       stream_.callbackInfo.thread = _beginthreadex( NULL, 0, &asioStopStream,
3485                                                     &stream_.callbackInfo, 0, &threadId );
3486     }
3487     return SUCCESS;
3488   }
3489
3490   // Invoke user callback to get fresh output data UNLESS we are
3491   // draining stream.
3492   if ( handle->drainCounter == 0 ) {
3493     RtAudioCallback callback = (RtAudioCallback) info->callback;
3494     double streamTime = getStreamTime();
3495     RtAudioStreamStatus status = 0;
3496     if ( stream_.mode != INPUT && asioXRun == true ) {
3497       status |= RTAUDIO_OUTPUT_UNDERFLOW;
3498       asioXRun = false;
3499     }
3500     if ( stream_.mode != OUTPUT && asioXRun == true ) {
3501       status |= RTAUDIO_INPUT_OVERFLOW;
3502       asioXRun = false;
3503     }
3504     int cbReturnValue = callback( stream_.userBuffer[0], stream_.userBuffer[1],
3505                                      stream_.bufferSize, streamTime, status, info->userData );
3506     if ( cbReturnValue == 2 ) {
3507       stream_.state = STREAM_STOPPING;
3508       handle->drainCounter = 2;
3509       unsigned threadId;
3510       stream_.callbackInfo.thread = _beginthreadex( NULL, 0, &asioStopStream,
3511                                                     &stream_.callbackInfo, 0, &threadId );
3512       return SUCCESS;
3513     }
3514     else if ( cbReturnValue == 1 ) {
3515       handle->drainCounter = 1;
3516       handle->internalDrain = true;
3517     }
3518   }
3519
3520   unsigned int nChannels, bufferBytes, i, j;
3521   nChannels = stream_.nDeviceChannels[0] + stream_.nDeviceChannels[1];
3522   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
3523
3524     bufferBytes = stream_.bufferSize * formatBytes( stream_.deviceFormat[0] );
3525
3526     if ( handle->drainCounter > 1 ) { // write zeros to the output stream
3527
3528       for ( i=0, j=0; i<nChannels; i++ ) {
3529         if ( handle->bufferInfos[i].isInput != ASIOTrue )
3530           memset( handle->bufferInfos[i].buffers[bufferIndex], 0, bufferBytes );
3531       }
3532
3533     }
3534     else if ( stream_.doConvertBuffer[0] ) {
3535
3536       convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] );
3537       if ( stream_.doByteSwap[0] )
3538         byteSwapBuffer( stream_.deviceBuffer,
3539                         stream_.bufferSize * stream_.nDeviceChannels[0],
3540                         stream_.deviceFormat[0] );
3541
3542       for ( i=0, j=0; i<nChannels; i++ ) {
3543         if ( handle->bufferInfos[i].isInput != ASIOTrue )
3544           memcpy( handle->bufferInfos[i].buffers[bufferIndex],
3545                   &stream_.deviceBuffer[j++*bufferBytes], bufferBytes );
3546       }
3547
3548     }
3549     else {
3550
3551       if ( stream_.doByteSwap[0] )
3552         byteSwapBuffer( stream_.userBuffer[0],
3553                         stream_.bufferSize * stream_.nUserChannels[0],
3554                         stream_.userFormat );
3555
3556       for ( i=0, j=0; i<nChannels; i++ ) {
3557         if ( handle->bufferInfos[i].isInput != ASIOTrue )
3558           memcpy( handle->bufferInfos[i].buffers[bufferIndex],
3559                   &stream_.userBuffer[0][bufferBytes*j++], bufferBytes );
3560       }
3561
3562     }
3563   }
3564
3565   // Don't bother draining input
3566   if ( handle->drainCounter ) {
3567     handle->drainCounter++;
3568     goto unlock;
3569   }
3570
3571   if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
3572
3573     bufferBytes = stream_.bufferSize * formatBytes(stream_.deviceFormat[1]);
3574
3575     if (stream_.doConvertBuffer[1]) {
3576
3577       // Always interleave ASIO input data.
3578       for ( i=0, j=0; i<nChannels; i++ ) {
3579         if ( handle->bufferInfos[i].isInput == ASIOTrue )
3580           memcpy( &stream_.deviceBuffer[j++*bufferBytes],
3581                   handle->bufferInfos[i].buffers[bufferIndex],
3582                   bufferBytes );
3583       }
3584
3585       if ( stream_.doByteSwap[1] )
3586         byteSwapBuffer( stream_.deviceBuffer,
3587                         stream_.bufferSize * stream_.nDeviceChannels[1],
3588                         stream_.deviceFormat[1] );
3589       convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
3590
3591     }
3592     else {
3593       for ( i=0, j=0; i<nChannels; i++ ) {
3594         if ( handle->bufferInfos[i].isInput == ASIOTrue ) {
3595           memcpy( &stream_.userBuffer[1][bufferBytes*j++],
3596                   handle->bufferInfos[i].buffers[bufferIndex],
3597                   bufferBytes );
3598         }
3599       }
3600
3601       if ( stream_.doByteSwap[1] )
3602         byteSwapBuffer( stream_.userBuffer[1],
3603                         stream_.bufferSize * stream_.nUserChannels[1],
3604                         stream_.userFormat );
3605     }
3606   }
3607
3608  unlock:
3609   // The following call was suggested by Malte Clasen.  While the API
3610   // documentation indicates it should not be required, some device
3611   // drivers apparently do not function correctly without it.
3612   ASIOOutputReady();
3613
3614   RtApi::tickStreamTime();
3615   return SUCCESS;
3616 }
3617
3618 static void sampleRateChanged( ASIOSampleRate sRate )
3619 {
3620   // The ASIO documentation says that this usually only happens during
3621   // external sync.  Audio processing is not stopped by the driver,
3622   // actual sample rate might not have even changed, maybe only the
3623   // sample rate status of an AES/EBU or S/PDIF digital input at the
3624   // audio device.
3625
3626   RtApi *object = (RtApi *) asioCallbackInfo->object;
3627   try {
3628     object->stopStream();
3629   }
3630   catch ( RtAudioError &exception ) {
3631     std::cerr << "\nRtApiAsio: sampleRateChanged() error (" << exception.getMessage() << ")!\n" << std::endl;
3632     return;
3633   }
3634
3635   std::cerr << "\nRtApiAsio: driver reports sample rate changed to " << sRate << " ... stream stopped!!!\n" << std::endl;
3636 }
3637
3638 static long asioMessages( long selector, long value, void* /*message*/, double* /*opt*/ )
3639 {
3640   long ret = 0;
3641
3642   switch( selector ) {
3643   case kAsioSelectorSupported:
3644     if ( value == kAsioResetRequest
3645          || value == kAsioEngineVersion
3646          || value == kAsioResyncRequest
3647          || value == kAsioLatenciesChanged
3648          // The following three were added for ASIO 2.0, you don't
3649          // necessarily have to support them.
3650          || value == kAsioSupportsTimeInfo
3651          || value == kAsioSupportsTimeCode
3652          || value == kAsioSupportsInputMonitor)
3653       ret = 1L;
3654     break;
3655   case kAsioResetRequest:
3656     // Defer the task and perform the reset of the driver during the
3657     // next "safe" situation.  You cannot reset the driver right now,
3658     // as this code is called from the driver.  Reset the driver is
3659     // done by completely destruct is. I.e. ASIOStop(),
3660     // ASIODisposeBuffers(), Destruction Afterwards you initialize the
3661     // driver again.
3662     std::cerr << "\nRtApiAsio: driver reset requested!!!" << std::endl;
3663     ret = 1L;
3664     break;
3665   case kAsioResyncRequest:
3666     // This informs the application that the driver encountered some
3667     // non-fatal data loss.  It is used for synchronization purposes
3668     // of different media.  Added mainly to work around the Win16Mutex
3669     // problems in Windows 95/98 with the Windows Multimedia system,
3670     // which could lose data because the Mutex was held too long by
3671     // another thread.  However a driver can issue it in other
3672     // situations, too.
3673     // std::cerr << "\nRtApiAsio: driver resync requested!!!" << std::endl;
3674     asioXRun = true;
3675     ret = 1L;
3676     break;
3677   case kAsioLatenciesChanged:
3678     // This will inform the host application that the drivers were
3679     // latencies changed.  Beware, it this does not mean that the
3680     // buffer sizes have changed!  You might need to update internal
3681     // delay data.
3682     std::cerr << "\nRtApiAsio: driver latency may have changed!!!" << std::endl;
3683     ret = 1L;
3684     break;
3685   case kAsioEngineVersion:
3686     // Return the supported ASIO version of the host application.  If
3687     // a host application does not implement this selector, ASIO 1.0
3688     // is assumed by the driver.
3689     ret = 2L;
3690     break;
3691   case kAsioSupportsTimeInfo:
3692     // Informs the driver whether the
3693     // asioCallbacks.bufferSwitchTimeInfo() callback is supported.
3694     // For compatibility with ASIO 1.0 drivers the host application
3695     // should always support the "old" bufferSwitch method, too.
3696     ret = 0;
3697     break;
3698   case kAsioSupportsTimeCode:
3699     // Informs the driver whether application is interested in time
3700     // code info.  If an application does not need to know about time
3701     // code, the driver has less work to do.
3702     ret = 0;
3703     break;
3704   }
3705   return ret;
3706 }
3707
3708 static const char* getAsioErrorString( ASIOError result )
3709 {
3710   struct Messages
3711   {
3712     ASIOError value;
3713     const char*message;
3714   };
3715
3716   static const Messages m[] =
3717     {
3718       {   ASE_NotPresent,    "Hardware input or output is not present or available." },
3719       {   ASE_HWMalfunction,  "Hardware is malfunctioning." },
3720       {   ASE_InvalidParameter, "Invalid input parameter." },
3721       {   ASE_InvalidMode,      "Invalid mode." },
3722       {   ASE_SPNotAdvancing,     "Sample position not advancing." },
3723       {   ASE_NoClock,            "Sample clock or rate cannot be determined or is not present." },
3724       {   ASE_NoMemory,           "Not enough memory to complete the request." }
3725     };
3726
3727   for ( unsigned int i = 0; i < sizeof(m)/sizeof(m[0]); ++i )
3728     if ( m[i].value == result ) return m[i].message;
3729
3730   return "Unknown error.";
3731 }
3732
3733 //******************** End of __WINDOWS_ASIO__ *********************//
3734 #endif
3735
3736
3737 #if defined(__WINDOWS_WASAPI__) // Windows WASAPI API
3738
3739 // Authored by Marcus Tomlinson <themarcustomlinson@gmail.com>, April 2014
3740 // - Introduces support for the Windows WASAPI API
3741 // - Aims to deliver bit streams to and from hardware at the lowest possible latency, via the absolute minimum buffer sizes required
3742 // - Provides flexible stream configuration to an otherwise strict and inflexible WASAPI interface
3743 // - Includes automatic internal conversion of sample rate and buffer size between hardware and the user
3744
3745 #ifndef INITGUID
3746   #define INITGUID
3747 #endif
3748
3749 #include <mfapi.h>
3750 #include <mferror.h>
3751 #include <mfplay.h>
3752 #include <mftransform.h>
3753 #include <wmcodecdsp.h>
3754
3755 #include <audioclient.h>
3756 #include <avrt.h>
3757 #include <mmdeviceapi.h>
3758 #include <functiondiscoverykeys_devpkey.h>
3759
3760 #ifndef MF_E_TRANSFORM_NEED_MORE_INPUT
3761   #define MF_E_TRANSFORM_NEED_MORE_INPUT _HRESULT_TYPEDEF_(0xc00d6d72)
3762 #endif
3763
3764 #ifndef MFSTARTUP_NOSOCKET
3765   #define MFSTARTUP_NOSOCKET 0x1
3766 #endif
3767
3768 #ifdef _MSC_VER
3769   #pragma comment( lib, "ksuser" )
3770   #pragma comment( lib, "mfplat.lib" )
3771   #pragma comment( lib, "mfuuid.lib" )
3772   #pragma comment( lib, "wmcodecdspuuid" )
3773 #endif
3774
3775 //=============================================================================
3776
3777 #define SAFE_RELEASE( objectPtr )\
3778 if ( objectPtr )\
3779 {\
3780   objectPtr->Release();\
3781   objectPtr = NULL;\
3782 }
3783
3784 typedef HANDLE ( __stdcall *TAvSetMmThreadCharacteristicsPtr )( LPCWSTR TaskName, LPDWORD TaskIndex );
3785
3786 //-----------------------------------------------------------------------------
3787
3788 // WASAPI dictates stream sample rate, format, channel count, and in some cases, buffer size.
3789 // Therefore we must perform all necessary conversions to user buffers in order to satisfy these
3790 // requirements. WasapiBuffer ring buffers are used between HwIn->UserIn and UserOut->HwOut to
3791 // provide intermediate storage for read / write synchronization.
3792 class WasapiBuffer
3793 {
3794 public:
3795   WasapiBuffer()
3796     : buffer_( NULL ),
3797       bufferSize_( 0 ),
3798       inIndex_( 0 ),
3799       outIndex_( 0 ) {}
3800
3801   ~WasapiBuffer() {
3802     free( buffer_ );
3803   }
3804
3805   // sets the length of the internal ring buffer
3806   void setBufferSize( unsigned int bufferSize, unsigned int formatBytes ) {
3807     free( buffer_ );
3808
3809     buffer_ = ( char* ) calloc( bufferSize, formatBytes );
3810
3811     bufferSize_ = bufferSize;
3812     inIndex_ = 0;
3813     outIndex_ = 0;
3814   }
3815
3816   // attempt to push a buffer into the ring buffer at the current "in" index
3817   bool pushBuffer( char* buffer, unsigned int bufferSize, RtAudioFormat format )
3818   {
3819     if ( !buffer ||                 // incoming buffer is NULL
3820          bufferSize == 0 ||         // incoming buffer has no data
3821          bufferSize > bufferSize_ ) // incoming buffer too large
3822     {
3823       return false;
3824     }
3825
3826     unsigned int relOutIndex = outIndex_;
3827     unsigned int inIndexEnd = inIndex_ + bufferSize;
3828     if ( relOutIndex < inIndex_ && inIndexEnd >= bufferSize_ ) {
3829       relOutIndex += bufferSize_;
3830     }
3831
3832     // "in" index can end on the "out" index but cannot begin at it
3833     if ( inIndex_ <= relOutIndex && inIndexEnd > relOutIndex ) {
3834       return false; // not enough space between "in" index and "out" index
3835     }
3836
3837     // copy buffer from external to internal
3838     int fromZeroSize = inIndex_ + bufferSize - bufferSize_;
3839     fromZeroSize = fromZeroSize < 0 ? 0 : fromZeroSize;
3840     int fromInSize = bufferSize - fromZeroSize;
3841
3842     switch( format )
3843       {
3844       case RTAUDIO_SINT8:
3845         memcpy( &( ( char* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( char ) );
3846         memcpy( buffer_, &( ( char* ) buffer )[fromInSize], fromZeroSize * sizeof( char ) );
3847         break;
3848       case RTAUDIO_SINT16:
3849         memcpy( &( ( short* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( short ) );
3850         memcpy( buffer_, &( ( short* ) buffer )[fromInSize], fromZeroSize * sizeof( short ) );
3851         break;
3852       case RTAUDIO_SINT24:
3853         memcpy( &( ( S24* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( S24 ) );
3854         memcpy( buffer_, &( ( S24* ) buffer )[fromInSize], fromZeroSize * sizeof( S24 ) );
3855         break;
3856       case RTAUDIO_SINT32:
3857         memcpy( &( ( int* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( int ) );
3858         memcpy( buffer_, &( ( int* ) buffer )[fromInSize], fromZeroSize * sizeof( int ) );
3859         break;
3860       case RTAUDIO_FLOAT32:
3861         memcpy( &( ( float* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( float ) );
3862         memcpy( buffer_, &( ( float* ) buffer )[fromInSize], fromZeroSize * sizeof( float ) );
3863         break;
3864       case RTAUDIO_FLOAT64:
3865         memcpy( &( ( double* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( double ) );
3866         memcpy( buffer_, &( ( double* ) buffer )[fromInSize], fromZeroSize * sizeof( double ) );
3867         break;
3868     }
3869
3870     // update "in" index
3871     inIndex_ += bufferSize;
3872     inIndex_ %= bufferSize_;
3873
3874     return true;
3875   }
3876
3877   // attempt to pull a buffer from the ring buffer from the current "out" index
3878   bool pullBuffer( char* buffer, unsigned int bufferSize, RtAudioFormat format )
3879   {
3880     if ( !buffer ||                 // incoming buffer is NULL
3881          bufferSize == 0 ||         // incoming buffer has no data
3882          bufferSize > bufferSize_ ) // incoming buffer too large
3883     {
3884       return false;
3885     }
3886
3887     unsigned int relInIndex = inIndex_;
3888     unsigned int outIndexEnd = outIndex_ + bufferSize;
3889     if ( relInIndex < outIndex_ && outIndexEnd >= bufferSize_ ) {
3890       relInIndex += bufferSize_;
3891     }
3892
3893     // "out" index can begin at and end on the "in" index
3894     if ( outIndex_ < relInIndex && outIndexEnd > relInIndex ) {
3895       return false; // not enough space between "out" index and "in" index
3896     }
3897
3898     // copy buffer from internal to external
3899     int fromZeroSize = outIndex_ + bufferSize - bufferSize_;
3900     fromZeroSize = fromZeroSize < 0 ? 0 : fromZeroSize;
3901     int fromOutSize = bufferSize - fromZeroSize;
3902
3903     switch( format )
3904     {
3905       case RTAUDIO_SINT8:
3906         memcpy( buffer, &( ( char* ) buffer_ )[outIndex_], fromOutSize * sizeof( char ) );
3907         memcpy( &( ( char* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( char ) );
3908         break;
3909       case RTAUDIO_SINT16:
3910         memcpy( buffer, &( ( short* ) buffer_ )[outIndex_], fromOutSize * sizeof( short ) );
3911         memcpy( &( ( short* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( short ) );
3912         break;
3913       case RTAUDIO_SINT24:
3914         memcpy( buffer, &( ( S24* ) buffer_ )[outIndex_], fromOutSize * sizeof( S24 ) );
3915         memcpy( &( ( S24* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( S24 ) );
3916         break;
3917       case RTAUDIO_SINT32:
3918         memcpy( buffer, &( ( int* ) buffer_ )[outIndex_], fromOutSize * sizeof( int ) );
3919         memcpy( &( ( int* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( int ) );
3920         break;
3921       case RTAUDIO_FLOAT32:
3922         memcpy( buffer, &( ( float* ) buffer_ )[outIndex_], fromOutSize * sizeof( float ) );
3923         memcpy( &( ( float* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( float ) );
3924         break;
3925       case RTAUDIO_FLOAT64:
3926         memcpy( buffer, &( ( double* ) buffer_ )[outIndex_], fromOutSize * sizeof( double ) );
3927         memcpy( &( ( double* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( double ) );
3928         break;
3929     }
3930
3931     // update "out" index
3932     outIndex_ += bufferSize;
3933     outIndex_ %= bufferSize_;
3934
3935     return true;
3936   }
3937
3938 private:
3939   char* buffer_;
3940   unsigned int bufferSize_;
3941   unsigned int inIndex_;
3942   unsigned int outIndex_;
3943 };
3944
3945 //-----------------------------------------------------------------------------
3946
3947 // In order to satisfy WASAPI's buffer requirements, we need a means of converting sample rate
3948 // between HW and the user. The WasapiResampler class is used to perform this conversion between
3949 // HwIn->UserIn and UserOut->HwOut during the stream callback loop.
3950 class WasapiResampler
3951 {
3952 public:
3953   WasapiResampler( bool isFloat, unsigned int bitsPerSample, unsigned int channelCount,
3954                    unsigned int inSampleRate, unsigned int outSampleRate )
3955     : _bytesPerSample( bitsPerSample / 8 )
3956     , _channelCount( channelCount )
3957     , _sampleRatio( ( float ) outSampleRate / inSampleRate )
3958     , _transformUnk( NULL )
3959     , _transform( NULL )
3960     , _mediaType( NULL )
3961     , _inputMediaType( NULL )
3962     , _outputMediaType( NULL )
3963
3964     #ifdef __IWMResamplerProps_FWD_DEFINED__
3965       , _resamplerProps( NULL )
3966     #endif
3967   {
3968     // 1. Initialization
3969
3970     MFStartup( MF_VERSION, MFSTARTUP_NOSOCKET );
3971
3972     // 2. Create Resampler Transform Object
3973
3974     CoCreateInstance( CLSID_CResamplerMediaObject, NULL, CLSCTX_INPROC_SERVER,
3975                       IID_IUnknown, ( void** ) &_transformUnk );
3976
3977     _transformUnk->QueryInterface( IID_PPV_ARGS( &_transform ) );
3978
3979     #ifdef __IWMResamplerProps_FWD_DEFINED__
3980       _transformUnk->QueryInterface( IID_PPV_ARGS( &_resamplerProps ) );
3981       _resamplerProps->SetHalfFilterLength( 60 ); // best conversion quality
3982     #endif
3983
3984     // 3. Specify input / output format
3985
3986     MFCreateMediaType( &_mediaType );
3987     _mediaType->SetGUID( MF_MT_MAJOR_TYPE, MFMediaType_Audio );
3988     _mediaType->SetGUID( MF_MT_SUBTYPE, isFloat ? MFAudioFormat_Float : MFAudioFormat_PCM );
3989     _mediaType->SetUINT32( MF_MT_AUDIO_NUM_CHANNELS, channelCount );
3990     _mediaType->SetUINT32( MF_MT_AUDIO_SAMPLES_PER_SECOND, inSampleRate );
3991     _mediaType->SetUINT32( MF_MT_AUDIO_BLOCK_ALIGNMENT, _bytesPerSample * channelCount );
3992     _mediaType->SetUINT32( MF_MT_AUDIO_AVG_BYTES_PER_SECOND, _bytesPerSample * channelCount * inSampleRate );
3993     _mediaType->SetUINT32( MF_MT_AUDIO_BITS_PER_SAMPLE, bitsPerSample );
3994     _mediaType->SetUINT32( MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE );
3995
3996     MFCreateMediaType( &_inputMediaType );
3997     _mediaType->CopyAllItems( _inputMediaType );
3998
3999     _transform->SetInputType( 0, _inputMediaType, 0 );
4000
4001     MFCreateMediaType( &_outputMediaType );
4002     _mediaType->CopyAllItems( _outputMediaType );
4003
4004     _outputMediaType->SetUINT32( MF_MT_AUDIO_SAMPLES_PER_SECOND, outSampleRate );
4005     _outputMediaType->SetUINT32( MF_MT_AUDIO_AVG_BYTES_PER_SECOND, _bytesPerSample * channelCount * outSampleRate );
4006
4007     _transform->SetOutputType( 0, _outputMediaType, 0 );
4008
4009     // 4. Send stream start messages to Resampler
4010
4011     _transform->ProcessMessage( MFT_MESSAGE_COMMAND_FLUSH, 0 );
4012     _transform->ProcessMessage( MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0 );
4013     _transform->ProcessMessage( MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0 );
4014   }
4015
4016   ~WasapiResampler()
4017   {
4018     // 8. Send stream stop messages to Resampler
4019
4020     _transform->ProcessMessage( MFT_MESSAGE_NOTIFY_END_OF_STREAM, 0 );
4021     _transform->ProcessMessage( MFT_MESSAGE_NOTIFY_END_STREAMING, 0 );
4022
4023     // 9. Cleanup
4024
4025     MFShutdown();
4026
4027     SAFE_RELEASE( _transformUnk );
4028     SAFE_RELEASE( _transform );
4029     SAFE_RELEASE( _mediaType );
4030     SAFE_RELEASE( _inputMediaType );
4031     SAFE_RELEASE( _outputMediaType );
4032
4033     #ifdef __IWMResamplerProps_FWD_DEFINED__
4034       SAFE_RELEASE( _resamplerProps );
4035     #endif
4036   }
4037
4038   void Convert( char* outBuffer, const char* inBuffer, unsigned int inSampleCount, unsigned int& outSampleCount )
4039   {
4040     unsigned int inputBufferSize = _bytesPerSample * _channelCount * inSampleCount;
4041     if ( _sampleRatio == 1 )
4042     {
4043       // no sample rate conversion required
4044       memcpy( outBuffer, inBuffer, inputBufferSize );
4045       outSampleCount = inSampleCount;
4046       return;
4047     }
4048
4049     unsigned int outputBufferSize = ( unsigned int ) ceilf( inputBufferSize * _sampleRatio ) + ( _bytesPerSample * _channelCount );
4050
4051     IMFMediaBuffer* rInBuffer;
4052     IMFSample* rInSample;
4053     BYTE* rInByteBuffer = NULL;
4054
4055     // 5. Create Sample object from input data
4056
4057     MFCreateMemoryBuffer( inputBufferSize, &rInBuffer );
4058
4059     rInBuffer->Lock( &rInByteBuffer, NULL, NULL );
4060     memcpy( rInByteBuffer, inBuffer, inputBufferSize );
4061     rInBuffer->Unlock();
4062     rInByteBuffer = NULL;
4063
4064     rInBuffer->SetCurrentLength( inputBufferSize );
4065
4066     MFCreateSample( &rInSample );
4067     rInSample->AddBuffer( rInBuffer );
4068
4069     // 6. Pass input data to Resampler
4070
4071     _transform->ProcessInput( 0, rInSample, 0 );
4072
4073     SAFE_RELEASE( rInBuffer );
4074     SAFE_RELEASE( rInSample );
4075
4076     // 7. Perform sample rate conversion
4077
4078     IMFMediaBuffer* rOutBuffer = NULL;
4079     BYTE* rOutByteBuffer = NULL;
4080
4081     MFT_OUTPUT_DATA_BUFFER rOutDataBuffer;
4082     DWORD rStatus;
4083     DWORD rBytes = outputBufferSize; // maximum bytes accepted per ProcessOutput
4084
4085     // 7.1 Create Sample object for output data
4086
4087     memset( &rOutDataBuffer, 0, sizeof rOutDataBuffer );
4088     MFCreateSample( &( rOutDataBuffer.pSample ) );
4089     MFCreateMemoryBuffer( rBytes, &rOutBuffer );
4090     rOutDataBuffer.pSample->AddBuffer( rOutBuffer );
4091     rOutDataBuffer.dwStreamID = 0;
4092     rOutDataBuffer.dwStatus = 0;
4093     rOutDataBuffer.pEvents = NULL;
4094
4095     // 7.2 Get output data from Resampler
4096
4097     if ( _transform->ProcessOutput( 0, 1, &rOutDataBuffer, &rStatus ) == MF_E_TRANSFORM_NEED_MORE_INPUT )
4098     {
4099       outSampleCount = 0;
4100       SAFE_RELEASE( rOutBuffer );
4101       SAFE_RELEASE( rOutDataBuffer.pSample );
4102       return;
4103     }
4104
4105     // 7.3 Write output data to outBuffer
4106
4107     SAFE_RELEASE( rOutBuffer );
4108     rOutDataBuffer.pSample->ConvertToContiguousBuffer( &rOutBuffer );
4109     rOutBuffer->GetCurrentLength( &rBytes );
4110
4111     rOutBuffer->Lock( &rOutByteBuffer, NULL, NULL );
4112     memcpy( outBuffer, rOutByteBuffer, rBytes );
4113     rOutBuffer->Unlock();
4114     rOutByteBuffer = NULL;
4115
4116     outSampleCount = rBytes / _bytesPerSample / _channelCount;
4117     SAFE_RELEASE( rOutBuffer );
4118     SAFE_RELEASE( rOutDataBuffer.pSample );
4119   }
4120
4121 private:
4122   unsigned int _bytesPerSample;
4123   unsigned int _channelCount;
4124   float _sampleRatio;
4125
4126   IUnknown* _transformUnk;
4127   IMFTransform* _transform;
4128   IMFMediaType* _mediaType;
4129   IMFMediaType* _inputMediaType;
4130   IMFMediaType* _outputMediaType;
4131
4132   #ifdef __IWMResamplerProps_FWD_DEFINED__
4133     IWMResamplerProps* _resamplerProps;
4134   #endif
4135 };
4136
4137 //-----------------------------------------------------------------------------
4138
4139 // A structure to hold various information related to the WASAPI implementation.
4140 struct WasapiHandle
4141 {
4142   IAudioClient* captureAudioClient;
4143   IAudioClient* renderAudioClient;
4144   IAudioCaptureClient* captureClient;
4145   IAudioRenderClient* renderClient;
4146   HANDLE captureEvent;
4147   HANDLE renderEvent;
4148
4149   WasapiHandle()
4150   : captureAudioClient( NULL ),
4151     renderAudioClient( NULL ),
4152     captureClient( NULL ),
4153     renderClient( NULL ),
4154     captureEvent( NULL ),
4155     renderEvent( NULL ) {}
4156 };
4157
4158 //=============================================================================
4159
4160 RtApiWasapi::RtApiWasapi()
4161   : coInitialized_( false ), deviceEnumerator_( NULL )
4162 {
4163   // WASAPI can run either apartment or multi-threaded
4164   HRESULT hr = CoInitialize( NULL );
4165   if ( !FAILED( hr ) )
4166     coInitialized_ = true;
4167
4168   // Instantiate device enumerator
4169   hr = CoCreateInstance( __uuidof( MMDeviceEnumerator ), NULL,
4170                          CLSCTX_ALL, __uuidof( IMMDeviceEnumerator ),
4171                          ( void** ) &deviceEnumerator_ );
4172
4173   // If this runs on an old Windows, it will fail. Ignore and proceed.
4174   if ( FAILED( hr ) )
4175     deviceEnumerator_ = NULL;
4176 }
4177
4178 //-----------------------------------------------------------------------------
4179
4180 RtApiWasapi::~RtApiWasapi()
4181 {
4182   if ( stream_.state != STREAM_CLOSED )
4183     closeStream();
4184
4185   SAFE_RELEASE( deviceEnumerator_ );
4186
4187   // If this object previously called CoInitialize()
4188   if ( coInitialized_ )
4189     CoUninitialize();
4190 }
4191
4192 //=============================================================================
4193
4194 unsigned int RtApiWasapi::getDeviceCount( void )
4195 {
4196   unsigned int captureDeviceCount = 0;
4197   unsigned int renderDeviceCount = 0;
4198
4199   IMMDeviceCollection* captureDevices = NULL;
4200   IMMDeviceCollection* renderDevices = NULL;
4201
4202   if ( !deviceEnumerator_ )
4203     return 0;
4204
4205   // Count capture devices
4206   errorText_.clear();
4207   HRESULT hr = deviceEnumerator_->EnumAudioEndpoints( eCapture, DEVICE_STATE_ACTIVE, &captureDevices );
4208   if ( FAILED( hr ) ) {
4209     errorText_ = "RtApiWasapi::getDeviceCount: Unable to retrieve capture device collection.";
4210     goto Exit;
4211   }
4212
4213   hr = captureDevices->GetCount( &captureDeviceCount );
4214   if ( FAILED( hr ) ) {
4215     errorText_ = "RtApiWasapi::getDeviceCount: Unable to retrieve capture device count.";
4216     goto Exit;
4217   }
4218
4219   // Count render devices
4220   hr = deviceEnumerator_->EnumAudioEndpoints( eRender, DEVICE_STATE_ACTIVE, &renderDevices );
4221   if ( FAILED( hr ) ) {
4222     errorText_ = "RtApiWasapi::getDeviceCount: Unable to retrieve render device collection.";
4223     goto Exit;
4224   }
4225
4226   hr = renderDevices->GetCount( &renderDeviceCount );
4227   if ( FAILED( hr ) ) {
4228     errorText_ = "RtApiWasapi::getDeviceCount: Unable to retrieve render device count.";
4229     goto Exit;
4230   }
4231
4232 Exit:
4233   // release all references
4234   SAFE_RELEASE( captureDevices );
4235   SAFE_RELEASE( renderDevices );
4236
4237   if ( errorText_.empty() )
4238     return captureDeviceCount + renderDeviceCount;
4239
4240   error( RtAudioError::DRIVER_ERROR );
4241   return 0;
4242 }
4243
4244 //-----------------------------------------------------------------------------
4245
4246 RtAudio::DeviceInfo RtApiWasapi::getDeviceInfo( unsigned int device )
4247 {
4248   RtAudio::DeviceInfo info;
4249   unsigned int captureDeviceCount = 0;
4250   unsigned int renderDeviceCount = 0;
4251   std::string defaultDeviceName;
4252   bool isCaptureDevice = false;
4253
4254   PROPVARIANT deviceNameProp;
4255   PROPVARIANT defaultDeviceNameProp;
4256
4257   IMMDeviceCollection* captureDevices = NULL;
4258   IMMDeviceCollection* renderDevices = NULL;
4259   IMMDevice* devicePtr = NULL;
4260   IMMDevice* defaultDevicePtr = NULL;
4261   IAudioClient* audioClient = NULL;
4262   IPropertyStore* devicePropStore = NULL;
4263   IPropertyStore* defaultDevicePropStore = NULL;
4264
4265   WAVEFORMATEX* deviceFormat = NULL;
4266   WAVEFORMATEX* closestMatchFormat = NULL;
4267
4268   // probed
4269   info.probed = false;
4270
4271   // Count capture devices
4272   errorText_.clear();
4273   RtAudioError::Type errorType = RtAudioError::DRIVER_ERROR;
4274   HRESULT hr = deviceEnumerator_->EnumAudioEndpoints( eCapture, DEVICE_STATE_ACTIVE, &captureDevices );
4275   if ( FAILED( hr ) ) {
4276     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve capture device collection.";
4277     goto Exit;
4278   }
4279
4280   hr = captureDevices->GetCount( &captureDeviceCount );
4281   if ( FAILED( hr ) ) {
4282     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve capture device count.";
4283     goto Exit;
4284   }
4285
4286   // Count render devices
4287   hr = deviceEnumerator_->EnumAudioEndpoints( eRender, DEVICE_STATE_ACTIVE, &renderDevices );
4288   if ( FAILED( hr ) ) {
4289     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve render device collection.";
4290     goto Exit;
4291   }
4292
4293   hr = renderDevices->GetCount( &renderDeviceCount );
4294   if ( FAILED( hr ) ) {
4295     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve render device count.";
4296     goto Exit;
4297   }
4298
4299   // validate device index
4300   if ( device >= captureDeviceCount + renderDeviceCount ) {
4301     errorText_ = "RtApiWasapi::getDeviceInfo: Invalid device index.";
4302     errorType = RtAudioError::INVALID_USE;
4303     goto Exit;
4304   }
4305
4306   // determine whether index falls within capture or render devices
4307   if ( device >= renderDeviceCount ) {
4308     hr = captureDevices->Item( device - renderDeviceCount, &devicePtr );
4309     if ( FAILED( hr ) ) {
4310       errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve capture device handle.";
4311       goto Exit;
4312     }
4313     isCaptureDevice = true;
4314   }
4315   else {
4316     hr = renderDevices->Item( device, &devicePtr );
4317     if ( FAILED( hr ) ) {
4318       errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve render device handle.";
4319       goto Exit;
4320     }
4321     isCaptureDevice = false;
4322   }
4323
4324   // get default device name
4325   if ( isCaptureDevice ) {
4326     hr = deviceEnumerator_->GetDefaultAudioEndpoint( eCapture, eConsole, &defaultDevicePtr );
4327     if ( FAILED( hr ) ) {
4328       errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve default capture device handle.";
4329       goto Exit;
4330     }
4331   }
4332   else {
4333     hr = deviceEnumerator_->GetDefaultAudioEndpoint( eRender, eConsole, &defaultDevicePtr );
4334     if ( FAILED( hr ) ) {
4335       errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve default render device handle.";
4336       goto Exit;
4337     }
4338   }
4339
4340   hr = defaultDevicePtr->OpenPropertyStore( STGM_READ, &defaultDevicePropStore );
4341   if ( FAILED( hr ) ) {
4342     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to open default device property store.";
4343     goto Exit;
4344   }
4345   PropVariantInit( &defaultDeviceNameProp );
4346
4347   hr = defaultDevicePropStore->GetValue( PKEY_Device_FriendlyName, &defaultDeviceNameProp );
4348   if ( FAILED( hr ) ) {
4349     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve default device property: PKEY_Device_FriendlyName.";
4350     goto Exit;
4351   }
4352
4353   defaultDeviceName = convertCharPointerToStdString(defaultDeviceNameProp.pwszVal);
4354
4355   // name
4356   hr = devicePtr->OpenPropertyStore( STGM_READ, &devicePropStore );
4357   if ( FAILED( hr ) ) {
4358     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to open device property store.";
4359     goto Exit;
4360   }
4361
4362   PropVariantInit( &deviceNameProp );
4363
4364   hr = devicePropStore->GetValue( PKEY_Device_FriendlyName, &deviceNameProp );
4365   if ( FAILED( hr ) ) {
4366     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve device property: PKEY_Device_FriendlyName.";
4367     goto Exit;
4368   }
4369
4370   info.name =convertCharPointerToStdString(deviceNameProp.pwszVal);
4371
4372   // is default
4373   if ( isCaptureDevice ) {
4374     info.isDefaultInput = info.name == defaultDeviceName;
4375     info.isDefaultOutput = false;
4376   }
4377   else {
4378     info.isDefaultInput = false;
4379     info.isDefaultOutput = info.name == defaultDeviceName;
4380   }
4381
4382   // channel count
4383   hr = devicePtr->Activate( __uuidof( IAudioClient ), CLSCTX_ALL, NULL, ( void** ) &audioClient );
4384   if ( FAILED( hr ) ) {
4385     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve device audio client.";
4386     goto Exit;
4387   }
4388
4389   hr = audioClient->GetMixFormat( &deviceFormat );
4390   if ( FAILED( hr ) ) {
4391     errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve device mix format.";
4392     goto Exit;
4393   }
4394
4395   if ( isCaptureDevice ) {
4396     info.inputChannels = deviceFormat->nChannels;
4397     info.outputChannels = 0;
4398     info.duplexChannels = 0;
4399   }
4400   else {
4401     info.inputChannels = 0;
4402     info.outputChannels = deviceFormat->nChannels;
4403     info.duplexChannels = 0;
4404   }
4405
4406   // sample rates
4407   info.sampleRates.clear();
4408
4409   // allow support for all sample rates as we have a built-in sample rate converter
4410   for ( unsigned int i = 0; i < MAX_SAMPLE_RATES; i++ ) {
4411     info.sampleRates.push_back( SAMPLE_RATES[i] );
4412   }
4413   info.preferredSampleRate = deviceFormat->nSamplesPerSec;
4414
4415   // native format
4416   info.nativeFormats = 0;
4417
4418   if ( deviceFormat->wFormatTag == WAVE_FORMAT_IEEE_FLOAT ||
4419        ( deviceFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
4420          ( ( WAVEFORMATEXTENSIBLE* ) deviceFormat )->SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT ) )
4421   {
4422     if ( deviceFormat->wBitsPerSample == 32 ) {
4423       info.nativeFormats |= RTAUDIO_FLOAT32;
4424     }
4425     else if ( deviceFormat->wBitsPerSample == 64 ) {
4426       info.nativeFormats |= RTAUDIO_FLOAT64;
4427     }
4428   }
4429   else if ( deviceFormat->wFormatTag == WAVE_FORMAT_PCM ||
4430            ( deviceFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
4431              ( ( WAVEFORMATEXTENSIBLE* ) deviceFormat )->SubFormat == KSDATAFORMAT_SUBTYPE_PCM ) )
4432   {
4433     if ( deviceFormat->wBitsPerSample == 8 ) {
4434       info.nativeFormats |= RTAUDIO_SINT8;
4435     }
4436     else if ( deviceFormat->wBitsPerSample == 16 ) {
4437       info.nativeFormats |= RTAUDIO_SINT16;
4438     }
4439     else if ( deviceFormat->wBitsPerSample == 24 ) {
4440       info.nativeFormats |= RTAUDIO_SINT24;
4441     }
4442     else if ( deviceFormat->wBitsPerSample == 32 ) {
4443       info.nativeFormats |= RTAUDIO_SINT32;
4444     }
4445   }
4446
4447   // probed
4448   info.probed = true;
4449
4450 Exit:
4451   // release all references
4452   PropVariantClear( &deviceNameProp );
4453   PropVariantClear( &defaultDeviceNameProp );
4454
4455   SAFE_RELEASE( captureDevices );
4456   SAFE_RELEASE( renderDevices );
4457   SAFE_RELEASE( devicePtr );
4458   SAFE_RELEASE( defaultDevicePtr );
4459   SAFE_RELEASE( audioClient );
4460   SAFE_RELEASE( devicePropStore );
4461   SAFE_RELEASE( defaultDevicePropStore );
4462
4463   CoTaskMemFree( deviceFormat );
4464   CoTaskMemFree( closestMatchFormat );
4465
4466   if ( !errorText_.empty() )
4467     error( errorType );
4468   return info;
4469 }
4470
4471 //-----------------------------------------------------------------------------
4472
4473 unsigned int RtApiWasapi::getDefaultOutputDevice( void )
4474 {
4475   for ( unsigned int i = 0; i < getDeviceCount(); i++ ) {
4476     if ( getDeviceInfo( i ).isDefaultOutput ) {
4477       return i;
4478     }
4479   }
4480
4481   return 0;
4482 }
4483
4484 //-----------------------------------------------------------------------------
4485
4486 unsigned int RtApiWasapi::getDefaultInputDevice( void )
4487 {
4488   for ( unsigned int i = 0; i < getDeviceCount(); i++ ) {
4489     if ( getDeviceInfo( i ).isDefaultInput ) {
4490       return i;
4491     }
4492   }
4493
4494   return 0;
4495 }
4496
4497 //-----------------------------------------------------------------------------
4498
4499 void RtApiWasapi::closeStream( void )
4500 {
4501   if ( stream_.state == STREAM_CLOSED ) {
4502     errorText_ = "RtApiWasapi::closeStream: No open stream to close.";
4503     error( RtAudioError::WARNING );
4504     return;
4505   }
4506
4507   if ( stream_.state != STREAM_STOPPED )
4508     stopStream();
4509
4510   // clean up stream memory
4511   SAFE_RELEASE( ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient )
4512   SAFE_RELEASE( ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient )
4513
4514   SAFE_RELEASE( ( ( WasapiHandle* ) stream_.apiHandle )->captureClient )
4515   SAFE_RELEASE( ( ( WasapiHandle* ) stream_.apiHandle )->renderClient )
4516
4517   if ( ( ( WasapiHandle* ) stream_.apiHandle )->captureEvent )
4518     CloseHandle( ( ( WasapiHandle* ) stream_.apiHandle )->captureEvent );
4519
4520   if ( ( ( WasapiHandle* ) stream_.apiHandle )->renderEvent )
4521     CloseHandle( ( ( WasapiHandle* ) stream_.apiHandle )->renderEvent );
4522
4523   delete ( WasapiHandle* ) stream_.apiHandle;
4524   stream_.apiHandle = NULL;
4525
4526   for ( int i = 0; i < 2; i++ ) {
4527     if ( stream_.userBuffer[i] ) {
4528       free( stream_.userBuffer[i] );
4529       stream_.userBuffer[i] = 0;
4530     }
4531   }
4532
4533   if ( stream_.deviceBuffer ) {
4534     free( stream_.deviceBuffer );
4535     stream_.deviceBuffer = 0;
4536   }
4537
4538   // update stream state
4539   stream_.state = STREAM_CLOSED;
4540 }
4541
4542 //-----------------------------------------------------------------------------
4543
4544 void RtApiWasapi::startStream( void )
4545 {
4546   verifyStream();
4547
4548   if ( stream_.state == STREAM_RUNNING ) {
4549     errorText_ = "RtApiWasapi::startStream: The stream is already running.";
4550     error( RtAudioError::WARNING );
4551     return;
4552   }
4553
4554   // update stream state
4555   stream_.state = STREAM_RUNNING;
4556
4557   // create WASAPI stream thread
4558   stream_.callbackInfo.thread = ( ThreadHandle ) CreateThread( NULL, 0, runWasapiThread, this, CREATE_SUSPENDED, NULL );
4559
4560   if ( !stream_.callbackInfo.thread ) {
4561     errorText_ = "RtApiWasapi::startStream: Unable to instantiate callback thread.";
4562     error( RtAudioError::THREAD_ERROR );
4563   }
4564   else {
4565     SetThreadPriority( ( void* ) stream_.callbackInfo.thread, stream_.callbackInfo.priority );
4566     ResumeThread( ( void* ) stream_.callbackInfo.thread );
4567   }
4568 }
4569
4570 //-----------------------------------------------------------------------------
4571
4572 void RtApiWasapi::stopStream( void )
4573 {
4574   verifyStream();
4575
4576   if ( stream_.state == STREAM_STOPPED ) {
4577     errorText_ = "RtApiWasapi::stopStream: The stream is already stopped.";
4578     error( RtAudioError::WARNING );
4579     return;
4580   }
4581
4582   // inform stream thread by setting stream state to STREAM_STOPPING
4583   stream_.state = STREAM_STOPPING;
4584
4585   // wait until stream thread is stopped
4586   while( stream_.state != STREAM_STOPPED ) {
4587     Sleep( 1 );
4588   }
4589
4590   // Wait for the last buffer to play before stopping.
4591   Sleep( 1000 * stream_.bufferSize / stream_.sampleRate );
4592
4593   // stop capture client if applicable
4594   if ( ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient ) {
4595     HRESULT hr = ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient->Stop();
4596     if ( FAILED( hr ) ) {
4597       errorText_ = "RtApiWasapi::stopStream: Unable to stop capture stream.";
4598       error( RtAudioError::DRIVER_ERROR );
4599       return;
4600     }
4601   }
4602
4603   // stop render client if applicable
4604   if ( ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient ) {
4605     HRESULT hr = ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient->Stop();
4606     if ( FAILED( hr ) ) {
4607       errorText_ = "RtApiWasapi::stopStream: Unable to stop render stream.";
4608       error( RtAudioError::DRIVER_ERROR );
4609       return;
4610     }
4611   }
4612
4613   // close thread handle
4614   if ( stream_.callbackInfo.thread && !CloseHandle( ( void* ) stream_.callbackInfo.thread ) ) {
4615     errorText_ = "RtApiWasapi::stopStream: Unable to close callback thread.";
4616     error( RtAudioError::THREAD_ERROR );
4617     return;
4618   }
4619
4620   stream_.callbackInfo.thread = (ThreadHandle) NULL;
4621 }
4622
4623 //-----------------------------------------------------------------------------
4624
4625 void RtApiWasapi::abortStream( void )
4626 {
4627   verifyStream();
4628
4629   if ( stream_.state == STREAM_STOPPED ) {
4630     errorText_ = "RtApiWasapi::abortStream: The stream is already stopped.";
4631     error( RtAudioError::WARNING );
4632     return;
4633   }
4634
4635   // inform stream thread by setting stream state to STREAM_STOPPING
4636   stream_.state = STREAM_STOPPING;
4637
4638   // wait until stream thread is stopped
4639   while ( stream_.state != STREAM_STOPPED ) {
4640     Sleep( 1 );
4641   }
4642
4643   // stop capture client if applicable
4644   if ( ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient ) {
4645     HRESULT hr = ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient->Stop();
4646     if ( FAILED( hr ) ) {
4647       errorText_ = "RtApiWasapi::abortStream: Unable to stop capture stream.";
4648       error( RtAudioError::DRIVER_ERROR );
4649       return;
4650     }
4651   }
4652
4653   // stop render client if applicable
4654   if ( ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient ) {
4655     HRESULT hr = ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient->Stop();
4656     if ( FAILED( hr ) ) {
4657       errorText_ = "RtApiWasapi::abortStream: Unable to stop render stream.";
4658       error( RtAudioError::DRIVER_ERROR );
4659       return;
4660     }
4661   }
4662
4663   // close thread handle
4664   if ( stream_.callbackInfo.thread && !CloseHandle( ( void* ) stream_.callbackInfo.thread ) ) {
4665     errorText_ = "RtApiWasapi::abortStream: Unable to close callback thread.";
4666     error( RtAudioError::THREAD_ERROR );
4667     return;
4668   }
4669
4670   stream_.callbackInfo.thread = (ThreadHandle) NULL;
4671 }
4672
4673 //-----------------------------------------------------------------------------
4674
4675 bool RtApiWasapi::probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
4676                                    unsigned int firstChannel, unsigned int sampleRate,
4677                                    RtAudioFormat format, unsigned int* bufferSize,
4678                                    RtAudio::StreamOptions* options )
4679 {
4680   bool methodResult = FAILURE;
4681   unsigned int captureDeviceCount = 0;
4682   unsigned int renderDeviceCount = 0;
4683
4684   IMMDeviceCollection* captureDevices = NULL;
4685   IMMDeviceCollection* renderDevices = NULL;
4686   IMMDevice* devicePtr = NULL;
4687   WAVEFORMATEX* deviceFormat = NULL;
4688   unsigned int bufferBytes;
4689   stream_.state = STREAM_STOPPED;
4690
4691   // create API Handle if not already created
4692   if ( !stream_.apiHandle )
4693     stream_.apiHandle = ( void* ) new WasapiHandle();
4694
4695   // Count capture devices
4696   errorText_.clear();
4697   RtAudioError::Type errorType = RtAudioError::DRIVER_ERROR;
4698   HRESULT hr = deviceEnumerator_->EnumAudioEndpoints( eCapture, DEVICE_STATE_ACTIVE, &captureDevices );
4699   if ( FAILED( hr ) ) {
4700     errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device collection.";
4701     goto Exit;
4702   }
4703
4704   hr = captureDevices->GetCount( &captureDeviceCount );
4705   if ( FAILED( hr ) ) {
4706     errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device count.";
4707     goto Exit;
4708   }
4709
4710   // Count render devices
4711   hr = deviceEnumerator_->EnumAudioEndpoints( eRender, DEVICE_STATE_ACTIVE, &renderDevices );
4712   if ( FAILED( hr ) ) {
4713     errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device collection.";
4714     goto Exit;
4715   }
4716
4717   hr = renderDevices->GetCount( &renderDeviceCount );
4718   if ( FAILED( hr ) ) {
4719     errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device count.";
4720     goto Exit;
4721   }
4722
4723   // validate device index
4724   if ( device >= captureDeviceCount + renderDeviceCount ) {
4725     errorType = RtAudioError::INVALID_USE;
4726     errorText_ = "RtApiWasapi::probeDeviceOpen: Invalid device index.";
4727     goto Exit;
4728   }
4729
4730   // if device index falls within capture devices
4731   if ( device >= renderDeviceCount ) {
4732     if ( mode != INPUT ) {
4733       errorType = RtAudioError::INVALID_USE;
4734       errorText_ = "RtApiWasapi::probeDeviceOpen: Capture device selected as output device.";
4735       goto Exit;
4736     }
4737
4738     // retrieve captureAudioClient from devicePtr
4739     IAudioClient*& captureAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient;
4740
4741     hr = captureDevices->Item( device - renderDeviceCount, &devicePtr );
4742     if ( FAILED( hr ) ) {
4743       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device handle.";
4744       goto Exit;
4745     }
4746
4747     hr = devicePtr->Activate( __uuidof( IAudioClient ), CLSCTX_ALL,
4748                               NULL, ( void** ) &captureAudioClient );
4749     if ( FAILED( hr ) ) {
4750       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device audio client.";
4751       goto Exit;
4752     }
4753
4754     hr = captureAudioClient->GetMixFormat( &deviceFormat );
4755     if ( FAILED( hr ) ) {
4756       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device mix format.";
4757       goto Exit;
4758     }
4759
4760     stream_.nDeviceChannels[mode] = deviceFormat->nChannels;
4761     captureAudioClient->GetStreamLatency( ( long long* ) &stream_.latency[mode] );
4762   }
4763
4764   // if device index falls within render devices and is configured for loopback
4765   if ( device < renderDeviceCount && mode == INPUT )
4766   {
4767     // if renderAudioClient is not initialised, initialise it now
4768     IAudioClient*& renderAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient;
4769     if ( !renderAudioClient )
4770     {
4771       probeDeviceOpen( device, OUTPUT, channels, firstChannel, sampleRate, format, bufferSize, options );
4772     }
4773
4774     // retrieve captureAudioClient from devicePtr
4775     IAudioClient*& captureAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient;
4776
4777     hr = renderDevices->Item( device, &devicePtr );
4778     if ( FAILED( hr ) ) {
4779       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device handle.";
4780       goto Exit;
4781     }
4782
4783     hr = devicePtr->Activate( __uuidof( IAudioClient ), CLSCTX_ALL,
4784                               NULL, ( void** ) &captureAudioClient );
4785     if ( FAILED( hr ) ) {
4786       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device audio client.";
4787       goto Exit;
4788     }
4789
4790     hr = captureAudioClient->GetMixFormat( &deviceFormat );
4791     if ( FAILED( hr ) ) {
4792       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device mix format.";
4793       goto Exit;
4794     }
4795
4796     stream_.nDeviceChannels[mode] = deviceFormat->nChannels;
4797     captureAudioClient->GetStreamLatency( ( long long* ) &stream_.latency[mode] );
4798   }
4799
4800   // if device index falls within render devices and is configured for output
4801   if ( device < renderDeviceCount && mode == OUTPUT )
4802   {
4803     // if renderAudioClient is already initialised, don't initialise it again
4804     IAudioClient*& renderAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient;
4805     if ( renderAudioClient )
4806     {
4807       methodResult = SUCCESS;
4808       goto Exit;
4809     }
4810
4811     hr = renderDevices->Item( device, &devicePtr );
4812     if ( FAILED( hr ) ) {
4813       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device handle.";
4814       goto Exit;
4815     }
4816
4817     hr = devicePtr->Activate( __uuidof( IAudioClient ), CLSCTX_ALL,
4818                               NULL, ( void** ) &renderAudioClient );
4819     if ( FAILED( hr ) ) {
4820       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device audio client.";
4821       goto Exit;
4822     }
4823
4824     hr = renderAudioClient->GetMixFormat( &deviceFormat );
4825     if ( FAILED( hr ) ) {
4826       errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device mix format.";
4827       goto Exit;
4828     }
4829
4830     stream_.nDeviceChannels[mode] = deviceFormat->nChannels;
4831     renderAudioClient->GetStreamLatency( ( long long* ) &stream_.latency[mode] );
4832   }
4833
4834   // fill stream data
4835   if ( ( stream_.mode == OUTPUT && mode == INPUT ) ||
4836        ( stream_.mode == INPUT && mode == OUTPUT ) ) {
4837     stream_.mode = DUPLEX;
4838   }
4839   else {
4840     stream_.mode = mode;
4841   }
4842
4843   stream_.device[mode] = device;
4844   stream_.doByteSwap[mode] = false;
4845   stream_.sampleRate = sampleRate;
4846   stream_.bufferSize = *bufferSize;
4847   stream_.nBuffers = 1;
4848   stream_.nUserChannels[mode] = channels;
4849   stream_.channelOffset[mode] = firstChannel;
4850   stream_.userFormat = format;
4851   stream_.deviceFormat[mode] = getDeviceInfo( device ).nativeFormats;
4852
4853   if ( options && options->flags & RTAUDIO_NONINTERLEAVED )
4854     stream_.userInterleaved = false;
4855   else
4856     stream_.userInterleaved = true;
4857   stream_.deviceInterleaved[mode] = true;
4858
4859   // Set flags for buffer conversion.
4860   stream_.doConvertBuffer[mode] = false;
4861   if ( stream_.userFormat != stream_.deviceFormat[mode] ||
4862        stream_.nUserChannels[0] != stream_.nDeviceChannels[0] ||
4863        stream_.nUserChannels[1] != stream_.nDeviceChannels[1] )
4864     stream_.doConvertBuffer[mode] = true;
4865   else if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
4866             stream_.nUserChannels[mode] > 1 )
4867     stream_.doConvertBuffer[mode] = true;
4868
4869   if ( stream_.doConvertBuffer[mode] )
4870     setConvertInfo( mode, 0 );
4871
4872   // Allocate necessary internal buffers
4873   bufferBytes = stream_.nUserChannels[mode] * stream_.bufferSize * formatBytes( stream_.userFormat );
4874
4875   stream_.userBuffer[mode] = ( char* ) calloc( bufferBytes, 1 );
4876   if ( !stream_.userBuffer[mode] ) {
4877     errorType = RtAudioError::MEMORY_ERROR;
4878     errorText_ = "RtApiWasapi::probeDeviceOpen: Error allocating user buffer memory.";
4879     goto Exit;
4880   }
4881
4882   if ( options && options->flags & RTAUDIO_SCHEDULE_REALTIME )
4883     stream_.callbackInfo.priority = 15;
4884   else
4885     stream_.callbackInfo.priority = 0;
4886
4887   ///! TODO: RTAUDIO_MINIMIZE_LATENCY // Provide stream buffers directly to callback
4888   ///! TODO: RTAUDIO_HOG_DEVICE       // Exclusive mode
4889
4890   methodResult = SUCCESS;
4891
4892 Exit:
4893   //clean up
4894   SAFE_RELEASE( captureDevices );
4895   SAFE_RELEASE( renderDevices );
4896   SAFE_RELEASE( devicePtr );
4897   CoTaskMemFree( deviceFormat );
4898
4899   // if method failed, close the stream
4900   if ( methodResult == FAILURE )
4901     closeStream();
4902
4903   if ( !errorText_.empty() )
4904     error( errorType );
4905   return methodResult;
4906 }
4907
4908 //=============================================================================
4909
4910 DWORD WINAPI RtApiWasapi::runWasapiThread( void* wasapiPtr )
4911 {
4912   if ( wasapiPtr )
4913     ( ( RtApiWasapi* ) wasapiPtr )->wasapiThread();
4914
4915   return 0;
4916 }
4917
4918 DWORD WINAPI RtApiWasapi::stopWasapiThread( void* wasapiPtr )
4919 {
4920   if ( wasapiPtr )
4921     ( ( RtApiWasapi* ) wasapiPtr )->stopStream();
4922
4923   return 0;
4924 }
4925
4926 DWORD WINAPI RtApiWasapi::abortWasapiThread( void* wasapiPtr )
4927 {
4928   if ( wasapiPtr )
4929     ( ( RtApiWasapi* ) wasapiPtr )->abortStream();
4930
4931   return 0;
4932 }
4933
4934 //-----------------------------------------------------------------------------
4935
4936 void RtApiWasapi::wasapiThread()
4937 {
4938   // as this is a new thread, we must CoInitialize it
4939   CoInitialize( NULL );
4940
4941   HRESULT hr;
4942
4943   IAudioClient* captureAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient;
4944   IAudioClient* renderAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient;
4945   IAudioCaptureClient* captureClient = ( ( WasapiHandle* ) stream_.apiHandle )->captureClient;
4946   IAudioRenderClient* renderClient = ( ( WasapiHandle* ) stream_.apiHandle )->renderClient;
4947   HANDLE captureEvent = ( ( WasapiHandle* ) stream_.apiHandle )->captureEvent;
4948   HANDLE renderEvent = ( ( WasapiHandle* ) stream_.apiHandle )->renderEvent;
4949
4950   WAVEFORMATEX* captureFormat = NULL;
4951   WAVEFORMATEX* renderFormat = NULL;
4952   float captureSrRatio = 0.0f;
4953   float renderSrRatio = 0.0f;
4954   WasapiBuffer captureBuffer;
4955   WasapiBuffer renderBuffer;
4956   WasapiResampler* captureResampler = NULL;
4957   WasapiResampler* renderResampler = NULL;
4958
4959   // declare local stream variables
4960   RtAudioCallback callback = ( RtAudioCallback ) stream_.callbackInfo.callback;
4961   BYTE* streamBuffer = NULL;
4962   unsigned long captureFlags = 0;
4963   unsigned int bufferFrameCount = 0;
4964   unsigned int numFramesPadding = 0;
4965   unsigned int convBufferSize = 0;
4966   bool loopbackEnabled = stream_.device[INPUT] == stream_.device[OUTPUT];
4967   bool callbackPushed = true;
4968   bool callbackPulled = false;
4969   bool callbackStopped = false;
4970   int callbackResult = 0;
4971
4972   // convBuffer is used to store converted buffers between WASAPI and the user
4973   char* convBuffer = NULL;
4974   unsigned int convBuffSize = 0;
4975   unsigned int deviceBuffSize = 0;
4976
4977   std::string errorText;
4978   RtAudioError::Type errorType = RtAudioError::DRIVER_ERROR;
4979
4980   // Attempt to assign "Pro Audio" characteristic to thread
4981   HMODULE AvrtDll = LoadLibrary( (LPCTSTR) "AVRT.dll" );
4982   if ( AvrtDll ) {
4983     DWORD taskIndex = 0;
4984     TAvSetMmThreadCharacteristicsPtr AvSetMmThreadCharacteristicsPtr = ( TAvSetMmThreadCharacteristicsPtr ) GetProcAddress( AvrtDll, "AvSetMmThreadCharacteristicsW" );
4985     AvSetMmThreadCharacteristicsPtr( L"Pro Audio", &taskIndex );
4986     FreeLibrary( AvrtDll );
4987   }
4988
4989   // start capture stream if applicable
4990   if ( captureAudioClient ) {
4991     hr = captureAudioClient->GetMixFormat( &captureFormat );
4992     if ( FAILED( hr ) ) {
4993       errorText = "RtApiWasapi::wasapiThread: Unable to retrieve device mix format.";
4994       goto Exit;
4995     }
4996
4997     // init captureResampler
4998     captureResampler = new WasapiResampler( stream_.deviceFormat[INPUT] == RTAUDIO_FLOAT32 || stream_.deviceFormat[INPUT] == RTAUDIO_FLOAT64,
4999                                             formatBytes( stream_.deviceFormat[INPUT] ) * 8, stream_.nDeviceChannels[INPUT],
5000                                             captureFormat->nSamplesPerSec, stream_.sampleRate );
5001
5002     captureSrRatio = ( ( float ) captureFormat->nSamplesPerSec / stream_.sampleRate );
5003
5004     if ( !captureClient ) {
5005       hr = captureAudioClient->Initialize( AUDCLNT_SHAREMODE_SHARED,
5006                                            loopbackEnabled ? AUDCLNT_STREAMFLAGS_LOOPBACK : AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
5007                                            0,
5008                                            0,
5009                                            captureFormat,
5010                                            NULL );
5011       if ( FAILED( hr ) ) {
5012         errorText = "RtApiWasapi::wasapiThread: Unable to initialize capture audio client.";
5013         goto Exit;
5014       }
5015
5016       hr = captureAudioClient->GetService( __uuidof( IAudioCaptureClient ),
5017                                            ( void** ) &captureClient );
5018       if ( FAILED( hr ) ) {
5019         errorText = "RtApiWasapi::wasapiThread: Unable to retrieve capture client handle.";
5020         goto Exit;
5021       }
5022
5023       // don't configure captureEvent if in loopback mode
5024       if ( !loopbackEnabled )
5025       {
5026         // configure captureEvent to trigger on every available capture buffer
5027         captureEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
5028         if ( !captureEvent ) {
5029           errorType = RtAudioError::SYSTEM_ERROR;
5030           errorText = "RtApiWasapi::wasapiThread: Unable to create capture event.";
5031           goto Exit;
5032         }
5033
5034         hr = captureAudioClient->SetEventHandle( captureEvent );
5035         if ( FAILED( hr ) ) {
5036           errorText = "RtApiWasapi::wasapiThread: Unable to set capture event handle.";
5037           goto Exit;
5038         }
5039
5040         ( ( WasapiHandle* ) stream_.apiHandle )->captureEvent = captureEvent;
5041       }
5042
5043       ( ( WasapiHandle* ) stream_.apiHandle )->captureClient = captureClient;
5044     }
5045
5046     unsigned int inBufferSize = 0;
5047     hr = captureAudioClient->GetBufferSize( &inBufferSize );
5048     if ( FAILED( hr ) ) {
5049       errorText = "RtApiWasapi::wasapiThread: Unable to get capture buffer size.";
5050       goto Exit;
5051     }
5052
5053     // scale outBufferSize according to stream->user sample rate ratio
5054     unsigned int outBufferSize = ( unsigned int ) ceilf( stream_.bufferSize * captureSrRatio ) * stream_.nDeviceChannels[INPUT];
5055     inBufferSize *= stream_.nDeviceChannels[INPUT];
5056
5057     // set captureBuffer size
5058     captureBuffer.setBufferSize( inBufferSize + outBufferSize, formatBytes( stream_.deviceFormat[INPUT] ) );
5059
5060     // reset the capture stream
5061     hr = captureAudioClient->Reset();
5062     if ( FAILED( hr ) ) {
5063       errorText = "RtApiWasapi::wasapiThread: Unable to reset capture stream.";
5064       goto Exit;
5065     }
5066
5067     // start the capture stream
5068     hr = captureAudioClient->Start();
5069     if ( FAILED( hr ) ) {
5070       errorText = "RtApiWasapi::wasapiThread: Unable to start capture stream.";
5071       goto Exit;
5072     }
5073   }
5074
5075   // start render stream if applicable
5076   if ( renderAudioClient ) {
5077     hr = renderAudioClient->GetMixFormat( &renderFormat );
5078     if ( FAILED( hr ) ) {
5079       errorText = "RtApiWasapi::wasapiThread: Unable to retrieve device mix format.";
5080       goto Exit;
5081     }
5082
5083     // init renderResampler
5084     renderResampler = new WasapiResampler( stream_.deviceFormat[OUTPUT] == RTAUDIO_FLOAT32 || stream_.deviceFormat[OUTPUT] == RTAUDIO_FLOAT64,
5085                                            formatBytes( stream_.deviceFormat[OUTPUT] ) * 8, stream_.nDeviceChannels[OUTPUT],
5086                                            stream_.sampleRate, renderFormat->nSamplesPerSec );
5087
5088     renderSrRatio = ( ( float ) renderFormat->nSamplesPerSec / stream_.sampleRate );
5089
5090     if ( !renderClient ) {
5091       hr = renderAudioClient->Initialize( AUDCLNT_SHAREMODE_SHARED,
5092                                           AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
5093                                           0,
5094                                           0,
5095                                           renderFormat,
5096                                           NULL );
5097       if ( FAILED( hr ) ) {
5098         errorText = "RtApiWasapi::wasapiThread: Unable to initialize render audio client.";
5099         goto Exit;
5100       }
5101
5102       hr = renderAudioClient->GetService( __uuidof( IAudioRenderClient ),
5103                                           ( void** ) &renderClient );
5104       if ( FAILED( hr ) ) {
5105         errorText = "RtApiWasapi::wasapiThread: Unable to retrieve render client handle.";
5106         goto Exit;
5107       }
5108
5109       // configure renderEvent to trigger on every available render buffer
5110       renderEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
5111       if ( !renderEvent ) {
5112         errorType = RtAudioError::SYSTEM_ERROR;
5113         errorText = "RtApiWasapi::wasapiThread: Unable to create render event.";
5114         goto Exit;
5115       }
5116
5117       hr = renderAudioClient->SetEventHandle( renderEvent );
5118       if ( FAILED( hr ) ) {
5119         errorText = "RtApiWasapi::wasapiThread: Unable to set render event handle.";
5120         goto Exit;
5121       }
5122
5123       ( ( WasapiHandle* ) stream_.apiHandle )->renderClient = renderClient;
5124       ( ( WasapiHandle* ) stream_.apiHandle )->renderEvent = renderEvent;
5125     }
5126
5127     unsigned int outBufferSize = 0;
5128     hr = renderAudioClient->GetBufferSize( &outBufferSize );
5129     if ( FAILED( hr ) ) {
5130       errorText = "RtApiWasapi::wasapiThread: Unable to get render buffer size.";
5131       goto Exit;
5132     }
5133
5134     // scale inBufferSize according to user->stream sample rate ratio
5135     unsigned int inBufferSize = ( unsigned int ) ceilf( stream_.bufferSize * renderSrRatio ) * stream_.nDeviceChannels[OUTPUT];
5136     outBufferSize *= stream_.nDeviceChannels[OUTPUT];
5137
5138     // set renderBuffer size
5139     renderBuffer.setBufferSize( inBufferSize + outBufferSize, formatBytes( stream_.deviceFormat[OUTPUT] ) );
5140
5141     // reset the render stream
5142     hr = renderAudioClient->Reset();
5143     if ( FAILED( hr ) ) {
5144       errorText = "RtApiWasapi::wasapiThread: Unable to reset render stream.";
5145       goto Exit;
5146     }
5147
5148     // start the render stream
5149     hr = renderAudioClient->Start();
5150     if ( FAILED( hr ) ) {
5151       errorText = "RtApiWasapi::wasapiThread: Unable to start render stream.";
5152       goto Exit;
5153     }
5154   }
5155
5156   // malloc buffer memory
5157   if ( stream_.mode == INPUT )
5158   {
5159     using namespace std; // for ceilf
5160     convBuffSize = ( size_t ) ( ceilf( stream_.bufferSize * captureSrRatio ) ) * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] );
5161     deviceBuffSize = stream_.bufferSize * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] );
5162   }
5163   else if ( stream_.mode == OUTPUT )
5164   {
5165     convBuffSize = ( size_t ) ( ceilf( stream_.bufferSize * renderSrRatio ) ) * stream_.nDeviceChannels[OUTPUT] * formatBytes( stream_.deviceFormat[OUTPUT] );
5166     deviceBuffSize = stream_.bufferSize * stream_.nDeviceChannels[OUTPUT] * formatBytes( stream_.deviceFormat[OUTPUT] );
5167   }
5168   else if ( stream_.mode == DUPLEX )
5169   {
5170     convBuffSize = std::max( ( size_t ) ( ceilf( stream_.bufferSize * captureSrRatio ) ) * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] ),
5171                              ( size_t ) ( ceilf( stream_.bufferSize * renderSrRatio ) ) * stream_.nDeviceChannels[OUTPUT] * formatBytes( stream_.deviceFormat[OUTPUT] ) );
5172     deviceBuffSize = std::max( stream_.bufferSize * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] ),
5173                                stream_.bufferSize * stream_.nDeviceChannels[OUTPUT] * formatBytes( stream_.deviceFormat[OUTPUT] ) );
5174   }
5175
5176   convBuffSize *= 2; // allow overflow for *SrRatio remainders
5177   convBuffer = ( char* ) malloc( convBuffSize );
5178   stream_.deviceBuffer = ( char* ) malloc( deviceBuffSize );
5179   if ( !convBuffer || !stream_.deviceBuffer ) {
5180     errorType = RtAudioError::MEMORY_ERROR;
5181     errorText = "RtApiWasapi::wasapiThread: Error allocating device buffer memory.";
5182     goto Exit;
5183   }
5184
5185   // stream process loop
5186   while ( stream_.state != STREAM_STOPPING ) {
5187     if ( !callbackPulled ) {
5188       // Callback Input
5189       // ==============
5190       // 1. Pull callback buffer from inputBuffer
5191       // 2. If 1. was successful: Convert callback buffer to user sample rate and channel count
5192       //                          Convert callback buffer to user format
5193
5194       if ( captureAudioClient )
5195       {
5196         int samplesToPull = ( unsigned int ) floorf( stream_.bufferSize * captureSrRatio );
5197         if ( captureSrRatio != 1 )
5198         {
5199           // account for remainders
5200           samplesToPull--;
5201         }
5202
5203         convBufferSize = 0;
5204         while ( convBufferSize < stream_.bufferSize )
5205         {
5206           // Pull callback buffer from inputBuffer
5207           callbackPulled = captureBuffer.pullBuffer( convBuffer,
5208                                                      samplesToPull * stream_.nDeviceChannels[INPUT],
5209                                                      stream_.deviceFormat[INPUT] );
5210
5211           if ( !callbackPulled )
5212           {
5213             break;
5214           }
5215
5216           // Convert callback buffer to user sample rate
5217           unsigned int deviceBufferOffset = convBufferSize * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] );
5218           unsigned int convSamples = 0;
5219
5220           captureResampler->Convert( stream_.deviceBuffer + deviceBufferOffset,
5221                                      convBuffer,
5222                                      samplesToPull,
5223                                      convSamples );
5224
5225           convBufferSize += convSamples;
5226           samplesToPull = 1; // now pull one sample at a time until we have stream_.bufferSize samples
5227         }
5228
5229         if ( callbackPulled )
5230         {
5231           if ( stream_.doConvertBuffer[INPUT] ) {
5232             // Convert callback buffer to user format
5233             convertBuffer( stream_.userBuffer[INPUT],
5234                            stream_.deviceBuffer,
5235                            stream_.convertInfo[INPUT] );
5236           }
5237           else {
5238             // no further conversion, simple copy deviceBuffer to userBuffer
5239             memcpy( stream_.userBuffer[INPUT],
5240                     stream_.deviceBuffer,
5241                     stream_.bufferSize * stream_.nUserChannels[INPUT] * formatBytes( stream_.userFormat ) );
5242           }
5243         }
5244       }
5245       else {
5246         // if there is no capture stream, set callbackPulled flag
5247         callbackPulled = true;
5248       }
5249
5250       // Execute Callback
5251       // ================
5252       // 1. Execute user callback method
5253       // 2. Handle return value from callback
5254
5255       // if callback has not requested the stream to stop
5256       if ( callbackPulled && !callbackStopped ) {
5257         // Execute user callback method
5258         callbackResult = callback( stream_.userBuffer[OUTPUT],
5259                                    stream_.userBuffer[INPUT],
5260                                    stream_.bufferSize,
5261                                    getStreamTime(),
5262                                    captureFlags & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY ? RTAUDIO_INPUT_OVERFLOW : 0,
5263                                    stream_.callbackInfo.userData );
5264
5265         // Handle return value from callback
5266         if ( callbackResult == 1 ) {
5267           // instantiate a thread to stop this thread
5268           HANDLE threadHandle = CreateThread( NULL, 0, stopWasapiThread, this, 0, NULL );
5269           if ( !threadHandle ) {
5270             errorType = RtAudioError::THREAD_ERROR;
5271             errorText = "RtApiWasapi::wasapiThread: Unable to instantiate stream stop thread.";
5272             goto Exit;
5273           }
5274           else if ( !CloseHandle( threadHandle ) ) {
5275             errorType = RtAudioError::THREAD_ERROR;
5276             errorText = "RtApiWasapi::wasapiThread: Unable to close stream stop thread handle.";
5277             goto Exit;
5278           }
5279
5280           callbackStopped = true;
5281         }
5282         else if ( callbackResult == 2 ) {
5283           // instantiate a thread to stop this thread
5284           HANDLE threadHandle = CreateThread( NULL, 0, abortWasapiThread, this, 0, NULL );
5285           if ( !threadHandle ) {
5286             errorType = RtAudioError::THREAD_ERROR;
5287             errorText = "RtApiWasapi::wasapiThread: Unable to instantiate stream abort thread.";
5288             goto Exit;
5289           }
5290           else if ( !CloseHandle( threadHandle ) ) {
5291             errorType = RtAudioError::THREAD_ERROR;
5292             errorText = "RtApiWasapi::wasapiThread: Unable to close stream abort thread handle.";
5293             goto Exit;
5294           }
5295
5296           callbackStopped = true;
5297         }
5298       }
5299     }
5300
5301     // Callback Output
5302     // ===============
5303     // 1. Convert callback buffer to stream format
5304     // 2. Convert callback buffer to stream sample rate and channel count
5305     // 3. Push callback buffer into outputBuffer
5306
5307     if ( renderAudioClient && callbackPulled )
5308     {
5309       // if the last call to renderBuffer.PushBuffer() was successful
5310       if ( callbackPushed || convBufferSize == 0 )
5311       {
5312         if ( stream_.doConvertBuffer[OUTPUT] )
5313         {
5314           // Convert callback buffer to stream format
5315           convertBuffer( stream_.deviceBuffer,
5316                          stream_.userBuffer[OUTPUT],
5317                          stream_.convertInfo[OUTPUT] );
5318
5319         }
5320
5321         // Convert callback buffer to stream sample rate
5322         renderResampler->Convert( convBuffer,
5323                                   stream_.deviceBuffer,
5324                                   stream_.bufferSize,
5325                                   convBufferSize );
5326       }
5327
5328       // Push callback buffer into outputBuffer
5329       callbackPushed = renderBuffer.pushBuffer( convBuffer,
5330                                                 convBufferSize * stream_.nDeviceChannels[OUTPUT],
5331                                                 stream_.deviceFormat[OUTPUT] );
5332     }
5333     else {
5334       // if there is no render stream, set callbackPushed flag
5335       callbackPushed = true;
5336     }
5337
5338     // Stream Capture
5339     // ==============
5340     // 1. Get capture buffer from stream
5341     // 2. Push capture buffer into inputBuffer
5342     // 3. If 2. was successful: Release capture buffer
5343
5344     if ( captureAudioClient ) {
5345       // if the callback input buffer was not pulled from captureBuffer, wait for next capture event
5346       if ( !callbackPulled ) {
5347         WaitForSingleObject( loopbackEnabled ? renderEvent : captureEvent, INFINITE );
5348       }
5349
5350       // Get capture buffer from stream
5351       hr = captureClient->GetBuffer( &streamBuffer,
5352                                      &bufferFrameCount,
5353                                      &captureFlags, NULL, NULL );
5354       if ( FAILED( hr ) ) {
5355         errorText = "RtApiWasapi::wasapiThread: Unable to retrieve capture buffer.";
5356         goto Exit;
5357       }
5358
5359       if ( bufferFrameCount != 0 ) {
5360         // Push capture buffer into inputBuffer
5361         if ( captureBuffer.pushBuffer( ( char* ) streamBuffer,
5362                                        bufferFrameCount * stream_.nDeviceChannels[INPUT],
5363                                        stream_.deviceFormat[INPUT] ) )
5364         {
5365           // Release capture buffer
5366           hr = captureClient->ReleaseBuffer( bufferFrameCount );
5367           if ( FAILED( hr ) ) {
5368             errorText = "RtApiWasapi::wasapiThread: Unable to release capture buffer.";
5369             goto Exit;
5370           }
5371         }
5372         else
5373         {
5374           // Inform WASAPI that capture was unsuccessful
5375           hr = captureClient->ReleaseBuffer( 0 );
5376           if ( FAILED( hr ) ) {
5377             errorText = "RtApiWasapi::wasapiThread: Unable to release capture buffer.";
5378             goto Exit;
5379           }
5380         }
5381       }
5382       else
5383       {
5384         // Inform WASAPI that capture was unsuccessful
5385         hr = captureClient->ReleaseBuffer( 0 );
5386         if ( FAILED( hr ) ) {
5387           errorText = "RtApiWasapi::wasapiThread: Unable to release capture buffer.";
5388           goto Exit;
5389         }
5390       }
5391     }
5392
5393     // Stream Render
5394     // =============
5395     // 1. Get render buffer from stream
5396     // 2. Pull next buffer from outputBuffer
5397     // 3. If 2. was successful: Fill render buffer with next buffer
5398     //                          Release render buffer
5399
5400     if ( renderAudioClient ) {
5401       // if the callback output buffer was not pushed to renderBuffer, wait for next render event
5402       if ( callbackPulled && !callbackPushed ) {
5403         WaitForSingleObject( renderEvent, INFINITE );
5404       }
5405
5406       // Get render buffer from stream
5407       hr = renderAudioClient->GetBufferSize( &bufferFrameCount );
5408       if ( FAILED( hr ) ) {
5409         errorText = "RtApiWasapi::wasapiThread: Unable to retrieve render buffer size.";
5410         goto Exit;
5411       }
5412
5413       hr = renderAudioClient->GetCurrentPadding( &numFramesPadding );
5414       if ( FAILED( hr ) ) {
5415         errorText = "RtApiWasapi::wasapiThread: Unable to retrieve render buffer padding.";
5416         goto Exit;
5417       }
5418
5419       bufferFrameCount -= numFramesPadding;
5420
5421       if ( bufferFrameCount != 0 ) {
5422         hr = renderClient->GetBuffer( bufferFrameCount, &streamBuffer );
5423         if ( FAILED( hr ) ) {
5424           errorText = "RtApiWasapi::wasapiThread: Unable to retrieve render buffer.";
5425           goto Exit;
5426         }
5427
5428         // Pull next buffer from outputBuffer
5429         // Fill render buffer with next buffer
5430         if ( renderBuffer.pullBuffer( ( char* ) streamBuffer,
5431                                       bufferFrameCount * stream_.nDeviceChannels[OUTPUT],
5432                                       stream_.deviceFormat[OUTPUT] ) )
5433         {
5434           // Release render buffer
5435           hr = renderClient->ReleaseBuffer( bufferFrameCount, 0 );
5436           if ( FAILED( hr ) ) {
5437             errorText = "RtApiWasapi::wasapiThread: Unable to release render buffer.";
5438             goto Exit;
5439           }
5440         }
5441         else
5442         {
5443           // Inform WASAPI that render was unsuccessful
5444           hr = renderClient->ReleaseBuffer( 0, 0 );
5445           if ( FAILED( hr ) ) {
5446             errorText = "RtApiWasapi::wasapiThread: Unable to release render buffer.";
5447             goto Exit;
5448           }
5449         }
5450       }
5451       else
5452       {
5453         // Inform WASAPI that render was unsuccessful
5454         hr = renderClient->ReleaseBuffer( 0, 0 );
5455         if ( FAILED( hr ) ) {
5456           errorText = "RtApiWasapi::wasapiThread: Unable to release render buffer.";
5457           goto Exit;
5458         }
5459       }
5460     }
5461
5462     // if the callback buffer was pushed renderBuffer reset callbackPulled flag
5463     if ( callbackPushed ) {
5464       // unsetting the callbackPulled flag lets the stream know that
5465       // the audio device is ready for another callback output buffer.
5466       callbackPulled = false;
5467
5468       // tick stream time
5469       RtApi::tickStreamTime();
5470     }
5471
5472   }
5473
5474 Exit:
5475   // clean up
5476   CoTaskMemFree( captureFormat );
5477   CoTaskMemFree( renderFormat );
5478
5479   free ( convBuffer );
5480   delete renderResampler;
5481   delete captureResampler;
5482
5483   CoUninitialize();
5484
5485   // update stream state
5486   stream_.state = STREAM_STOPPED;
5487
5488   if ( !errorText.empty() )
5489   {
5490     errorText_ = errorText;
5491     error( errorType );
5492   }
5493 }
5494
5495 //******************** End of __WINDOWS_WASAPI__ *********************//
5496 #endif
5497
5498
5499 #if defined(__WINDOWS_DS__) // Windows DirectSound API
5500
5501 // Modified by Robin Davies, October 2005
5502 // - Improvements to DirectX pointer chasing.
5503 // - Bug fix for non-power-of-two Asio granularity used by Edirol PCR-A30.
5504 // - Auto-call CoInitialize for DSOUND and ASIO platforms.
5505 // Various revisions for RtAudio 4.0 by Gary Scavone, April 2007
5506 // Changed device query structure for RtAudio 4.0.7, January 2010
5507
5508 #include <windows.h>
5509 #include <process.h>
5510 #include <mmsystem.h>
5511 #include <mmreg.h>
5512 #include <dsound.h>
5513 #include <assert.h>
5514 #include <algorithm>
5515
5516 #if defined(__MINGW32__)
5517   // missing from latest mingw winapi
5518 #define WAVE_FORMAT_96M08 0x00010000 /* 96 kHz, Mono, 8-bit */
5519 #define WAVE_FORMAT_96S08 0x00020000 /* 96 kHz, Stereo, 8-bit */
5520 #define WAVE_FORMAT_96M16 0x00040000 /* 96 kHz, Mono, 16-bit */
5521 #define WAVE_FORMAT_96S16 0x00080000 /* 96 kHz, Stereo, 16-bit */
5522 #endif
5523
5524 #define MINIMUM_DEVICE_BUFFER_SIZE 32768
5525
5526 #ifdef _MSC_VER // if Microsoft Visual C++
5527 #pragma comment( lib, "winmm.lib" ) // then, auto-link winmm.lib. Otherwise, it has to be added manually.
5528 #endif
5529
5530 static inline DWORD dsPointerBetween( DWORD pointer, DWORD laterPointer, DWORD earlierPointer, DWORD bufferSize )
5531 {
5532   if ( pointer > bufferSize ) pointer -= bufferSize;
5533   if ( laterPointer < earlierPointer ) laterPointer += bufferSize;
5534   if ( pointer < earlierPointer ) pointer += bufferSize;
5535   return pointer >= earlierPointer && pointer < laterPointer;
5536 }
5537
5538 // A structure to hold various information related to the DirectSound
5539 // API implementation.
5540 struct DsHandle {
5541   unsigned int drainCounter; // Tracks callback counts when draining
5542   bool internalDrain;        // Indicates if stop is initiated from callback or not.
5543   void *id[2];
5544   void *buffer[2];
5545   bool xrun[2];
5546   UINT bufferPointer[2];
5547   DWORD dsBufferSize[2];
5548   DWORD dsPointerLeadTime[2]; // the number of bytes ahead of the safe pointer to lead by.
5549   HANDLE condition;
5550
5551   DsHandle()
5552     :drainCounter(0), internalDrain(false) { id[0] = 0; id[1] = 0; buffer[0] = 0; buffer[1] = 0; xrun[0] = false; xrun[1] = false; bufferPointer[0] = 0; bufferPointer[1] = 0; }
5553 };
5554
5555 // Declarations for utility functions, callbacks, and structures
5556 // specific to the DirectSound implementation.
5557 static BOOL CALLBACK deviceQueryCallback( LPGUID lpguid,
5558                                           LPCTSTR description,
5559                                           LPCTSTR module,
5560                                           LPVOID lpContext );
5561
5562 static const char* getErrorString( int code );
5563
5564 static unsigned __stdcall callbackHandler( void *ptr );
5565
5566 struct DsDevice {
5567   LPGUID id[2];
5568   bool validId[2];
5569   bool found;
5570   std::string name;
5571
5572   DsDevice()
5573   : found(false) { validId[0] = false; validId[1] = false; }
5574 };
5575
5576 struct DsProbeData {
5577   bool isInput;
5578   std::vector<struct DsDevice>* dsDevices;
5579 };
5580
5581 RtApiDs :: RtApiDs()
5582 {
5583   // Dsound will run both-threaded. If CoInitialize fails, then just
5584   // accept whatever the mainline chose for a threading model.
5585   coInitialized_ = false;
5586   HRESULT hr = CoInitialize( NULL );
5587   if ( !FAILED( hr ) ) coInitialized_ = true;
5588 }
5589
5590 RtApiDs :: ~RtApiDs()
5591 {
5592   if ( stream_.state != STREAM_CLOSED ) closeStream();
5593   if ( coInitialized_ ) CoUninitialize(); // balanced call.
5594 }
5595
5596 // The DirectSound default output is always the first device.
5597 unsigned int RtApiDs :: getDefaultOutputDevice( void )
5598 {
5599   return 0;
5600 }
5601
5602 // The DirectSound default input is always the first input device,
5603 // which is the first capture device enumerated.
5604 unsigned int RtApiDs :: getDefaultInputDevice( void )
5605 {
5606   return 0;
5607 }
5608
5609 unsigned int RtApiDs :: getDeviceCount( void )
5610 {
5611   // Set query flag for previously found devices to false, so that we
5612   // can check for any devices that have disappeared.
5613   for ( unsigned int i=0; i<dsDevices.size(); i++ )
5614     dsDevices[i].found = false;
5615
5616   // Query DirectSound devices.
5617   struct DsProbeData probeInfo;
5618   probeInfo.isInput = false;
5619   probeInfo.dsDevices = &dsDevices;
5620   HRESULT result = DirectSoundEnumerate( (LPDSENUMCALLBACK) deviceQueryCallback, &probeInfo );
5621   if ( FAILED( result ) ) {
5622     errorStream_ << "RtApiDs::getDeviceCount: error (" << getErrorString( result ) << ") enumerating output devices!";
5623     errorText_ = errorStream_.str();
5624     error( RtAudioError::WARNING );
5625   }
5626
5627   // Query DirectSoundCapture devices.
5628   probeInfo.isInput = true;
5629   result = DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK) deviceQueryCallback, &probeInfo );
5630   if ( FAILED( result ) ) {
5631     errorStream_ << "RtApiDs::getDeviceCount: error (" << getErrorString( result ) << ") enumerating input devices!";
5632     errorText_ = errorStream_.str();
5633     error( RtAudioError::WARNING );
5634   }
5635
5636   // Clean out any devices that may have disappeared (code update submitted by Eli Zehngut).
5637   for ( unsigned int i=0; i<dsDevices.size(); ) {
5638     if ( dsDevices[i].found == false ) dsDevices.erase( dsDevices.begin() + i );
5639     else i++;
5640   }
5641
5642   return static_cast<unsigned int>(dsDevices.size());
5643 }
5644
5645 RtAudio::DeviceInfo RtApiDs :: getDeviceInfo( unsigned int device )
5646 {
5647   RtAudio::DeviceInfo info;
5648   info.probed = false;
5649
5650   if ( dsDevices.size() == 0 ) {
5651     // Force a query of all devices
5652     getDeviceCount();
5653     if ( dsDevices.size() == 0 ) {
5654       errorText_ = "RtApiDs::getDeviceInfo: no devices found!";
5655       error( RtAudioError::INVALID_USE );
5656       return info;
5657     }
5658   }
5659
5660   if ( device >= dsDevices.size() ) {
5661     errorText_ = "RtApiDs::getDeviceInfo: device ID is invalid!";
5662     error( RtAudioError::INVALID_USE );
5663     return info;
5664   }
5665
5666   HRESULT result;
5667   if ( dsDevices[ device ].validId[0] == false ) goto probeInput;
5668
5669   LPDIRECTSOUND output;
5670   DSCAPS outCaps;
5671   result = DirectSoundCreate( dsDevices[ device ].id[0], &output, NULL );
5672   if ( FAILED( result ) ) {
5673     errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") opening output device (" << dsDevices[ device ].name << ")!";
5674     errorText_ = errorStream_.str();
5675     error( RtAudioError::WARNING );
5676     goto probeInput;
5677   }
5678
5679   outCaps.dwSize = sizeof( outCaps );
5680   result = output->GetCaps( &outCaps );
5681   if ( FAILED( result ) ) {
5682     output->Release();
5683     errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") getting capabilities!";
5684     errorText_ = errorStream_.str();
5685     error( RtAudioError::WARNING );
5686     goto probeInput;
5687   }
5688
5689   // Get output channel information.
5690   info.outputChannels = ( outCaps.dwFlags & DSCAPS_PRIMARYSTEREO ) ? 2 : 1;
5691
5692   // Get sample rate information.
5693   info.sampleRates.clear();
5694   for ( unsigned int k=0; k<MAX_SAMPLE_RATES; k++ ) {
5695     if ( SAMPLE_RATES[k] >= (unsigned int) outCaps.dwMinSecondarySampleRate &&
5696          SAMPLE_RATES[k] <= (unsigned int) outCaps.dwMaxSecondarySampleRate ) {
5697       info.sampleRates.push_back( SAMPLE_RATES[k] );
5698
5699       if ( !info.preferredSampleRate || ( SAMPLE_RATES[k] <= 48000 && SAMPLE_RATES[k] > info.preferredSampleRate ) )
5700         info.preferredSampleRate = SAMPLE_RATES[k];
5701     }
5702   }
5703
5704   // Get format information.
5705   if ( outCaps.dwFlags & DSCAPS_PRIMARY16BIT ) info.nativeFormats |= RTAUDIO_SINT16;
5706   if ( outCaps.dwFlags & DSCAPS_PRIMARY8BIT ) info.nativeFormats |= RTAUDIO_SINT8;
5707
5708   output->Release();
5709
5710   if ( getDefaultOutputDevice() == device )
5711     info.isDefaultOutput = true;
5712
5713   if ( dsDevices[ device ].validId[1] == false ) {
5714     info.name = dsDevices[ device ].name;
5715     info.probed = true;
5716     return info;
5717   }
5718
5719  probeInput:
5720
5721   LPDIRECTSOUNDCAPTURE input;
5722   result = DirectSoundCaptureCreate( dsDevices[ device ].id[1], &input, NULL );
5723   if ( FAILED( result ) ) {
5724     errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") opening input device (" << dsDevices[ device ].name << ")!";
5725     errorText_ = errorStream_.str();
5726     error( RtAudioError::WARNING );
5727     return info;
5728   }
5729
5730   DSCCAPS inCaps;
5731   inCaps.dwSize = sizeof( inCaps );
5732   result = input->GetCaps( &inCaps );
5733   if ( FAILED( result ) ) {
5734     input->Release();
5735     errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") getting object capabilities (" << dsDevices[ device ].name << ")!";
5736     errorText_ = errorStream_.str();
5737     error( RtAudioError::WARNING );
5738     return info;
5739   }
5740
5741   // Get input channel information.
5742   info.inputChannels = inCaps.dwChannels;
5743
5744   // Get sample rate and format information.
5745   std::vector<unsigned int> rates;
5746   if ( inCaps.dwChannels >= 2 ) {
5747     if ( inCaps.dwFormats & WAVE_FORMAT_1S16 ) info.nativeFormats |= RTAUDIO_SINT16;
5748     if ( inCaps.dwFormats & WAVE_FORMAT_2S16 ) info.nativeFormats |= RTAUDIO_SINT16;
5749     if ( inCaps.dwFormats & WAVE_FORMAT_4S16 ) info.nativeFormats |= RTAUDIO_SINT16;
5750     if ( inCaps.dwFormats & WAVE_FORMAT_96S16 ) info.nativeFormats |= RTAUDIO_SINT16;
5751     if ( inCaps.dwFormats & WAVE_FORMAT_1S08 ) info.nativeFormats |= RTAUDIO_SINT8;
5752     if ( inCaps.dwFormats & WAVE_FORMAT_2S08 ) info.nativeFormats |= RTAUDIO_SINT8;
5753     if ( inCaps.dwFormats & WAVE_FORMAT_4S08 ) info.nativeFormats |= RTAUDIO_SINT8;
5754     if ( inCaps.dwFormats & WAVE_FORMAT_96S08 ) info.nativeFormats |= RTAUDIO_SINT8;
5755
5756     if ( info.nativeFormats & RTAUDIO_SINT16 ) {
5757       if ( inCaps.dwFormats & WAVE_FORMAT_1S16 ) rates.push_back( 11025 );
5758       if ( inCaps.dwFormats & WAVE_FORMAT_2S16 ) rates.push_back( 22050 );
5759       if ( inCaps.dwFormats & WAVE_FORMAT_4S16 ) rates.push_back( 44100 );
5760       if ( inCaps.dwFormats & WAVE_FORMAT_96S16 ) rates.push_back( 96000 );
5761     }
5762     else if ( info.nativeFormats & RTAUDIO_SINT8 ) {
5763       if ( inCaps.dwFormats & WAVE_FORMAT_1S08 ) rates.push_back( 11025 );
5764       if ( inCaps.dwFormats & WAVE_FORMAT_2S08 ) rates.push_back( 22050 );
5765       if ( inCaps.dwFormats & WAVE_FORMAT_4S08 ) rates.push_back( 44100 );
5766       if ( inCaps.dwFormats & WAVE_FORMAT_96S08 ) rates.push_back( 96000 );
5767     }
5768   }
5769   else if ( inCaps.dwChannels == 1 ) {
5770     if ( inCaps.dwFormats & WAVE_FORMAT_1M16 ) info.nativeFormats |= RTAUDIO_SINT16;
5771     if ( inCaps.dwFormats & WAVE_FORMAT_2M16 ) info.nativeFormats |= RTAUDIO_SINT16;
5772     if ( inCaps.dwFormats & WAVE_FORMAT_4M16 ) info.nativeFormats |= RTAUDIO_SINT16;
5773     if ( inCaps.dwFormats & WAVE_FORMAT_96M16 ) info.nativeFormats |= RTAUDIO_SINT16;
5774     if ( inCaps.dwFormats & WAVE_FORMAT_1M08 ) info.nativeFormats |= RTAUDIO_SINT8;
5775     if ( inCaps.dwFormats & WAVE_FORMAT_2M08 ) info.nativeFormats |= RTAUDIO_SINT8;
5776     if ( inCaps.dwFormats & WAVE_FORMAT_4M08 ) info.nativeFormats |= RTAUDIO_SINT8;
5777     if ( inCaps.dwFormats & WAVE_FORMAT_96M08 ) info.nativeFormats |= RTAUDIO_SINT8;
5778
5779     if ( info.nativeFormats & RTAUDIO_SINT16 ) {
5780       if ( inCaps.dwFormats & WAVE_FORMAT_1M16 ) rates.push_back( 11025 );
5781       if ( inCaps.dwFormats & WAVE_FORMAT_2M16 ) rates.push_back( 22050 );
5782       if ( inCaps.dwFormats & WAVE_FORMAT_4M16 ) rates.push_back( 44100 );
5783       if ( inCaps.dwFormats & WAVE_FORMAT_96M16 ) rates.push_back( 96000 );
5784     }
5785     else if ( info.nativeFormats & RTAUDIO_SINT8 ) {
5786       if ( inCaps.dwFormats & WAVE_FORMAT_1M08 ) rates.push_back( 11025 );
5787       if ( inCaps.dwFormats & WAVE_FORMAT_2M08 ) rates.push_back( 22050 );
5788       if ( inCaps.dwFormats & WAVE_FORMAT_4M08 ) rates.push_back( 44100 );
5789       if ( inCaps.dwFormats & WAVE_FORMAT_96M08 ) rates.push_back( 96000 );
5790     }
5791   }
5792   else info.inputChannels = 0; // technically, this would be an error
5793
5794   input->Release();
5795
5796   if ( info.inputChannels == 0 ) return info;
5797
5798   // Copy the supported rates to the info structure but avoid duplication.
5799   bool found;
5800   for ( unsigned int i=0; i<rates.size(); i++ ) {
5801     found = false;
5802     for ( unsigned int j=0; j<info.sampleRates.size(); j++ ) {
5803       if ( rates[i] == info.sampleRates[j] ) {
5804         found = true;
5805         break;
5806       }
5807     }
5808     if ( found == false ) info.sampleRates.push_back( rates[i] );
5809   }
5810   std::sort( info.sampleRates.begin(), info.sampleRates.end() );
5811
5812   // If device opens for both playback and capture, we determine the channels.
5813   if ( info.outputChannels > 0 && info.inputChannels > 0 )
5814     info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
5815
5816   if ( device == 0 ) info.isDefaultInput = true;
5817
5818   // Copy name and return.
5819   info.name = dsDevices[ device ].name;
5820   info.probed = true;
5821   return info;
5822 }
5823
5824 bool RtApiDs :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
5825                                  unsigned int firstChannel, unsigned int sampleRate,
5826                                  RtAudioFormat format, unsigned int *bufferSize,
5827                                  RtAudio::StreamOptions *options )
5828 {
5829   if ( channels + firstChannel > 2 ) {
5830     errorText_ = "RtApiDs::probeDeviceOpen: DirectSound does not support more than 2 channels per device.";
5831     return FAILURE;
5832   }
5833
5834   size_t nDevices = dsDevices.size();
5835   if ( nDevices == 0 ) {
5836     // This should not happen because a check is made before this function is called.
5837     errorText_ = "RtApiDs::probeDeviceOpen: no devices found!";
5838     return FAILURE;
5839   }
5840
5841   if ( device >= nDevices ) {
5842     // This should not happen because a check is made before this function is called.
5843     errorText_ = "RtApiDs::probeDeviceOpen: device ID is invalid!";
5844     return FAILURE;
5845   }
5846
5847   if ( mode == OUTPUT ) {
5848     if ( dsDevices[ device ].validId[0] == false ) {
5849       errorStream_ << "RtApiDs::probeDeviceOpen: device (" << device << ") does not support output!";
5850       errorText_ = errorStream_.str();
5851       return FAILURE;
5852     }
5853   }
5854   else { // mode == INPUT
5855     if ( dsDevices[ device ].validId[1] == false ) {
5856       errorStream_ << "RtApiDs::probeDeviceOpen: device (" << device << ") does not support input!";
5857       errorText_ = errorStream_.str();
5858       return FAILURE;
5859     }
5860   }
5861
5862   // According to a note in PortAudio, using GetDesktopWindow()
5863   // instead of GetForegroundWindow() is supposed to avoid problems
5864   // that occur when the application's window is not the foreground
5865   // window.  Also, if the application window closes before the
5866   // DirectSound buffer, DirectSound can crash.  In the past, I had
5867   // problems when using GetDesktopWindow() but it seems fine now
5868   // (January 2010).  I'll leave it commented here.
5869   // HWND hWnd = GetForegroundWindow();
5870   HWND hWnd = GetDesktopWindow();
5871
5872   // Check the numberOfBuffers parameter and limit the lowest value to
5873   // two.  This is a judgement call and a value of two is probably too
5874   // low for capture, but it should work for playback.
5875   int nBuffers = 0;
5876   if ( options ) nBuffers = options->numberOfBuffers;
5877   if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) nBuffers = 2;
5878   if ( nBuffers < 2 ) nBuffers = 3;
5879
5880   // Check the lower range of the user-specified buffer size and set
5881   // (arbitrarily) to a lower bound of 32.
5882   if ( *bufferSize < 32 ) *bufferSize = 32;
5883
5884   // Create the wave format structure.  The data format setting will
5885   // be determined later.
5886   WAVEFORMATEX waveFormat;
5887   ZeroMemory( &waveFormat, sizeof(WAVEFORMATEX) );
5888   waveFormat.wFormatTag = WAVE_FORMAT_PCM;
5889   waveFormat.nChannels = channels + firstChannel;
5890   waveFormat.nSamplesPerSec = (unsigned long) sampleRate;
5891
5892   // Determine the device buffer size. By default, we'll use the value
5893   // defined above (32K), but we will grow it to make allowances for
5894   // very large software buffer sizes.
5895   DWORD dsBufferSize = MINIMUM_DEVICE_BUFFER_SIZE;
5896   DWORD dsPointerLeadTime = 0;
5897
5898   void *ohandle = 0, *bhandle = 0;
5899   HRESULT result;
5900   if ( mode == OUTPUT ) {
5901
5902     LPDIRECTSOUND output;
5903     result = DirectSoundCreate( dsDevices[ device ].id[0], &output, NULL );
5904     if ( FAILED( result ) ) {
5905       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") opening output device (" << dsDevices[ device ].name << ")!";
5906       errorText_ = errorStream_.str();
5907       return FAILURE;
5908     }
5909
5910     DSCAPS outCaps;
5911     outCaps.dwSize = sizeof( outCaps );
5912     result = output->GetCaps( &outCaps );
5913     if ( FAILED( result ) ) {
5914       output->Release();
5915       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting capabilities (" << dsDevices[ device ].name << ")!";
5916       errorText_ = errorStream_.str();
5917       return FAILURE;
5918     }
5919
5920     // Check channel information.
5921     if ( channels + firstChannel == 2 && !( outCaps.dwFlags & DSCAPS_PRIMARYSTEREO ) ) {
5922       errorStream_ << "RtApiDs::getDeviceInfo: the output device (" << dsDevices[ device ].name << ") does not support stereo playback.";
5923       errorText_ = errorStream_.str();
5924       return FAILURE;
5925     }
5926
5927     // Check format information.  Use 16-bit format unless not
5928     // supported or user requests 8-bit.
5929     if ( outCaps.dwFlags & DSCAPS_PRIMARY16BIT &&
5930          !( format == RTAUDIO_SINT8 && outCaps.dwFlags & DSCAPS_PRIMARY8BIT ) ) {
5931       waveFormat.wBitsPerSample = 16;
5932       stream_.deviceFormat[mode] = RTAUDIO_SINT16;
5933     }
5934     else {
5935       waveFormat.wBitsPerSample = 8;
5936       stream_.deviceFormat[mode] = RTAUDIO_SINT8;
5937     }
5938     stream_.userFormat = format;
5939
5940     // Update wave format structure and buffer information.
5941     waveFormat.nBlockAlign = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
5942     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
5943     dsPointerLeadTime = nBuffers * (*bufferSize) * (waveFormat.wBitsPerSample / 8) * channels;
5944
5945     // If the user wants an even bigger buffer, increase the device buffer size accordingly.
5946     while ( dsPointerLeadTime * 2U > dsBufferSize )
5947       dsBufferSize *= 2;
5948
5949     // Set cooperative level to DSSCL_EXCLUSIVE ... sound stops when window focus changes.
5950     // result = output->SetCooperativeLevel( hWnd, DSSCL_EXCLUSIVE );
5951     // Set cooperative level to DSSCL_PRIORITY ... sound remains when window focus changes.
5952     result = output->SetCooperativeLevel( hWnd, DSSCL_PRIORITY );
5953     if ( FAILED( result ) ) {
5954       output->Release();
5955       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") setting cooperative level (" << dsDevices[ device ].name << ")!";
5956       errorText_ = errorStream_.str();
5957       return FAILURE;
5958     }
5959
5960     // Even though we will write to the secondary buffer, we need to
5961     // access the primary buffer to set the correct output format
5962     // (since the default is 8-bit, 22 kHz!).  Setup the DS primary
5963     // buffer description.
5964     DSBUFFERDESC bufferDescription;
5965     ZeroMemory( &bufferDescription, sizeof( DSBUFFERDESC ) );
5966     bufferDescription.dwSize = sizeof( DSBUFFERDESC );
5967     bufferDescription.dwFlags = DSBCAPS_PRIMARYBUFFER;
5968
5969     // Obtain the primary buffer
5970     LPDIRECTSOUNDBUFFER buffer;
5971     result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL );
5972     if ( FAILED( result ) ) {
5973       output->Release();
5974       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") accessing primary buffer (" << dsDevices[ device ].name << ")!";
5975       errorText_ = errorStream_.str();
5976       return FAILURE;
5977     }
5978
5979     // Set the primary DS buffer sound format.
5980     result = buffer->SetFormat( &waveFormat );
5981     if ( FAILED( result ) ) {
5982       output->Release();
5983       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") setting primary buffer format (" << dsDevices[ device ].name << ")!";
5984       errorText_ = errorStream_.str();
5985       return FAILURE;
5986     }
5987
5988     // Setup the secondary DS buffer description.
5989     ZeroMemory( &bufferDescription, sizeof( DSBUFFERDESC ) );
5990     bufferDescription.dwSize = sizeof( DSBUFFERDESC );
5991     bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS |
5992                                   DSBCAPS_GLOBALFOCUS |
5993                                   DSBCAPS_GETCURRENTPOSITION2 |
5994                                   DSBCAPS_LOCHARDWARE );  // Force hardware mixing
5995     bufferDescription.dwBufferBytes = dsBufferSize;
5996     bufferDescription.lpwfxFormat = &waveFormat;
5997
5998     // Try to create the secondary DS buffer.  If that doesn't work,
5999     // try to use software mixing.  Otherwise, there's a problem.
6000     result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL );
6001     if ( FAILED( result ) ) {
6002       bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS |
6003                                     DSBCAPS_GLOBALFOCUS |
6004                                     DSBCAPS_GETCURRENTPOSITION2 |
6005                                     DSBCAPS_LOCSOFTWARE );  // Force software mixing
6006       result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL );
6007       if ( FAILED( result ) ) {
6008         output->Release();
6009         errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") creating secondary buffer (" << dsDevices[ device ].name << ")!";
6010         errorText_ = errorStream_.str();
6011         return FAILURE;
6012       }
6013     }
6014
6015     // Get the buffer size ... might be different from what we specified.
6016     DSBCAPS dsbcaps;
6017     dsbcaps.dwSize = sizeof( DSBCAPS );
6018     result = buffer->GetCaps( &dsbcaps );
6019     if ( FAILED( result ) ) {
6020       output->Release();
6021       buffer->Release();
6022       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting buffer settings (" << dsDevices[ device ].name << ")!";
6023       errorText_ = errorStream_.str();
6024       return FAILURE;
6025     }
6026
6027     dsBufferSize = dsbcaps.dwBufferBytes;
6028
6029     // Lock the DS buffer
6030     LPVOID audioPtr;
6031     DWORD dataLen;
6032     result = buffer->Lock( 0, dsBufferSize, &audioPtr, &dataLen, NULL, NULL, 0 );
6033     if ( FAILED( result ) ) {
6034       output->Release();
6035       buffer->Release();
6036       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") locking buffer (" << dsDevices[ device ].name << ")!";
6037       errorText_ = errorStream_.str();
6038       return FAILURE;
6039     }
6040
6041     // Zero the DS buffer
6042     ZeroMemory( audioPtr, dataLen );
6043
6044     // Unlock the DS buffer
6045     result = buffer->Unlock( audioPtr, dataLen, NULL, 0 );
6046     if ( FAILED( result ) ) {
6047       output->Release();
6048       buffer->Release();
6049       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") unlocking buffer (" << dsDevices[ device ].name << ")!";
6050       errorText_ = errorStream_.str();
6051       return FAILURE;
6052     }
6053
6054     ohandle = (void *) output;
6055     bhandle = (void *) buffer;
6056   }
6057
6058   if ( mode == INPUT ) {
6059
6060     LPDIRECTSOUNDCAPTURE input;
6061     result = DirectSoundCaptureCreate( dsDevices[ device ].id[1], &input, NULL );
6062     if ( FAILED( result ) ) {
6063       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") opening input device (" << dsDevices[ device ].name << ")!";
6064       errorText_ = errorStream_.str();
6065       return FAILURE;
6066     }
6067
6068     DSCCAPS inCaps;
6069     inCaps.dwSize = sizeof( inCaps );
6070     result = input->GetCaps( &inCaps );
6071     if ( FAILED( result ) ) {
6072       input->Release();
6073       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting input capabilities (" << dsDevices[ device ].name << ")!";
6074       errorText_ = errorStream_.str();
6075       return FAILURE;
6076     }
6077
6078     // Check channel information.
6079     if ( inCaps.dwChannels < channels + firstChannel ) {
6080       errorText_ = "RtApiDs::getDeviceInfo: the input device does not support requested input channels.";
6081       return FAILURE;
6082     }
6083
6084     // Check format information.  Use 16-bit format unless user
6085     // requests 8-bit.
6086     DWORD deviceFormats;
6087     if ( channels + firstChannel == 2 ) {
6088       deviceFormats = WAVE_FORMAT_1S08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_96S08;
6089       if ( format == RTAUDIO_SINT8 && inCaps.dwFormats & deviceFormats ) {
6090         waveFormat.wBitsPerSample = 8;
6091         stream_.deviceFormat[mode] = RTAUDIO_SINT8;
6092       }
6093       else { // assume 16-bit is supported
6094         waveFormat.wBitsPerSample = 16;
6095         stream_.deviceFormat[mode] = RTAUDIO_SINT16;
6096       }
6097     }
6098     else { // channel == 1
6099       deviceFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_2M08 | WAVE_FORMAT_4M08 | WAVE_FORMAT_96M08;
6100       if ( format == RTAUDIO_SINT8 && inCaps.dwFormats & deviceFormats ) {
6101         waveFormat.wBitsPerSample = 8;
6102         stream_.deviceFormat[mode] = RTAUDIO_SINT8;
6103       }
6104       else { // assume 16-bit is supported
6105         waveFormat.wBitsPerSample = 16;
6106         stream_.deviceFormat[mode] = RTAUDIO_SINT16;
6107       }
6108     }
6109     stream_.userFormat = format;
6110
6111     // Update wave format structure and buffer information.
6112     waveFormat.nBlockAlign = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
6113     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
6114     dsPointerLeadTime = nBuffers * (*bufferSize) * (waveFormat.wBitsPerSample / 8) * channels;
6115
6116     // If the user wants an even bigger buffer, increase the device buffer size accordingly.
6117     while ( dsPointerLeadTime * 2U > dsBufferSize )
6118       dsBufferSize *= 2;
6119
6120     // Setup the secondary DS buffer description.
6121     DSCBUFFERDESC bufferDescription;
6122     ZeroMemory( &bufferDescription, sizeof( DSCBUFFERDESC ) );
6123     bufferDescription.dwSize = sizeof( DSCBUFFERDESC );
6124     bufferDescription.dwFlags = 0;
6125     bufferDescription.dwReserved = 0;
6126     bufferDescription.dwBufferBytes = dsBufferSize;
6127     bufferDescription.lpwfxFormat = &waveFormat;
6128
6129     // Create the capture buffer.
6130     LPDIRECTSOUNDCAPTUREBUFFER buffer;
6131     result = input->CreateCaptureBuffer( &bufferDescription, &buffer, NULL );
6132     if ( FAILED( result ) ) {
6133       input->Release();
6134       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") creating input buffer (" << dsDevices[ device ].name << ")!";
6135       errorText_ = errorStream_.str();
6136       return FAILURE;
6137     }
6138
6139     // Get the buffer size ... might be different from what we specified.
6140     DSCBCAPS dscbcaps;
6141     dscbcaps.dwSize = sizeof( DSCBCAPS );
6142     result = buffer->GetCaps( &dscbcaps );
6143     if ( FAILED( result ) ) {
6144       input->Release();
6145       buffer->Release();
6146       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting buffer settings (" << dsDevices[ device ].name << ")!";
6147       errorText_ = errorStream_.str();
6148       return FAILURE;
6149     }
6150
6151     dsBufferSize = dscbcaps.dwBufferBytes;
6152
6153     // NOTE: We could have a problem here if this is a duplex stream
6154     // and the play and capture hardware buffer sizes are different
6155     // (I'm actually not sure if that is a problem or not).
6156     // Currently, we are not verifying that.
6157
6158     // Lock the capture buffer
6159     LPVOID audioPtr;
6160     DWORD dataLen;
6161     result = buffer->Lock( 0, dsBufferSize, &audioPtr, &dataLen, NULL, NULL, 0 );
6162     if ( FAILED( result ) ) {
6163       input->Release();
6164       buffer->Release();
6165       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") locking input buffer (" << dsDevices[ device ].name << ")!";
6166       errorText_ = errorStream_.str();
6167       return FAILURE;
6168     }
6169
6170     // Zero the buffer
6171     ZeroMemory( audioPtr, dataLen );
6172
6173     // Unlock the buffer
6174     result = buffer->Unlock( audioPtr, dataLen, NULL, 0 );
6175     if ( FAILED( result ) ) {
6176       input->Release();
6177       buffer->Release();
6178       errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") unlocking input buffer (" << dsDevices[ device ].name << ")!";
6179       errorText_ = errorStream_.str();
6180       return FAILURE;
6181     }
6182
6183     ohandle = (void *) input;
6184     bhandle = (void *) buffer;
6185   }
6186
6187   // Set various stream parameters
6188   DsHandle *handle = 0;
6189   stream_.nDeviceChannels[mode] = channels + firstChannel;
6190   stream_.nUserChannels[mode] = channels;
6191   stream_.bufferSize = *bufferSize;
6192   stream_.channelOffset[mode] = firstChannel;
6193   stream_.deviceInterleaved[mode] = true;
6194   if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
6195   else stream_.userInterleaved = true;
6196
6197   // Set flag for buffer conversion
6198   stream_.doConvertBuffer[mode] = false;
6199   if (stream_.nUserChannels[mode] != stream_.nDeviceChannels[mode])
6200     stream_.doConvertBuffer[mode] = true;
6201   if (stream_.userFormat != stream_.deviceFormat[mode])
6202     stream_.doConvertBuffer[mode] = true;
6203   if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
6204        stream_.nUserChannels[mode] > 1 )
6205     stream_.doConvertBuffer[mode] = true;
6206
6207   // Allocate necessary internal buffers
6208   long bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
6209   stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
6210   if ( stream_.userBuffer[mode] == NULL ) {
6211     errorText_ = "RtApiDs::probeDeviceOpen: error allocating user buffer memory.";
6212     goto error;
6213   }
6214
6215   if ( stream_.doConvertBuffer[mode] ) {
6216
6217     bool makeBuffer = true;
6218     bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
6219     if ( mode == INPUT ) {
6220       if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
6221         unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
6222         if ( bufferBytes <= (long) bytesOut ) makeBuffer = false;
6223       }
6224     }
6225
6226     if ( makeBuffer ) {
6227       bufferBytes *= *bufferSize;
6228       if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
6229       stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
6230       if ( stream_.deviceBuffer == NULL ) {
6231         errorText_ = "RtApiDs::probeDeviceOpen: error allocating device buffer memory.";
6232         goto error;
6233       }
6234     }
6235   }
6236
6237   // Allocate our DsHandle structures for the stream.
6238   if ( stream_.apiHandle == 0 ) {
6239     try {
6240       handle = new DsHandle;
6241     }
6242     catch ( std::bad_alloc& ) {
6243       errorText_ = "RtApiDs::probeDeviceOpen: error allocating AsioHandle memory.";
6244       goto error;
6245     }
6246
6247     // Create a manual-reset event.
6248     handle->condition = CreateEvent( NULL,   // no security
6249                                      TRUE,   // manual-reset
6250                                      FALSE,  // non-signaled initially
6251                                      NULL ); // unnamed
6252     stream_.apiHandle = (void *) handle;
6253   }
6254   else
6255     handle = (DsHandle *) stream_.apiHandle;
6256   handle->id[mode] = ohandle;
6257   handle->buffer[mode] = bhandle;
6258   handle->dsBufferSize[mode] = dsBufferSize;
6259   handle->dsPointerLeadTime[mode] = dsPointerLeadTime;
6260
6261   stream_.device[mode] = device;
6262   stream_.state = STREAM_STOPPED;
6263   if ( stream_.mode == OUTPUT && mode == INPUT )
6264     // We had already set up an output stream.
6265     stream_.mode = DUPLEX;
6266   else
6267     stream_.mode = mode;
6268   stream_.nBuffers = nBuffers;
6269   stream_.sampleRate = sampleRate;
6270
6271   // Setup the buffer conversion information structure.
6272   if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel );
6273
6274   // Setup the callback thread.
6275   if ( stream_.callbackInfo.isRunning == false ) {
6276     unsigned threadId;
6277     stream_.callbackInfo.isRunning = true;
6278     stream_.callbackInfo.object = (void *) this;
6279     stream_.callbackInfo.thread = _beginthreadex( NULL, 0, &callbackHandler,
6280                                                   &stream_.callbackInfo, 0, &threadId );
6281     if ( stream_.callbackInfo.thread == 0 ) {
6282       errorText_ = "RtApiDs::probeDeviceOpen: error creating callback thread!";
6283       goto error;
6284     }
6285
6286     // Boost DS thread priority
6287     SetThreadPriority( (HANDLE) stream_.callbackInfo.thread, THREAD_PRIORITY_HIGHEST );
6288   }
6289   return SUCCESS;
6290
6291  error:
6292   if ( handle ) {
6293     if ( handle->buffer[0] ) { // the object pointer can be NULL and valid
6294       LPDIRECTSOUND object = (LPDIRECTSOUND) handle->id[0];
6295       LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
6296       if ( buffer ) buffer->Release();
6297       object->Release();
6298     }
6299     if ( handle->buffer[1] ) {
6300       LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handle->id[1];
6301       LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
6302       if ( buffer ) buffer->Release();
6303       object->Release();
6304     }
6305     CloseHandle( handle->condition );
6306     delete handle;
6307     stream_.apiHandle = 0;
6308   }
6309
6310   for ( int i=0; i<2; i++ ) {
6311     if ( stream_.userBuffer[i] ) {
6312       free( stream_.userBuffer[i] );
6313       stream_.userBuffer[i] = 0;
6314     }
6315   }
6316
6317   if ( stream_.deviceBuffer ) {
6318     free( stream_.deviceBuffer );
6319     stream_.deviceBuffer = 0;
6320   }
6321
6322   stream_.state = STREAM_CLOSED;
6323   return FAILURE;
6324 }
6325
6326 void RtApiDs :: closeStream()
6327 {
6328   if ( stream_.state == STREAM_CLOSED ) {
6329     errorText_ = "RtApiDs::closeStream(): no open stream to close!";
6330     error( RtAudioError::WARNING );
6331     return;
6332   }
6333
6334   // Stop the callback thread.
6335   stream_.callbackInfo.isRunning = false;
6336   WaitForSingleObject( (HANDLE) stream_.callbackInfo.thread, INFINITE );
6337   CloseHandle( (HANDLE) stream_.callbackInfo.thread );
6338
6339   DsHandle *handle = (DsHandle *) stream_.apiHandle;
6340   if ( handle ) {
6341     if ( handle->buffer[0] ) { // the object pointer can be NULL and valid
6342       LPDIRECTSOUND object = (LPDIRECTSOUND) handle->id[0];
6343       LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
6344       if ( buffer ) {
6345         buffer->Stop();
6346         buffer->Release();
6347       }
6348       object->Release();
6349     }
6350     if ( handle->buffer[1] ) {
6351       LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handle->id[1];
6352       LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
6353       if ( buffer ) {
6354         buffer->Stop();
6355         buffer->Release();
6356       }
6357       object->Release();
6358     }
6359     CloseHandle( handle->condition );
6360     delete handle;
6361     stream_.apiHandle = 0;
6362   }
6363
6364   for ( int i=0; i<2; i++ ) {
6365     if ( stream_.userBuffer[i] ) {
6366       free( stream_.userBuffer[i] );
6367       stream_.userBuffer[i] = 0;
6368     }
6369   }
6370
6371   if ( stream_.deviceBuffer ) {
6372     free( stream_.deviceBuffer );
6373     stream_.deviceBuffer = 0;
6374   }
6375
6376   stream_.mode = UNINITIALIZED;
6377   stream_.state = STREAM_CLOSED;
6378 }
6379
6380 void RtApiDs :: startStream()
6381 {
6382   verifyStream();
6383   if ( stream_.state == STREAM_RUNNING ) {
6384     errorText_ = "RtApiDs::startStream(): the stream is already running!";
6385     error( RtAudioError::WARNING );
6386     return;
6387   }
6388
6389   DsHandle *handle = (DsHandle *) stream_.apiHandle;
6390
6391   // Increase scheduler frequency on lesser windows (a side-effect of
6392   // increasing timer accuracy).  On greater windows (Win2K or later),
6393   // this is already in effect.
6394   timeBeginPeriod( 1 );
6395
6396   buffersRolling = false;
6397   duplexPrerollBytes = 0;
6398
6399   if ( stream_.mode == DUPLEX ) {
6400     // 0.5 seconds of silence in DUPLEX mode while the devices spin up and synchronize.
6401     duplexPrerollBytes = (int) ( 0.5 * stream_.sampleRate * formatBytes( stream_.deviceFormat[1] ) * stream_.nDeviceChannels[1] );
6402   }
6403
6404   HRESULT result = 0;
6405   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
6406
6407     LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
6408     result = buffer->Play( 0, 0, DSBPLAY_LOOPING );
6409     if ( FAILED( result ) ) {
6410       errorStream_ << "RtApiDs::startStream: error (" << getErrorString( result ) << ") starting output buffer!";
6411       errorText_ = errorStream_.str();
6412       goto unlock;
6413     }
6414   }
6415
6416   if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
6417
6418     LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
6419     result = buffer->Start( DSCBSTART_LOOPING );
6420     if ( FAILED( result ) ) {
6421       errorStream_ << "RtApiDs::startStream: error (" << getErrorString( result ) << ") starting input buffer!";
6422       errorText_ = errorStream_.str();
6423       goto unlock;
6424     }
6425   }
6426
6427   handle->drainCounter = 0;
6428   handle->internalDrain = false;
6429   ResetEvent( handle->condition );
6430   stream_.state = STREAM_RUNNING;
6431
6432  unlock:
6433   if ( FAILED( result ) ) error( RtAudioError::SYSTEM_ERROR );
6434 }
6435
6436 void RtApiDs :: stopStream()
6437 {
6438   verifyStream();
6439   if ( stream_.state == STREAM_STOPPED ) {
6440     errorText_ = "RtApiDs::stopStream(): the stream is already stopped!";
6441     error( RtAudioError::WARNING );
6442     return;
6443   }
6444
6445   HRESULT result = 0;
6446   LPVOID audioPtr;
6447   DWORD dataLen;
6448   DsHandle *handle = (DsHandle *) stream_.apiHandle;
6449   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
6450     if ( handle->drainCounter == 0 ) {
6451       handle->drainCounter = 2;
6452       WaitForSingleObject( handle->condition, INFINITE );  // block until signaled
6453     }
6454
6455     stream_.state = STREAM_STOPPED;
6456
6457     MUTEX_LOCK( &stream_.mutex );
6458
6459     // Stop the buffer and clear memory
6460     LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
6461     result = buffer->Stop();
6462     if ( FAILED( result ) ) {
6463       errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") stopping output buffer!";
6464       errorText_ = errorStream_.str();
6465       goto unlock;
6466     }
6467
6468     // Lock the buffer and clear it so that if we start to play again,
6469     // we won't have old data playing.
6470     result = buffer->Lock( 0, handle->dsBufferSize[0], &audioPtr, &dataLen, NULL, NULL, 0 );
6471     if ( FAILED( result ) ) {
6472       errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") locking output buffer!";
6473       errorText_ = errorStream_.str();
6474       goto unlock;
6475     }
6476
6477     // Zero the DS buffer
6478     ZeroMemory( audioPtr, dataLen );
6479
6480     // Unlock the DS buffer
6481     result = buffer->Unlock( audioPtr, dataLen, NULL, 0 );
6482     if ( FAILED( result ) ) {
6483       errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") unlocking output buffer!";
6484       errorText_ = errorStream_.str();
6485       goto unlock;
6486     }
6487
6488     // If we start playing again, we must begin at beginning of buffer.
6489     handle->bufferPointer[0] = 0;
6490   }
6491
6492   if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
6493     LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
6494     audioPtr = NULL;
6495     dataLen = 0;
6496
6497     stream_.state = STREAM_STOPPED;
6498
6499     if ( stream_.mode != DUPLEX )
6500       MUTEX_LOCK( &stream_.mutex );
6501
6502     result = buffer->Stop();
6503     if ( FAILED( result ) ) {
6504       errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") stopping input buffer!";
6505       errorText_ = errorStream_.str();
6506       goto unlock;
6507     }
6508
6509     // Lock the buffer and clear it so that if we start to play again,
6510     // we won't have old data playing.
6511     result = buffer->Lock( 0, handle->dsBufferSize[1], &audioPtr, &dataLen, NULL, NULL, 0 );
6512     if ( FAILED( result ) ) {
6513       errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") locking input buffer!";
6514       errorText_ = errorStream_.str();
6515       goto unlock;
6516     }
6517
6518     // Zero the DS buffer
6519     ZeroMemory( audioPtr, dataLen );
6520
6521     // Unlock the DS buffer
6522     result = buffer->Unlock( audioPtr, dataLen, NULL, 0 );
6523     if ( FAILED( result ) ) {
6524       errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") unlocking input buffer!";
6525       errorText_ = errorStream_.str();
6526       goto unlock;
6527     }
6528
6529     // If we start recording again, we must begin at beginning of buffer.
6530     handle->bufferPointer[1] = 0;
6531   }
6532
6533  unlock:
6534   timeEndPeriod( 1 ); // revert to normal scheduler frequency on lesser windows.
6535   MUTEX_UNLOCK( &stream_.mutex );
6536
6537   if ( FAILED( result ) ) error( RtAudioError::SYSTEM_ERROR );
6538 }
6539
6540 void RtApiDs :: abortStream()
6541 {
6542   verifyStream();
6543   if ( stream_.state == STREAM_STOPPED ) {
6544     errorText_ = "RtApiDs::abortStream(): the stream is already stopped!";
6545     error( RtAudioError::WARNING );
6546     return;
6547   }
6548
6549   DsHandle *handle = (DsHandle *) stream_.apiHandle;
6550   handle->drainCounter = 2;
6551
6552   stopStream();
6553 }
6554
6555 void RtApiDs :: callbackEvent()
6556 {
6557   if ( stream_.state == STREAM_STOPPED || stream_.state == STREAM_STOPPING ) {
6558     Sleep( 50 ); // sleep 50 milliseconds
6559     return;
6560   }
6561
6562   if ( stream_.state == STREAM_CLOSED ) {
6563     errorText_ = "RtApiDs::callbackEvent(): the stream is closed ... this shouldn't happen!";
6564     error( RtAudioError::WARNING );
6565     return;
6566   }
6567
6568   CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
6569   DsHandle *handle = (DsHandle *) stream_.apiHandle;
6570
6571   // Check if we were draining the stream and signal is finished.
6572   if ( handle->drainCounter > stream_.nBuffers + 2 ) {
6573
6574     stream_.state = STREAM_STOPPING;
6575     if ( handle->internalDrain == false )
6576       SetEvent( handle->condition );
6577     else
6578       stopStream();
6579     return;
6580   }
6581
6582   // Invoke user callback to get fresh output data UNLESS we are
6583   // draining stream.
6584   if ( handle->drainCounter == 0 ) {
6585     RtAudioCallback callback = (RtAudioCallback) info->callback;
6586     double streamTime = getStreamTime();
6587     RtAudioStreamStatus status = 0;
6588     if ( stream_.mode != INPUT && handle->xrun[0] == true ) {
6589       status |= RTAUDIO_OUTPUT_UNDERFLOW;
6590       handle->xrun[0] = false;
6591     }
6592     if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) {
6593       status |= RTAUDIO_INPUT_OVERFLOW;
6594       handle->xrun[1] = false;
6595     }
6596     int cbReturnValue = callback( stream_.userBuffer[0], stream_.userBuffer[1],
6597                                   stream_.bufferSize, streamTime, status, info->userData );
6598     if ( cbReturnValue == 2 ) {
6599       stream_.state = STREAM_STOPPING;
6600       handle->drainCounter = 2;
6601       abortStream();
6602       return;
6603     }
6604     else if ( cbReturnValue == 1 ) {
6605       handle->drainCounter = 1;
6606       handle->internalDrain = true;
6607     }
6608   }
6609
6610   HRESULT result;
6611   DWORD currentWritePointer, safeWritePointer;
6612   DWORD currentReadPointer, safeReadPointer;
6613   UINT nextWritePointer;
6614
6615   LPVOID buffer1 = NULL;
6616   LPVOID buffer2 = NULL;
6617   DWORD bufferSize1 = 0;
6618   DWORD bufferSize2 = 0;
6619
6620   char *buffer;
6621   long bufferBytes;
6622
6623   MUTEX_LOCK( &stream_.mutex );
6624   if ( stream_.state == STREAM_STOPPED ) {
6625     MUTEX_UNLOCK( &stream_.mutex );
6626     return;
6627   }
6628
6629   if ( buffersRolling == false ) {
6630     if ( stream_.mode == DUPLEX ) {
6631       //assert( handle->dsBufferSize[0] == handle->dsBufferSize[1] );
6632
6633       // It takes a while for the devices to get rolling. As a result,
6634       // there's no guarantee that the capture and write device pointers
6635       // will move in lockstep.  Wait here for both devices to start
6636       // rolling, and then set our buffer pointers accordingly.
6637       // e.g. Crystal Drivers: the capture buffer starts up 5700 to 9600
6638       // bytes later than the write buffer.
6639
6640       // Stub: a serious risk of having a pre-emptive scheduling round
6641       // take place between the two GetCurrentPosition calls... but I'm
6642       // really not sure how to solve the problem.  Temporarily boost to
6643       // Realtime priority, maybe; but I'm not sure what priority the
6644       // DirectSound service threads run at. We *should* be roughly
6645       // within a ms or so of correct.
6646
6647       LPDIRECTSOUNDBUFFER dsWriteBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
6648       LPDIRECTSOUNDCAPTUREBUFFER dsCaptureBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
6649
6650       DWORD startSafeWritePointer, startSafeReadPointer;
6651
6652       result = dsWriteBuffer->GetCurrentPosition( NULL, &startSafeWritePointer );
6653       if ( FAILED( result ) ) {
6654         errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!";
6655         errorText_ = errorStream_.str();
6656         MUTEX_UNLOCK( &stream_.mutex );
6657         error( RtAudioError::SYSTEM_ERROR );
6658         return;
6659       }
6660       result = dsCaptureBuffer->GetCurrentPosition( NULL, &startSafeReadPointer );
6661       if ( FAILED( result ) ) {
6662         errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!";
6663         errorText_ = errorStream_.str();
6664         MUTEX_UNLOCK( &stream_.mutex );
6665         error( RtAudioError::SYSTEM_ERROR );
6666         return;
6667       }
6668       while ( true ) {
6669         result = dsWriteBuffer->GetCurrentPosition( NULL, &safeWritePointer );
6670         if ( FAILED( result ) ) {
6671           errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!";
6672           errorText_ = errorStream_.str();
6673           MUTEX_UNLOCK( &stream_.mutex );
6674           error( RtAudioError::SYSTEM_ERROR );
6675           return;
6676         }
6677         result = dsCaptureBuffer->GetCurrentPosition( NULL, &safeReadPointer );
6678         if ( FAILED( result ) ) {
6679           errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!";
6680           errorText_ = errorStream_.str();
6681           MUTEX_UNLOCK( &stream_.mutex );
6682           error( RtAudioError::SYSTEM_ERROR );
6683           return;
6684         }
6685         if ( safeWritePointer != startSafeWritePointer && safeReadPointer != startSafeReadPointer ) break;
6686         Sleep( 1 );
6687       }
6688
6689       //assert( handle->dsBufferSize[0] == handle->dsBufferSize[1] );
6690
6691       handle->bufferPointer[0] = safeWritePointer + handle->dsPointerLeadTime[0];
6692       if ( handle->bufferPointer[0] >= handle->dsBufferSize[0] ) handle->bufferPointer[0] -= handle->dsBufferSize[0];
6693       handle->bufferPointer[1] = safeReadPointer;
6694     }
6695     else if ( stream_.mode == OUTPUT ) {
6696
6697       // Set the proper nextWritePosition after initial startup.
6698       LPDIRECTSOUNDBUFFER dsWriteBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
6699       result = dsWriteBuffer->GetCurrentPosition( &currentWritePointer, &safeWritePointer );
6700       if ( FAILED( result ) ) {
6701         errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!";
6702         errorText_ = errorStream_.str();
6703         MUTEX_UNLOCK( &stream_.mutex );
6704         error( RtAudioError::SYSTEM_ERROR );
6705         return;
6706       }
6707       handle->bufferPointer[0] = safeWritePointer + handle->dsPointerLeadTime[0];
6708       if ( handle->bufferPointer[0] >= handle->dsBufferSize[0] ) handle->bufferPointer[0] -= handle->dsBufferSize[0];
6709     }
6710
6711     buffersRolling = true;
6712   }
6713
6714   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
6715
6716     LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
6717
6718     if ( handle->drainCounter > 1 ) { // write zeros to the output stream
6719       bufferBytes = stream_.bufferSize * stream_.nUserChannels[0];
6720       bufferBytes *= formatBytes( stream_.userFormat );
6721       memset( stream_.userBuffer[0], 0, bufferBytes );
6722     }
6723
6724     // Setup parameters and do buffer conversion if necessary.
6725     if ( stream_.doConvertBuffer[0] ) {
6726       buffer = stream_.deviceBuffer;
6727       convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] );
6728       bufferBytes = stream_.bufferSize * stream_.nDeviceChannels[0];
6729       bufferBytes *= formatBytes( stream_.deviceFormat[0] );
6730     }
6731     else {
6732       buffer = stream_.userBuffer[0];
6733       bufferBytes = stream_.bufferSize * stream_.nUserChannels[0];
6734       bufferBytes *= formatBytes( stream_.userFormat );
6735     }
6736
6737     // No byte swapping necessary in DirectSound implementation.
6738
6739     // Ahhh ... windoze.  16-bit data is signed but 8-bit data is
6740     // unsigned.  So, we need to convert our signed 8-bit data here to
6741     // unsigned.
6742     if ( stream_.deviceFormat[0] == RTAUDIO_SINT8 )
6743       for ( int i=0; i<bufferBytes; i++ ) buffer[i] = (unsigned char) ( buffer[i] + 128 );
6744
6745     DWORD dsBufferSize = handle->dsBufferSize[0];
6746     nextWritePointer = handle->bufferPointer[0];
6747
6748     DWORD endWrite, leadPointer;
6749     while ( true ) {
6750       // Find out where the read and "safe write" pointers are.
6751       result = dsBuffer->GetCurrentPosition( &currentWritePointer, &safeWritePointer );
6752       if ( FAILED( result ) ) {
6753         errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!";
6754         errorText_ = errorStream_.str();
6755         MUTEX_UNLOCK( &stream_.mutex );
6756         error( RtAudioError::SYSTEM_ERROR );
6757         return;
6758       }
6759
6760       // We will copy our output buffer into the region between
6761       // safeWritePointer and leadPointer.  If leadPointer is not
6762       // beyond the next endWrite position, wait until it is.
6763       leadPointer = safeWritePointer + handle->dsPointerLeadTime[0];
6764       //std::cout << "safeWritePointer = " << safeWritePointer << ", leadPointer = " << leadPointer << ", nextWritePointer = " << nextWritePointer << std::endl;
6765       if ( leadPointer > dsBufferSize ) leadPointer -= dsBufferSize;
6766       if ( leadPointer < nextWritePointer ) leadPointer += dsBufferSize; // unwrap offset
6767       endWrite = nextWritePointer + bufferBytes;
6768
6769       // Check whether the entire write region is behind the play pointer.
6770       if ( leadPointer >= endWrite ) break;
6771
6772       // If we are here, then we must wait until the leadPointer advances
6773       // beyond the end of our next write region. We use the
6774       // Sleep() function to suspend operation until that happens.
6775       double millis = ( endWrite - leadPointer ) * 1000.0;
6776       millis /= ( formatBytes( stream_.deviceFormat[0]) * stream_.nDeviceChannels[0] * stream_.sampleRate);
6777       if ( millis < 1.0 ) millis = 1.0;
6778       Sleep( (DWORD) millis );
6779     }
6780
6781     if ( dsPointerBetween( nextWritePointer, safeWritePointer, currentWritePointer, dsBufferSize )
6782          || dsPointerBetween( endWrite, safeWritePointer, currentWritePointer, dsBufferSize ) ) {
6783       // We've strayed into the forbidden zone ... resync the read pointer.
6784       handle->xrun[0] = true;
6785       nextWritePointer = safeWritePointer + handle->dsPointerLeadTime[0] - bufferBytes;
6786       if ( nextWritePointer >= dsBufferSize ) nextWritePointer -= dsBufferSize;
6787       handle->bufferPointer[0] = nextWritePointer;
6788       endWrite = nextWritePointer + bufferBytes;
6789     }
6790
6791     // Lock free space in the buffer
6792     result = dsBuffer->Lock( nextWritePointer, bufferBytes, &buffer1,
6793                              &bufferSize1, &buffer2, &bufferSize2, 0 );
6794     if ( FAILED( result ) ) {
6795       errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") locking buffer during playback!";
6796       errorText_ = errorStream_.str();
6797       MUTEX_UNLOCK( &stream_.mutex );
6798       error( RtAudioError::SYSTEM_ERROR );
6799       return;
6800     }
6801
6802     // Copy our buffer into the DS buffer
6803     CopyMemory( buffer1, buffer, bufferSize1 );
6804     if ( buffer2 != NULL ) CopyMemory( buffer2, buffer+bufferSize1, bufferSize2 );
6805
6806     // Update our buffer offset and unlock sound buffer
6807     dsBuffer->Unlock( buffer1, bufferSize1, buffer2, bufferSize2 );
6808     if ( FAILED( result ) ) {
6809       errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") unlocking buffer during playback!";
6810       errorText_ = errorStream_.str();
6811       MUTEX_UNLOCK( &stream_.mutex );
6812       error( RtAudioError::SYSTEM_ERROR );
6813       return;
6814     }
6815     nextWritePointer = ( nextWritePointer + bufferSize1 + bufferSize2 ) % dsBufferSize;
6816     handle->bufferPointer[0] = nextWritePointer;
6817   }
6818
6819   // Don't bother draining input
6820   if ( handle->drainCounter ) {
6821     handle->drainCounter++;
6822     goto unlock;
6823   }
6824
6825   if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
6826
6827     // Setup parameters.
6828     if ( stream_.doConvertBuffer[1] ) {
6829       buffer = stream_.deviceBuffer;
6830       bufferBytes = stream_.bufferSize * stream_.nDeviceChannels[1];
6831       bufferBytes *= formatBytes( stream_.deviceFormat[1] );
6832     }
6833     else {
6834       buffer = stream_.userBuffer[1];
6835       bufferBytes = stream_.bufferSize * stream_.nUserChannels[1];
6836       bufferBytes *= formatBytes( stream_.userFormat );
6837     }
6838
6839     LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
6840     long nextReadPointer = handle->bufferPointer[1];
6841     DWORD dsBufferSize = handle->dsBufferSize[1];
6842
6843     // Find out where the write and "safe read" pointers are.
6844     result = dsBuffer->GetCurrentPosition( &currentReadPointer, &safeReadPointer );
6845     if ( FAILED( result ) ) {
6846       errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!";
6847       errorText_ = errorStream_.str();
6848       MUTEX_UNLOCK( &stream_.mutex );
6849       error( RtAudioError::SYSTEM_ERROR );
6850       return;
6851     }
6852
6853     if ( safeReadPointer < (DWORD)nextReadPointer ) safeReadPointer += dsBufferSize; // unwrap offset
6854     DWORD endRead = nextReadPointer + bufferBytes;
6855
6856     // Handling depends on whether we are INPUT or DUPLEX.
6857     // If we're in INPUT mode then waiting is a good thing. If we're in DUPLEX mode,
6858     // then a wait here will drag the write pointers into the forbidden zone.
6859     //
6860     // In DUPLEX mode, rather than wait, we will back off the read pointer until
6861     // it's in a safe position. This causes dropouts, but it seems to be the only
6862     // practical way to sync up the read and write pointers reliably, given the
6863     // the very complex relationship between phase and increment of the read and write
6864     // pointers.
6865     //
6866     // In order to minimize audible dropouts in DUPLEX mode, we will
6867     // provide a pre-roll period of 0.5 seconds in which we return
6868     // zeros from the read buffer while the pointers sync up.
6869
6870     if ( stream_.mode == DUPLEX ) {
6871       if ( safeReadPointer < endRead ) {
6872         if ( duplexPrerollBytes <= 0 ) {
6873           // Pre-roll time over. Be more agressive.
6874           int adjustment = endRead-safeReadPointer;
6875
6876           handle->xrun[1] = true;
6877           // Two cases:
6878           //   - large adjustments: we've probably run out of CPU cycles, so just resync exactly,
6879           //     and perform fine adjustments later.
6880           //   - small adjustments: back off by twice as much.
6881           if ( adjustment >= 2*bufferBytes )
6882             nextReadPointer = safeReadPointer-2*bufferBytes;
6883           else
6884             nextReadPointer = safeReadPointer-bufferBytes-adjustment;
6885
6886           if ( nextReadPointer < 0 ) nextReadPointer += dsBufferSize;
6887
6888         }
6889         else {
6890           // In pre=roll time. Just do it.
6891           nextReadPointer = safeReadPointer - bufferBytes;
6892           while ( nextReadPointer < 0 ) nextReadPointer += dsBufferSize;
6893         }
6894         endRead = nextReadPointer + bufferBytes;
6895       }
6896     }
6897     else { // mode == INPUT
6898       while ( safeReadPointer < endRead && stream_.callbackInfo.isRunning ) {
6899         // See comments for playback.
6900         double millis = (endRead - safeReadPointer) * 1000.0;
6901         millis /= ( formatBytes(stream_.deviceFormat[1]) * stream_.nDeviceChannels[1] * stream_.sampleRate);
6902         if ( millis < 1.0 ) millis = 1.0;
6903         Sleep( (DWORD) millis );
6904
6905         // Wake up and find out where we are now.
6906         result = dsBuffer->GetCurrentPosition( &currentReadPointer, &safeReadPointer );
6907         if ( FAILED( result ) ) {
6908           errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!";
6909           errorText_ = errorStream_.str();
6910           MUTEX_UNLOCK( &stream_.mutex );
6911           error( RtAudioError::SYSTEM_ERROR );
6912           return;
6913         }
6914
6915         if ( safeReadPointer < (DWORD)nextReadPointer ) safeReadPointer += dsBufferSize; // unwrap offset
6916       }
6917     }
6918
6919     // Lock free space in the buffer
6920     result = dsBuffer->Lock( nextReadPointer, bufferBytes, &buffer1,
6921                              &bufferSize1, &buffer2, &bufferSize2, 0 );
6922     if ( FAILED( result ) ) {
6923       errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") locking capture buffer!";
6924       errorText_ = errorStream_.str();
6925       MUTEX_UNLOCK( &stream_.mutex );
6926       error( RtAudioError::SYSTEM_ERROR );
6927       return;
6928     }
6929
6930     if ( duplexPrerollBytes <= 0 ) {
6931       // Copy our buffer into the DS buffer
6932       CopyMemory( buffer, buffer1, bufferSize1 );
6933       if ( buffer2 != NULL ) CopyMemory( buffer+bufferSize1, buffer2, bufferSize2 );
6934     }
6935     else {
6936       memset( buffer, 0, bufferSize1 );
6937       if ( buffer2 != NULL ) memset( buffer + bufferSize1, 0, bufferSize2 );
6938       duplexPrerollBytes -= bufferSize1 + bufferSize2;
6939     }
6940
6941     // Update our buffer offset and unlock sound buffer
6942     nextReadPointer = ( nextReadPointer + bufferSize1 + bufferSize2 ) % dsBufferSize;
6943     dsBuffer->Unlock( buffer1, bufferSize1, buffer2, bufferSize2 );
6944     if ( FAILED( result ) ) {
6945       errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") unlocking capture buffer!";
6946       errorText_ = errorStream_.str();
6947       MUTEX_UNLOCK( &stream_.mutex );
6948       error( RtAudioError::SYSTEM_ERROR );
6949       return;
6950     }
6951     handle->bufferPointer[1] = nextReadPointer;
6952
6953     // No byte swapping necessary in DirectSound implementation.
6954
6955     // If necessary, convert 8-bit data from unsigned to signed.
6956     if ( stream_.deviceFormat[1] == RTAUDIO_SINT8 )
6957       for ( int j=0; j<bufferBytes; j++ ) buffer[j] = (signed char) ( buffer[j] - 128 );
6958
6959     // Do buffer conversion if necessary.
6960     if ( stream_.doConvertBuffer[1] )
6961       convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
6962   }
6963
6964  unlock:
6965   MUTEX_UNLOCK( &stream_.mutex );
6966   RtApi::tickStreamTime();
6967 }
6968
6969 // Definitions for utility functions and callbacks
6970 // specific to the DirectSound implementation.
6971
6972 static unsigned __stdcall callbackHandler( void *ptr )
6973 {
6974   CallbackInfo *info = (CallbackInfo *) ptr;
6975   RtApiDs *object = (RtApiDs *) info->object;
6976   bool* isRunning = &info->isRunning;
6977
6978   while ( *isRunning == true ) {
6979     object->callbackEvent();
6980   }
6981
6982   _endthreadex( 0 );
6983   return 0;
6984 }
6985
6986 static BOOL CALLBACK deviceQueryCallback( LPGUID lpguid,
6987                                           LPCTSTR description,
6988                                           LPCTSTR /*module*/,
6989                                           LPVOID lpContext )
6990 {
6991   struct DsProbeData& probeInfo = *(struct DsProbeData*) lpContext;
6992   std::vector<struct DsDevice>& dsDevices = *probeInfo.dsDevices;
6993
6994   HRESULT hr;
6995   bool validDevice = false;
6996   if ( probeInfo.isInput == true ) {
6997     DSCCAPS caps;
6998     LPDIRECTSOUNDCAPTURE object;
6999
7000     hr = DirectSoundCaptureCreate(  lpguid, &object,   NULL );
7001     if ( hr != DS_OK ) return TRUE;
7002
7003     caps.dwSize = sizeof(caps);
7004     hr = object->GetCaps( &caps );
7005     if ( hr == DS_OK ) {
7006       if ( caps.dwChannels > 0 && caps.dwFormats > 0 )
7007         validDevice = true;
7008     }
7009     object->Release();
7010   }
7011   else {
7012     DSCAPS caps;
7013     LPDIRECTSOUND object;
7014     hr = DirectSoundCreate(  lpguid, &object,   NULL );
7015     if ( hr != DS_OK ) return TRUE;
7016
7017     caps.dwSize = sizeof(caps);
7018     hr = object->GetCaps( &caps );
7019     if ( hr == DS_OK ) {
7020       if ( caps.dwFlags & DSCAPS_PRIMARYMONO || caps.dwFlags & DSCAPS_PRIMARYSTEREO )
7021         validDevice = true;
7022     }
7023     object->Release();
7024   }
7025
7026   // If good device, then save its name and guid.
7027   std::string name = convertCharPointerToStdString( description );
7028   //if ( name == "Primary Sound Driver" || name == "Primary Sound Capture Driver" )
7029   if ( lpguid == NULL )
7030     name = "Default Device";
7031   if ( validDevice ) {
7032     for ( unsigned int i=0; i<dsDevices.size(); i++ ) {
7033       if ( dsDevices[i].name == name ) {
7034         dsDevices[i].found = true;
7035         if ( probeInfo.isInput ) {
7036           dsDevices[i].id[1] = lpguid;
7037           dsDevices[i].validId[1] = true;
7038         }
7039         else {
7040           dsDevices[i].id[0] = lpguid;
7041           dsDevices[i].validId[0] = true;
7042         }
7043         return TRUE;
7044       }
7045     }
7046
7047     DsDevice device;
7048     device.name = name;
7049     device.found = true;
7050     if ( probeInfo.isInput ) {
7051       device.id[1] = lpguid;
7052       device.validId[1] = true;
7053     }
7054     else {
7055       device.id[0] = lpguid;
7056       device.validId[0] = true;
7057     }
7058     dsDevices.push_back( device );
7059   }
7060
7061   return TRUE;
7062 }
7063
7064 static const char* getErrorString( int code )
7065 {
7066   switch ( code ) {
7067
7068   case DSERR_ALLOCATED:
7069     return "Already allocated";
7070
7071   case DSERR_CONTROLUNAVAIL:
7072     return "Control unavailable";
7073
7074   case DSERR_INVALIDPARAM:
7075     return "Invalid parameter";
7076
7077   case DSERR_INVALIDCALL:
7078     return "Invalid call";
7079
7080   case DSERR_GENERIC:
7081     return "Generic error";
7082
7083   case DSERR_PRIOLEVELNEEDED:
7084     return "Priority level needed";
7085
7086   case DSERR_OUTOFMEMORY:
7087     return "Out of memory";
7088
7089   case DSERR_BADFORMAT:
7090     return "The sample rate or the channel format is not supported";
7091
7092   case DSERR_UNSUPPORTED:
7093     return "Not supported";
7094
7095   case DSERR_NODRIVER:
7096     return "No driver";
7097
7098   case DSERR_ALREADYINITIALIZED:
7099     return "Already initialized";
7100
7101   case DSERR_NOAGGREGATION:
7102     return "No aggregation";
7103
7104   case DSERR_BUFFERLOST:
7105     return "Buffer lost";
7106
7107   case DSERR_OTHERAPPHASPRIO:
7108     return "Another application already has priority";
7109
7110   case DSERR_UNINITIALIZED:
7111     return "Uninitialized";
7112
7113   default:
7114     return "DirectSound unknown error";
7115   }
7116 }
7117 //******************** End of __WINDOWS_DS__ *********************//
7118 #endif
7119
7120
7121 #if defined(__LINUX_ALSA__)
7122
7123 #include <alsa/asoundlib.h>
7124 #include <unistd.h>
7125
7126   // A structure to hold various information related to the ALSA API
7127   // implementation.
7128 struct AlsaHandle {
7129   snd_pcm_t *handles[2];
7130   bool synchronized;
7131   bool xrun[2];
7132   pthread_cond_t runnable_cv;
7133   bool runnable;
7134
7135   AlsaHandle()
7136     :synchronized(false), runnable(false) { xrun[0] = false; xrun[1] = false; }
7137 };
7138
7139 static void *alsaCallbackHandler( void * ptr );
7140
7141 RtApiAlsa :: RtApiAlsa()
7142 {
7143   // Nothing to do here.
7144 }
7145
7146 RtApiAlsa :: ~RtApiAlsa()
7147 {
7148   if ( stream_.state != STREAM_CLOSED ) closeStream();
7149 }
7150
7151 unsigned int RtApiAlsa :: getDeviceCount( void )
7152 {
7153   unsigned nDevices = 0;
7154   int result, subdevice, card;
7155   char name[64];
7156   snd_ctl_t *handle;
7157
7158   // Count cards and devices
7159   card = -1;
7160   snd_card_next( &card );
7161   while ( card >= 0 ) {
7162     sprintf( name, "hw:%d", card );
7163     result = snd_ctl_open( &handle, name, 0 );
7164     if ( result < 0 ) {
7165       errorStream_ << "RtApiAlsa::getDeviceCount: control open, card = " << card << ", " << snd_strerror( result ) << ".";
7166       errorText_ = errorStream_.str();
7167       error( RtAudioError::WARNING );
7168       goto nextcard;
7169     }
7170     subdevice = -1;
7171     while( 1 ) {
7172       result = snd_ctl_pcm_next_device( handle, &subdevice );
7173       if ( result < 0 ) {
7174         errorStream_ << "RtApiAlsa::getDeviceCount: control next device, card = " << card << ", " << snd_strerror( result ) << ".";
7175         errorText_ = errorStream_.str();
7176         error( RtAudioError::WARNING );
7177         break;
7178       }
7179       if ( subdevice < 0 )
7180         break;
7181       nDevices++;
7182     }
7183   nextcard:
7184     snd_ctl_close( handle );
7185     snd_card_next( &card );
7186   }
7187
7188   result = snd_ctl_open( &handle, "default", 0 );
7189   if (result == 0) {
7190     nDevices++;
7191     snd_ctl_close( handle );
7192   }
7193
7194   return nDevices;
7195 }
7196
7197 RtAudio::DeviceInfo RtApiAlsa :: getDeviceInfo( unsigned int device )
7198 {
7199   RtAudio::DeviceInfo info;
7200   info.probed = false;
7201
7202   unsigned nDevices = 0;
7203   int result, subdevice, card;
7204   char name[64];
7205   snd_ctl_t *chandle;
7206
7207   // Count cards and devices
7208   card = -1;
7209   subdevice = -1;
7210   snd_card_next( &card );
7211   while ( card >= 0 ) {
7212     sprintf( name, "hw:%d", card );
7213     result = snd_ctl_open( &chandle, name, SND_CTL_NONBLOCK );
7214     if ( result < 0 ) {
7215       errorStream_ << "RtApiAlsa::getDeviceInfo: control open, card = " << card << ", " << snd_strerror( result ) << ".";
7216       errorText_ = errorStream_.str();
7217       error( RtAudioError::WARNING );
7218       goto nextcard;
7219     }
7220     subdevice = -1;
7221     while( 1 ) {
7222       result = snd_ctl_pcm_next_device( chandle, &subdevice );
7223       if ( result < 0 ) {
7224         errorStream_ << "RtApiAlsa::getDeviceInfo: control next device, card = " << card << ", " << snd_strerror( result ) << ".";
7225         errorText_ = errorStream_.str();
7226         error( RtAudioError::WARNING );
7227         break;
7228       }
7229       if ( subdevice < 0 ) break;
7230       if ( nDevices == device ) {
7231         sprintf( name, "hw:%d,%d", card, subdevice );
7232         goto foundDevice;
7233       }
7234       nDevices++;
7235     }
7236   nextcard:
7237     snd_ctl_close( chandle );
7238     snd_card_next( &card );
7239   }
7240
7241   result = snd_ctl_open( &chandle, "default", SND_CTL_NONBLOCK );
7242   if ( result == 0 ) {
7243     if ( nDevices == device ) {
7244       strcpy( name, "default" );
7245       goto foundDevice;
7246     }
7247     nDevices++;
7248   }
7249
7250   if ( nDevices == 0 ) {
7251     errorText_ = "RtApiAlsa::getDeviceInfo: no devices found!";
7252     error( RtAudioError::INVALID_USE );
7253     return info;
7254   }
7255
7256   if ( device >= nDevices ) {
7257     errorText_ = "RtApiAlsa::getDeviceInfo: device ID is invalid!";
7258     error( RtAudioError::INVALID_USE );
7259     return info;
7260   }
7261
7262  foundDevice:
7263
7264   // If a stream is already open, we cannot probe the stream devices.
7265   // Thus, use the saved results.
7266   if ( stream_.state != STREAM_CLOSED &&
7267        ( stream_.device[0] == device || stream_.device[1] == device ) ) {
7268     snd_ctl_close( chandle );
7269     if ( device >= devices_.size() ) {
7270       errorText_ = "RtApiAlsa::getDeviceInfo: device ID was not present before stream was opened.";
7271       error( RtAudioError::WARNING );
7272       return info;
7273     }
7274     return devices_[ device ];
7275   }
7276
7277   int openMode = SND_PCM_ASYNC;
7278   snd_pcm_stream_t stream;
7279   snd_pcm_info_t *pcminfo;
7280   snd_pcm_info_alloca( &pcminfo );
7281   snd_pcm_t *phandle;
7282   snd_pcm_hw_params_t *params;
7283   snd_pcm_hw_params_alloca( &params );
7284
7285   // First try for playback unless default device (which has subdev -1)
7286   stream = SND_PCM_STREAM_PLAYBACK;
7287   snd_pcm_info_set_stream( pcminfo, stream );
7288   if ( subdevice != -1 ) {
7289     snd_pcm_info_set_device( pcminfo, subdevice );
7290     snd_pcm_info_set_subdevice( pcminfo, 0 );
7291
7292     result = snd_ctl_pcm_info( chandle, pcminfo );
7293     if ( result < 0 ) {
7294       // Device probably doesn't support playback.
7295       goto captureProbe;
7296     }
7297   }
7298
7299   result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK );
7300   if ( result < 0 ) {
7301     errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << ".";
7302     errorText_ = errorStream_.str();
7303     error( RtAudioError::WARNING );
7304     goto captureProbe;
7305   }
7306
7307   // The device is open ... fill the parameter structure.
7308   result = snd_pcm_hw_params_any( phandle, params );
7309   if ( result < 0 ) {
7310     snd_pcm_close( phandle );
7311     errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << ".";
7312     errorText_ = errorStream_.str();
7313     error( RtAudioError::WARNING );
7314     goto captureProbe;
7315   }
7316
7317   // Get output channel information.
7318   unsigned int value;
7319   result = snd_pcm_hw_params_get_channels_max( params, &value );
7320   if ( result < 0 ) {
7321     snd_pcm_close( phandle );
7322     errorStream_ << "RtApiAlsa::getDeviceInfo: error getting device (" << name << ") output channels, " << snd_strerror( result ) << ".";
7323     errorText_ = errorStream_.str();
7324     error( RtAudioError::WARNING );
7325     goto captureProbe;
7326   }
7327   info.outputChannels = value;
7328   snd_pcm_close( phandle );
7329
7330  captureProbe:
7331   stream = SND_PCM_STREAM_CAPTURE;
7332   snd_pcm_info_set_stream( pcminfo, stream );
7333
7334   // Now try for capture unless default device (with subdev = -1)
7335   if ( subdevice != -1 ) {
7336     result = snd_ctl_pcm_info( chandle, pcminfo );
7337     snd_ctl_close( chandle );
7338     if ( result < 0 ) {
7339       // Device probably doesn't support capture.
7340       if ( info.outputChannels == 0 ) return info;
7341       goto probeParameters;
7342     }
7343   }
7344   else
7345     snd_ctl_close( chandle );
7346
7347   result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK);
7348   if ( result < 0 ) {
7349     errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << ".";
7350     errorText_ = errorStream_.str();
7351     error( RtAudioError::WARNING );
7352     if ( info.outputChannels == 0 ) return info;
7353     goto probeParameters;
7354   }
7355
7356   // The device is open ... fill the parameter structure.
7357   result = snd_pcm_hw_params_any( phandle, params );
7358   if ( result < 0 ) {
7359     snd_pcm_close( phandle );
7360     errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << ".";
7361     errorText_ = errorStream_.str();
7362     error( RtAudioError::WARNING );
7363     if ( info.outputChannels == 0 ) return info;
7364     goto probeParameters;
7365   }
7366
7367   result = snd_pcm_hw_params_get_channels_max( params, &value );
7368   if ( result < 0 ) {
7369     snd_pcm_close( phandle );
7370     errorStream_ << "RtApiAlsa::getDeviceInfo: error getting device (" << name << ") input channels, " << snd_strerror( result ) << ".";
7371     errorText_ = errorStream_.str();
7372     error( RtAudioError::WARNING );
7373     if ( info.outputChannels == 0 ) return info;
7374     goto probeParameters;
7375   }
7376   info.inputChannels = value;
7377   snd_pcm_close( phandle );
7378
7379   // If device opens for both playback and capture, we determine the channels.
7380   if ( info.outputChannels > 0 && info.inputChannels > 0 )
7381     info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
7382
7383   // ALSA doesn't provide default devices so we'll use the first available one.
7384   if ( device == 0 && info.outputChannels > 0 )
7385     info.isDefaultOutput = true;
7386   if ( device == 0 && info.inputChannels > 0 )
7387     info.isDefaultInput = true;
7388
7389  probeParameters:
7390   // At this point, we just need to figure out the supported data
7391   // formats and sample rates.  We'll proceed by opening the device in
7392   // the direction with the maximum number of channels, or playback if
7393   // they are equal.  This might limit our sample rate options, but so
7394   // be it.
7395
7396   if ( info.outputChannels >= info.inputChannels )
7397     stream = SND_PCM_STREAM_PLAYBACK;
7398   else
7399     stream = SND_PCM_STREAM_CAPTURE;
7400   snd_pcm_info_set_stream( pcminfo, stream );
7401
7402   result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK);
7403   if ( result < 0 ) {
7404     errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << ".";
7405     errorText_ = errorStream_.str();
7406     error( RtAudioError::WARNING );
7407     return info;
7408   }
7409
7410   // The device is open ... fill the parameter structure.
7411   result = snd_pcm_hw_params_any( phandle, params );
7412   if ( result < 0 ) {
7413     snd_pcm_close( phandle );
7414     errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << ".";
7415     errorText_ = errorStream_.str();
7416     error( RtAudioError::WARNING );
7417     return info;
7418   }
7419
7420   // Test our discrete set of sample rate values.
7421   info.sampleRates.clear();
7422   for ( unsigned int i=0; i<MAX_SAMPLE_RATES; i++ ) {
7423     if ( snd_pcm_hw_params_test_rate( phandle, params, SAMPLE_RATES[i], 0 ) == 0 ) {
7424       info.sampleRates.push_back( SAMPLE_RATES[i] );
7425
7426       if ( !info.preferredSampleRate || ( SAMPLE_RATES[i] <= 48000 && SAMPLE_RATES[i] > info.preferredSampleRate ) )
7427         info.preferredSampleRate = SAMPLE_RATES[i];
7428     }
7429   }
7430   if ( info.sampleRates.size() == 0 ) {
7431     snd_pcm_close( phandle );
7432     errorStream_ << "RtApiAlsa::getDeviceInfo: no supported sample rates found for device (" << name << ").";
7433     errorText_ = errorStream_.str();
7434     error( RtAudioError::WARNING );
7435     return info;
7436   }
7437
7438   // Probe the supported data formats ... we don't care about endian-ness just yet
7439   snd_pcm_format_t format;
7440   info.nativeFormats = 0;
7441   format = SND_PCM_FORMAT_S8;
7442   if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
7443     info.nativeFormats |= RTAUDIO_SINT8;
7444   format = SND_PCM_FORMAT_S16;
7445   if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
7446     info.nativeFormats |= RTAUDIO_SINT16;
7447   format = SND_PCM_FORMAT_S24;
7448   if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
7449     info.nativeFormats |= RTAUDIO_SINT24;
7450   format = SND_PCM_FORMAT_S32;
7451   if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
7452     info.nativeFormats |= RTAUDIO_SINT32;
7453   format = SND_PCM_FORMAT_FLOAT;
7454   if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
7455     info.nativeFormats |= RTAUDIO_FLOAT32;
7456   format = SND_PCM_FORMAT_FLOAT64;
7457   if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
7458     info.nativeFormats |= RTAUDIO_FLOAT64;
7459
7460   // Check that we have at least one supported format
7461   if ( info.nativeFormats == 0 ) {
7462     snd_pcm_close( phandle );
7463     errorStream_ << "RtApiAlsa::getDeviceInfo: pcm device (" << name << ") data format not supported by RtAudio.";
7464     errorText_ = errorStream_.str();
7465     error( RtAudioError::WARNING );
7466     return info;
7467   }
7468
7469   // Get the device name
7470   char *cardname;
7471   result = snd_card_get_name( card, &cardname );
7472   if ( result >= 0 ) {
7473     sprintf( name, "hw:%s,%d", cardname, subdevice );
7474     free( cardname );
7475   }
7476   info.name = name;
7477
7478   // That's all ... close the device and return
7479   snd_pcm_close( phandle );
7480   info.probed = true;
7481   return info;
7482 }
7483
7484 void RtApiAlsa :: saveDeviceInfo( void )
7485 {
7486   devices_.clear();
7487
7488   unsigned int nDevices = getDeviceCount();
7489   devices_.resize( nDevices );
7490   for ( unsigned int i=0; i<nDevices; i++ )
7491     devices_[i] = getDeviceInfo( i );
7492 }
7493
7494 bool RtApiAlsa :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
7495                                    unsigned int firstChannel, unsigned int sampleRate,
7496                                    RtAudioFormat format, unsigned int *bufferSize,
7497                                    RtAudio::StreamOptions *options )
7498
7499 {
7500 #if defined(__RTAUDIO_DEBUG__)
7501   snd_output_t *out;
7502   snd_output_stdio_attach(&out, stderr, 0);
7503 #endif
7504
7505   // I'm not using the "plug" interface ... too much inconsistent behavior.
7506
7507   unsigned nDevices = 0;
7508   int result, subdevice, card;
7509   char name[64];
7510   snd_ctl_t *chandle;
7511
7512   if ( options && options->flags & RTAUDIO_ALSA_USE_DEFAULT )
7513     snprintf(name, sizeof(name), "%s", "default");
7514   else {
7515     // Count cards and devices
7516     card = -1;
7517     snd_card_next( &card );
7518     while ( card >= 0 ) {
7519       sprintf( name, "hw:%d", card );
7520       result = snd_ctl_open( &chandle, name, SND_CTL_NONBLOCK );
7521       if ( result < 0 ) {
7522         errorStream_ << "RtApiAlsa::probeDeviceOpen: control open, card = " << card << ", " << snd_strerror( result ) << ".";
7523         errorText_ = errorStream_.str();
7524         return FAILURE;
7525       }
7526       subdevice = -1;
7527       while( 1 ) {
7528         result = snd_ctl_pcm_next_device( chandle, &subdevice );
7529         if ( result < 0 ) break;
7530         if ( subdevice < 0 ) break;
7531         if ( nDevices == device ) {
7532           sprintf( name, "hw:%d,%d", card, subdevice );
7533           snd_ctl_close( chandle );
7534           goto foundDevice;
7535         }
7536         nDevices++;
7537       }
7538       snd_ctl_close( chandle );
7539       snd_card_next( &card );
7540     }
7541
7542     result = snd_ctl_open( &chandle, "default", SND_CTL_NONBLOCK );
7543     if ( result == 0 ) {
7544       if ( nDevices == device ) {
7545         strcpy( name, "default" );
7546         snd_ctl_close( chandle );
7547         goto foundDevice;
7548       }
7549       nDevices++;
7550     }
7551     snd_ctl_close( chandle );
7552
7553     if ( nDevices == 0 ) {
7554       // This should not happen because a check is made before this function is called.
7555       errorText_ = "RtApiAlsa::probeDeviceOpen: no devices found!";
7556       return FAILURE;
7557     }
7558
7559     if ( device >= nDevices ) {
7560       // This should not happen because a check is made before this function is called.
7561       errorText_ = "RtApiAlsa::probeDeviceOpen: device ID is invalid!";
7562       return FAILURE;
7563     }
7564   }
7565
7566  foundDevice:
7567
7568   // The getDeviceInfo() function will not work for a device that is
7569   // already open.  Thus, we'll probe the system before opening a
7570   // stream and save the results for use by getDeviceInfo().
7571   if ( mode == OUTPUT || ( mode == INPUT && stream_.mode != OUTPUT ) ) // only do once
7572     this->saveDeviceInfo();
7573
7574   snd_pcm_stream_t stream;
7575   if ( mode == OUTPUT )
7576     stream = SND_PCM_STREAM_PLAYBACK;
7577   else
7578     stream = SND_PCM_STREAM_CAPTURE;
7579
7580   snd_pcm_t *phandle;
7581   int openMode = SND_PCM_ASYNC;
7582   result = snd_pcm_open( &phandle, name, stream, openMode );
7583   if ( result < 0 ) {
7584     if ( mode == OUTPUT )
7585       errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device (" << name << ") won't open for output.";
7586     else
7587       errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device (" << name << ") won't open for input.";
7588     errorText_ = errorStream_.str();
7589     return FAILURE;
7590   }
7591
7592   // Fill the parameter structure.
7593   snd_pcm_hw_params_t *hw_params;
7594   snd_pcm_hw_params_alloca( &hw_params );
7595   result = snd_pcm_hw_params_any( phandle, hw_params );
7596   if ( result < 0 ) {
7597     snd_pcm_close( phandle );
7598     errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting pcm device (" << name << ") parameters, " << snd_strerror( result ) << ".";
7599     errorText_ = errorStream_.str();
7600     return FAILURE;
7601   }
7602
7603 #if defined(__RTAUDIO_DEBUG__)
7604   fprintf( stderr, "\nRtApiAlsa: dump hardware params just after device open:\n\n" );
7605   snd_pcm_hw_params_dump( hw_params, out );
7606 #endif
7607
7608   // Set access ... check user preference.
7609   if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) {
7610     stream_.userInterleaved = false;
7611     result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED );
7612     if ( result < 0 ) {
7613       result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED );
7614       stream_.deviceInterleaved[mode] =  true;
7615     }
7616     else
7617       stream_.deviceInterleaved[mode] = false;
7618   }
7619   else {
7620     stream_.userInterleaved = true;
7621     result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED );
7622     if ( result < 0 ) {
7623       result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED );
7624       stream_.deviceInterleaved[mode] =  false;
7625     }
7626     else
7627       stream_.deviceInterleaved[mode] =  true;
7628   }
7629
7630   if ( result < 0 ) {
7631     snd_pcm_close( phandle );
7632     errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting pcm device (" << name << ") access, " << snd_strerror( result ) << ".";
7633     errorText_ = errorStream_.str();
7634     return FAILURE;
7635   }
7636
7637   // Determine how to set the device format.
7638   stream_.userFormat = format;
7639   snd_pcm_format_t deviceFormat = SND_PCM_FORMAT_UNKNOWN;
7640
7641   if ( format == RTAUDIO_SINT8 )
7642     deviceFormat = SND_PCM_FORMAT_S8;
7643   else if ( format == RTAUDIO_SINT16 )
7644     deviceFormat = SND_PCM_FORMAT_S16;
7645   else if ( format == RTAUDIO_SINT24 )
7646     deviceFormat = SND_PCM_FORMAT_S24;
7647   else if ( format == RTAUDIO_SINT32 )
7648     deviceFormat = SND_PCM_FORMAT_S32;
7649   else if ( format == RTAUDIO_FLOAT32 )
7650     deviceFormat = SND_PCM_FORMAT_FLOAT;
7651   else if ( format == RTAUDIO_FLOAT64 )
7652     deviceFormat = SND_PCM_FORMAT_FLOAT64;
7653
7654   if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
7655     stream_.deviceFormat[mode] = format;
7656     goto setFormat;
7657   }
7658
7659   // The user requested format is not natively supported by the device.
7660   deviceFormat = SND_PCM_FORMAT_FLOAT64;
7661   if ( snd_pcm_hw_params_test_format( phandle, hw_params, deviceFormat ) == 0 ) {
7662     stream_.deviceFormat[mode] = RTAUDIO_FLOAT64;
7663     goto setFormat;
7664   }
7665
7666   deviceFormat = SND_PCM_FORMAT_FLOAT;
7667   if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
7668     stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
7669     goto setFormat;
7670   }
7671
7672   deviceFormat = SND_PCM_FORMAT_S32;
7673   if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
7674     stream_.deviceFormat[mode] = RTAUDIO_SINT32;
7675     goto setFormat;
7676   }
7677
7678   deviceFormat = SND_PCM_FORMAT_S24;
7679   if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
7680     stream_.deviceFormat[mode] = RTAUDIO_SINT24;
7681     goto setFormat;
7682   }
7683
7684   deviceFormat = SND_PCM_FORMAT_S16;
7685   if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
7686     stream_.deviceFormat[mode] = RTAUDIO_SINT16;
7687     goto setFormat;
7688   }
7689
7690   deviceFormat = SND_PCM_FORMAT_S8;
7691   if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
7692     stream_.deviceFormat[mode] = RTAUDIO_SINT8;
7693     goto setFormat;
7694   }
7695
7696   // If we get here, no supported format was found.
7697   snd_pcm_close( phandle );
7698   errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device " << device << " data format not supported by RtAudio.";
7699   errorText_ = errorStream_.str();
7700   return FAILURE;
7701
7702  setFormat:
7703   result = snd_pcm_hw_params_set_format( phandle, hw_params, deviceFormat );
7704   if ( result < 0 ) {
7705     snd_pcm_close( phandle );
7706     errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting pcm device (" << name << ") data format, " << snd_strerror( result ) << ".";
7707     errorText_ = errorStream_.str();
7708     return FAILURE;
7709   }
7710
7711   // Determine whether byte-swaping is necessary.
7712   stream_.doByteSwap[mode] = false;
7713   if ( deviceFormat != SND_PCM_FORMAT_S8 ) {
7714     result = snd_pcm_format_cpu_endian( deviceFormat );
7715     if ( result == 0 )
7716       stream_.doByteSwap[mode] = true;
7717     else if (result < 0) {
7718       snd_pcm_close( phandle );
7719       errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting pcm device (" << name << ") endian-ness, " << snd_strerror( result ) << ".";
7720       errorText_ = errorStream_.str();
7721       return FAILURE;
7722     }
7723   }
7724
7725   // Set the sample rate.
7726   result = snd_pcm_hw_params_set_rate_near( phandle, hw_params, (unsigned int*) &sampleRate, 0 );
7727   if ( result < 0 ) {
7728     snd_pcm_close( phandle );
7729     errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting sample rate on device (" << name << "), " << snd_strerror( result ) << ".";
7730     errorText_ = errorStream_.str();
7731     return FAILURE;
7732   }
7733
7734   // Determine the number of channels for this device.  We support a possible
7735   // minimum device channel number > than the value requested by the user.
7736   stream_.nUserChannels[mode] = channels;
7737   unsigned int value;
7738   result = snd_pcm_hw_params_get_channels_max( hw_params, &value );
7739   unsigned int deviceChannels = value;
7740   if ( result < 0 || deviceChannels < channels + firstChannel ) {
7741     snd_pcm_close( phandle );
7742     errorStream_ << "RtApiAlsa::probeDeviceOpen: requested channel parameters not supported by device (" << name << "), " << snd_strerror( result ) << ".";
7743     errorText_ = errorStream_.str();
7744     return FAILURE;
7745   }
7746
7747   result = snd_pcm_hw_params_get_channels_min( hw_params, &value );
7748   if ( result < 0 ) {
7749     snd_pcm_close( phandle );
7750     errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting minimum channels for device (" << name << "), " << snd_strerror( result ) << ".";
7751     errorText_ = errorStream_.str();
7752     return FAILURE;
7753   }
7754   deviceChannels = value;
7755   if ( deviceChannels < channels + firstChannel ) deviceChannels = channels + firstChannel;
7756   stream_.nDeviceChannels[mode] = deviceChannels;
7757
7758   // Set the device channels.
7759   result = snd_pcm_hw_params_set_channels( phandle, hw_params, deviceChannels );
7760   if ( result < 0 ) {
7761     snd_pcm_close( phandle );
7762     errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting channels for device (" << name << "), " << snd_strerror( result ) << ".";
7763     errorText_ = errorStream_.str();
7764     return FAILURE;
7765   }
7766
7767   // Set the buffer (or period) size.
7768   int dir = 0;
7769   snd_pcm_uframes_t periodSize = *bufferSize;
7770   result = snd_pcm_hw_params_set_period_size_near( phandle, hw_params, &periodSize, &dir );
7771   if ( result < 0 ) {
7772     snd_pcm_close( phandle );
7773     errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting period size for device (" << name << "), " << snd_strerror( result ) << ".";
7774     errorText_ = errorStream_.str();
7775     return FAILURE;
7776   }
7777   *bufferSize = periodSize;
7778
7779   // Set the buffer number, which in ALSA is referred to as the "period".
7780   unsigned int periods = 0;
7781   if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) periods = 2;
7782   if ( options && options->numberOfBuffers > 0 ) periods = options->numberOfBuffers;
7783   if ( periods < 2 ) periods = 4; // a fairly safe default value
7784   result = snd_pcm_hw_params_set_periods_near( phandle, hw_params, &periods, &dir );
7785   if ( result < 0 ) {
7786     snd_pcm_close( phandle );
7787     errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting periods for device (" << name << "), " << snd_strerror( result ) << ".";
7788     errorText_ = errorStream_.str();
7789     return FAILURE;
7790   }
7791
7792   // If attempting to setup a duplex stream, the bufferSize parameter
7793   // MUST be the same in both directions!
7794   if ( stream_.mode == OUTPUT && mode == INPUT && *bufferSize != stream_.bufferSize ) {
7795     snd_pcm_close( phandle );
7796     errorStream_ << "RtApiAlsa::probeDeviceOpen: system error setting buffer size for duplex stream on device (" << name << ").";
7797     errorText_ = errorStream_.str();
7798     return FAILURE;
7799   }
7800
7801   stream_.bufferSize = *bufferSize;
7802
7803   // Install the hardware configuration
7804   result = snd_pcm_hw_params( phandle, hw_params );
7805   if ( result < 0 ) {
7806     snd_pcm_close( phandle );
7807     errorStream_ << "RtApiAlsa::probeDeviceOpen: error installing hardware configuration on device (" << name << "), " << snd_strerror( result ) << ".";
7808     errorText_ = errorStream_.str();
7809     return FAILURE;
7810   }
7811
7812 #if defined(__RTAUDIO_DEBUG__)
7813   fprintf(stderr, "\nRtApiAlsa: dump hardware params after installation:\n\n");
7814   snd_pcm_hw_params_dump( hw_params, out );
7815 #endif
7816
7817   // Set the software configuration to fill buffers with zeros and prevent device stopping on xruns.
7818   snd_pcm_sw_params_t *sw_params = NULL;
7819   snd_pcm_sw_params_alloca( &sw_params );
7820   snd_pcm_sw_params_current( phandle, sw_params );
7821   snd_pcm_sw_params_set_start_threshold( phandle, sw_params, *bufferSize );
7822   snd_pcm_sw_params_set_stop_threshold( phandle, sw_params, ULONG_MAX );
7823   snd_pcm_sw_params_set_silence_threshold( phandle, sw_params, 0 );
7824
7825   // The following two settings were suggested by Theo Veenker
7826   //snd_pcm_sw_params_set_avail_min( phandle, sw_params, *bufferSize );
7827   //snd_pcm_sw_params_set_xfer_align( phandle, sw_params, 1 );
7828
7829   // here are two options for a fix
7830   //snd_pcm_sw_params_set_silence_size( phandle, sw_params, ULONG_MAX );
7831   snd_pcm_uframes_t val;
7832   snd_pcm_sw_params_get_boundary( sw_params, &val );
7833   snd_pcm_sw_params_set_silence_size( phandle, sw_params, val );
7834
7835   result = snd_pcm_sw_params( phandle, sw_params );
7836   if ( result < 0 ) {
7837     snd_pcm_close( phandle );
7838     errorStream_ << "RtApiAlsa::probeDeviceOpen: error installing software configuration on device (" << name << "), " << snd_strerror( result ) << ".";
7839     errorText_ = errorStream_.str();
7840     return FAILURE;
7841   }
7842
7843 #if defined(__RTAUDIO_DEBUG__)
7844   fprintf(stderr, "\nRtApiAlsa: dump software params after installation:\n\n");
7845   snd_pcm_sw_params_dump( sw_params, out );
7846 #endif
7847
7848   // Set flags for buffer conversion
7849   stream_.doConvertBuffer[mode] = false;
7850   if ( stream_.userFormat != stream_.deviceFormat[mode] )
7851     stream_.doConvertBuffer[mode] = true;
7852   if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] )
7853     stream_.doConvertBuffer[mode] = true;
7854   if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
7855        stream_.nUserChannels[mode] > 1 )
7856     stream_.doConvertBuffer[mode] = true;
7857
7858   // Allocate the ApiHandle if necessary and then save.
7859   AlsaHandle *apiInfo = 0;
7860   if ( stream_.apiHandle == 0 ) {
7861     try {
7862       apiInfo = (AlsaHandle *) new AlsaHandle;
7863     }
7864     catch ( std::bad_alloc& ) {
7865       errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating AlsaHandle memory.";
7866       goto error;
7867     }
7868
7869     if ( pthread_cond_init( &apiInfo->runnable_cv, NULL ) ) {
7870       errorText_ = "RtApiAlsa::probeDeviceOpen: error initializing pthread condition variable.";
7871       goto error;
7872     }
7873
7874     stream_.apiHandle = (void *) apiInfo;
7875     apiInfo->handles[0] = 0;
7876     apiInfo->handles[1] = 0;
7877   }
7878   else {
7879     apiInfo = (AlsaHandle *) stream_.apiHandle;
7880   }
7881   apiInfo->handles[mode] = phandle;
7882   phandle = 0;
7883
7884   // Allocate necessary internal buffers.
7885   unsigned long bufferBytes;
7886   bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
7887   stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
7888   if ( stream_.userBuffer[mode] == NULL ) {
7889     errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating user buffer memory.";
7890     goto error;
7891   }
7892
7893   if ( stream_.doConvertBuffer[mode] ) {
7894
7895     bool makeBuffer = true;
7896     bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
7897     if ( mode == INPUT ) {
7898       if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
7899         unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
7900         if ( bufferBytes <= bytesOut ) makeBuffer = false;
7901       }
7902     }
7903
7904     if ( makeBuffer ) {
7905       bufferBytes *= *bufferSize;
7906       if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
7907       stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
7908       if ( stream_.deviceBuffer == NULL ) {
7909         errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating device buffer memory.";
7910         goto error;
7911       }
7912     }
7913   }
7914
7915   stream_.sampleRate = sampleRate;
7916   stream_.nBuffers = periods;
7917   stream_.device[mode] = device;
7918   stream_.state = STREAM_STOPPED;
7919
7920   // Setup the buffer conversion information structure.
7921   if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel );
7922
7923   // Setup thread if necessary.
7924   if ( stream_.mode == OUTPUT && mode == INPUT ) {
7925     // We had already set up an output stream.
7926     stream_.mode = DUPLEX;
7927     // Link the streams if possible.
7928     apiInfo->synchronized = false;
7929     if ( snd_pcm_link( apiInfo->handles[0], apiInfo->handles[1] ) == 0 )
7930       apiInfo->synchronized = true;
7931     else {
7932       errorText_ = "RtApiAlsa::probeDeviceOpen: unable to synchronize input and output devices.";
7933       error( RtAudioError::WARNING );
7934     }
7935   }
7936   else {
7937     stream_.mode = mode;
7938
7939     // Setup callback thread.
7940     stream_.callbackInfo.object = (void *) this;
7941
7942     // Set the thread attributes for joinable and realtime scheduling
7943     // priority (optional).  The higher priority will only take affect
7944     // if the program is run as root or suid. Note, under Linux
7945     // processes with CAP_SYS_NICE privilege, a user can change
7946     // scheduling policy and priority (thus need not be root). See
7947     // POSIX "capabilities".
7948     pthread_attr_t attr;
7949     pthread_attr_init( &attr );
7950     pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
7951 #ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
7952     if ( options && options->flags & RTAUDIO_SCHEDULE_REALTIME ) {
7953       stream_.callbackInfo.doRealtime = true;
7954       struct sched_param param;
7955       int priority = options->priority;
7956       int min = sched_get_priority_min( SCHED_RR );
7957       int max = sched_get_priority_max( SCHED_RR );
7958       if ( priority < min ) priority = min;
7959       else if ( priority > max ) priority = max;
7960       param.sched_priority = priority;
7961
7962       // Set the policy BEFORE the priority. Otherwise it fails.
7963       pthread_attr_setschedpolicy(&attr, SCHED_RR);
7964       pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
7965       // This is definitely required. Otherwise it fails.
7966       pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
7967       pthread_attr_setschedparam(&attr, &param);
7968     }
7969     else
7970       pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
7971 #else
7972     pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
7973 #endif
7974
7975     stream_.callbackInfo.isRunning = true;
7976     result = pthread_create( &stream_.callbackInfo.thread, &attr, alsaCallbackHandler, &stream_.callbackInfo );
7977     pthread_attr_destroy( &attr );
7978     if ( result ) {
7979       // Failed. Try instead with default attributes.
7980       result = pthread_create( &stream_.callbackInfo.thread, NULL, alsaCallbackHandler, &stream_.callbackInfo );
7981       if ( result ) {
7982         stream_.callbackInfo.isRunning = false;
7983         errorText_ = "RtApiAlsa::error creating callback thread!";
7984         goto error;
7985       }
7986     }
7987   }
7988
7989   return SUCCESS;
7990
7991  error:
7992   if ( apiInfo ) {
7993     pthread_cond_destroy( &apiInfo->runnable_cv );
7994     if ( apiInfo->handles[0] ) snd_pcm_close( apiInfo->handles[0] );
7995     if ( apiInfo->handles[1] ) snd_pcm_close( apiInfo->handles[1] );
7996     delete apiInfo;
7997     stream_.apiHandle = 0;
7998   }
7999
8000   if ( phandle) snd_pcm_close( phandle );
8001
8002   for ( int i=0; i<2; i++ ) {
8003     if ( stream_.userBuffer[i] ) {
8004       free( stream_.userBuffer[i] );
8005       stream_.userBuffer[i] = 0;
8006     }
8007   }
8008
8009   if ( stream_.deviceBuffer ) {
8010     free( stream_.deviceBuffer );
8011     stream_.deviceBuffer = 0;
8012   }
8013
8014   stream_.state = STREAM_CLOSED;
8015   return FAILURE;
8016 }
8017
8018 void RtApiAlsa :: closeStream()
8019 {
8020   if ( stream_.state == STREAM_CLOSED ) {
8021     errorText_ = "RtApiAlsa::closeStream(): no open stream to close!";
8022     error( RtAudioError::WARNING );
8023     return;
8024   }
8025
8026   AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
8027   stream_.callbackInfo.isRunning = false;
8028   MUTEX_LOCK( &stream_.mutex );
8029   if ( stream_.state == STREAM_STOPPED ) {
8030     apiInfo->runnable = true;
8031     pthread_cond_signal( &apiInfo->runnable_cv );
8032   }
8033   MUTEX_UNLOCK( &stream_.mutex );
8034   pthread_join( stream_.callbackInfo.thread, NULL );
8035
8036   if ( stream_.state == STREAM_RUNNING ) {
8037     stream_.state = STREAM_STOPPED;
8038     if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX )
8039       snd_pcm_drop( apiInfo->handles[0] );
8040     if ( stream_.mode == INPUT || stream_.mode == DUPLEX )
8041       snd_pcm_drop( apiInfo->handles[1] );
8042   }
8043
8044   if ( apiInfo ) {
8045     pthread_cond_destroy( &apiInfo->runnable_cv );
8046     if ( apiInfo->handles[0] ) snd_pcm_close( apiInfo->handles[0] );
8047     if ( apiInfo->handles[1] ) snd_pcm_close( apiInfo->handles[1] );
8048     delete apiInfo;
8049     stream_.apiHandle = 0;
8050   }
8051
8052   for ( int i=0; i<2; i++ ) {
8053     if ( stream_.userBuffer[i] ) {
8054       free( stream_.userBuffer[i] );
8055       stream_.userBuffer[i] = 0;
8056     }
8057   }
8058
8059   if ( stream_.deviceBuffer ) {
8060     free( stream_.deviceBuffer );
8061     stream_.deviceBuffer = 0;
8062   }
8063
8064   stream_.mode = UNINITIALIZED;
8065   stream_.state = STREAM_CLOSED;
8066 }
8067
8068 void RtApiAlsa :: startStream()
8069 {
8070   // This method calls snd_pcm_prepare if the device isn't already in that state.
8071
8072   verifyStream();
8073   if ( stream_.state == STREAM_RUNNING ) {
8074     errorText_ = "RtApiAlsa::startStream(): the stream is already running!";
8075     error( RtAudioError::WARNING );
8076     return;
8077   }
8078
8079   MUTEX_LOCK( &stream_.mutex );
8080
8081   int result = 0;
8082   snd_pcm_state_t state;
8083   AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
8084   snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles;
8085   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
8086     state = snd_pcm_state( handle[0] );
8087     if ( state != SND_PCM_STATE_PREPARED ) {
8088       result = snd_pcm_prepare( handle[0] );
8089       if ( result < 0 ) {
8090         errorStream_ << "RtApiAlsa::startStream: error preparing output pcm device, " << snd_strerror( result ) << ".";
8091         errorText_ = errorStream_.str();
8092         goto unlock;
8093       }
8094     }
8095   }
8096
8097   if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) {
8098     result = snd_pcm_drop(handle[1]); // fix to remove stale data received since device has been open
8099     state = snd_pcm_state( handle[1] );
8100     if ( state != SND_PCM_STATE_PREPARED ) {
8101       result = snd_pcm_prepare( handle[1] );
8102       if ( result < 0 ) {
8103         errorStream_ << "RtApiAlsa::startStream: error preparing input pcm device, " << snd_strerror( result ) << ".";
8104         errorText_ = errorStream_.str();
8105         goto unlock;
8106       }
8107     }
8108   }
8109
8110   stream_.state = STREAM_RUNNING;
8111
8112  unlock:
8113   apiInfo->runnable = true;
8114   pthread_cond_signal( &apiInfo->runnable_cv );
8115   MUTEX_UNLOCK( &stream_.mutex );
8116
8117   if ( result >= 0 ) return;
8118   error( RtAudioError::SYSTEM_ERROR );
8119 }
8120
8121 void RtApiAlsa :: stopStream()
8122 {
8123   verifyStream();
8124   if ( stream_.state == STREAM_STOPPED ) {
8125     errorText_ = "RtApiAlsa::stopStream(): the stream is already stopped!";
8126     error( RtAudioError::WARNING );
8127     return;
8128   }
8129
8130   stream_.state = STREAM_STOPPED;
8131   MUTEX_LOCK( &stream_.mutex );
8132
8133   int result = 0;
8134   AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
8135   snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles;
8136   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
8137     if ( apiInfo->synchronized )
8138       result = snd_pcm_drop( handle[0] );
8139     else
8140       result = snd_pcm_drain( handle[0] );
8141     if ( result < 0 ) {
8142       errorStream_ << "RtApiAlsa::stopStream: error draining output pcm device, " << snd_strerror( result ) << ".";
8143       errorText_ = errorStream_.str();
8144       goto unlock;
8145     }
8146   }
8147
8148   if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) {
8149     result = snd_pcm_drop( handle[1] );
8150     if ( result < 0 ) {
8151       errorStream_ << "RtApiAlsa::stopStream: error stopping input pcm device, " << snd_strerror( result ) << ".";
8152       errorText_ = errorStream_.str();
8153       goto unlock;
8154     }
8155   }
8156
8157  unlock:
8158   apiInfo->runnable = false; // fixes high CPU usage when stopped
8159   MUTEX_UNLOCK( &stream_.mutex );
8160
8161   if ( result >= 0 ) return;
8162   error( RtAudioError::SYSTEM_ERROR );
8163 }
8164
8165 void RtApiAlsa :: abortStream()
8166 {
8167   verifyStream();
8168   if ( stream_.state == STREAM_STOPPED ) {
8169     errorText_ = "RtApiAlsa::abortStream(): the stream is already stopped!";
8170     error( RtAudioError::WARNING );
8171     return;
8172   }
8173
8174   stream_.state = STREAM_STOPPED;
8175   MUTEX_LOCK( &stream_.mutex );
8176
8177   int result = 0;
8178   AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
8179   snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles;
8180   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
8181     result = snd_pcm_drop( handle[0] );
8182     if ( result < 0 ) {
8183       errorStream_ << "RtApiAlsa::abortStream: error aborting output pcm device, " << snd_strerror( result ) << ".";
8184       errorText_ = errorStream_.str();
8185       goto unlock;
8186     }
8187   }
8188
8189   if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) {
8190     result = snd_pcm_drop( handle[1] );
8191     if ( result < 0 ) {
8192       errorStream_ << "RtApiAlsa::abortStream: error aborting input pcm device, " << snd_strerror( result ) << ".";
8193       errorText_ = errorStream_.str();
8194       goto unlock;
8195     }
8196   }
8197
8198  unlock:
8199   apiInfo->runnable = false; // fixes high CPU usage when stopped
8200   MUTEX_UNLOCK( &stream_.mutex );
8201
8202   if ( result >= 0 ) return;
8203   error( RtAudioError::SYSTEM_ERROR );
8204 }
8205
8206 void RtApiAlsa :: callbackEvent()
8207 {
8208   AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
8209   if ( stream_.state == STREAM_STOPPED ) {
8210     MUTEX_LOCK( &stream_.mutex );
8211     while ( !apiInfo->runnable )
8212       pthread_cond_wait( &apiInfo->runnable_cv, &stream_.mutex );
8213
8214     if ( stream_.state != STREAM_RUNNING ) {
8215       MUTEX_UNLOCK( &stream_.mutex );
8216       return;
8217     }
8218     MUTEX_UNLOCK( &stream_.mutex );
8219   }
8220
8221   if ( stream_.state == STREAM_CLOSED ) {
8222     errorText_ = "RtApiAlsa::callbackEvent(): the stream is closed ... this shouldn't happen!";
8223     error( RtAudioError::WARNING );
8224     return;
8225   }
8226
8227   int doStopStream = 0;
8228   RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback;
8229   double streamTime = getStreamTime();
8230   RtAudioStreamStatus status = 0;
8231   if ( stream_.mode != INPUT && apiInfo->xrun[0] == true ) {
8232     status |= RTAUDIO_OUTPUT_UNDERFLOW;
8233     apiInfo->xrun[0] = false;
8234   }
8235   if ( stream_.mode != OUTPUT && apiInfo->xrun[1] == true ) {
8236     status |= RTAUDIO_INPUT_OVERFLOW;
8237     apiInfo->xrun[1] = false;
8238   }
8239   doStopStream = callback( stream_.userBuffer[0], stream_.userBuffer[1],
8240                            stream_.bufferSize, streamTime, status, stream_.callbackInfo.userData );
8241
8242   if ( doStopStream == 2 ) {
8243     abortStream();
8244     return;
8245   }
8246
8247   MUTEX_LOCK( &stream_.mutex );
8248
8249   // The state might change while waiting on a mutex.
8250   if ( stream_.state == STREAM_STOPPED ) goto unlock;
8251
8252   int result;
8253   char *buffer;
8254   int channels;
8255   snd_pcm_t **handle;
8256   snd_pcm_sframes_t frames;
8257   RtAudioFormat format;
8258   handle = (snd_pcm_t **) apiInfo->handles;
8259
8260   if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
8261
8262     // Setup parameters.
8263     if ( stream_.doConvertBuffer[1] ) {
8264       buffer = stream_.deviceBuffer;
8265       channels = stream_.nDeviceChannels[1];
8266       format = stream_.deviceFormat[1];
8267     }
8268     else {
8269       buffer = stream_.userBuffer[1];
8270       channels = stream_.nUserChannels[1];
8271       format = stream_.userFormat;
8272     }
8273
8274     // Read samples from device in interleaved/non-interleaved format.
8275     if ( stream_.deviceInterleaved[1] )
8276       result = snd_pcm_readi( handle[1], buffer, stream_.bufferSize );
8277     else {
8278       void *bufs[channels];
8279       size_t offset = stream_.bufferSize * formatBytes( format );
8280       for ( int i=0; i<channels; i++ )
8281         bufs[i] = (void *) (buffer + (i * offset));
8282       result = snd_pcm_readn( handle[1], bufs, stream_.bufferSize );
8283     }
8284
8285     if ( result < (int) stream_.bufferSize ) {
8286       // Either an error or overrun occured.
8287       if ( result == -EPIPE ) {
8288         snd_pcm_state_t state = snd_pcm_state( handle[1] );
8289         if ( state == SND_PCM_STATE_XRUN ) {
8290           apiInfo->xrun[1] = true;
8291           result = snd_pcm_prepare( handle[1] );
8292           if ( result < 0 ) {
8293             errorStream_ << "RtApiAlsa::callbackEvent: error preparing device after overrun, " << snd_strerror( result ) << ".";
8294             errorText_ = errorStream_.str();
8295           }
8296         }
8297         else {
8298           errorStream_ << "RtApiAlsa::callbackEvent: error, current state is " << snd_pcm_state_name( state ) << ", " << snd_strerror( result ) << ".";
8299           errorText_ = errorStream_.str();
8300         }
8301       }
8302       else {
8303         errorStream_ << "RtApiAlsa::callbackEvent: audio read error, " << snd_strerror( result ) << ".";
8304         errorText_ = errorStream_.str();
8305       }
8306       error( RtAudioError::WARNING );
8307       goto tryOutput;
8308     }
8309
8310     // Do byte swapping if necessary.
8311     if ( stream_.doByteSwap[1] )
8312       byteSwapBuffer( buffer, stream_.bufferSize * channels, format );
8313
8314     // Do buffer conversion if necessary.
8315     if ( stream_.doConvertBuffer[1] )
8316       convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
8317
8318     // Check stream latency
8319     result = snd_pcm_delay( handle[1], &frames );
8320     if ( result == 0 && frames > 0 ) stream_.latency[1] = frames;
8321   }
8322
8323  tryOutput:
8324
8325   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
8326
8327     // Setup parameters and do buffer conversion if necessary.
8328     if ( stream_.doConvertBuffer[0] ) {
8329       buffer = stream_.deviceBuffer;
8330       convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] );
8331       channels = stream_.nDeviceChannels[0];
8332       format = stream_.deviceFormat[0];
8333     }
8334     else {
8335       buffer = stream_.userBuffer[0];
8336       channels = stream_.nUserChannels[0];
8337       format = stream_.userFormat;
8338     }
8339
8340     // Do byte swapping if necessary.
8341     if ( stream_.doByteSwap[0] )
8342       byteSwapBuffer(buffer, stream_.bufferSize * channels, format);
8343
8344     // Write samples to device in interleaved/non-interleaved format.
8345     if ( stream_.deviceInterleaved[0] )
8346       result = snd_pcm_writei( handle[0], buffer, stream_.bufferSize );
8347     else {
8348       void *bufs[channels];
8349       size_t offset = stream_.bufferSize * formatBytes( format );
8350       for ( int i=0; i<channels; i++ )
8351         bufs[i] = (void *) (buffer + (i * offset));
8352       result = snd_pcm_writen( handle[0], bufs, stream_.bufferSize );
8353     }
8354
8355     if ( result < (int) stream_.bufferSize ) {
8356       // Either an error or underrun occured.
8357       if ( result == -EPIPE ) {
8358         snd_pcm_state_t state = snd_pcm_state( handle[0] );
8359         if ( state == SND_PCM_STATE_XRUN ) {
8360           apiInfo->xrun[0] = true;
8361           result = snd_pcm_prepare( handle[0] );
8362           if ( result < 0 ) {
8363             errorStream_ << "RtApiAlsa::callbackEvent: error preparing device after underrun, " << snd_strerror( result ) << ".";
8364             errorText_ = errorStream_.str();
8365           }
8366           else
8367             errorText_ =  "RtApiAlsa::callbackEvent: audio write error, underrun.";
8368         }
8369         else {
8370           errorStream_ << "RtApiAlsa::callbackEvent: error, current state is " << snd_pcm_state_name( state ) << ", " << snd_strerror( result ) << ".";
8371           errorText_ = errorStream_.str();
8372         }
8373       }
8374       else {
8375         errorStream_ << "RtApiAlsa::callbackEvent: audio write error, " << snd_strerror( result ) << ".";
8376         errorText_ = errorStream_.str();
8377       }
8378       error( RtAudioError::WARNING );
8379       goto unlock;
8380     }
8381
8382     // Check stream latency
8383     result = snd_pcm_delay( handle[0], &frames );
8384     if ( result == 0 && frames > 0 ) stream_.latency[0] = frames;
8385   }
8386
8387  unlock:
8388   MUTEX_UNLOCK( &stream_.mutex );
8389
8390   RtApi::tickStreamTime();
8391   if ( doStopStream == 1 ) this->stopStream();
8392 }
8393
8394 static void *alsaCallbackHandler( void *ptr )
8395 {
8396   CallbackInfo *info = (CallbackInfo *) ptr;
8397   RtApiAlsa *object = (RtApiAlsa *) info->object;
8398   bool *isRunning = &info->isRunning;
8399
8400 #ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
8401   if ( info->doRealtime ) {
8402     std::cerr << "RtAudio alsa: " <<
8403              (sched_getscheduler(0) == SCHED_RR ? "" : "_NOT_ ") <<
8404              "running realtime scheduling" << std::endl;
8405   }
8406 #endif
8407
8408   while ( *isRunning == true ) {
8409     pthread_testcancel();
8410     object->callbackEvent();
8411   }
8412
8413   pthread_exit( NULL );
8414 }
8415
8416 //******************** End of __LINUX_ALSA__ *********************//
8417 #endif
8418
8419 #if defined(__LINUX_PULSE__)
8420
8421 // Code written by Peter Meerwald, pmeerw@pmeerw.net
8422 // and Tristan Matthews.
8423
8424 #include <pulse/error.h>
8425 #include <pulse/simple.h>
8426 #include <cstdio>
8427
8428 static const unsigned int SUPPORTED_SAMPLERATES[] = { 8000, 16000, 22050, 32000,
8429                                                       44100, 48000, 96000, 0};
8430
8431 struct rtaudio_pa_format_mapping_t {
8432   RtAudioFormat rtaudio_format;
8433   pa_sample_format_t pa_format;
8434 };
8435
8436 static const rtaudio_pa_format_mapping_t supported_sampleformats[] = {
8437   {RTAUDIO_SINT16, PA_SAMPLE_S16LE},
8438   {RTAUDIO_SINT32, PA_SAMPLE_S32LE},
8439   {RTAUDIO_FLOAT32, PA_SAMPLE_FLOAT32LE},
8440   {0, PA_SAMPLE_INVALID}};
8441
8442 struct PulseAudioHandle {
8443   pa_simple *s_play;
8444   pa_simple *s_rec;
8445   pthread_t thread;
8446   pthread_cond_t runnable_cv;
8447   bool runnable;
8448   PulseAudioHandle() : s_play(0), s_rec(0), runnable(false) { }
8449 };
8450
8451 RtApiPulse::~RtApiPulse()
8452 {
8453   if ( stream_.state != STREAM_CLOSED )
8454     closeStream();
8455 }
8456
8457 unsigned int RtApiPulse::getDeviceCount( void )
8458 {
8459   return 1;
8460 }
8461
8462 RtAudio::DeviceInfo RtApiPulse::getDeviceInfo( unsigned int /*device*/ )
8463 {
8464   RtAudio::DeviceInfo info;
8465   info.probed = true;
8466   info.name = "PulseAudio";
8467   info.outputChannels = 2;
8468   info.inputChannels = 2;
8469   info.duplexChannels = 2;
8470   info.isDefaultOutput = true;
8471   info.isDefaultInput = true;
8472
8473   for ( const unsigned int *sr = SUPPORTED_SAMPLERATES; *sr; ++sr )
8474     info.sampleRates.push_back( *sr );
8475
8476   info.preferredSampleRate = 48000;
8477   info.nativeFormats = RTAUDIO_SINT16 | RTAUDIO_SINT32 | RTAUDIO_FLOAT32;
8478
8479   return info;
8480 }
8481
8482 static void *pulseaudio_callback( void * user )
8483 {
8484   CallbackInfo *cbi = static_cast<CallbackInfo *>( user );
8485   RtApiPulse *context = static_cast<RtApiPulse *>( cbi->object );
8486   volatile bool *isRunning = &cbi->isRunning;
8487
8488 #ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
8489   if (cbi->doRealtime) {
8490     std::cerr << "RtAudio pulse: " <<
8491              (sched_getscheduler(0) == SCHED_RR ? "" : "_NOT_ ") <<
8492              "running realtime scheduling" << std::endl;
8493   }
8494 #endif
8495
8496   while ( *isRunning ) {
8497     pthread_testcancel();
8498     context->callbackEvent();
8499   }
8500
8501   pthread_exit( NULL );
8502 }
8503
8504 void RtApiPulse::closeStream( void )
8505 {
8506   PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
8507
8508   stream_.callbackInfo.isRunning = false;
8509   if ( pah ) {
8510     MUTEX_LOCK( &stream_.mutex );
8511     if ( stream_.state == STREAM_STOPPED ) {
8512       pah->runnable = true;
8513       pthread_cond_signal( &pah->runnable_cv );
8514     }
8515     MUTEX_UNLOCK( &stream_.mutex );
8516
8517     pthread_join( pah->thread, 0 );
8518     if ( pah->s_play ) {
8519       pa_simple_flush( pah->s_play, NULL );
8520       pa_simple_free( pah->s_play );
8521     }
8522     if ( pah->s_rec )
8523       pa_simple_free( pah->s_rec );
8524
8525     pthread_cond_destroy( &pah->runnable_cv );
8526     delete pah;
8527     stream_.apiHandle = 0;
8528   }
8529
8530   if ( stream_.userBuffer[0] ) {
8531     free( stream_.userBuffer[0] );
8532     stream_.userBuffer[0] = 0;
8533   }
8534   if ( stream_.userBuffer[1] ) {
8535     free( stream_.userBuffer[1] );
8536     stream_.userBuffer[1] = 0;
8537   }
8538
8539   stream_.state = STREAM_CLOSED;
8540   stream_.mode = UNINITIALIZED;
8541 }
8542
8543 void RtApiPulse::callbackEvent( void )
8544 {
8545   PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
8546
8547   if ( stream_.state == STREAM_STOPPED ) {
8548     MUTEX_LOCK( &stream_.mutex );
8549     while ( !pah->runnable )
8550       pthread_cond_wait( &pah->runnable_cv, &stream_.mutex );
8551
8552     if ( stream_.state != STREAM_RUNNING ) {
8553       MUTEX_UNLOCK( &stream_.mutex );
8554       return;
8555     }
8556     MUTEX_UNLOCK( &stream_.mutex );
8557   }
8558
8559   if ( stream_.state == STREAM_CLOSED ) {
8560     errorText_ = "RtApiPulse::callbackEvent(): the stream is closed ... "
8561       "this shouldn't happen!";
8562     error( RtAudioError::WARNING );
8563     return;
8564   }
8565
8566   RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback;
8567   double streamTime = getStreamTime();
8568   RtAudioStreamStatus status = 0;
8569   int doStopStream = callback( stream_.userBuffer[OUTPUT], stream_.userBuffer[INPUT],
8570                                stream_.bufferSize, streamTime, status,
8571                                stream_.callbackInfo.userData );
8572
8573   if ( doStopStream == 2 ) {
8574     abortStream();
8575     return;
8576   }
8577
8578   MUTEX_LOCK( &stream_.mutex );
8579   void *pulse_in = stream_.doConvertBuffer[INPUT] ? stream_.deviceBuffer : stream_.userBuffer[INPUT];
8580   void *pulse_out = stream_.doConvertBuffer[OUTPUT] ? stream_.deviceBuffer : stream_.userBuffer[OUTPUT];
8581
8582   if ( stream_.state != STREAM_RUNNING )
8583     goto unlock;
8584
8585   int pa_error;
8586   size_t bytes;
8587   if (stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
8588     if ( stream_.doConvertBuffer[OUTPUT] ) {
8589         convertBuffer( stream_.deviceBuffer,
8590                        stream_.userBuffer[OUTPUT],
8591                        stream_.convertInfo[OUTPUT] );
8592         bytes = stream_.nDeviceChannels[OUTPUT] * stream_.bufferSize *
8593                 formatBytes( stream_.deviceFormat[OUTPUT] );
8594     } else
8595         bytes = stream_.nUserChannels[OUTPUT] * stream_.bufferSize *
8596                 formatBytes( stream_.userFormat );
8597
8598     if ( pa_simple_write( pah->s_play, pulse_out, bytes, &pa_error ) < 0 ) {
8599       errorStream_ << "RtApiPulse::callbackEvent: audio write error, " <<
8600         pa_strerror( pa_error ) << ".";
8601       errorText_ = errorStream_.str();
8602       error( RtAudioError::WARNING );
8603     }
8604   }
8605
8606   if ( stream_.mode == INPUT || stream_.mode == DUPLEX) {
8607     if ( stream_.doConvertBuffer[INPUT] )
8608       bytes = stream_.nDeviceChannels[INPUT] * stream_.bufferSize *
8609         formatBytes( stream_.deviceFormat[INPUT] );
8610     else
8611       bytes = stream_.nUserChannels[INPUT] * stream_.bufferSize *
8612         formatBytes( stream_.userFormat );
8613
8614     if ( pa_simple_read( pah->s_rec, pulse_in, bytes, &pa_error ) < 0 ) {
8615       errorStream_ << "RtApiPulse::callbackEvent: audio read error, " <<
8616         pa_strerror( pa_error ) << ".";
8617       errorText_ = errorStream_.str();
8618       error( RtAudioError::WARNING );
8619     }
8620     if ( stream_.doConvertBuffer[INPUT] ) {
8621       convertBuffer( stream_.userBuffer[INPUT],
8622                      stream_.deviceBuffer,
8623                      stream_.convertInfo[INPUT] );
8624     }
8625   }
8626
8627  unlock:
8628   MUTEX_UNLOCK( &stream_.mutex );
8629   RtApi::tickStreamTime();
8630
8631   if ( doStopStream == 1 )
8632     stopStream();
8633 }
8634
8635 void RtApiPulse::startStream( void )
8636 {
8637   PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
8638
8639   if ( stream_.state == STREAM_CLOSED ) {
8640     errorText_ = "RtApiPulse::startStream(): the stream is not open!";
8641     error( RtAudioError::INVALID_USE );
8642     return;
8643   }
8644   if ( stream_.state == STREAM_RUNNING ) {
8645     errorText_ = "RtApiPulse::startStream(): the stream is already running!";
8646     error( RtAudioError::WARNING );
8647     return;
8648   }
8649
8650   MUTEX_LOCK( &stream_.mutex );
8651
8652   stream_.state = STREAM_RUNNING;
8653
8654   pah->runnable = true;
8655   pthread_cond_signal( &pah->runnable_cv );
8656   MUTEX_UNLOCK( &stream_.mutex );
8657 }
8658
8659 void RtApiPulse::stopStream( void )
8660 {
8661   PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
8662
8663   if ( stream_.state == STREAM_CLOSED ) {
8664     errorText_ = "RtApiPulse::stopStream(): the stream is not open!";
8665     error( RtAudioError::INVALID_USE );
8666     return;
8667   }
8668   if ( stream_.state == STREAM_STOPPED ) {
8669     errorText_ = "RtApiPulse::stopStream(): the stream is already stopped!";
8670     error( RtAudioError::WARNING );
8671     return;
8672   }
8673
8674   stream_.state = STREAM_STOPPED;
8675   MUTEX_LOCK( &stream_.mutex );
8676
8677   if ( pah && pah->s_play ) {
8678     int pa_error;
8679     if ( pa_simple_drain( pah->s_play, &pa_error ) < 0 ) {
8680       errorStream_ << "RtApiPulse::stopStream: error draining output device, " <<
8681         pa_strerror( pa_error ) << ".";
8682       errorText_ = errorStream_.str();
8683       MUTEX_UNLOCK( &stream_.mutex );
8684       error( RtAudioError::SYSTEM_ERROR );
8685       return;
8686     }
8687   }
8688
8689   stream_.state = STREAM_STOPPED;
8690   MUTEX_UNLOCK( &stream_.mutex );
8691 }
8692
8693 void RtApiPulse::abortStream( void )
8694 {
8695   PulseAudioHandle *pah = static_cast<PulseAudioHandle*>( stream_.apiHandle );
8696
8697   if ( stream_.state == STREAM_CLOSED ) {
8698     errorText_ = "RtApiPulse::abortStream(): the stream is not open!";
8699     error( RtAudioError::INVALID_USE );
8700     return;
8701   }
8702   if ( stream_.state == STREAM_STOPPED ) {
8703     errorText_ = "RtApiPulse::abortStream(): the stream is already stopped!";
8704     error( RtAudioError::WARNING );
8705     return;
8706   }
8707
8708   stream_.state = STREAM_STOPPED;
8709   MUTEX_LOCK( &stream_.mutex );
8710
8711   if ( pah && pah->s_play ) {
8712     int pa_error;
8713     if ( pa_simple_flush( pah->s_play, &pa_error ) < 0 ) {
8714       errorStream_ << "RtApiPulse::abortStream: error flushing output device, " <<
8715         pa_strerror( pa_error ) << ".";
8716       errorText_ = errorStream_.str();
8717       MUTEX_UNLOCK( &stream_.mutex );
8718       error( RtAudioError::SYSTEM_ERROR );
8719       return;
8720     }
8721   }
8722
8723   stream_.state = STREAM_STOPPED;
8724   MUTEX_UNLOCK( &stream_.mutex );
8725 }
8726
8727 bool RtApiPulse::probeDeviceOpen( unsigned int device, StreamMode mode,
8728                                   unsigned int channels, unsigned int firstChannel,
8729                                   unsigned int sampleRate, RtAudioFormat format,
8730                                   unsigned int *bufferSize, RtAudio::StreamOptions *options )
8731 {
8732   PulseAudioHandle *pah = 0;
8733   unsigned long bufferBytes = 0;
8734   pa_sample_spec ss;
8735
8736   if ( device != 0 ) return false;
8737   if ( mode != INPUT && mode != OUTPUT ) return false;
8738   if ( channels != 1 && channels != 2 ) {
8739     errorText_ = "RtApiPulse::probeDeviceOpen: unsupported number of channels.";
8740     return false;
8741   }
8742   ss.channels = channels;
8743
8744   if ( firstChannel != 0 ) return false;
8745
8746   bool sr_found = false;
8747   for ( const unsigned int *sr = SUPPORTED_SAMPLERATES; *sr; ++sr ) {
8748     if ( sampleRate == *sr ) {
8749       sr_found = true;
8750       stream_.sampleRate = sampleRate;
8751       ss.rate = sampleRate;
8752       break;
8753     }
8754   }
8755   if ( !sr_found ) {
8756     errorText_ = "RtApiPulse::probeDeviceOpen: unsupported sample rate.";
8757     return false;
8758   }
8759
8760   bool sf_found = 0;
8761   for ( const rtaudio_pa_format_mapping_t *sf = supported_sampleformats;
8762         sf->rtaudio_format && sf->pa_format != PA_SAMPLE_INVALID; ++sf ) {
8763     if ( format == sf->rtaudio_format ) {
8764       sf_found = true;
8765       stream_.userFormat = sf->rtaudio_format;
8766       stream_.deviceFormat[mode] = stream_.userFormat;
8767       ss.format = sf->pa_format;
8768       break;
8769     }
8770   }
8771   if ( !sf_found ) { // Use internal data format conversion.
8772     stream_.userFormat = format;
8773     stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
8774     ss.format = PA_SAMPLE_FLOAT32LE;
8775   }
8776
8777   // Set other stream parameters.
8778   if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
8779   else stream_.userInterleaved = true;
8780   stream_.deviceInterleaved[mode] = true;
8781   stream_.nBuffers = 1;
8782   stream_.doByteSwap[mode] = false;
8783   stream_.nUserChannels[mode] = channels;
8784   stream_.nDeviceChannels[mode] = channels + firstChannel;
8785   stream_.channelOffset[mode] = 0;
8786   std::string streamName = "RtAudio";
8787
8788   // Set flags for buffer conversion.
8789   stream_.doConvertBuffer[mode] = false;
8790   if ( stream_.userFormat != stream_.deviceFormat[mode] )
8791     stream_.doConvertBuffer[mode] = true;
8792   if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] )
8793     stream_.doConvertBuffer[mode] = true;
8794
8795   // Allocate necessary internal buffers.
8796   bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
8797   stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
8798   if ( stream_.userBuffer[mode] == NULL ) {
8799     errorText_ = "RtApiPulse::probeDeviceOpen: error allocating user buffer memory.";
8800     goto error;
8801   }
8802   stream_.bufferSize = *bufferSize;
8803
8804   if ( stream_.doConvertBuffer[mode] ) {
8805
8806     bool makeBuffer = true;
8807     bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
8808     if ( mode == INPUT ) {
8809       if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
8810         unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
8811         if ( bufferBytes <= bytesOut ) makeBuffer = false;
8812       }
8813     }
8814
8815     if ( makeBuffer ) {
8816       bufferBytes *= *bufferSize;
8817       if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
8818       stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
8819       if ( stream_.deviceBuffer == NULL ) {
8820         errorText_ = "RtApiPulse::probeDeviceOpen: error allocating device buffer memory.";
8821         goto error;
8822       }
8823     }
8824   }
8825
8826   stream_.device[mode] = device;
8827
8828   // Setup the buffer conversion information structure.
8829   if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel );
8830
8831   if ( !stream_.apiHandle ) {
8832     PulseAudioHandle *pah = new PulseAudioHandle;
8833     if ( !pah ) {
8834       errorText_ = "RtApiPulse::probeDeviceOpen: error allocating memory for handle.";
8835       goto error;
8836     }
8837
8838     stream_.apiHandle = pah;
8839     if ( pthread_cond_init( &pah->runnable_cv, NULL ) != 0 ) {
8840       errorText_ = "RtApiPulse::probeDeviceOpen: error creating condition variable.";
8841       goto error;
8842     }
8843   }
8844   pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
8845
8846   int error;
8847   if ( options && !options->streamName.empty() ) streamName = options->streamName;
8848   switch ( mode ) {
8849   case INPUT:
8850     pa_buffer_attr buffer_attr;
8851     buffer_attr.fragsize = bufferBytes;
8852     buffer_attr.maxlength = -1;
8853
8854     pah->s_rec = pa_simple_new( NULL, streamName.c_str(), PA_STREAM_RECORD, NULL, "Record", &ss, NULL, &buffer_attr, &error );
8855     if ( !pah->s_rec ) {
8856       errorText_ = "RtApiPulse::probeDeviceOpen: error connecting input to PulseAudio server.";
8857       goto error;
8858     }
8859     break;
8860   case OUTPUT:
8861     pah->s_play = pa_simple_new( NULL, streamName.c_str(), PA_STREAM_PLAYBACK, NULL, "Playback", &ss, NULL, NULL, &error );
8862     if ( !pah->s_play ) {
8863       errorText_ = "RtApiPulse::probeDeviceOpen: error connecting output to PulseAudio server.";
8864       goto error;
8865     }
8866     break;
8867   default:
8868     goto error;
8869   }
8870
8871   if ( stream_.mode == UNINITIALIZED )
8872     stream_.mode = mode;
8873   else if ( stream_.mode == mode )
8874     goto error;
8875   else
8876     stream_.mode = DUPLEX;
8877
8878   if ( !stream_.callbackInfo.isRunning ) {
8879     stream_.callbackInfo.object = this;
8880
8881     stream_.state = STREAM_STOPPED;
8882     // Set the thread attributes for joinable and realtime scheduling
8883     // priority (optional).  The higher priority will only take affect
8884     // if the program is run as root or suid. Note, under Linux
8885     // processes with CAP_SYS_NICE privilege, a user can change
8886     // scheduling policy and priority (thus need not be root). See
8887     // POSIX "capabilities".
8888     pthread_attr_t attr;
8889     pthread_attr_init( &attr );
8890     pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
8891 #ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
8892     if ( options && options->flags & RTAUDIO_SCHEDULE_REALTIME ) {
8893       stream_.callbackInfo.doRealtime = true;
8894       struct sched_param param;
8895       int priority = options->priority;
8896       int min = sched_get_priority_min( SCHED_RR );
8897       int max = sched_get_priority_max( SCHED_RR );
8898       if ( priority < min ) priority = min;
8899       else if ( priority > max ) priority = max;
8900       param.sched_priority = priority;
8901
8902       // Set the policy BEFORE the priority. Otherwise it fails.
8903       pthread_attr_setschedpolicy(&attr, SCHED_RR);
8904       pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
8905       // This is definitely required. Otherwise it fails.
8906       pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
8907       pthread_attr_setschedparam(&attr, &param);
8908     }
8909     else
8910       pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
8911 #else
8912     pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
8913 #endif
8914
8915     stream_.callbackInfo.isRunning = true;
8916     int result = pthread_create( &pah->thread, &attr, pulseaudio_callback, (void *)&stream_.callbackInfo);
8917     pthread_attr_destroy(&attr);
8918     if(result != 0) {
8919       // Failed. Try instead with default attributes.
8920       result = pthread_create( &pah->thread, NULL, pulseaudio_callback, (void *)&stream_.callbackInfo);
8921       if(result != 0) {
8922         stream_.callbackInfo.isRunning = false;
8923         errorText_ = "RtApiPulse::probeDeviceOpen: error creating thread.";
8924         goto error;
8925       }
8926     }
8927   }
8928
8929   return SUCCESS;
8930
8931  error:
8932   if ( pah && stream_.callbackInfo.isRunning ) {
8933     pthread_cond_destroy( &pah->runnable_cv );
8934     delete pah;
8935     stream_.apiHandle = 0;
8936   }
8937
8938   for ( int i=0; i<2; i++ ) {
8939     if ( stream_.userBuffer[i] ) {
8940       free( stream_.userBuffer[i] );
8941       stream_.userBuffer[i] = 0;
8942     }
8943   }
8944
8945   if ( stream_.deviceBuffer ) {
8946     free( stream_.deviceBuffer );
8947     stream_.deviceBuffer = 0;
8948   }
8949
8950   stream_.state = STREAM_CLOSED;
8951   return FAILURE;
8952 }
8953
8954 //******************** End of __LINUX_PULSE__ *********************//
8955 #endif
8956
8957 #if defined(__LINUX_OSS__)
8958
8959 #include <unistd.h>
8960 #include <sys/ioctl.h>
8961 #include <unistd.h>
8962 #include <fcntl.h>
8963 #include <sys/soundcard.h>
8964 #include <errno.h>
8965 #include <math.h>
8966
8967 static void *ossCallbackHandler(void * ptr);
8968
8969 // A structure to hold various information related to the OSS API
8970 // implementation.
8971 struct OssHandle {
8972   int id[2];    // device ids
8973   bool xrun[2];
8974   bool triggered;
8975   pthread_cond_t runnable;
8976
8977   OssHandle()
8978     :triggered(false) { id[0] = 0; id[1] = 0; xrun[0] = false; xrun[1] = false; }
8979 };
8980
8981 RtApiOss :: RtApiOss()
8982 {
8983   // Nothing to do here.
8984 }
8985
8986 RtApiOss :: ~RtApiOss()
8987 {
8988   if ( stream_.state != STREAM_CLOSED ) closeStream();
8989 }
8990
8991 unsigned int RtApiOss :: getDeviceCount( void )
8992 {
8993   int mixerfd = open( "/dev/mixer", O_RDWR, 0 );
8994   if ( mixerfd == -1 ) {
8995     errorText_ = "RtApiOss::getDeviceCount: error opening '/dev/mixer'.";
8996     error( RtAudioError::WARNING );
8997     return 0;
8998   }
8999
9000   oss_sysinfo sysinfo;
9001   if ( ioctl( mixerfd, SNDCTL_SYSINFO, &sysinfo ) == -1 ) {
9002     close( mixerfd );
9003     errorText_ = "RtApiOss::getDeviceCount: error getting sysinfo, OSS version >= 4.0 is required.";
9004     error( RtAudioError::WARNING );
9005     return 0;
9006   }
9007
9008   close( mixerfd );
9009   return sysinfo.numaudios;
9010 }
9011
9012 RtAudio::DeviceInfo RtApiOss :: getDeviceInfo( unsigned int device )
9013 {
9014   RtAudio::DeviceInfo info;
9015   info.probed = false;
9016
9017   int mixerfd = open( "/dev/mixer", O_RDWR, 0 );
9018   if ( mixerfd == -1 ) {
9019     errorText_ = "RtApiOss::getDeviceInfo: error opening '/dev/mixer'.";
9020     error( RtAudioError::WARNING );
9021     return info;
9022   }
9023
9024   oss_sysinfo sysinfo;
9025   int result = ioctl( mixerfd, SNDCTL_SYSINFO, &sysinfo );
9026   if ( result == -1 ) {
9027     close( mixerfd );
9028     errorText_ = "RtApiOss::getDeviceInfo: error getting sysinfo, OSS version >= 4.0 is required.";
9029     error( RtAudioError::WARNING );
9030     return info;
9031   }
9032
9033   unsigned nDevices = sysinfo.numaudios;
9034   if ( nDevices == 0 ) {
9035     close( mixerfd );
9036     errorText_ = "RtApiOss::getDeviceInfo: no devices found!";
9037     error( RtAudioError::INVALID_USE );
9038     return info;
9039   }
9040
9041   if ( device >= nDevices ) {
9042     close( mixerfd );
9043     errorText_ = "RtApiOss::getDeviceInfo: device ID is invalid!";
9044     error( RtAudioError::INVALID_USE );
9045     return info;
9046   }
9047
9048   oss_audioinfo ainfo;
9049   ainfo.dev = device;
9050   result = ioctl( mixerfd, SNDCTL_AUDIOINFO, &ainfo );
9051   close( mixerfd );
9052   if ( result == -1 ) {
9053     errorStream_ << "RtApiOss::getDeviceInfo: error getting device (" << ainfo.name << ") info.";
9054     errorText_ = errorStream_.str();
9055     error( RtAudioError::WARNING );
9056     return info;
9057   }
9058
9059   // Probe channels
9060   if ( ainfo.caps & PCM_CAP_OUTPUT ) info.outputChannels = ainfo.max_channels;
9061   if ( ainfo.caps & PCM_CAP_INPUT ) info.inputChannels = ainfo.max_channels;
9062   if ( ainfo.caps & PCM_CAP_DUPLEX ) {
9063     if ( info.outputChannels > 0 && info.inputChannels > 0 && ainfo.caps & PCM_CAP_DUPLEX )
9064       info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
9065   }
9066
9067   // Probe data formats ... do for input
9068   unsigned long mask = ainfo.iformats;
9069   if ( mask & AFMT_S16_LE || mask & AFMT_S16_BE )
9070     info.nativeFormats |= RTAUDIO_SINT16;
9071   if ( mask & AFMT_S8 )
9072     info.nativeFormats |= RTAUDIO_SINT8;
9073   if ( mask & AFMT_S32_LE || mask & AFMT_S32_BE )
9074     info.nativeFormats |= RTAUDIO_SINT32;
9075 #ifdef AFMT_FLOAT
9076   if ( mask & AFMT_FLOAT )
9077     info.nativeFormats |= RTAUDIO_FLOAT32;
9078 #endif
9079   if ( mask & AFMT_S24_LE || mask & AFMT_S24_BE )
9080     info.nativeFormats |= RTAUDIO_SINT24;
9081
9082   // Check that we have at least one supported format
9083   if ( info.nativeFormats == 0 ) {
9084     errorStream_ << "RtApiOss::getDeviceInfo: device (" << ainfo.name << ") data format not supported by RtAudio.";
9085     errorText_ = errorStream_.str();
9086     error( RtAudioError::WARNING );
9087     return info;
9088   }
9089
9090   // Probe the supported sample rates.
9091   info.sampleRates.clear();
9092   if ( ainfo.nrates ) {
9093     for ( unsigned int i=0; i<ainfo.nrates; i++ ) {
9094       for ( unsigned int k=0; k<MAX_SAMPLE_RATES; k++ ) {
9095         if ( ainfo.rates[i] == SAMPLE_RATES[k] ) {
9096           info.sampleRates.push_back( SAMPLE_RATES[k] );
9097
9098           if ( !info.preferredSampleRate || ( SAMPLE_RATES[k] <= 48000 && SAMPLE_RATES[k] > info.preferredSampleRate ) )
9099             info.preferredSampleRate = SAMPLE_RATES[k];
9100
9101           break;
9102         }
9103       }
9104     }
9105   }
9106   else {
9107     // Check min and max rate values;
9108     for ( unsigned int k=0; k<MAX_SAMPLE_RATES; k++ ) {
9109       if ( ainfo.min_rate <= (int) SAMPLE_RATES[k] && ainfo.max_rate >= (int) SAMPLE_RATES[k] ) {
9110         info.sampleRates.push_back( SAMPLE_RATES[k] );
9111
9112         if ( !info.preferredSampleRate || ( SAMPLE_RATES[k] <= 48000 && SAMPLE_RATES[k] > info.preferredSampleRate ) )
9113           info.preferredSampleRate = SAMPLE_RATES[k];
9114       }
9115     }
9116   }
9117
9118   if ( info.sampleRates.size() == 0 ) {
9119     errorStream_ << "RtApiOss::getDeviceInfo: no supported sample rates found for device (" << ainfo.name << ").";
9120     errorText_ = errorStream_.str();
9121     error( RtAudioError::WARNING );
9122   }
9123   else {
9124     info.probed = true;
9125     info.name = ainfo.name;
9126   }
9127
9128   return info;
9129 }
9130
9131
9132 bool RtApiOss :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
9133                                   unsigned int firstChannel, unsigned int sampleRate,
9134                                   RtAudioFormat format, unsigned int *bufferSize,
9135                                   RtAudio::StreamOptions *options )
9136 {
9137   int mixerfd = open( "/dev/mixer", O_RDWR, 0 );
9138   if ( mixerfd == -1 ) {
9139     errorText_ = "RtApiOss::probeDeviceOpen: error opening '/dev/mixer'.";
9140     return FAILURE;
9141   }
9142
9143   oss_sysinfo sysinfo;
9144   int result = ioctl( mixerfd, SNDCTL_SYSINFO, &sysinfo );
9145   if ( result == -1 ) {
9146     close( mixerfd );
9147     errorText_ = "RtApiOss::probeDeviceOpen: error getting sysinfo, OSS version >= 4.0 is required.";
9148     return FAILURE;
9149   }
9150
9151   unsigned nDevices = sysinfo.numaudios;
9152   if ( nDevices == 0 ) {
9153     // This should not happen because a check is made before this function is called.
9154     close( mixerfd );
9155     errorText_ = "RtApiOss::probeDeviceOpen: no devices found!";
9156     return FAILURE;
9157   }
9158
9159   if ( device >= nDevices ) {
9160     // This should not happen because a check is made before this function is called.
9161     close( mixerfd );
9162     errorText_ = "RtApiOss::probeDeviceOpen: device ID is invalid!";
9163     return FAILURE;
9164   }
9165
9166   oss_audioinfo ainfo;
9167   ainfo.dev = device;
9168   result = ioctl( mixerfd, SNDCTL_AUDIOINFO, &ainfo );
9169   close( mixerfd );
9170   if ( result == -1 ) {
9171     errorStream_ << "RtApiOss::getDeviceInfo: error getting device (" << ainfo.name << ") info.";
9172     errorText_ = errorStream_.str();
9173     return FAILURE;
9174   }
9175
9176   // Check if device supports input or output
9177   if ( ( mode == OUTPUT && !( ainfo.caps & PCM_CAP_OUTPUT ) ) ||
9178        ( mode == INPUT && !( ainfo.caps & PCM_CAP_INPUT ) ) ) {
9179     if ( mode == OUTPUT )
9180       errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support output.";
9181     else
9182       errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support input.";
9183     errorText_ = errorStream_.str();
9184     return FAILURE;
9185   }
9186
9187   int flags = 0;
9188   OssHandle *handle = (OssHandle *) stream_.apiHandle;
9189   if ( mode == OUTPUT )
9190     flags |= O_WRONLY;
9191   else { // mode == INPUT
9192     if (stream_.mode == OUTPUT && stream_.device[0] == device) {
9193       // We just set the same device for playback ... close and reopen for duplex (OSS only).
9194       close( handle->id[0] );
9195       handle->id[0] = 0;
9196       if ( !( ainfo.caps & PCM_CAP_DUPLEX ) ) {
9197         errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support duplex mode.";
9198         errorText_ = errorStream_.str();
9199         return FAILURE;
9200       }
9201       // Check that the number previously set channels is the same.
9202       if ( stream_.nUserChannels[0] != channels ) {
9203         errorStream_ << "RtApiOss::probeDeviceOpen: input/output channels must be equal for OSS duplex device (" << ainfo.name << ").";
9204         errorText_ = errorStream_.str();
9205         return FAILURE;
9206       }
9207       flags |= O_RDWR;
9208     }
9209     else
9210       flags |= O_RDONLY;
9211   }
9212
9213   // Set exclusive access if specified.
9214   if ( options && options->flags & RTAUDIO_HOG_DEVICE ) flags |= O_EXCL;
9215
9216   // Try to open the device.
9217   int fd;
9218   fd = open( ainfo.devnode, flags, 0 );
9219   if ( fd == -1 ) {
9220     if ( errno == EBUSY )
9221       errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") is busy.";
9222     else
9223       errorStream_ << "RtApiOss::probeDeviceOpen: error opening device (" << ainfo.name << ").";
9224     errorText_ = errorStream_.str();
9225     return FAILURE;
9226   }
9227
9228   // For duplex operation, specifically set this mode (this doesn't seem to work).
9229   /*
9230     if ( flags | O_RDWR ) {
9231     result = ioctl( fd, SNDCTL_DSP_SETDUPLEX, NULL );
9232     if ( result == -1) {
9233     errorStream_ << "RtApiOss::probeDeviceOpen: error setting duplex mode for device (" << ainfo.name << ").";
9234     errorText_ = errorStream_.str();
9235     return FAILURE;
9236     }
9237     }
9238   */
9239
9240   // Check the device channel support.
9241   stream_.nUserChannels[mode] = channels;
9242   if ( ainfo.max_channels < (int)(channels + firstChannel) ) {
9243     close( fd );
9244     errorStream_ << "RtApiOss::probeDeviceOpen: the device (" << ainfo.name << ") does not support requested channel parameters.";
9245     errorText_ = errorStream_.str();
9246     return FAILURE;
9247   }
9248
9249   // Set the number of channels.
9250   int deviceChannels = channels + firstChannel;
9251   result = ioctl( fd, SNDCTL_DSP_CHANNELS, &deviceChannels );
9252   if ( result == -1 || deviceChannels < (int)(channels + firstChannel) ) {
9253     close( fd );
9254     errorStream_ << "RtApiOss::probeDeviceOpen: error setting channel parameters on device (" << ainfo.name << ").";
9255     errorText_ = errorStream_.str();
9256     return FAILURE;
9257   }
9258   stream_.nDeviceChannels[mode] = deviceChannels;
9259
9260   // Get the data format mask
9261   int mask;
9262   result = ioctl( fd, SNDCTL_DSP_GETFMTS, &mask );
9263   if ( result == -1 ) {
9264     close( fd );
9265     errorStream_ << "RtApiOss::probeDeviceOpen: error getting device (" << ainfo.name << ") data formats.";
9266     errorText_ = errorStream_.str();
9267     return FAILURE;
9268   }
9269
9270   // Determine how to set the device format.
9271   stream_.userFormat = format;
9272   int deviceFormat = -1;
9273   stream_.doByteSwap[mode] = false;
9274   if ( format == RTAUDIO_SINT8 ) {
9275     if ( mask & AFMT_S8 ) {
9276       deviceFormat = AFMT_S8;
9277       stream_.deviceFormat[mode] = RTAUDIO_SINT8;
9278     }
9279   }
9280   else if ( format == RTAUDIO_SINT16 ) {
9281     if ( mask & AFMT_S16_NE ) {
9282       deviceFormat = AFMT_S16_NE;
9283       stream_.deviceFormat[mode] = RTAUDIO_SINT16;
9284     }
9285     else if ( mask & AFMT_S16_OE ) {
9286       deviceFormat = AFMT_S16_OE;
9287       stream_.deviceFormat[mode] = RTAUDIO_SINT16;
9288       stream_.doByteSwap[mode] = true;
9289     }
9290   }
9291   else if ( format == RTAUDIO_SINT24 ) {
9292     if ( mask & AFMT_S24_NE ) {
9293       deviceFormat = AFMT_S24_NE;
9294       stream_.deviceFormat[mode] = RTAUDIO_SINT24;
9295     }
9296     else if ( mask & AFMT_S24_OE ) {
9297       deviceFormat = AFMT_S24_OE;
9298       stream_.deviceFormat[mode] = RTAUDIO_SINT24;
9299       stream_.doByteSwap[mode] = true;
9300     }
9301   }
9302   else if ( format == RTAUDIO_SINT32 ) {
9303     if ( mask & AFMT_S32_NE ) {
9304       deviceFormat = AFMT_S32_NE;
9305       stream_.deviceFormat[mode] = RTAUDIO_SINT32;
9306     }
9307     else if ( mask & AFMT_S32_OE ) {
9308       deviceFormat = AFMT_S32_OE;
9309       stream_.deviceFormat[mode] = RTAUDIO_SINT32;
9310       stream_.doByteSwap[mode] = true;
9311     }
9312   }
9313
9314   if ( deviceFormat == -1 ) {
9315     // The user requested format is not natively supported by the device.
9316     if ( mask & AFMT_S16_NE ) {
9317       deviceFormat = AFMT_S16_NE;
9318       stream_.deviceFormat[mode] = RTAUDIO_SINT16;
9319     }
9320     else if ( mask & AFMT_S32_NE ) {
9321       deviceFormat = AFMT_S32_NE;
9322       stream_.deviceFormat[mode] = RTAUDIO_SINT32;
9323     }
9324     else if ( mask & AFMT_S24_NE ) {
9325       deviceFormat = AFMT_S24_NE;
9326       stream_.deviceFormat[mode] = RTAUDIO_SINT24;
9327     }
9328     else if ( mask & AFMT_S16_OE ) {
9329       deviceFormat = AFMT_S16_OE;
9330       stream_.deviceFormat[mode] = RTAUDIO_SINT16;
9331       stream_.doByteSwap[mode] = true;
9332     }
9333     else if ( mask & AFMT_S32_OE ) {
9334       deviceFormat = AFMT_S32_OE;
9335       stream_.deviceFormat[mode] = RTAUDIO_SINT32;
9336       stream_.doByteSwap[mode] = true;
9337     }
9338     else if ( mask & AFMT_S24_OE ) {
9339       deviceFormat = AFMT_S24_OE;
9340       stream_.deviceFormat[mode] = RTAUDIO_SINT24;
9341       stream_.doByteSwap[mode] = true;
9342     }
9343     else if ( mask & AFMT_S8) {
9344       deviceFormat = AFMT_S8;
9345       stream_.deviceFormat[mode] = RTAUDIO_SINT8;
9346     }
9347   }
9348
9349   if ( stream_.deviceFormat[mode] == 0 ) {
9350     // This really shouldn't happen ...
9351     close( fd );
9352     errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") data format not supported by RtAudio.";
9353     errorText_ = errorStream_.str();
9354     return FAILURE;
9355   }
9356
9357   // Set the data format.
9358   int temp = deviceFormat;
9359   result = ioctl( fd, SNDCTL_DSP_SETFMT, &deviceFormat );
9360   if ( result == -1 || deviceFormat != temp ) {
9361     close( fd );
9362     errorStream_ << "RtApiOss::probeDeviceOpen: error setting data format on device (" << ainfo.name << ").";
9363     errorText_ = errorStream_.str();
9364     return FAILURE;
9365   }
9366
9367   // Attempt to set the buffer size.  According to OSS, the minimum
9368   // number of buffers is two.  The supposed minimum buffer size is 16
9369   // bytes, so that will be our lower bound.  The argument to this
9370   // call is in the form 0xMMMMSSSS (hex), where the buffer size (in
9371   // bytes) is given as 2^SSSS and the number of buffers as 2^MMMM.
9372   // We'll check the actual value used near the end of the setup
9373   // procedure.
9374   int ossBufferBytes = *bufferSize * formatBytes( stream_.deviceFormat[mode] ) * deviceChannels;
9375   if ( ossBufferBytes < 16 ) ossBufferBytes = 16;
9376   int buffers = 0;
9377   if ( options ) buffers = options->numberOfBuffers;
9378   if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) buffers = 2;
9379   if ( buffers < 2 ) buffers = 3;
9380   temp = ((int) buffers << 16) + (int)( log10( (double)ossBufferBytes ) / log10( 2.0 ) );
9381   result = ioctl( fd, SNDCTL_DSP_SETFRAGMENT, &temp );
9382   if ( result == -1 ) {
9383     close( fd );
9384     errorStream_ << "RtApiOss::probeDeviceOpen: error setting buffer size on device (" << ainfo.name << ").";
9385     errorText_ = errorStream_.str();
9386     return FAILURE;
9387   }
9388   stream_.nBuffers = buffers;
9389
9390   // Save buffer size (in sample frames).
9391   *bufferSize = ossBufferBytes / ( formatBytes(stream_.deviceFormat[mode]) * deviceChannels );
9392   stream_.bufferSize = *bufferSize;
9393
9394   // Set the sample rate.
9395   int srate = sampleRate;
9396   result = ioctl( fd, SNDCTL_DSP_SPEED, &srate );
9397   if ( result == -1 ) {
9398     close( fd );
9399     errorStream_ << "RtApiOss::probeDeviceOpen: error setting sample rate (" << sampleRate << ") on device (" << ainfo.name << ").";
9400     errorText_ = errorStream_.str();
9401     return FAILURE;
9402   }
9403
9404   // Verify the sample rate setup worked.
9405   if ( abs( srate - (int)sampleRate ) > 100 ) {
9406     close( fd );
9407     errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support sample rate (" << sampleRate << ").";
9408     errorText_ = errorStream_.str();
9409     return FAILURE;
9410   }
9411   stream_.sampleRate = sampleRate;
9412
9413   if ( mode == INPUT && stream_.mode == OUTPUT && stream_.device[0] == device) {
9414     // We're doing duplex setup here.
9415     stream_.deviceFormat[0] = stream_.deviceFormat[1];
9416     stream_.nDeviceChannels[0] = deviceChannels;
9417   }
9418
9419   // Set interleaving parameters.
9420   stream_.userInterleaved = true;
9421   stream_.deviceInterleaved[mode] =  true;
9422   if ( options && options->flags & RTAUDIO_NONINTERLEAVED )
9423     stream_.userInterleaved = false;
9424
9425   // Set flags for buffer conversion
9426   stream_.doConvertBuffer[mode] = false;
9427   if ( stream_.userFormat != stream_.deviceFormat[mode] )
9428     stream_.doConvertBuffer[mode] = true;
9429   if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] )
9430     stream_.doConvertBuffer[mode] = true;
9431   if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
9432        stream_.nUserChannels[mode] > 1 )
9433     stream_.doConvertBuffer[mode] = true;
9434
9435   // Allocate the stream handles if necessary and then save.
9436   if ( stream_.apiHandle == 0 ) {
9437     try {
9438       handle = new OssHandle;
9439     }
9440     catch ( std::bad_alloc& ) {
9441       errorText_ = "RtApiOss::probeDeviceOpen: error allocating OssHandle memory.";
9442       goto error;
9443     }
9444
9445     if ( pthread_cond_init( &handle->runnable, NULL ) ) {
9446       errorText_ = "RtApiOss::probeDeviceOpen: error initializing pthread condition variable.";
9447       goto error;
9448     }
9449
9450     stream_.apiHandle = (void *) handle;
9451   }
9452   else {
9453     handle = (OssHandle *) stream_.apiHandle;
9454   }
9455   handle->id[mode] = fd;
9456
9457   // Allocate necessary internal buffers.
9458   unsigned long bufferBytes;
9459   bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
9460   stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
9461   if ( stream_.userBuffer[mode] == NULL ) {
9462     errorText_ = "RtApiOss::probeDeviceOpen: error allocating user buffer memory.";
9463     goto error;
9464   }
9465
9466   if ( stream_.doConvertBuffer[mode] ) {
9467
9468     bool makeBuffer = true;
9469     bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
9470     if ( mode == INPUT ) {
9471       if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
9472         unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
9473         if ( bufferBytes <= bytesOut ) makeBuffer = false;
9474       }
9475     }
9476
9477     if ( makeBuffer ) {
9478       bufferBytes *= *bufferSize;
9479       if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
9480       stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
9481       if ( stream_.deviceBuffer == NULL ) {
9482         errorText_ = "RtApiOss::probeDeviceOpen: error allocating device buffer memory.";
9483         goto error;
9484       }
9485     }
9486   }
9487
9488   stream_.device[mode] = device;
9489   stream_.state = STREAM_STOPPED;
9490
9491   // Setup the buffer conversion information structure.
9492   if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel );
9493
9494   // Setup thread if necessary.
9495   if ( stream_.mode == OUTPUT && mode == INPUT ) {
9496     // We had already set up an output stream.
9497     stream_.mode = DUPLEX;
9498     if ( stream_.device[0] == device ) handle->id[0] = fd;
9499   }
9500   else {
9501     stream_.mode = mode;
9502
9503     // Setup callback thread.
9504     stream_.callbackInfo.object = (void *) this;
9505
9506     // Set the thread attributes for joinable and realtime scheduling
9507     // priority.  The higher priority will only take affect if the
9508     // program is run as root or suid.
9509     pthread_attr_t attr;
9510     pthread_attr_init( &attr );
9511     pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
9512 #ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
9513     if ( options && options->flags & RTAUDIO_SCHEDULE_REALTIME ) {
9514       stream_.callbackInfo.doRealtime = true;
9515       struct sched_param param;
9516       int priority = options->priority;
9517       int min = sched_get_priority_min( SCHED_RR );
9518       int max = sched_get_priority_max( SCHED_RR );
9519       if ( priority < min ) priority = min;
9520       else if ( priority > max ) priority = max;
9521       param.sched_priority = priority;
9522
9523       // Set the policy BEFORE the priority. Otherwise it fails.
9524       pthread_attr_setschedpolicy(&attr, SCHED_RR);
9525       pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
9526       // This is definitely required. Otherwise it fails.
9527       pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
9528       pthread_attr_setschedparam(&attr, &param);
9529     }
9530     else
9531       pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
9532 #else
9533     pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
9534 #endif
9535
9536     stream_.callbackInfo.isRunning = true;
9537     result = pthread_create( &stream_.callbackInfo.thread, &attr, ossCallbackHandler, &stream_.callbackInfo );
9538     pthread_attr_destroy( &attr );
9539     if ( result ) {
9540       // Failed. Try instead with default attributes.
9541       result = pthread_create( &stream_.callbackInfo.thread, NULL, ossCallbackHandler, &stream_.callbackInfo );
9542       if ( result ) {
9543         stream_.callbackInfo.isRunning = false;
9544         errorText_ = "RtApiOss::error creating callback thread!";
9545         goto error;
9546       }
9547     }
9548   }
9549
9550   return SUCCESS;
9551
9552  error:
9553   if ( handle ) {
9554     pthread_cond_destroy( &handle->runnable );
9555     if ( handle->id[0] ) close( handle->id[0] );
9556     if ( handle->id[1] ) close( handle->id[1] );
9557     delete handle;
9558     stream_.apiHandle = 0;
9559   }
9560
9561   for ( int i=0; i<2; i++ ) {
9562     if ( stream_.userBuffer[i] ) {
9563       free( stream_.userBuffer[i] );
9564       stream_.userBuffer[i] = 0;
9565     }
9566   }
9567
9568   if ( stream_.deviceBuffer ) {
9569     free( stream_.deviceBuffer );
9570     stream_.deviceBuffer = 0;
9571   }
9572
9573   stream_.state = STREAM_CLOSED;
9574   return FAILURE;
9575 }
9576
9577 void RtApiOss :: closeStream()
9578 {
9579   if ( stream_.state == STREAM_CLOSED ) {
9580     errorText_ = "RtApiOss::closeStream(): no open stream to close!";
9581     error( RtAudioError::WARNING );
9582     return;
9583   }
9584
9585   OssHandle *handle = (OssHandle *) stream_.apiHandle;
9586   stream_.callbackInfo.isRunning = false;
9587   MUTEX_LOCK( &stream_.mutex );
9588   if ( stream_.state == STREAM_STOPPED )
9589     pthread_cond_signal( &handle->runnable );
9590   MUTEX_UNLOCK( &stream_.mutex );
9591   pthread_join( stream_.callbackInfo.thread, NULL );
9592
9593   if ( stream_.state == STREAM_RUNNING ) {
9594     if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX )
9595       ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 );
9596     else
9597       ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 );
9598     stream_.state = STREAM_STOPPED;
9599   }
9600
9601   if ( handle ) {
9602     pthread_cond_destroy( &handle->runnable );
9603     if ( handle->id[0] ) close( handle->id[0] );
9604     if ( handle->id[1] ) close( handle->id[1] );
9605     delete handle;
9606     stream_.apiHandle = 0;
9607   }
9608
9609   for ( int i=0; i<2; i++ ) {
9610     if ( stream_.userBuffer[i] ) {
9611       free( stream_.userBuffer[i] );
9612       stream_.userBuffer[i] = 0;
9613     }
9614   }
9615
9616   if ( stream_.deviceBuffer ) {
9617     free( stream_.deviceBuffer );
9618     stream_.deviceBuffer = 0;
9619   }
9620
9621   stream_.mode = UNINITIALIZED;
9622   stream_.state = STREAM_CLOSED;
9623 }
9624
9625 void RtApiOss :: startStream()
9626 {
9627   verifyStream();
9628   if ( stream_.state == STREAM_RUNNING ) {
9629     errorText_ = "RtApiOss::startStream(): the stream is already running!";
9630     error( RtAudioError::WARNING );
9631     return;
9632   }
9633
9634   MUTEX_LOCK( &stream_.mutex );
9635
9636   stream_.state = STREAM_RUNNING;
9637
9638   // No need to do anything else here ... OSS automatically starts
9639   // when fed samples.
9640
9641   MUTEX_UNLOCK( &stream_.mutex );
9642
9643   OssHandle *handle = (OssHandle *) stream_.apiHandle;
9644   pthread_cond_signal( &handle->runnable );
9645 }
9646
9647 void RtApiOss :: stopStream()
9648 {
9649   verifyStream();
9650   if ( stream_.state == STREAM_STOPPED ) {
9651     errorText_ = "RtApiOss::stopStream(): the stream is already stopped!";
9652     error( RtAudioError::WARNING );
9653     return;
9654   }
9655
9656   MUTEX_LOCK( &stream_.mutex );
9657
9658   // The state might change while waiting on a mutex.
9659   if ( stream_.state == STREAM_STOPPED ) {
9660     MUTEX_UNLOCK( &stream_.mutex );
9661     return;
9662   }
9663
9664   int result = 0;
9665   OssHandle *handle = (OssHandle *) stream_.apiHandle;
9666   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
9667
9668     // Flush the output with zeros a few times.
9669     char *buffer;
9670     int samples;
9671     RtAudioFormat format;
9672
9673     if ( stream_.doConvertBuffer[0] ) {
9674       buffer = stream_.deviceBuffer;
9675       samples = stream_.bufferSize * stream_.nDeviceChannels[0];
9676       format = stream_.deviceFormat[0];
9677     }
9678     else {
9679       buffer = stream_.userBuffer[0];
9680       samples = stream_.bufferSize * stream_.nUserChannels[0];
9681       format = stream_.userFormat;
9682     }
9683
9684     memset( buffer, 0, samples * formatBytes(format) );
9685     for ( unsigned int i=0; i<stream_.nBuffers+1; i++ ) {
9686       result = write( handle->id[0], buffer, samples * formatBytes(format) );
9687       if ( result == -1 ) {
9688         errorText_ = "RtApiOss::stopStream: audio write error.";
9689         error( RtAudioError::WARNING );
9690       }
9691     }
9692
9693     result = ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 );
9694     if ( result == -1 ) {
9695       errorStream_ << "RtApiOss::stopStream: system error stopping callback procedure on device (" << stream_.device[0] << ").";
9696       errorText_ = errorStream_.str();
9697       goto unlock;
9698     }
9699     handle->triggered = false;
9700   }
9701
9702   if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && handle->id[0] != handle->id[1] ) ) {
9703     result = ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 );
9704     if ( result == -1 ) {
9705       errorStream_ << "RtApiOss::stopStream: system error stopping input callback procedure on device (" << stream_.device[0] << ").";
9706       errorText_ = errorStream_.str();
9707       goto unlock;
9708     }
9709   }
9710
9711  unlock:
9712   stream_.state = STREAM_STOPPED;
9713   MUTEX_UNLOCK( &stream_.mutex );
9714
9715   if ( result != -1 ) return;
9716   error( RtAudioError::SYSTEM_ERROR );
9717 }
9718
9719 void RtApiOss :: abortStream()
9720 {
9721   verifyStream();
9722   if ( stream_.state == STREAM_STOPPED ) {
9723     errorText_ = "RtApiOss::abortStream(): the stream is already stopped!";
9724     error( RtAudioError::WARNING );
9725     return;
9726   }
9727
9728   MUTEX_LOCK( &stream_.mutex );
9729
9730   // The state might change while waiting on a mutex.
9731   if ( stream_.state == STREAM_STOPPED ) {
9732     MUTEX_UNLOCK( &stream_.mutex );
9733     return;
9734   }
9735
9736   int result = 0;
9737   OssHandle *handle = (OssHandle *) stream_.apiHandle;
9738   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
9739     result = ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 );
9740     if ( result == -1 ) {
9741       errorStream_ << "RtApiOss::abortStream: system error stopping callback procedure on device (" << stream_.device[0] << ").";
9742       errorText_ = errorStream_.str();
9743       goto unlock;
9744     }
9745     handle->triggered = false;
9746   }
9747
9748   if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && handle->id[0] != handle->id[1] ) ) {
9749     result = ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 );
9750     if ( result == -1 ) {
9751       errorStream_ << "RtApiOss::abortStream: system error stopping input callback procedure on device (" << stream_.device[0] << ").";
9752       errorText_ = errorStream_.str();
9753       goto unlock;
9754     }
9755   }
9756
9757  unlock:
9758   stream_.state = STREAM_STOPPED;
9759   MUTEX_UNLOCK( &stream_.mutex );
9760
9761   if ( result != -1 ) return;
9762   error( RtAudioError::SYSTEM_ERROR );
9763 }
9764
9765 void RtApiOss :: callbackEvent()
9766 {
9767   OssHandle *handle = (OssHandle *) stream_.apiHandle;
9768   if ( stream_.state == STREAM_STOPPED ) {
9769     MUTEX_LOCK( &stream_.mutex );
9770     pthread_cond_wait( &handle->runnable, &stream_.mutex );
9771     if ( stream_.state != STREAM_RUNNING ) {
9772       MUTEX_UNLOCK( &stream_.mutex );
9773       return;
9774     }
9775     MUTEX_UNLOCK( &stream_.mutex );
9776   }
9777
9778   if ( stream_.state == STREAM_CLOSED ) {
9779     errorText_ = "RtApiOss::callbackEvent(): the stream is closed ... this shouldn't happen!";
9780     error( RtAudioError::WARNING );
9781     return;
9782   }
9783
9784   // Invoke user callback to get fresh output data.
9785   int doStopStream = 0;
9786   RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback;
9787   double streamTime = getStreamTime();
9788   RtAudioStreamStatus status = 0;
9789   if ( stream_.mode != INPUT && handle->xrun[0] == true ) {
9790     status |= RTAUDIO_OUTPUT_UNDERFLOW;
9791     handle->xrun[0] = false;
9792   }
9793   if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) {
9794     status |= RTAUDIO_INPUT_OVERFLOW;
9795     handle->xrun[1] = false;
9796   }
9797   doStopStream = callback( stream_.userBuffer[0], stream_.userBuffer[1],
9798                            stream_.bufferSize, streamTime, status, stream_.callbackInfo.userData );
9799   if ( doStopStream == 2 ) {
9800     this->abortStream();
9801     return;
9802   }
9803
9804   MUTEX_LOCK( &stream_.mutex );
9805
9806   // The state might change while waiting on a mutex.
9807   if ( stream_.state == STREAM_STOPPED ) goto unlock;
9808
9809   int result;
9810   char *buffer;
9811   int samples;
9812   RtAudioFormat format;
9813
9814   if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
9815
9816     // Setup parameters and do buffer conversion if necessary.
9817     if ( stream_.doConvertBuffer[0] ) {
9818       buffer = stream_.deviceBuffer;
9819       convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] );
9820       samples = stream_.bufferSize * stream_.nDeviceChannels[0];
9821       format = stream_.deviceFormat[0];
9822     }
9823     else {
9824       buffer = stream_.userBuffer[0];
9825       samples = stream_.bufferSize * stream_.nUserChannels[0];
9826       format = stream_.userFormat;
9827     }
9828
9829     // Do byte swapping if necessary.
9830     if ( stream_.doByteSwap[0] )
9831       byteSwapBuffer( buffer, samples, format );
9832
9833     if ( stream_.mode == DUPLEX && handle->triggered == false ) {
9834       int trig = 0;
9835       ioctl( handle->id[0], SNDCTL_DSP_SETTRIGGER, &trig );
9836       result = write( handle->id[0], buffer, samples * formatBytes(format) );
9837       trig = PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT;
9838       ioctl( handle->id[0], SNDCTL_DSP_SETTRIGGER, &trig );
9839       handle->triggered = true;
9840     }
9841     else
9842       // Write samples to device.
9843       result = write( handle->id[0], buffer, samples * formatBytes(format) );
9844
9845     if ( result == -1 ) {
9846       // We'll assume this is an underrun, though there isn't a
9847       // specific means for determining that.
9848       handle->xrun[0] = true;
9849       errorText_ = "RtApiOss::callbackEvent: audio write error.";
9850       error( RtAudioError::WARNING );
9851       // Continue on to input section.
9852     }
9853   }
9854
9855   if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
9856
9857     // Setup parameters.
9858     if ( stream_.doConvertBuffer[1] ) {
9859       buffer = stream_.deviceBuffer;
9860       samples = stream_.bufferSize * stream_.nDeviceChannels[1];
9861       format = stream_.deviceFormat[1];
9862     }
9863     else {
9864       buffer = stream_.userBuffer[1];
9865       samples = stream_.bufferSize * stream_.nUserChannels[1];
9866       format = stream_.userFormat;
9867     }
9868
9869     // Read samples from device.
9870     result = read( handle->id[1], buffer, samples * formatBytes(format) );
9871
9872     if ( result == -1 ) {
9873       // We'll assume this is an overrun, though there isn't a
9874       // specific means for determining that.
9875       handle->xrun[1] = true;
9876       errorText_ = "RtApiOss::callbackEvent: audio read error.";
9877       error( RtAudioError::WARNING );
9878       goto unlock;
9879     }
9880
9881     // Do byte swapping if necessary.
9882     if ( stream_.doByteSwap[1] )
9883       byteSwapBuffer( buffer, samples, format );
9884
9885     // Do buffer conversion if necessary.
9886     if ( stream_.doConvertBuffer[1] )
9887       convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
9888   }
9889
9890  unlock:
9891   MUTEX_UNLOCK( &stream_.mutex );
9892
9893   RtApi::tickStreamTime();
9894   if ( doStopStream == 1 ) this->stopStream();
9895 }
9896
9897 static void *ossCallbackHandler( void *ptr )
9898 {
9899   CallbackInfo *info = (CallbackInfo *) ptr;
9900   RtApiOss *object = (RtApiOss *) info->object;
9901   bool *isRunning = &info->isRunning;
9902
9903 #ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
9904   if (info->doRealtime) {
9905     std::cerr << "RtAudio oss: " <<
9906              (sched_getscheduler(0) == SCHED_RR ? "" : "_NOT_ ") <<
9907              "running realtime scheduling" << std::endl;
9908   }
9909 #endif
9910
9911   while ( *isRunning == true ) {
9912     pthread_testcancel();
9913     object->callbackEvent();
9914   }
9915
9916   pthread_exit( NULL );
9917 }
9918
9919 //******************** End of __LINUX_OSS__ *********************//
9920 #endif
9921
9922
9923 // *************************************************** //
9924 //
9925 // Protected common (OS-independent) RtAudio methods.
9926 //
9927 // *************************************************** //
9928
9929 // This method can be modified to control the behavior of error
9930 // message printing.
9931 void RtApi :: error( RtAudioError::Type type )
9932 {
9933   errorStream_.str(""); // clear the ostringstream
9934
9935   RtAudioErrorCallback errorCallback = (RtAudioErrorCallback) stream_.callbackInfo.errorCallback;
9936   if ( errorCallback ) {
9937     // abortStream() can generate new error messages. Ignore them. Just keep original one.
9938
9939     if ( firstErrorOccurred_ )
9940       return;
9941
9942     firstErrorOccurred_ = true;
9943     const std::string errorMessage = errorText_;
9944
9945     if ( type != RtAudioError::WARNING && stream_.state != STREAM_STOPPED) {
9946       stream_.callbackInfo.isRunning = false; // exit from the thread
9947       abortStream();
9948     }
9949
9950     errorCallback( type, errorMessage );
9951     firstErrorOccurred_ = false;
9952     return;
9953   }
9954
9955   if ( type == RtAudioError::WARNING && showWarnings_ == true )
9956     std::cerr << '\n' << errorText_ << "\n\n";
9957   else if ( type != RtAudioError::WARNING )
9958     throw( RtAudioError( errorText_, type ) );
9959 }
9960
9961 void RtApi :: verifyStream()
9962 {
9963   if ( stream_.state == STREAM_CLOSED ) {
9964     errorText_ = "RtApi:: a stream is not open!";
9965     error( RtAudioError::INVALID_USE );
9966   }
9967 }
9968
9969 void RtApi :: clearStreamInfo()
9970 {
9971   stream_.mode = UNINITIALIZED;
9972   stream_.state = STREAM_CLOSED;
9973   stream_.sampleRate = 0;
9974   stream_.bufferSize = 0;
9975   stream_.nBuffers = 0;
9976   stream_.userFormat = 0;
9977   stream_.userInterleaved = true;
9978   stream_.streamTime = 0.0;
9979   stream_.apiHandle = 0;
9980   stream_.deviceBuffer = 0;
9981   stream_.callbackInfo.callback = 0;
9982   stream_.callbackInfo.userData = 0;
9983   stream_.callbackInfo.isRunning = false;
9984   stream_.callbackInfo.errorCallback = 0;
9985   for ( int i=0; i<2; i++ ) {
9986     stream_.device[i] = 11111;
9987     stream_.doConvertBuffer[i] = false;
9988     stream_.deviceInterleaved[i] = true;
9989     stream_.doByteSwap[i] = false;
9990     stream_.nUserChannels[i] = 0;
9991     stream_.nDeviceChannels[i] = 0;
9992     stream_.channelOffset[i] = 0;
9993     stream_.deviceFormat[i] = 0;
9994     stream_.latency[i] = 0;
9995     stream_.userBuffer[i] = 0;
9996     stream_.convertInfo[i].channels = 0;
9997     stream_.convertInfo[i].inJump = 0;
9998     stream_.convertInfo[i].outJump = 0;
9999     stream_.convertInfo[i].inFormat = 0;
10000     stream_.convertInfo[i].outFormat = 0;
10001     stream_.convertInfo[i].inOffset.clear();
10002     stream_.convertInfo[i].outOffset.clear();
10003   }
10004 }
10005
10006 unsigned int RtApi :: formatBytes( RtAudioFormat format )
10007 {
10008   if ( format == RTAUDIO_SINT16 )
10009     return 2;
10010   else if ( format == RTAUDIO_SINT32 || format == RTAUDIO_FLOAT32 )
10011     return 4;
10012   else if ( format == RTAUDIO_FLOAT64 )
10013     return 8;
10014   else if ( format == RTAUDIO_SINT24 )
10015     return 3;
10016   else if ( format == RTAUDIO_SINT8 )
10017     return 1;
10018
10019   errorText_ = "RtApi::formatBytes: undefined format.";
10020   error( RtAudioError::WARNING );
10021
10022   return 0;
10023 }
10024
10025 void RtApi :: setConvertInfo( StreamMode mode, unsigned int firstChannel )
10026 {
10027   if ( mode == INPUT ) { // convert device to user buffer
10028     stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1];
10029     stream_.convertInfo[mode].outJump = stream_.nUserChannels[1];
10030     stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1];
10031     stream_.convertInfo[mode].outFormat = stream_.userFormat;
10032   }
10033   else { // convert user to device buffer
10034     stream_.convertInfo[mode].inJump = stream_.nUserChannels[0];
10035     stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0];
10036     stream_.convertInfo[mode].inFormat = stream_.userFormat;
10037     stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0];
10038   }
10039
10040   if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump )
10041     stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump;
10042   else
10043     stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump;
10044
10045   // Set up the interleave/deinterleave offsets.
10046   if ( stream_.deviceInterleaved[mode] != stream_.userInterleaved ) {
10047     if ( ( mode == OUTPUT && stream_.deviceInterleaved[mode] ) ||
10048          ( mode == INPUT && stream_.userInterleaved ) ) {
10049       for ( int k=0; k<stream_.convertInfo[mode].channels; k++ ) {
10050         stream_.convertInfo[mode].inOffset.push_back( k * stream_.bufferSize );
10051         stream_.convertInfo[mode].outOffset.push_back( k );
10052         stream_.convertInfo[mode].inJump = 1;
10053       }
10054     }
10055     else {
10056       for ( int k=0; k<stream_.convertInfo[mode].channels; k++ ) {
10057         stream_.convertInfo[mode].inOffset.push_back( k );
10058         stream_.convertInfo[mode].outOffset.push_back( k * stream_.bufferSize );
10059         stream_.convertInfo[mode].outJump = 1;
10060       }
10061     }
10062   }
10063   else { // no (de)interleaving
10064     if ( stream_.userInterleaved ) {
10065       for ( int k=0; k<stream_.convertInfo[mode].channels; k++ ) {
10066         stream_.convertInfo[mode].inOffset.push_back( k );
10067         stream_.convertInfo[mode].outOffset.push_back( k );
10068       }
10069     }
10070     else {
10071       for ( int k=0; k<stream_.convertInfo[mode].channels; k++ ) {
10072         stream_.convertInfo[mode].inOffset.push_back( k * stream_.bufferSize );
10073         stream_.convertInfo[mode].outOffset.push_back( k * stream_.bufferSize );
10074         stream_.convertInfo[mode].inJump = 1;
10075         stream_.convertInfo[mode].outJump = 1;
10076       }
10077     }
10078   }
10079
10080   // Add channel offset.
10081   if ( firstChannel > 0 ) {
10082     if ( stream_.deviceInterleaved[mode] ) {
10083       if ( mode == OUTPUT ) {
10084         for ( int k=0; k<stream_.convertInfo[mode].channels; k++ )
10085           stream_.convertInfo[mode].outOffset[k] += firstChannel;
10086       }
10087       else {
10088         for ( int k=0; k<stream_.convertInfo[mode].channels; k++ )
10089           stream_.convertInfo[mode].inOffset[k] += firstChannel;
10090       }
10091     }
10092     else {
10093       if ( mode == OUTPUT ) {
10094         for ( int k=0; k<stream_.convertInfo[mode].channels; k++ )
10095           stream_.convertInfo[mode].outOffset[k] += ( firstChannel * stream_.bufferSize );
10096       }
10097       else {
10098         for ( int k=0; k<stream_.convertInfo[mode].channels; k++ )
10099           stream_.convertInfo[mode].inOffset[k] += ( firstChannel  * stream_.bufferSize );
10100       }
10101     }
10102   }
10103 }
10104
10105 void RtApi :: convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info )
10106 {
10107   // This function does format conversion, input/output channel compensation, and
10108   // data interleaving/deinterleaving.  24-bit integers are assumed to occupy
10109   // the lower three bytes of a 32-bit integer.
10110
10111   // Clear our device buffer when in/out duplex device channels are different
10112   if ( outBuffer == stream_.deviceBuffer && stream_.mode == DUPLEX &&
10113        ( stream_.nDeviceChannels[0] < stream_.nDeviceChannels[1] ) )
10114     memset( outBuffer, 0, stream_.bufferSize * info.outJump * formatBytes( info.outFormat ) );
10115
10116   int j;
10117   if (info.outFormat == RTAUDIO_FLOAT64) {
10118     Float64 scale;
10119     Float64 *out = (Float64 *)outBuffer;
10120
10121     if (info.inFormat == RTAUDIO_SINT8) {
10122       signed char *in = (signed char *)inBuffer;
10123       scale = 1.0 / 127.5;
10124       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10125         for (j=0; j<info.channels; j++) {
10126           out[info.outOffset[j]] = (Float64) in[info.inOffset[j]];
10127           out[info.outOffset[j]] += 0.5;
10128           out[info.outOffset[j]] *= scale;
10129         }
10130         in += info.inJump;
10131         out += info.outJump;
10132       }
10133     }
10134     else if (info.inFormat == RTAUDIO_SINT16) {
10135       Int16 *in = (Int16 *)inBuffer;
10136       scale = 1.0 / 32767.5;
10137       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10138         for (j=0; j<info.channels; j++) {
10139           out[info.outOffset[j]] = (Float64) in[info.inOffset[j]];
10140           out[info.outOffset[j]] += 0.5;
10141           out[info.outOffset[j]] *= scale;
10142         }
10143         in += info.inJump;
10144         out += info.outJump;
10145       }
10146     }
10147     else if (info.inFormat == RTAUDIO_SINT24) {
10148       Int24 *in = (Int24 *)inBuffer;
10149       scale = 1.0 / 8388607.5;
10150       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10151         for (j=0; j<info.channels; j++) {
10152           out[info.outOffset[j]] = (Float64) (in[info.inOffset[j]].asInt());
10153           out[info.outOffset[j]] += 0.5;
10154           out[info.outOffset[j]] *= scale;
10155         }
10156         in += info.inJump;
10157         out += info.outJump;
10158       }
10159     }
10160     else if (info.inFormat == RTAUDIO_SINT32) {
10161       Int32 *in = (Int32 *)inBuffer;
10162       scale = 1.0 / 2147483647.5;
10163       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10164         for (j=0; j<info.channels; j++) {
10165           out[info.outOffset[j]] = (Float64) in[info.inOffset[j]];
10166           out[info.outOffset[j]] += 0.5;
10167           out[info.outOffset[j]] *= scale;
10168         }
10169         in += info.inJump;
10170         out += info.outJump;
10171       }
10172     }
10173     else if (info.inFormat == RTAUDIO_FLOAT32) {
10174       Float32 *in = (Float32 *)inBuffer;
10175       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10176         for (j=0; j<info.channels; j++) {
10177           out[info.outOffset[j]] = (Float64) in[info.inOffset[j]];
10178         }
10179         in += info.inJump;
10180         out += info.outJump;
10181       }
10182     }
10183     else if (info.inFormat == RTAUDIO_FLOAT64) {
10184       // Channel compensation and/or (de)interleaving only.
10185       Float64 *in = (Float64 *)inBuffer;
10186       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10187         for (j=0; j<info.channels; j++) {
10188           out[info.outOffset[j]] = in[info.inOffset[j]];
10189         }
10190         in += info.inJump;
10191         out += info.outJump;
10192       }
10193     }
10194   }
10195   else if (info.outFormat == RTAUDIO_FLOAT32) {
10196     Float32 scale;
10197     Float32 *out = (Float32 *)outBuffer;
10198
10199     if (info.inFormat == RTAUDIO_SINT8) {
10200       signed char *in = (signed char *)inBuffer;
10201       scale = (Float32) ( 1.0 / 127.5 );
10202       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10203         for (j=0; j<info.channels; j++) {
10204           out[info.outOffset[j]] = (Float32) in[info.inOffset[j]];
10205           out[info.outOffset[j]] += 0.5;
10206           out[info.outOffset[j]] *= scale;
10207         }
10208         in += info.inJump;
10209         out += info.outJump;
10210       }
10211     }
10212     else if (info.inFormat == RTAUDIO_SINT16) {
10213       Int16 *in = (Int16 *)inBuffer;
10214       scale = (Float32) ( 1.0 / 32767.5 );
10215       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10216         for (j=0; j<info.channels; j++) {
10217           out[info.outOffset[j]] = (Float32) in[info.inOffset[j]];
10218           out[info.outOffset[j]] += 0.5;
10219           out[info.outOffset[j]] *= scale;
10220         }
10221         in += info.inJump;
10222         out += info.outJump;
10223       }
10224     }
10225     else if (info.inFormat == RTAUDIO_SINT24) {
10226       Int24 *in = (Int24 *)inBuffer;
10227       scale = (Float32) ( 1.0 / 8388607.5 );
10228       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10229         for (j=0; j<info.channels; j++) {
10230           out[info.outOffset[j]] = (Float32) (in[info.inOffset[j]].asInt());
10231           out[info.outOffset[j]] += 0.5;
10232           out[info.outOffset[j]] *= scale;
10233         }
10234         in += info.inJump;
10235         out += info.outJump;
10236       }
10237     }
10238     else if (info.inFormat == RTAUDIO_SINT32) {
10239       Int32 *in = (Int32 *)inBuffer;
10240       scale = (Float32) ( 1.0 / 2147483647.5 );
10241       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10242         for (j=0; j<info.channels; j++) {
10243           out[info.outOffset[j]] = (Float32) in[info.inOffset[j]];
10244           out[info.outOffset[j]] += 0.5;
10245           out[info.outOffset[j]] *= scale;
10246         }
10247         in += info.inJump;
10248         out += info.outJump;
10249       }
10250     }
10251     else if (info.inFormat == RTAUDIO_FLOAT32) {
10252       // Channel compensation and/or (de)interleaving only.
10253       Float32 *in = (Float32 *)inBuffer;
10254       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10255         for (j=0; j<info.channels; j++) {
10256           out[info.outOffset[j]] = in[info.inOffset[j]];
10257         }
10258         in += info.inJump;
10259         out += info.outJump;
10260       }
10261     }
10262     else if (info.inFormat == RTAUDIO_FLOAT64) {
10263       Float64 *in = (Float64 *)inBuffer;
10264       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10265         for (j=0; j<info.channels; j++) {
10266           out[info.outOffset[j]] = (Float32) in[info.inOffset[j]];
10267         }
10268         in += info.inJump;
10269         out += info.outJump;
10270       }
10271     }
10272   }
10273   else if (info.outFormat == RTAUDIO_SINT32) {
10274     Int32 *out = (Int32 *)outBuffer;
10275     if (info.inFormat == RTAUDIO_SINT8) {
10276       signed char *in = (signed char *)inBuffer;
10277       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10278         for (j=0; j<info.channels; j++) {
10279           out[info.outOffset[j]] = (Int32) in[info.inOffset[j]];
10280           out[info.outOffset[j]] <<= 24;
10281         }
10282         in += info.inJump;
10283         out += info.outJump;
10284       }
10285     }
10286     else if (info.inFormat == RTAUDIO_SINT16) {
10287       Int16 *in = (Int16 *)inBuffer;
10288       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10289         for (j=0; j<info.channels; j++) {
10290           out[info.outOffset[j]] = (Int32) in[info.inOffset[j]];
10291           out[info.outOffset[j]] <<= 16;
10292         }
10293         in += info.inJump;
10294         out += info.outJump;
10295       }
10296     }
10297     else if (info.inFormat == RTAUDIO_SINT24) {
10298       Int24 *in = (Int24 *)inBuffer;
10299       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10300         for (j=0; j<info.channels; j++) {
10301           out[info.outOffset[j]] = (Int32) in[info.inOffset[j]].asInt();
10302           out[info.outOffset[j]] <<= 8;
10303         }
10304         in += info.inJump;
10305         out += info.outJump;
10306       }
10307     }
10308     else if (info.inFormat == RTAUDIO_SINT32) {
10309       // Channel compensation and/or (de)interleaving only.
10310       Int32 *in = (Int32 *)inBuffer;
10311       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10312         for (j=0; j<info.channels; j++) {
10313           out[info.outOffset[j]] = in[info.inOffset[j]];
10314         }
10315         in += info.inJump;
10316         out += info.outJump;
10317       }
10318     }
10319     else if (info.inFormat == RTAUDIO_FLOAT32) {
10320       Float32 *in = (Float32 *)inBuffer;
10321       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10322         for (j=0; j<info.channels; j++) {
10323           out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] * 2147483647.5 - 0.5);
10324         }
10325         in += info.inJump;
10326         out += info.outJump;
10327       }
10328     }
10329     else if (info.inFormat == RTAUDIO_FLOAT64) {
10330       Float64 *in = (Float64 *)inBuffer;
10331       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10332         for (j=0; j<info.channels; j++) {
10333           out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] * 2147483647.5 - 0.5);
10334         }
10335         in += info.inJump;
10336         out += info.outJump;
10337       }
10338     }
10339   }
10340   else if (info.outFormat == RTAUDIO_SINT24) {
10341     Int24 *out = (Int24 *)outBuffer;
10342     if (info.inFormat == RTAUDIO_SINT8) {
10343       signed char *in = (signed char *)inBuffer;
10344       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10345         for (j=0; j<info.channels; j++) {
10346           out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] << 16);
10347           //out[info.outOffset[j]] <<= 16;
10348         }
10349         in += info.inJump;
10350         out += info.outJump;
10351       }
10352     }
10353     else if (info.inFormat == RTAUDIO_SINT16) {
10354       Int16 *in = (Int16 *)inBuffer;
10355       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10356         for (j=0; j<info.channels; j++) {
10357           out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] << 8);
10358           //out[info.outOffset[j]] <<= 8;
10359         }
10360         in += info.inJump;
10361         out += info.outJump;
10362       }
10363     }
10364     else if (info.inFormat == RTAUDIO_SINT24) {
10365       // Channel compensation and/or (de)interleaving only.
10366       Int24 *in = (Int24 *)inBuffer;
10367       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10368         for (j=0; j<info.channels; j++) {
10369           out[info.outOffset[j]] = in[info.inOffset[j]];
10370         }
10371         in += info.inJump;
10372         out += info.outJump;
10373       }
10374     }
10375     else if (info.inFormat == RTAUDIO_SINT32) {
10376       Int32 *in = (Int32 *)inBuffer;
10377       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10378         for (j=0; j<info.channels; j++) {
10379           out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] >> 8);
10380           //out[info.outOffset[j]] >>= 8;
10381         }
10382         in += info.inJump;
10383         out += info.outJump;
10384       }
10385     }
10386     else if (info.inFormat == RTAUDIO_FLOAT32) {
10387       Float32 *in = (Float32 *)inBuffer;
10388       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10389         for (j=0; j<info.channels; j++) {
10390           out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] * 8388607.5 - 0.5);
10391         }
10392         in += info.inJump;
10393         out += info.outJump;
10394       }
10395     }
10396     else if (info.inFormat == RTAUDIO_FLOAT64) {
10397       Float64 *in = (Float64 *)inBuffer;
10398       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10399         for (j=0; j<info.channels; j++) {
10400           out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] * 8388607.5 - 0.5);
10401         }
10402         in += info.inJump;
10403         out += info.outJump;
10404       }
10405     }
10406   }
10407   else if (info.outFormat == RTAUDIO_SINT16) {
10408     Int16 *out = (Int16 *)outBuffer;
10409     if (info.inFormat == RTAUDIO_SINT8) {
10410       signed char *in = (signed char *)inBuffer;
10411       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10412         for (j=0; j<info.channels; j++) {
10413           out[info.outOffset[j]] = (Int16) in[info.inOffset[j]];
10414           out[info.outOffset[j]] <<= 8;
10415         }
10416         in += info.inJump;
10417         out += info.outJump;
10418       }
10419     }
10420     else if (info.inFormat == RTAUDIO_SINT16) {
10421       // Channel compensation and/or (de)interleaving only.
10422       Int16 *in = (Int16 *)inBuffer;
10423       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10424         for (j=0; j<info.channels; j++) {
10425           out[info.outOffset[j]] = in[info.inOffset[j]];
10426         }
10427         in += info.inJump;
10428         out += info.outJump;
10429       }
10430     }
10431     else if (info.inFormat == RTAUDIO_SINT24) {
10432       Int24 *in = (Int24 *)inBuffer;
10433       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10434         for (j=0; j<info.channels; j++) {
10435           out[info.outOffset[j]] = (Int16) (in[info.inOffset[j]].asInt() >> 8);
10436         }
10437         in += info.inJump;
10438         out += info.outJump;
10439       }
10440     }
10441     else if (info.inFormat == RTAUDIO_SINT32) {
10442       Int32 *in = (Int32 *)inBuffer;
10443       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10444         for (j=0; j<info.channels; j++) {
10445           out[info.outOffset[j]] = (Int16) ((in[info.inOffset[j]] >> 16) & 0x0000ffff);
10446         }
10447         in += info.inJump;
10448         out += info.outJump;
10449       }
10450     }
10451     else if (info.inFormat == RTAUDIO_FLOAT32) {
10452       Float32 *in = (Float32 *)inBuffer;
10453       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10454         for (j=0; j<info.channels; j++) {
10455           out[info.outOffset[j]] = (Int16) (in[info.inOffset[j]] * 32767.5 - 0.5);
10456         }
10457         in += info.inJump;
10458         out += info.outJump;
10459       }
10460     }
10461     else if (info.inFormat == RTAUDIO_FLOAT64) {
10462       Float64 *in = (Float64 *)inBuffer;
10463       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10464         for (j=0; j<info.channels; j++) {
10465           out[info.outOffset[j]] = (Int16) (in[info.inOffset[j]] * 32767.5 - 0.5);
10466         }
10467         in += info.inJump;
10468         out += info.outJump;
10469       }
10470     }
10471   }
10472   else if (info.outFormat == RTAUDIO_SINT8) {
10473     signed char *out = (signed char *)outBuffer;
10474     if (info.inFormat == RTAUDIO_SINT8) {
10475       // Channel compensation and/or (de)interleaving only.
10476       signed char *in = (signed char *)inBuffer;
10477       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10478         for (j=0; j<info.channels; j++) {
10479           out[info.outOffset[j]] = in[info.inOffset[j]];
10480         }
10481         in += info.inJump;
10482         out += info.outJump;
10483       }
10484     }
10485     if (info.inFormat == RTAUDIO_SINT16) {
10486       Int16 *in = (Int16 *)inBuffer;
10487       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10488         for (j=0; j<info.channels; j++) {
10489           out[info.outOffset[j]] = (signed char) ((in[info.inOffset[j]] >> 8) & 0x00ff);
10490         }
10491         in += info.inJump;
10492         out += info.outJump;
10493       }
10494     }
10495     else if (info.inFormat == RTAUDIO_SINT24) {
10496       Int24 *in = (Int24 *)inBuffer;
10497       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10498         for (j=0; j<info.channels; j++) {
10499           out[info.outOffset[j]] = (signed char) (in[info.inOffset[j]].asInt() >> 16);
10500         }
10501         in += info.inJump;
10502         out += info.outJump;
10503       }
10504     }
10505     else if (info.inFormat == RTAUDIO_SINT32) {
10506       Int32 *in = (Int32 *)inBuffer;
10507       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10508         for (j=0; j<info.channels; j++) {
10509           out[info.outOffset[j]] = (signed char) ((in[info.inOffset[j]] >> 24) & 0x000000ff);
10510         }
10511         in += info.inJump;
10512         out += info.outJump;
10513       }
10514     }
10515     else if (info.inFormat == RTAUDIO_FLOAT32) {
10516       Float32 *in = (Float32 *)inBuffer;
10517       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10518         for (j=0; j<info.channels; j++) {
10519           out[info.outOffset[j]] = (signed char) (in[info.inOffset[j]] * 127.5 - 0.5);
10520         }
10521         in += info.inJump;
10522         out += info.outJump;
10523       }
10524     }
10525     else if (info.inFormat == RTAUDIO_FLOAT64) {
10526       Float64 *in = (Float64 *)inBuffer;
10527       for (unsigned int i=0; i<stream_.bufferSize; i++) {
10528         for (j=0; j<info.channels; j++) {
10529           out[info.outOffset[j]] = (signed char) (in[info.inOffset[j]] * 127.5 - 0.5);
10530         }
10531         in += info.inJump;
10532         out += info.outJump;
10533       }
10534     }
10535   }
10536 }
10537
10538 //static inline uint16_t bswap_16(uint16_t x) { return (x>>8) | (x<<8); }
10539 //static inline uint32_t bswap_32(uint32_t x) { return (bswap_16(x&0xffff)<<16) | (bswap_16(x>>16)); }
10540 //static inline uint64_t bswap_64(uint64_t x) { return (((unsigned long long)bswap_32(x&0xffffffffull))<<32) | (bswap_32(x>>32)); }
10541
10542 void RtApi :: byteSwapBuffer( char *buffer, unsigned int samples, RtAudioFormat format )
10543 {
10544   char val;
10545   char *ptr;
10546
10547   ptr = buffer;
10548   if ( format == RTAUDIO_SINT16 ) {
10549     for ( unsigned int i=0; i<samples; i++ ) {
10550       // Swap 1st and 2nd bytes.
10551       val = *(ptr);
10552       *(ptr) = *(ptr+1);
10553       *(ptr+1) = val;
10554
10555       // Increment 2 bytes.
10556       ptr += 2;
10557     }
10558   }
10559   else if ( format == RTAUDIO_SINT32 ||
10560             format == RTAUDIO_FLOAT32 ) {
10561     for ( unsigned int i=0; i<samples; i++ ) {
10562       // Swap 1st and 4th bytes.
10563       val = *(ptr);
10564       *(ptr) = *(ptr+3);
10565       *(ptr+3) = val;
10566
10567       // Swap 2nd and 3rd bytes.
10568       ptr += 1;
10569       val = *(ptr);
10570       *(ptr) = *(ptr+1);
10571       *(ptr+1) = val;
10572
10573       // Increment 3 more bytes.
10574       ptr += 3;
10575     }
10576   }
10577   else if ( format == RTAUDIO_SINT24 ) {
10578     for ( unsigned int i=0; i<samples; i++ ) {
10579       // Swap 1st and 3rd bytes.
10580       val = *(ptr);
10581       *(ptr) = *(ptr+2);
10582       *(ptr+2) = val;
10583
10584       // Increment 2 more bytes.
10585       ptr += 2;
10586     }
10587   }
10588   else if ( format == RTAUDIO_FLOAT64 ) {
10589     for ( unsigned int i=0; i<samples; i++ ) {
10590       // Swap 1st and 8th bytes
10591       val = *(ptr);
10592       *(ptr) = *(ptr+7);
10593       *(ptr+7) = val;
10594
10595       // Swap 2nd and 7th bytes
10596       ptr += 1;
10597       val = *(ptr);
10598       *(ptr) = *(ptr+5);
10599       *(ptr+5) = val;
10600
10601       // Swap 3rd and 6th bytes
10602       ptr += 1;
10603       val = *(ptr);
10604       *(ptr) = *(ptr+3);
10605       *(ptr+3) = val;
10606
10607       // Swap 4th and 5th bytes
10608       ptr += 1;
10609       val = *(ptr);
10610       *(ptr) = *(ptr+1);
10611       *(ptr+1) = val;
10612
10613       // Increment 5 more bytes.
10614       ptr += 5;
10615     }
10616   }
10617 }
10618
10619   // Indentation settings for Vim and Emacs
10620   //
10621   // Local Variables:
10622   // c-basic-offset: 2
10623   // indent-tabs-mode: nil
10624   // End:
10625   //
10626   // vim: et sts=2 sw=2
10627