RtAudio.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "AudioCaptureCore.h"
 
#if PLATFORM_MICROSOFT || PLATFORM_MAC
/************************************************************************/
/************************************************************************/
 
#ifndef __RTAUDIO_H
#define __RTAUDIO_H
 
// Per-platform preprocessor defines here.
#if PLATFORM_WINDOWS
#include "Windows/WindowsHWrapper.h"
 
#ifndef __WINDOWS_DS__
#define __WINDOWS_DS__
#endif // __WINDOWS_DS__
 
#ifdef __WINDOWS_WASAPI__
#undef __WINDOWS_WASAPI__
#endif
 
#elif PLATFORM_MICROSOFT
 
// On Xbox, we use WASAPI.
#include "Windows/WindowsHWrapper.h"
 
#ifdef __WINDOWS_DS__
#undef __WINDOWS_DS__
#endif // __WINDOWS_DS__
 
#ifndef __WINDOWS_WASAPI__
#define __WINDOWS_WASAPI__
#endif
 
#elif PLATFORM_MAC
#ifndef __MACOSX_CORE__
#define __MACOSX_CORE__
#endif // __MACOSX_CORE__
#endif // PLATFORM_WINDOWS
 
#define RTAUDIO_VERSION "5.0.0"
 
#if defined _WIN32 || defined __CYGWIN__
  #define RTAUDIO_DLL_PUBLIC
#else
  #if __GNUC__ >= 4
    #define RTAUDIO_DLL_PUBLIC __attribute__( (visibility( "default" )) )
  #else
    #define RTAUDIO_DLL_PUBLIC
  #endif
#endif
 
THIRD_PARTY_INCLUDES_START
#include <string>
#include <vector>
#include <stdexcept>
#include <iostream>
THIRD_PARTY_INCLUDES_END
 
typedef unsigned long RtAudioFormat;
static const RtAudioFormat RTAUDIO_SINT8 = 0x1;    // 8-bit signed integer.
static const RtAudioFormat RTAUDIO_SINT16 = 0x2;   // 16-bit signed integer.
static const RtAudioFormat RTAUDIO_SINT24 = 0x4;   // 24-bit signed integer.
static const RtAudioFormat RTAUDIO_SINT32 = 0x8;   // 32-bit signed integer.
static const RtAudioFormat RTAUDIO_FLOAT32 = 0x10; // Normalized between plus/minus 1.0.
static const RtAudioFormat RTAUDIO_FLOAT64 = 0x20; // Normalized between plus/minus 1.0.
 
typedef unsigned int RtAudioStreamFlags;
static const RtAudioStreamFlags RTAUDIO_NONINTERLEAVED = 0x1;    // Use non-interleaved buffers (default = interleaved).
static const RtAudioStreamFlags RTAUDIO_MINIMIZE_LATENCY = 0x2;  // Attempt to set stream parameters for lowest possible latency.
static const RtAudioStreamFlags RTAUDIO_HOG_DEVICE = 0x4;        // Attempt grab device and prevent use by others.
static const RtAudioStreamFlags RTAUDIO_SCHEDULE_REALTIME = 0x8; // Try to select realtime scheduling for callback thread.
static const RtAudioStreamFlags RTAUDIO_ALSA_USE_DEFAULT = 0x10; // Use the "default" PCM device (ALSA only).
static const RtAudioStreamFlags RTAUDIO_JACK_DONT_CONNECT = 0x20; // Do not automatically connect ports (JACK only).
 
typedef unsigned int RtAudioStreamStatus;
static const RtAudioStreamStatus RTAUDIO_INPUT_OVERFLOW = 0x1;    // Input data was discarded because of an overflow condition at the driver.
static const RtAudioStreamStatus RTAUDIO_OUTPUT_UNDERFLOW = 0x2;  // The output buffer ran low, likely causing a gap in the output sound.
 
 
typedef int (*RtAudioCallback)( void *outputBuffer, void *inputBuffer,
                                unsigned int nFrames,
                                double streamTime,
                                RtAudioStreamStatus status,
                                void *userData );
 
/************************************************************************/
/************************************************************************/
 
