Home Class/Enum List File List Compound Members

# RtAudio.h

Go to the documentation of this file.

    00001 /************************************************************************/
    00039 /************************************************************************/
    00040
    00045 // RtAudio: Version 4.0.6
    00046
    00047 #ifndef __RTAUDIO_H
    00048 #define __RTAUDIO_H
    00049
    00050 #include <string>
    00051 #include <vector>
    00052 #include "RtError.h"
    00053
    00070 typedef unsigned long RtAudioFormat;
    00071 static const RtAudioFormat RTAUDIO_SINT8 = 0x1;    // 8-bit signed integer.
    00072 static const RtAudioFormat RTAUDIO_SINT16 = 0x2;   // 16-bit signed integer.
    00073 static const RtAudioFormat RTAUDIO_SINT24 = 0x4;   // Lower 3 bytes of 32-bit signed integer.
    00074 static const RtAudioFormat RTAUDIO_SINT32 = 0x8;   // 32-bit signed integer.
    00075 static const RtAudioFormat RTAUDIO_FLOAT32 = 0x10; // Normalized between plus/minus 1.0.
    00076 static const RtAudioFormat RTAUDIO_FLOAT64 = 0x20; // Normalized between plus/minus 1.0.
    00077
    00115 typedef unsigned int RtAudioStreamFlags;
    00116 static const RtAudioStreamFlags RTAUDIO_NONINTERLEAVED = 0x1;    // Use non-interleaved buffers (default = interleaved).
    00117 static const RtAudioStreamFlags RTAUDIO_MINIMIZE_LATENCY = 0x2;  // Attempt to set stream parameters for lowest possible latency.
    00118 static const RtAudioStreamFlags RTAUDIO_HOG_DEVICE = 0x4;        // Attempt grab device and prevent use by others.
    00119 static const RtAudioStreamFlags RTAUDIO_SCHEDULE_REALTIME = 0x8; // Try to select realtime scheduling for callback thread.
    00120
    00132 typedef unsigned int RtAudioStreamStatus;
    00133 static const RtAudioStreamStatus RTAUDIO_INPUT_OVERFLOW = 0x1;    // Input data was discarded because of an overflow condition at the driver.
    00134 static const RtAudioStreamStatus RTAUDIO_OUTPUT_UNDERFLOW = 0x2;  // The output buffer ran low, likely causing a gap in the output sound.
    00135
    00137
    00175 typedef int (*RtAudioCallback)( void *outputBuffer, void *inputBuffer,
    00176                                 unsigned int nFrames,
    00177                                 double streamTime,
    00178                                 RtAudioStreamStatus status,
    00179                                 void *userData );
    00180
    00181
    00182 // **************************************************************** //
    00183 //
    00184 // RtAudio class declaration.
    00185 //
    00186 // RtAudio is a "controller" used to select an available audio i/o
    00187 // interface.  It presents a common API for the user to call but all
    00188 // functionality is implemented by the class RtApi and its
    00189 // subclasses.  RtAudio creates an instance of an RtApi subclass
    00190 // based on the user's API choice.  If no choice is made, RtAudio
    00191 // attempts to make a "logical" API selection.
    00192 //
    00193 // **************************************************************** //
    00194
    00195 class RtApi;
    00196
    00197 class RtAudio
    00198 {
    00199  public:
    00200
    00202   enum Api {
    00203     UNSPECIFIED,
    00204     LINUX_ALSA,
    00205     LINUX_OSS,
    00206     UNIX_JACK,
    00207     MACOSX_CORE,
    00208     WINDOWS_ASIO,
    00209     WINDOWS_DS,
    00210     RTAUDIO_DUMMY
    00211   };
    00212
    00214   struct DeviceInfo {
    00215     bool probed;
    00216     std::string name;
    00217     unsigned int outputChannels;
    00218     unsigned int inputChannels;
    00219     unsigned int duplexChannels;
    00220     bool isDefaultOutput;
    00221     bool isDefaultInput;
    00222     std::vector<unsigned int> sampleRates;
    00223     RtAudioFormat nativeFormats;
    00225     // Default constructor.
    00226     DeviceInfo()
    00227       :probed(false), outputChannels(0), inputChannels(0), duplexChannels(0),
    00228        isDefaultOutput(false), isDefaultInput(false), nativeFormats(0) {}
    00229   };
    00230
    00232   struct StreamParameters {
    00233     unsigned int deviceId;
    00234     unsigned int nChannels;
    00235     unsigned int firstChannel;
    00237     // Default constructor.
    00238     StreamParameters()
    00239       : deviceId(0), nChannels(0), firstChannel(0) {}
    00240   };
    00241
    00243
    00294   struct StreamOptions {
    00295     RtAudioStreamFlags flags;
    00296     unsigned int numberOfBuffers;
    00297     std::string streamName;
    00298     int priority;
    00300     // Default constructor.
    00301     StreamOptions()
    00302     : flags(0), numberOfBuffers(0), priority(0) {}
    00303   };
    00304
    00306
    00311   static void getCompiledApi( std::vector<RtAudio::Api> &apis ) throw();
    00312
    00314
    00322   RtAudio( RtAudio::Api api=UNSPECIFIED ) throw();
    00323
    00325
    00329   ~RtAudio() throw();
    00330
    00332   RtAudio::Api getCurrentApi( void ) throw();
    00333
    00335
    00340   unsigned int getDeviceCount( void ) throw();
    00341
    00343
    00353   RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
    00354
    00356
    00363   unsigned int getDefaultOutputDevice( void ) throw();
    00364
    00366
    00373   unsigned int getDefaultInputDevice( void ) throw();
    00374
    00376
    00413   void openStream( RtAudio::StreamParameters *outputParameters,
    00414                    RtAudio::StreamParameters *inputParameters,
    00415                    RtAudioFormat format, unsigned int sampleRate,
    00416                    unsigned int *bufferFrames, RtAudioCallback callback,
    00417                    void *userData = NULL, RtAudio::StreamOptions *options = NULL );
    00418
    00420
    00424   void closeStream( void ) throw();
    00425
    00427
    00433   void startStream( void );
    00434
    00436
    00442   void stopStream( void );
    00443
    00445
    00451   void abortStream( void );
    00452
    00454   bool isStreamOpen( void ) const throw();
    00455
    00457   bool isStreamRunning( void ) const throw();
    00458
    00460
    00463   double getStreamTime( void );
    00464
    00466
    00474   long getStreamLatency( void );
    00475
    00477
    00482   unsigned int getStreamSampleRate( void );
    00483
    00485   void showWarnings( bool value = true ) throw();
    00486
    00487  protected:
    00488
    00489   void openRtApi( RtAudio::Api api );
    00490   RtApi *rtapi_;
    00491 };
    00492
    00493 // Operating system dependent thread functionality.
    00494 #if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)
    00495   #include <windows.h>
    00496   #include <process.h>
    00497
    00498   typedef unsigned long ThreadHandle;
    00499   typedef CRITICAL_SECTION StreamMutex;
    00500
    00501 #elif defined(__LINUX_ALSA__) || defined(__UNIX_JACK__) || defined(__LINUX_OSS__) || defined(__MACOSX_CORE__)
    00502   // Using pthread library for various flavors of unix.
    00503   #include <pthread.h>
    00504
    00505   typedef pthread_t ThreadHandle;
    00506   typedef pthread_mutex_t StreamMutex;
    00507
    00508 #else // Setup for "dummy" behavior
    00509
    00510   #define __RTAUDIO_DUMMY__
    00511   typedef int ThreadHandle;
    00512   typedef int StreamMutex;
    00513
    00514 #endif
    00515
    00516 // This global structure type is used to pass callback information
    00517 // between the private RtAudio stream structure and global callback
    00518 // handling functions.
    00519 struct CallbackInfo {
    00520   void *object;    // Used as a "this" pointer.
    00521   ThreadHandle thread;
    00522   void *callback;
    00523   void *userData;
    00524   void *apiInfo;   // void pointer for API specific callback information
    00525   bool isRunning;
    00526
    00527   // Default constructor.
    00528   CallbackInfo()
    00529     :object(0), callback(0), userData(0), apiInfo(0), isRunning(false) {}
    00530 };
    00531
    00532 // **************************************************************** //
    00533 //
    00534 // RtApi class declaration.
    00535 //
    00536 // Subclasses of RtApi contain all API- and OS-specific code necessary
    00537 // to fully implement the RtAudio API.
    00538 //
    00539 // Note that RtApi is an abstract base class and cannot be
    00540 // explicitly instantiated.  The class RtAudio will create an
    00541 // instance of an RtApi subclass (RtApiOss, RtApiAlsa,
    00542 // RtApiJack, RtApiCore, RtApiAl, RtApiDs, or RtApiAsio).
    00543 //
    00544 // **************************************************************** //
    00545
    00546 #if defined( HAVE_GETTIMEOFDAY )
    00547   #include <sys/time.h>
    00548 #endif
    00549
    00550 #include <sstream>
    00551
    00552 class RtApi
    00553 {
    00554 public:
    00555
    00556   RtApi();
    00557   virtual ~RtApi();
    00558   virtual RtAudio::Api getCurrentApi( void ) = 0;
    00559   virtual unsigned int getDeviceCount( void ) = 0;
    00560   virtual RtAudio::DeviceInfo getDeviceInfo( unsigned int device ) = 0;
    00561   virtual unsigned int getDefaultInputDevice( void );
    00562   virtual unsigned int getDefaultOutputDevice( void );
    00563   void openStream( RtAudio::StreamParameters *outputParameters,
    00564                    RtAudio::StreamParameters *inputParameters,
    00565                    RtAudioFormat format, unsigned int sampleRate,
    00566                    unsigned int *bufferFrames, RtAudioCallback callback,
    00567                    void *userData, RtAudio::StreamOptions *options );
    00568   virtual void closeStream( void );
    00569   virtual void startStream( void ) = 0;
    00570   virtual void stopStream( void ) = 0;
    00571   virtual void abortStream( void ) = 0;
    00572   long getStreamLatency( void );
    00573   unsigned int getStreamSampleRate( void );
    00574   virtual double getStreamTime( void );
    00575   bool isStreamOpen( void ) const { return stream_.state != STREAM_CLOSED; };
    00576   bool isStreamRunning( void ) const { return stream_.state == STREAM_RUNNING; };
    00577   void showWarnings( bool value ) { showWarnings_ = value; };
    00578
    00579
    00580 protected:
    00581
    00582   static const unsigned int MAX_SAMPLE_RATES;
    00583   static const unsigned int SAMPLE_RATES[];
    00584
    00585   enum { FAILURE, SUCCESS };
    00586
    00587   enum StreamState {
    00588     STREAM_STOPPED,
    00589     STREAM_RUNNING,
    00590     STREAM_CLOSED = -50
    00591   };
    00592
    00593   enum StreamMode {
    00594     OUTPUT,
    00595     INPUT,
    00596     DUPLEX,
    00597     UNINITIALIZED = -75
    00598   };
    00599
    00600   // A protected structure used for buffer conversion.
    00601   struct ConvertInfo {
    00602     int channels;
    00603     int inJump, outJump;
    00604     RtAudioFormat inFormat, outFormat;
    00605     std::vector<int> inOffset;
    00606     std::vector<int> outOffset;
    00607   };
    00608
    00609   // A protected structure for audio streams.
    00610   struct RtApiStream {
    00611     unsigned int device[2];    // Playback and record, respectively.
    00612     void *apiHandle;           // void pointer for API specific stream handle information
    00613     StreamMode mode;           // OUTPUT, INPUT, or DUPLEX.
    00614     StreamState state;         // STOPPED, RUNNING, or CLOSED
    00615     char *userBuffer[2];       // Playback and record, respectively.
    00616     char *deviceBuffer;
    00617     bool doConvertBuffer[2];   // Playback and record, respectively.
    00618     bool userInterleaved;
    00619     bool deviceInterleaved[2]; // Playback and record, respectively.
    00620     bool doByteSwap[2];        // Playback and record, respectively.
    00621     unsigned int sampleRate;
    00622     unsigned int bufferSize;
    00623     unsigned int nBuffers;
    00624     unsigned int nUserChannels[2];    // Playback and record, respectively.
    00625     unsigned int nDeviceChannels[2];  // Playback and record channels, respectively.
    00626     unsigned int channelOffset[2];    // Playback and record, respectively.
    00627     unsigned long latency[2];         // Playback and record, respectively.
    00628     RtAudioFormat userFormat;
    00629     RtAudioFormat deviceFormat[2];    // Playback and record, respectively.
    00630     StreamMutex mutex;
    00631     CallbackInfo callbackInfo;
    00632     ConvertInfo convertInfo[2];
    00633     double streamTime;         // Number of elapsed seconds since the stream started.
    00634
    00635 #if defined(HAVE_GETTIMEOFDAY)
    00636     struct timeval lastTickTimestamp;
    00637 #endif
    00638
    00639     RtApiStream()
    00640       :apiHandle(0), deviceBuffer(0) { device[0] = 11111; device[1] = 11111; }
    00641   };
    00642
    00643   typedef signed short Int16;
    00644   typedef signed int Int32;
    00645   typedef float Float32;
    00646   typedef double Float64;
    00647
    00648   std::ostringstream errorStream_;
    00649   std::string errorText_;
    00650   bool showWarnings_;
    00651   RtApiStream stream_;
    00652
    00660   virtual bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
    00661                                 unsigned int firstChannel, unsigned int sampleRate,
    00662                                 RtAudioFormat format, unsigned int *bufferSize,
    00663                                 RtAudio::StreamOptions *options );
    00664
    00666   void tickStreamTime( void );
    00667
    00669   void clearStreamInfo();
    00670
    00675   void verifyStream( void );
    00676
    00678   void error( RtError::Type type );
    00679
    00684   void convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info );
    00685
    00687   void byteSwapBuffer( char *buffer, unsigned int samples, RtAudioFormat format );
    00688
    00690   unsigned int formatBytes( RtAudioFormat format );
    00691
    00693   void setConvertInfo( StreamMode mode, unsigned int firstChannel );
    00694 };
    00695
    00696 // **************************************************************** //
    00697 //
    00698 // Inline RtAudio definitions.
    00699 //
    00700 // **************************************************************** //
    00701
    00702 inline RtAudio::Api RtAudio :: getCurrentApi( void ) throw() { return rtapi_->getCurrentApi(); }
    00703 inline unsigned int RtAudio :: getDeviceCount( void ) throw() { return rtapi_->getDeviceCount(); }
    00704 inline RtAudio::DeviceInfo RtAudio :: getDeviceInfo( unsigned int device ) { return rtapi_->getDeviceInfo( device ); }
    00705 inline unsigned int RtAudio :: getDefaultInputDevice( void ) throw() { return rtapi_->getDefaultInputDevice(); }
    00706 inline unsigned int RtAudio :: getDefaultOutputDevice( void ) throw() { return rtapi_->getDefaultOutputDevice(); }
    00707 inline void RtAudio :: closeStream( void ) throw() { return rtapi_->closeStream(); }
    00708 inline void RtAudio :: startStream( void ) { return rtapi_->startStream(); }
    00709 inline void RtAudio :: stopStream( void )  { return rtapi_->stopStream(); }
    00710 inline void RtAudio :: abortStream( void ) { return rtapi_->abortStream(); }
    00711 inline bool RtAudio :: isStreamOpen( void ) const throw() { return rtapi_->isStreamOpen(); }
    00712 inline bool RtAudio :: isStreamRunning( void ) const throw() { return rtapi_->isStreamRunning(); }
    00713 inline long RtAudio :: getStreamLatency( void ) { return rtapi_->getStreamLatency(); }
    00714 inline unsigned int RtAudio :: getStreamSampleRate( void ) { return rtapi_->getStreamSampleRate(); };
    00715 inline double RtAudio :: getStreamTime( void ) { return rtapi_->getStreamTime(); }
    00716 inline void RtAudio :: showWarnings( bool value ) throw() { rtapi_->showWarnings( value ); }
    00717
    00718 // RtApi Subclass prototypes.
    00719
    00720 #if defined(__MACOSX_CORE__)
    00721
    00722 #include <CoreAudio/AudioHardware.h>
    00723
    00724 class RtApiCore: public RtApi
    00725 {
    00726 public:
    00727
    00728   RtApiCore();
    00729   ~RtApiCore();
    00730   RtAudio::Api getCurrentApi( void ) { return RtAudio::MACOSX_CORE; };
    00731   unsigned int getDeviceCount( void );
    00732   RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
    00733   unsigned int getDefaultOutputDevice( void );
    00734   unsigned int getDefaultInputDevice( void );
    00735   void closeStream( void );
    00736   void startStream( void );
    00737   void stopStream( void );
    00738   void abortStream( void );
    00739   long getStreamLatency( void );
    00740
    00741   // This function is intended for internal use only.  It must be
    00742   // public because it is called by the internal callback handler,
    00743   // which is not a member of RtAudio.  External use of this function
    00744   // will most likely produce highly undesireable results!
    00745   bool callbackEvent( AudioDeviceID deviceId,
    00746                       const AudioBufferList *inBufferList,
    00747                       const AudioBufferList *outBufferList );
    00748
    00749   private:
    00750
    00751   bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
    00752                         unsigned int firstChannel, unsigned int sampleRate,
    00753                         RtAudioFormat format, unsigned int *bufferSize,
    00754                         RtAudio::StreamOptions *options );
    00755   static const char* getErrorCode( OSStatus code );
    00756 };
    00757
    00758 #endif
    00759
    00760 #if defined(__UNIX_JACK__)
    00761
    00762 class RtApiJack: public RtApi
    00763 {
    00764 public:
    00765
    00766   RtApiJack();
    00767   ~RtApiJack();
    00768   RtAudio::Api getCurrentApi( void ) { return RtAudio::UNIX_JACK; };
    00769   unsigned int getDeviceCount( void );
    00770   RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
    00771   void closeStream( void );
    00772   void startStream( void );
    00773   void stopStream( void );
    00774   void abortStream( void );
    00775   long getStreamLatency( void );
    00776
    00777   // This function is intended for internal use only.  It must be
    00778   // public because it is called by the internal callback handler,
    00779   // which is not a member of RtAudio.  External use of this function
    00780   // will most likely produce highly undesireable results!
    00781   bool callbackEvent( unsigned long nframes );
    00782
    00783   private:
    00784
    00785   bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
    00786                         unsigned int firstChannel, unsigned int sampleRate,
    00787                         RtAudioFormat format, unsigned int *bufferSize,
    00788                         RtAudio::StreamOptions *options );
    00789 };
    00790
    00791 #endif
    00792
    00793 #if defined(__WINDOWS_ASIO__)
    00794
    00795 class RtApiAsio: public RtApi
    00796 {
    00797 public:
    00798
    00799   RtApiAsio();
    00800   ~RtApiAsio();
    00801   RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_ASIO; };
    00802   unsigned int getDeviceCount( void );
    00803   RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
    00804   void closeStream( void );
    00805   void startStream( void );
    00806   void stopStream( void );
    00807   void abortStream( void );
    00808   long getStreamLatency( void );
    00809
    00810   // This function is intended for internal use only.  It must be
    00811   // public because it is called by the internal callback handler,
    00812   // which is not a member of RtAudio.  External use of this function
    00813   // will most likely produce highly undesireable results!
    00814   bool callbackEvent( long bufferIndex );
    00815
    00816   private:
    00817
    00818   std::vector<RtAudio::DeviceInfo> devices_;
    00819   void saveDeviceInfo( void );
    00820   bool coInitialized_;
    00821   bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
    00822                         unsigned int firstChannel, unsigned int sampleRate,
    00823                         RtAudioFormat format, unsigned int *bufferSize,
    00824                         RtAudio::StreamOptions *options );
    00825 };
    00826
    00827 #endif
    00828
    00829 #if defined(__WINDOWS_DS__)
    00830
    00831 class RtApiDs: public RtApi
    00832 {
    00833 public:
    00834
    00835   RtApiDs();
    00836   ~RtApiDs();
    00837   RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_DS; };
    00838   unsigned int getDeviceCount( void );
    00839   unsigned int getDefaultOutputDevice( void );
    00840   unsigned int getDefaultInputDevice( void );
    00841   RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
    00842   void closeStream( void );
    00843   void startStream( void );
    00844   void stopStream( void );
    00845   void abortStream( void );
    00846   long getStreamLatency( void );
    00847
    00848   // This function is intended for internal use only.  It must be
    00849   // public because it is called by the internal callback handler,
    00850   // which is not a member of RtAudio.  External use of this function
    00851   // will most likely produce highly undesireable results!
    00852   void callbackEvent( void );
    00853
    00854   private:
    00855
    00856   bool coInitialized_;
    00857   bool buffersRolling;
    00858   long duplexPrerollBytes;
    00859   bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
    00860                         unsigned int firstChannel, unsigned int sampleRate,
    00861                         RtAudioFormat format, unsigned int *bufferSize,
    00862                         RtAudio::StreamOptions *options );
    00863 };
    00864
    00865 #endif
    00866
    00867 #if defined(__LINUX_ALSA__)
    00868
    00869 class RtApiAlsa: public RtApi
    00870 {
    00871 public:
    00872
    00873   RtApiAlsa();
    00874   ~RtApiAlsa();
    00875   RtAudio::Api getCurrentApi() { return RtAudio::LINUX_ALSA; };
    00876   unsigned int getDeviceCount( void );
    00877   RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
    00878   void closeStream( void );
    00879   void startStream( void );
    00880   void stopStream( void );
    00881   void abortStream( void );
    00882
    00883   // This function is intended for internal use only.  It must be
    00884   // public because it is called by the internal callback handler,
    00885   // which is not a member of RtAudio.  External use of this function
    00886   // will most likely produce highly undesireable results!
    00887   void callbackEvent( void );
    00888
    00889   private:
    00890
    00891   std::vector<RtAudio::DeviceInfo> devices_;
    00892   void saveDeviceInfo( void );
    00893   bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
    00894                         unsigned int firstChannel, unsigned int sampleRate,
    00895                         RtAudioFormat format, unsigned int *bufferSize,
    00896                         RtAudio::StreamOptions *options );
    00897 };
    00898
    00899 #endif
    00900
    00901 #if defined(__LINUX_OSS__)
    00902
    00903 class RtApiOss: public RtApi
    00904 {
    00905 public:
    00906
    00907   RtApiOss();
    00908   ~RtApiOss();
    00909   RtAudio::Api getCurrentApi() { return RtAudio::LINUX_OSS; };
    00910   unsigned int getDeviceCount( void );
    00911   RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
    00912   void closeStream( void );
    00913   void startStream( void );
    00914   void stopStream( void );
    00915   void abortStream( void );
    00916
    00917   // This function is intended for internal use only.  It must be
    00918   // public because it is called by the internal callback handler,
    00919   // which is not a member of RtAudio.  External use of this function
    00920   // will most likely produce highly undesireable results!
    00921   void callbackEvent( void );
    00922
    00923   private:
    00924
    00925   bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
    00926                         unsigned int firstChannel, unsigned int sampleRate,
    00927                         RtAudioFormat format, unsigned int *bufferSize,
    00928                         RtAudio::StreamOptions *options );
    00929 };
    00930
    00931 #endif
    00932
    00933 #if defined(__RTAUDIO_DUMMY__)
    00934
    00935 class RtApiDummy: public RtApi
    00936 {
    00937 public:
    00938
    00939   RtApiDummy() { errorText_ = "RtApiDummy: This class provides no functionality."; error( RtError::WARNING ); };
    00940   RtAudio::Api getCurrentApi( void ) { return RtAudio::RTAUDIO_DUMMY; };
    00941   unsigned int getDeviceCount( void ) { return 0; };
    00942   RtAudio::DeviceInfo getDeviceInfo( unsigned int device ) { RtAudio::DeviceInfo info; return info; };
    00943   void closeStream( void ) {};
    00944   void startStream( void ) {};
    00945   void stopStream( void ) {};
    00946   void abortStream( void ) {};
    00947
    00948   private:
    00949
    00950   bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
    00951                         unsigned int firstChannel, unsigned int sampleRate,
    00952                         RtAudioFormat format, unsigned int *bufferSize,
    00953                         RtAudio::StreamOptions *options ) { return false; };
    00954 };
    00955
    00956 #endif
    00957
    00958 #endif
    00959
    00960 // Indentation settings for Vim and Emacs
    00961 //
    00962 // Local Variables:
    00963 // c-basic-offset: 2
    00964 // indent-tabs-mode: nil
    00965 // End:
    00966 //
    00967 // vim: et sts=2 sw=2

| ©2001-2009 Gary P. Scavone, McGill University. All Rights Reserved. Maintained by Gary P. Scavone.