Home   Information   Classes   Download   Usage   Mail List   Requirements   Links   FAQ   Tutorial


RtAudio.h

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

The Synthesis ToolKit in C++ (STK)
©1995-2012 Perry R. Cook and Gary P. Scavone. All Rights Reserved.