class RtAudioError : public std::runtime_error
{
 public:
  enum Type {
    WARNING,           
    DEBUG_WARNING,     
    UNSPECIFIED,       
    NO_DEVICES_FOUND,  
    INVALID_DEVICE,    
    MEMORY_ERROR,      
    INVALID_PARAMETER, 
    INVALID_USE,       
    DRIVER_ERROR,      
    SYSTEM_ERROR,      
    THREAD_ERROR       
  };
 
  RtAudioError( const std::string& message,
                Type type = RtAudioError::UNSPECIFIED )
    : std::runtime_error(message), type_(type) {}
 
  virtual void printMessage( void ) const
    { std::cerr << '\n' << what() << "\n\n"; }
 
  virtual const Type& getType(void) const { return type_; }
 
  virtual const std::string getMessage(void) const
    { return std::string(what()); }
 
 protected:
  Type type_;
};
 
 
typedef void (*RtAudioErrorCallback)( RtAudioError::Type type, const std::string &errorText );
 
// **************************************************************** //
//
// RtAudio class declaration.
//
// RtAudio is a "controller" used to select an available audio i/o
// interface.  It presents a common API for the user to call but all
// functionality is implemented by the class RtApi and its
// subclasses.  RtAudio creates an instance of an RtApi subclass
// based on the user's API choice.  If no choice is made, RtAudio
// attempts to make a "logical" API selection.
//
// **************************************************************** //
 
class RtApi;
 
class RtAudio
{
 public:
 
  enum Api {
    UNSPECIFIED,    
    LINUX_ALSA,     
    LINUX_PULSE,    
    LINUX_OSS,      
    UNIX_JACK,      
    MACOSX_CORE,    
    WINDOWS_WASAPI, 
    WINDOWS_ASIO,   
    WINDOWS_DS,     
    RTAUDIO_DUMMY   
  };
 
  struct DeviceInfo {
    bool probed;                  
    std::string name;             
    std::string deviceId;               
    unsigned int outputChannels;  
    unsigned int inputChannels;   
    unsigned int duplexChannels;  
    bool isDefaultOutput;         
    bool isDefaultInput;          
    std::vector<unsigned int> sampleRates; 
    unsigned int preferredSampleRate; 
    RtAudioFormat nativeFormats;  
    // Default constructor.
    DeviceInfo()
      :probed(false), outputChannels(0), inputChannels(0), duplexChannels(0),
       isDefaultOutput(false), isDefaultInput(false), preferredSampleRate(0), nativeFormats(0) {}
  };
 
  struct StreamParameters {
    unsigned int deviceId;     
    unsigned int nChannels;    
    unsigned int firstChannel; 
    // Default constructor.
    StreamParameters()
      : deviceId(0), nChannels(0), firstChannel(0) {}
  };
 
 
  struct StreamOptions {
    RtAudioStreamFlags flags;      
    unsigned int numberOfBuffers;  
    std::string streamName;        
    int priority;                  
    // Default constructor.
    StreamOptions()
    : flags(0), numberOfBuffers(0), priority(0) {}
  };
 
  static AUDIOCAPTURERTAUDIO_API std::string getVersion( void );
 
 
  static AUDIOCAPTURERTAUDIO_API void getCompiledApi( std::vector<RtAudio::Api> &apis );
 
 
  AUDIOCAPTURERTAUDIO_API RtAudio( RtAudio::Api api=UNSPECIFIED );
 
 
  AUDIOCAPTURERTAUDIO_API ~RtAudio();
 
  AUDIOCAPTURERTAUDIO_API RtAudio::Api getCurrentApi( void );
 
 
  AUDIOCAPTURERTAUDIO_API unsigned int getDeviceCount( void );
 
 
  AUDIOCAPTURERTAUDIO_API RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
 
 
  AUDIOCAPTURERTAUDIO_API unsigned int getDefaultOutputDevice( void );
 
 
  AUDIOCAPTURERTAUDIO_API unsigned int getDefaultInputDevice( void );
 
 
  AUDIOCAPTURERTAUDIO_API void openStream( RtAudio::StreamParameters *outputParameters,
                   RtAudio::StreamParameters *inputParameters,
                   RtAudioFormat format, unsigned int sampleRate,
                   unsigned int *bufferFrames, RtAudioCallback callback,
                   void *userData = NULL, RtAudio::StreamOptions *options = NULL, RtAudioErrorCallback errorCallback = NULL );
 
 
  AUDIOCAPTURERTAUDIO_API void closeStream( void );
 
 
  AUDIOCAPTURERTAUDIO_API void startStream( void );
 
 
  AUDIOCAPTURERTAUDIO_API void stopStream( void );
 
 
  AUDIOCAPTURERTAUDIO_API void abortStream( void );
 
  AUDIOCAPTURERTAUDIO_API bool isStreamOpen( void ) const;
 
  AUDIOCAPTURERTAUDIO_API bool isStreamRunning( void ) const;
 
 
  AUDIOCAPTURERTAUDIO_API double getStreamTime( void );
 
 
  AUDIOCAPTURERTAUDIO_API void setStreamTime( double time );
 
 
  AUDIOCAPTURERTAUDIO_API long getStreamLatency( void );
 
 
  AUDIOCAPTURERTAUDIO_API unsigned int getStreamSampleRate( void );
 
  AUDIOCAPTURERTAUDIO_API void showWarnings( bool value = true );
 
 protected:
 
  AUDIOCAPTURERTAUDIO_API void openRtApi( RtAudio::Api api );
  RtApi *rtapi_;
};
 
// Operating system dependent thread functionality.
#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_WASAPI__)
 
  #ifndef NOMINMAX
    #define NOMINMAX
  #endif
  #include <windows.h>
  #include <process.h>
 
  typedef uintptr_t ThreadHandle;
  typedef CRITICAL_SECTION StreamMutex;
 
#elif defined(__LINUX_ALSA__) || defined(__LINUX_PULSE__) || defined(__UNIX_JACK__) || defined(__LINUX_OSS__) || defined(__MACOSX_CORE__)
  // Using pthread library for various flavors of unix.
  #include <pthread.h>
 
  typedef pthread_t ThreadHandle;
  typedef pthread_mutex_t StreamMutex;
 
#else // Setup for "dummy" behavior
 
  #define __RTAUDIO_DUMMY__
  typedef int ThreadHandle;
  typedef int StreamMutex;
 
#endif
 
// This global structure type is used to pass callback information
// between the private RtAudio stream structure and global callback
// handling functions.
struct CallbackInfo {
  void *object;    // Used as a "this" pointer.
  ThreadHandle thread;
  void *callback;
  void *userData;
  void *errorCallback;
  void *apiInfo;   // void pointer for API specific callback information
  bool isRunning;
  bool doRealtime;
  int priority;
 
  // Default constructor.
  CallbackInfo()
  :object(0), callback(0), userData(0), errorCallback(0), apiInfo(0), isRunning(false), doRealtime(false), priority(0) {}
};
 
// **************************************************************** //
//
// RtApi class declaration.
//
// Subclasses of RtApi contain all API- and OS-specific code necessary
// to fully implement the RtAudio API.
//
// Note that RtApi is an abstract base class and cannot be
// explicitly instantiated.  The class RtAudio will create an
// instance of an RtApi subclass (RtApiOss, RtApiAlsa,
// RtApiJack, RtApiCore, RtApiDs, or RtApiAsio).
//
// **************************************************************** //
 
#pragma pack(push, 1)
class S24 {
 
 protected:
  unsigned char c3[3];
 
 public:
  S24() {}
 
  S24& operator = ( const int& i ) {
    c3[0] = (i & 0x000000ff);
    c3[1] = (i & 0x0000ff00) >> 8;
    c3[2] = (i & 0x00ff0000) >> 16;
    return *this;
  }
 
  S24( const S24& v ) { *this = v; }
  S24( const double& d ) { *this = (int) d; }
  S24( const float& f ) { *this = (int) f; }
  S24( const signed short& s ) { *this = (int) s; }
  S24( const char& c ) { *this = (int) c; }
 
  int asInt() {
    int i = c3[0] | (c3[1] << 8) | (c3[2] << 16);
    if (i & 0x800000) i |= ~0xffffff;
    return i;
  }
};
#pragma pack(pop)
 
#if defined( HAVE_GETTIMEOFDAY )
  #include <sys/time.h>
#endif
 
#include <sstream>
 
class RtApi
{
public:
 
  AUDIOCAPTURERTAUDIO_API RtApi();
  AUDIOCAPTURERTAUDIO_API virtual ~RtApi();
  virtual RtAudio::Api getCurrentApi( void ) = 0;
  virtual unsigned int getDeviceCount( void ) = 0;
  virtual RtAudio::DeviceInfo getDeviceInfo( unsigned int device ) = 0;
  AUDIOCAPTURERTAUDIO_API virtual unsigned int getDefaultInputDevice( void );
  AUDIOCAPTURERTAUDIO_API virtual unsigned int getDefaultOutputDevice( void );
  AUDIOCAPTURERTAUDIO_API void openStream( RtAudio::StreamParameters *outputParameters,
                   RtAudio::StreamParameters *inputParameters,
                   RtAudioFormat format, unsigned int sampleRate,
                   unsigned int *bufferFrames, RtAudioCallback callback,
                   void *userData, RtAudio::StreamOptions *options,
                   RtAudioErrorCallback errorCallback );
  AUDIOCAPTURERTAUDIO_API virtual void closeStream( void );
  virtual void startStream( void ) = 0;
  virtual void stopStream( void ) = 0;
  virtual void abortStream( void ) = 0;
  AUDIOCAPTURERTAUDIO_API long getStreamLatency( void );
  AUDIOCAPTURERTAUDIO_API unsigned int getStreamSampleRate( void );
  AUDIOCAPTURERTAUDIO_API virtual double getStreamTime( void );
  AUDIOCAPTURERTAUDIO_API virtual void setStreamTime( double time );
  bool isStreamOpen( void ) const { return stream_.state != STREAM_CLOSED; }
  bool isStreamRunning( void ) const { return stream_.state == STREAM_RUNNING; }
  void showWarnings( bool value ) { showWarnings_ = value; }
 
 
protected:
 
  static AUDIOCAPTURERTAUDIO_API const unsigned int MAX_SAMPLE_RATES;
  static AUDIOCAPTURERTAUDIO_API const unsigned int SAMPLE_RATES[];
 
  enum { FAILURE, SUCCESS };
 
  enum StreamState {
    STREAM_STOPPED,
    STREAM_STOPPING,
    STREAM_RUNNING,
    STREAM_CLOSED = -50
  };
 
  enum StreamMode {
    OUTPUT,
    INPUT,
    DUPLEX,
    UNINITIALIZED = -75
  };
 
  // A protected structure used for buffer conversion.
  struct ConvertInfo {
    int channels;
    int inJump, outJump;
    RtAudioFormat inFormat, outFormat;
    std::vector<int> inOffset;
    std::vector<int> outOffset;
  };
 
  // A protected structure for audio streams.
  struct RtApiStream {
    unsigned int device[2];    // Playback and record, respectively.
    void *apiHandle;           // void pointer for API specific stream handle information
    StreamMode mode;           // OUTPUT, INPUT, or DUPLEX.
    StreamState state;         // STOPPED, RUNNING, or CLOSED
    char *userBuffer[2];       // Playback and record, respectively.
    char *deviceBuffer;
    bool doConvertBuffer[2];   // Playback and record, respectively.
    bool userInterleaved;
    bool deviceInterleaved[2]; // Playback and record, respectively.
    bool doByteSwap[2];        // Playback and record, respectively.
    unsigned int sampleRate;
    unsigned int bufferSize;
    unsigned int nBuffers;
    unsigned int nUserChannels[2];    // Playback and record, respectively.
    unsigned int nDeviceChannels[2];  // Playback and record channels, respectively.
    unsigned int channelOffset[2];    // Playback and record, respectively.
    unsigned long latency[2];         // Playback and record, respectively.
    RtAudioFormat userFormat;
    RtAudioFormat deviceFormat[2];    // Playback and record, respectively.
    StreamMutex mutex;
    CallbackInfo callbackInfo;
    ConvertInfo convertInfo[2];
    double streamTime;         // Number of elapsed seconds since the stream started.
 
#if defined(HAVE_GETTIMEOFDAY)
    struct timeval lastTickTimestamp;
#endif
 
    RtApiStream()
      :apiHandle(0), deviceBuffer(0) { device[0] = 11111; device[1] = 11111; }
  };
 
  typedef S24 Int24;
  typedef signed short Int16;
  typedef signed int Int32;
  typedef float Float32;
  typedef double Float64;
 
  std::ostringstream errorStream_;
  std::string errorText_;
  bool showWarnings_;
  RtApiStream stream_;
  bool firstErrorOccurred_;
 
  AUDIOCAPTURERTAUDIO_API virtual bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, 
                                unsigned int firstChannel, unsigned int sampleRate,
                                RtAudioFormat format, unsigned int *bufferSize,
                                RtAudio::StreamOptions *options );
 
  AUDIOCAPTURERTAUDIO_API void tickStreamTime( void );
 
  AUDIOCAPTURERTAUDIO_API void clearStreamInfo();
 
  AUDIOCAPTURERTAUDIO_API void verifyStream( void );
 
  AUDIOCAPTURERTAUDIO_API void error( RtAudioError::Type type );
 
  AUDIOCAPTURERTAUDIO_API void convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info );
 
  AUDIOCAPTURERTAUDIO_API void byteSwapBuffer( char *buffer, unsigned int samples, RtAudioFormat format );
 
  AUDIOCAPTURERTAUDIO_API unsigned int formatBytes( RtAudioFormat format );
 
  AUDIOCAPTURERTAUDIO_API void setConvertInfo( StreamMode mode, unsigned int firstChannel );
};
 
// **************************************************************** //
//
// Inline RtAudio definitions.
//
// **************************************************************** //
 
inline RtAudio::Api RtAudio :: getCurrentApi( void ) { return rtapi_->getCurrentApi(); }
inline unsigned int RtAudio :: getDeviceCount( void ) { return rtapi_->getDeviceCount(); }
inline RtAudio::DeviceInfo RtAudio :: getDeviceInfo( unsigned int device ) { return rtapi_->getDeviceInfo( device ); }
inline unsigned int RtAudio :: getDefaultInputDevice( void ) { return rtapi_->getDefaultInputDevice(); }
inline unsigned int RtAudio :: getDefaultOutputDevice( void ) { return rtapi_->getDefaultOutputDevice(); }
inline void RtAudio :: closeStream( void ) { return rtapi_->closeStream(); }
inline void RtAudio :: startStream( void ) { return rtapi_->startStream(); }
inline void RtAudio :: stopStream( void )  { return rtapi_->stopStream(); }
inline void RtAudio :: abortStream( void ) { return rtapi_->abortStream(); }
inline bool RtAudio :: isStreamOpen( void ) const { return rtapi_->isStreamOpen(); }
inline bool RtAudio :: isStreamRunning( void ) const { return rtapi_->isStreamRunning(); }
inline long RtAudio :: getStreamLatency( void ) { return rtapi_->getStreamLatency(); }
inline unsigned int RtAudio :: getStreamSampleRate( void ) { return rtapi_->getStreamSampleRate(); }
inline double RtAudio :: getStreamTime( void ) { return rtapi_->getStreamTime(); }
inline void RtAudio :: setStreamTime( double time ) { return rtapi_->setStreamTime( time ); }
inline void RtAudio :: showWarnings( bool value ) { rtapi_->showWarnings( value ); }
 
// RtApi Subclass prototypes.
 
#if defined(__MACOSX_CORE__)
 
#include <CoreAudio/AudioHardware.h>
 
class RtApiCore: public RtApi
{
public:
 
  RtApiCore();
  ~RtApiCore();
  RtAudio::Api getCurrentApi( void ) { return RtAudio::MACOSX_CORE; }
  unsigned int getDeviceCount( void );
  RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
  unsigned int getDefaultOutputDevice( void );
  unsigned int getDefaultInputDevice( void );
  void closeStream( void );
  void startStream( void );
  void stopStream( void );
  void abortStream( void );
  long getStreamLatency( void );
 
  // This function is intended for internal use only.  It must be
  // public because it is called by the internal callback handler,
  // which is not a member of RtAudio.  External use of this function
  // will most likely produce highly undesireable results!
  bool callbackEvent( AudioDeviceID deviceId,
                      const AudioBufferList *inBufferList,
                      const AudioBufferList *outBufferList );
 
  private:
 
  bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, 
                        unsigned int firstChannel, unsigned int sampleRate,
                        RtAudioFormat format, unsigned int *bufferSize,
                        RtAudio::StreamOptions *options );
  static const char* getErrorCode( OSStatus code );
};
 
#endif
 
#if defined(__UNIX_JACK__)
 
class RtApiJack: public RtApi
{
public:
 
  RtApiJack();
  ~RtApiJack();
  RtAudio::Api getCurrentApi( void ) { return RtAudio::UNIX_JACK; }
  unsigned int getDeviceCount( void );
  RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
  void closeStream( void );
  void startStream( void );
  void stopStream( void );
  void abortStream( void );
  long getStreamLatency( void );
 
  // This function is intended for internal use only.  It must be
  // public because it is called by the internal callback handler,
  // which is not a member of RtAudio.  External use of this function
  // will most likely produce highly undesireable results!
  bool callbackEvent( unsigned long nframes );
 
  private:
 
  bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, 
                        unsigned int firstChannel, unsigned int sampleRate,
                        RtAudioFormat format, unsigned int *bufferSize,
                        RtAudio::StreamOptions *options );
 
  bool shouldAutoconnect_;
};
 
#endif
 
#if defined(__WINDOWS_ASIO__)
 
class RtApiAsio: public RtApi
{
public:
 
  RtApiAsio();
  ~RtApiAsio();
  RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_ASIO; }
  unsigned int getDeviceCount( void );
  RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
  void closeStream( void );
  void startStream( void );
  void stopStream( void );
  void abortStream( void );
  long getStreamLatency( void );
 
  // This function is intended for internal use only.  It must be
  // public because it is called by the internal callback handler,
  // which is not a member of RtAudio.  External use of this function
  // will most likely produce highly undesireable results!
  bool callbackEvent( long bufferIndex );
 
  private:
 
  std::vector<RtAudio::DeviceInfo> devices_;
  void saveDeviceInfo( void );
  bool coInitialized_;
  bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, 
                        unsigned int firstChannel, unsigned int sampleRate,
                        RtAudioFormat format, unsigned int *bufferSize,
                        RtAudio::StreamOptions *options );
};
 
#endif
 
#if defined(__WINDOWS_DS__)
 
class RtApiDs: public RtApi
{
public:
 
  RtApiDs();
  ~RtApiDs();
  RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_DS; }
  unsigned int getDeviceCount( void );
  unsigned int getDefaultOutputDevice( void );
  unsigned int getDefaultInputDevice( void );
  RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
  void closeStream( void );
  void startStream( void );
  void stopStream( void );
  void abortStream( void );
  long getStreamLatency( void );
 
  // This function is intended for internal use only.  It must be
  // public because it is called by the internal callback handler,
  // which is not a member of RtAudio.  External use of this function
  // will most likely produce highly undesireable results!
  void callbackEvent( void );
 
  private:
 
  bool coInitialized_;
  bool buffersRolling;
  long duplexPrerollBytes;
  std::vector<struct DsDevice> dsDevices;
  bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, 
                        unsigned int firstChannel, unsigned int sampleRate,
                        RtAudioFormat format, unsigned int *bufferSize,
                        RtAudio::StreamOptions *options );
};
 
#endif
 
#if defined(__WINDOWS_WASAPI__)
 
struct IMMDeviceEnumerator;
 
class RtApiWasapi : public RtApi
{
public:
  RtApiWasapi();
  ~RtApiWasapi();
 
  RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_WASAPI; }
  unsigned int getDeviceCount( void );
  RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
  unsigned int getDefaultOutputDevice( void );
  unsigned int getDefaultInputDevice( void );
  void closeStream( void );
  void startStream( void );
  void stopStream( void );
  void abortStream( void );
 
private:
  bool coInitialized_;
  IMMDeviceEnumerator* deviceEnumerator_;
 
  bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
                        unsigned int firstChannel, unsigned int sampleRate,
                        RtAudioFormat format, unsigned int* bufferSize,
                        RtAudio::StreamOptions* options );
 
  static DWORD WINAPI runWasapiThread( void* wasapiPtr );
  static DWORD WINAPI stopWasapiThread( void* wasapiPtr );
  static DWORD WINAPI abortWasapiThread( void* wasapiPtr );
  void wasapiThread();
};
 
#endif
 
#if defined(__LINUX_ALSA__)
 
class RtApiAlsa: public RtApi
{
public:
 
  RtApiAlsa();
  ~RtApiAlsa();
  RtAudio::Api getCurrentApi() { return RtAudio::LINUX_ALSA; }
  unsigned int getDeviceCount( void );
  RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
  void closeStream( void );
  void startStream( void );
  void stopStream( void );
  void abortStream( void );
 
  // This function is intended for internal use only.  It must be
  // public because it is called by the internal callback handler,
  // which is not a member of RtAudio.  External use of this function
  // will most likely produce highly undesireable results!
  void callbackEvent( void );
 
  private:
 
  std::vector<RtAudio::DeviceInfo> devices_;
  void saveDeviceInfo( void );
  bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, 
                        unsigned int firstChannel, unsigned int sampleRate,
                        RtAudioFormat format, unsigned int *bufferSize,
                        RtAudio::StreamOptions *options );
};
 
#endif
 
#if defined(__LINUX_PULSE__)
 
class RtApiPulse: public RtApi
{
public:
  ~RtApiPulse();
  RtAudio::Api getCurrentApi() { return RtAudio::LINUX_PULSE; }
  unsigned int getDeviceCount( void );
  RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
  void closeStream( void );
  void startStream( void );
  void stopStream( void );
  void abortStream( void );
 
  // This function is intended for internal use only.  It must be
  // public because it is called by the internal callback handler,
  // which is not a member of RtAudio.  External use of this function
  // will most likely produce highly undesireable results!
  void callbackEvent( void );
 
  private:
 
  std::vector<RtAudio::DeviceInfo> devices_;
  void saveDeviceInfo( void );
  bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
                        unsigned int firstChannel, unsigned int sampleRate,
                        RtAudioFormat format, unsigned int *bufferSize,
                        RtAudio::StreamOptions *options );
};
 
#endif
 
#if defined(__LINUX_OSS__)
 
class RtApiOss: public RtApi
{
public:
 
  RtApiOss();
  ~RtApiOss();
  RtAudio::Api getCurrentApi() { return RtAudio::LINUX_OSS; }
  unsigned int getDeviceCount( void );
  RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
  void closeStream( void );
  void startStream( void );
  void stopStream( void );
  void abortStream( void );
 
  // This function is intended for internal use only.  It must be
  // public because it is called by the internal callback handler,
  // which is not a member of RtAudio.  External use of this function
  // will most likely produce highly undesireable results!
  void callbackEvent( void );
 
  private:
 
  bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels, 
                        unsigned int firstChannel, unsigned int sampleRate,
                        RtAudioFormat format, unsigned int *bufferSize,
                        RtAudio::StreamOptions *options );
};
 
#endif
 
#if defined(__RTAUDIO_DUMMY__)
 
class RtApiDummy: public RtApi
{
public:
 
  RtApiDummy() { errorText_ = "RtApiDummy: This class provides no functionality."; error( RtAudioError::WARNING ); }
  RtAudio::Api getCurrentApi( void ) { return RtAudio::RTAUDIO_DUMMY; }
  unsigned int getDeviceCount( void ) { return 0; }
  RtAudio::DeviceInfo getDeviceInfo( unsigned int /*device*/ ) { RtAudio::DeviceInfo info; return info; }
  void closeStream( void ) {}
  void startStream( void ) {}
  void stopStream( void ) {}
  void abortStream( void ) {}
 
  private:
 
  bool probeDeviceOpen( unsigned int /*device*/, StreamMode /*mode*/, unsigned int /*channels*/, 
                        unsigned int /*firstChannel*/, unsigned int /*sampleRate*/,
                        RtAudioFormat /*format*/, unsigned int * /*bufferSize*/,
                        RtAudio::StreamOptions * /*options*/ ) { return false; }
};
 
#endif
 
#endif
 
// Indentation settings for Vim and Emacs
//
// Local Variables:
// c-basic-offset: 2
// indent-tabs-mode: nil
// End:
//
// vim: et sts=2 sw=2
#endif // PLATFORM_WINDOWS