The Synthesis ToolKit in C++ (STK)

Home Information Classes Download Usage Mail List Requirements Links FAQ Tutorial

RtAudio.h
Go to the documentation of this file.
1 /************************************************************************/
39 /************************************************************************/
40
45 #ifndef __RTAUDIO_H
46 #define __RTAUDIO_H
47
48 #define RTAUDIO_VERSION "5.0.0"
49
50 #include <string>
51 #include <vector>
52 #include <stdexcept>
53 #include <iostream>
54
71 typedef unsigned long RtAudioFormat;
72 static const RtAudioFormat RTAUDIO_SINT8 = 0x1; // 8-bit signed integer.
73 static const RtAudioFormat RTAUDIO_SINT16 = 0x2; // 16-bit signed integer.
74 static const RtAudioFormat RTAUDIO_SINT24 = 0x4; // 24-bit signed integer.
75 static const RtAudioFormat RTAUDIO_SINT32 = 0x8; // 32-bit signed integer.
76 static const RtAudioFormat RTAUDIO_FLOAT32 = 0x10; // Normalized between plus/minus 1.0.
77 static const RtAudioFormat RTAUDIO_FLOAT64 = 0x20; // Normalized between plus/minus 1.0.
78
125 typedef unsigned int RtAudioStreamFlags;
126 static const RtAudioStreamFlags RTAUDIO_NONINTERLEAVED = 0x1; // Use non-interleaved buffers (default = interleaved).
127 static const RtAudioStreamFlags RTAUDIO_MINIMIZE_LATENCY = 0x2; // Attempt to set stream parameters for lowest possible latency.
128 static const RtAudioStreamFlags RTAUDIO_HOG_DEVICE = 0x4; // Attempt grab device and prevent use by others.
129 static const RtAudioStreamFlags RTAUDIO_SCHEDULE_REALTIME = 0x8; // Try to select realtime scheduling for callback thread.
130 static const RtAudioStreamFlags RTAUDIO_ALSA_USE_DEFAULT = 0x10; // Use the "default" PCM device (ALSA only).
131 static const RtAudioStreamFlags RTAUDIO_JACK_DONT_CONNECT = 0x20; // Do not automatically connect ports (JACK only).
132
144 typedef unsigned int RtAudioStreamStatus;
145 static const RtAudioStreamStatus RTAUDIO_INPUT_OVERFLOW = 0x1; // Input data was discarded because of an overflow condition at the driver.
146 static const RtAudioStreamStatus RTAUDIO_OUTPUT_UNDERFLOW = 0x2; // The output buffer ran low, likely causing a gap in the output sound.
147
149
187 typedef int (*RtAudioCallback)( void *outputBuffer, void *inputBuffer,
188 unsigned int nFrames,
189 double streamTime,
190 RtAudioStreamStatus status,
191 void *userData );
192
193 /************************************************************************/
201 /************************************************************************/
202
203 class RtAudioError : public std::runtime_error
204 {
205 public:
207 enum Type {
208 WARNING,
209 DEBUG_WARNING,
210 UNSPECIFIED,
211 NO_DEVICES_FOUND,
212 INVALID_DEVICE,
213 MEMORY_ERROR,
214 INVALID_PARAMETER,
215 INVALID_USE,
216 DRIVER_ERROR,
217 SYSTEM_ERROR,
218 THREAD_ERROR
219 };
220
222 RtAudioError( const std::string& message,
223 Type type = RtAudioError::UNSPECIFIED )
224 : std::runtime_error(message), type_(type) {}
225
227 virtual void printMessage( void ) const
228 { std::cerr << '\n' << what() << "\n\n"; }
229
231 virtual const Type& getType(void) const { return type_; }
232
234 virtual const std::string getMessage(void) const
235 { return std::string(what()); }
236
237 protected:
238 Type type_;
239 };
240
242
246 typedef void (*RtAudioErrorCallback)( RtAudioError::Type type, const std::string &errorText );
247
248 // **************************************************************** //
249 //
250 // RtAudio class declaration.
251 //
252 // RtAudio is a "controller" used to select an available audio i/o
253 // interface. It presents a common API for the user to call but all
254 // functionality is implemented by the class RtApi and its
255 // subclasses. RtAudio creates an instance of an RtApi subclass
256 // based on the user's API choice. If no choice is made, RtAudio
257 // attempts to make a "logical" API selection.
258 //
259 // **************************************************************** //
260
261 class RtApi;
262
263 class RtAudio
264 {
265 public:
266
268 enum Api {
269 UNSPECIFIED,
270 LINUX_ALSA,
271 LINUX_PULSE,
272 LINUX_OSS,
273 UNIX_JACK,
274 MACOSX_CORE,
275 WINDOWS_WASAPI,
276 WINDOWS_ASIO,
277 WINDOWS_DS,
278 RTAUDIO_DUMMY
279 };
280
282 struct DeviceInfo {
283 bool probed;
284 std::string name;
285 unsigned int outputChannels;
286 unsigned int inputChannels;
287 unsigned int duplexChannels;
288 bool isDefaultOutput;
289 bool isDefaultInput;
290 std::vector<unsigned int> sampleRates;
291 unsigned int preferredSampleRate;
292 RtAudioFormat nativeFormats;
294 // Default constructor.
295 DeviceInfo()
296 :probed(false), outputChannels(0), inputChannels(0), duplexChannels(0),
297 isDefaultOutput(false), isDefaultInput(false), preferredSampleRate(0), nativeFormats(0) {}
298 };
299
301 struct StreamParameters {
302 unsigned int deviceId;
303 unsigned int nChannels;
304 unsigned int firstChannel;
306 // Default constructor.
307 StreamParameters()
308 : deviceId(0), nChannels(0), firstChannel(0) {}
309 };
310
312
368 struct StreamOptions {
369 RtAudioStreamFlags flags;
370 unsigned int numberOfBuffers;
371 std::string streamName;
372 int priority;
374 // Default constructor.
375 StreamOptions()
376 : flags(0), numberOfBuffers(0), priority(0) {}
377 };
378
380 static std::string getVersion( void );
381
383
388 static void getCompiledApi( std::vector<RtAudio::Api> &apis );
389
391
399 RtAudio( RtAudio::Api api=UNSPECIFIED );
400
402
406 ~RtAudio();
407
409 RtAudio::Api getCurrentApi( void );
410
412
417 unsigned int getDeviceCount( void );
418
420
430 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
431
433
440 unsigned int getDefaultOutputDevice( void );
441
443
450 unsigned int getDefaultInputDevice( void );
451
453
492 void openStream( RtAudio::StreamParameters *outputParameters,
493 RtAudio::StreamParameters *inputParameters,
494 RtAudioFormat format, unsigned int sampleRate,
495 unsigned int *bufferFrames, RtAudioCallback callback,
496 void *userData = NULL, RtAudio::StreamOptions *options = NULL, RtAudioErrorCallback errorCallback = NULL );
497
499
503 void closeStream( void );
504
506
512 void startStream( void );
513
515
521 void stopStream( void );
522
524
530 void abortStream( void );
531
533 bool isStreamOpen( void ) const;
534
536 bool isStreamRunning( void ) const;
537
539
542 double getStreamTime( void );
543
545
548 void setStreamTime( double time );
549
551
559 long getStreamLatency( void );
560
562
567 unsigned int getStreamSampleRate( void );
568
570 void showWarnings( bool value = true );
571
572 protected:
573
574 void openRtApi( RtAudio::Api api );
575 RtApi *rtapi_;
576 };
577
578 // Operating system dependent thread functionality.
579 #if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_WASAPI__)
580
581 #ifndef NOMINMAX
582 #define NOMINMAX
583 #endif
584 #include <windows.h>
585 #include <process.h>
586
587 typedef uintptr_t ThreadHandle;
588 typedef CRITICAL_SECTION StreamMutex;
589
590 #elif defined(__LINUX_ALSA__) || defined(__LINUX_PULSE__) || defined(__UNIX_JACK__) || defined(__LINUX_OSS__) || defined(__MACOSX_CORE__)
591 // Using pthread library for various flavors of unix.
592 #include <pthread.h>
593
594 typedef pthread_t ThreadHandle;
595 typedef pthread_mutex_t StreamMutex;
596
597 #else // Setup for "dummy" behavior
598
599 #define __RTAUDIO_DUMMY__
600 typedef int ThreadHandle;
601 typedef int StreamMutex;
602
603 #endif
604
605 // This global structure type is used to pass callback information
606 // between the private RtAudio stream structure and global callback
607 // handling functions.
608 struct CallbackInfo {
609 void *object; // Used as a "this" pointer.
610 ThreadHandle thread;
611 void *callback;
612 void *userData;
613 void *errorCallback;
614 void *apiInfo; // void pointer for API specific callback information
615 bool isRunning;
616 bool doRealtime;
617 int priority;
618
619 // Default constructor.
620 CallbackInfo()
621 :object(0), callback(0), userData(0), errorCallback(0), apiInfo(0), isRunning(false), doRealtime(false), priority(0) {}
622 };
623
624 // **************************************************************** //
625 //
626 // RtApi class declaration.
627 //
628 // Subclasses of RtApi contain all API- and OS-specific code necessary
629 // to fully implement the RtAudio API.
630 //
631 // Note that RtApi is an abstract base class and cannot be
632 // explicitly instantiated. The class RtAudio will create an
633 // instance of an RtApi subclass (RtApiOss, RtApiAlsa,
634 // RtApiJack, RtApiCore, RtApiDs, or RtApiAsio).
635 //
636 // **************************************************************** //
637
638 #pragma pack(push, 1)
639 class S24 {
640
641 protected:
642 unsigned char c3[3];
643
644 public:
645 S24() {}
646
647 S24& operator = ( const int& i ) {
648 c3[0] = (i & 0x000000ff);
649 c3[1] = (i & 0x0000ff00) >> 8;
650 c3[2] = (i & 0x00ff0000) >> 16;
651 return *this;
652 }
653
654 S24( const S24& v ) { *this = v; }
655 S24( const double& d ) { *this = (int) d; }
656 S24( const float& f ) { *this = (int) f; }
657 S24( const signed short& s ) { *this = (int) s; }
658 S24( const char& c ) { *this = (int) c; }
659
660 int asInt() {
661 int i = c3[0] | (c3[1] << 8) | (c3[2] << 16);
662 if (i & 0x800000) i |= ~0xffffff;
663 return i;
664 }
665 };
666 #pragma pack(pop)
667
668 #if defined( HAVE_GETTIMEOFDAY )
669 #include <sys/time.h>
670 #endif
671
672 #include <sstream>
673
674 class RtApi
675 {
676 public:
677
678 RtApi();
679 virtual ~RtApi();
680 virtual RtAudio::Api getCurrentApi( void ) = 0;
681 virtual unsigned int getDeviceCount( void ) = 0;
682 virtual RtAudio::DeviceInfo getDeviceInfo( unsigned int device ) = 0;
683 virtual unsigned int getDefaultInputDevice( void );
684 virtual unsigned int getDefaultOutputDevice( void );
685 void openStream( RtAudio::StreamParameters *outputParameters,
686 RtAudio::StreamParameters *inputParameters,
687 RtAudioFormat format, unsigned int sampleRate,
688 unsigned int *bufferFrames, RtAudioCallback callback,
689 void *userData, RtAudio::StreamOptions *options,
690 RtAudioErrorCallback errorCallback );
691 virtual void closeStream( void );
692 virtual void startStream( void ) = 0;
693 virtual void stopStream( void ) = 0;
694 virtual void abortStream( void ) = 0;
695 long getStreamLatency( void );
696 unsigned int getStreamSampleRate( void );
697 virtual double getStreamTime( void );
698 virtual void setStreamTime( double time );
699 bool isStreamOpen( void ) const { return stream_.state != STREAM_CLOSED; }
700 bool isStreamRunning( void ) const { return stream_.state == STREAM_RUNNING; }
701 void showWarnings( bool value ) { showWarnings_ = value; }
702
703
704 protected:
705
706 static const unsigned int MAX_SAMPLE_RATES;
707 static const unsigned int SAMPLE_RATES[];
708
709 enum { FAILURE, SUCCESS };
710
711 enum StreamState {
712 STREAM_STOPPED,
713 STREAM_STOPPING,
714 STREAM_RUNNING,
715 STREAM_CLOSED = -50
716 };
717
718 enum StreamMode {
719 OUTPUT,
720 INPUT,
721 DUPLEX,
722 UNINITIALIZED = -75
723 };
724
725 // A protected structure used for buffer conversion.
726 struct ConvertInfo {
727 int channels;
728 int inJump, outJump;
729 RtAudioFormat inFormat, outFormat;
730 std::vector<int> inOffset;
731 std::vector<int> outOffset;
732 };
733
734 // A protected structure for audio streams.
735 struct RtApiStream {
736 unsigned int device[2]; // Playback and record, respectively.
737 void *apiHandle; // void pointer for API specific stream handle information
738 StreamMode mode; // OUTPUT, INPUT, or DUPLEX.
739 StreamState state; // STOPPED, RUNNING, or CLOSED
740 char *userBuffer[2]; // Playback and record, respectively.
741 char *deviceBuffer;
742 bool doConvertBuffer[2]; // Playback and record, respectively.
743 bool userInterleaved;
744 bool deviceInterleaved[2]; // Playback and record, respectively.
745 bool doByteSwap[2]; // Playback and record, respectively.
746 unsigned int sampleRate;
747 unsigned int bufferSize;
748 unsigned int nBuffers;
749 unsigned int nUserChannels[2]; // Playback and record, respectively.
750 unsigned int nDeviceChannels[2]; // Playback and record channels, respectively.
751 unsigned int channelOffset[2]; // Playback and record, respectively.
752 unsigned long latency[2]; // Playback and record, respectively.
753 RtAudioFormat userFormat;
754 RtAudioFormat deviceFormat[2]; // Playback and record, respectively.
755 StreamMutex mutex;
756 CallbackInfo callbackInfo;
757 ConvertInfo convertInfo[2];
758 double streamTime; // Number of elapsed seconds since the stream started.
759
760 #if defined(HAVE_GETTIMEOFDAY)
761 struct timeval lastTickTimestamp;
762 #endif
763
764 RtApiStream()
765 :apiHandle(0), deviceBuffer(0) { device[0] = 11111; device[1] = 11111; }
766 };
767
768 typedef S24 Int24;
769 typedef signed short Int16;
770 typedef signed int Int32;
771 typedef float Float32;
772 typedef double Float64;
773
774 std::ostringstream errorStream_;
775 std::string errorText_;
776 bool showWarnings_;
777 RtApiStream stream_;
778 bool firstErrorOccurred_;
779
787 virtual bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
788 unsigned int firstChannel, unsigned int sampleRate,
789 RtAudioFormat format, unsigned int *bufferSize,
790 RtAudio::StreamOptions *options );
791
793 void tickStreamTime( void );
794
796 void clearStreamInfo();
797
802 void verifyStream( void );
803
805 void error( RtAudioError::Type type );
806
811 void convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info );
812
814 void byteSwapBuffer( char *buffer, unsigned int samples, RtAudioFormat format );
815
817 unsigned int formatBytes( RtAudioFormat format );
818
820 void setConvertInfo( StreamMode mode, unsigned int firstChannel );
821 };
822
823 // **************************************************************** //
824 //
825 // Inline RtAudio definitions.
826 //
827 // **************************************************************** //
828
829 inline RtAudio::Api RtAudio :: getCurrentApi( void ) { return rtapi_->getCurrentApi(); }
830 inline unsigned int RtAudio :: getDeviceCount( void ) { return rtapi_->getDeviceCount(); }
831 inline RtAudio::DeviceInfo RtAudio :: getDeviceInfo( unsigned int device ) { return rtapi_->getDeviceInfo( device ); }
832 inline unsigned int RtAudio :: getDefaultInputDevice( void ) { return rtapi_->getDefaultInputDevice(); }
833 inline unsigned int RtAudio :: getDefaultOutputDevice( void ) { return rtapi_->getDefaultOutputDevice(); }
834 inline void RtAudio :: closeStream( void ) { return rtapi_->closeStream(); }
835 inline void RtAudio :: startStream( void ) { return rtapi_->startStream(); }
836 inline void RtAudio :: stopStream( void ) { return rtapi_->stopStream(); }
837 inline void RtAudio :: abortStream( void ) { return rtapi_->abortStream(); }
838 inline bool RtAudio :: isStreamOpen( void ) const { return rtapi_->isStreamOpen(); }
839 inline bool RtAudio :: isStreamRunning( void ) const { return rtapi_->isStreamRunning(); }
840 inline long RtAudio :: getStreamLatency( void ) { return rtapi_->getStreamLatency(); }
841 inline unsigned int RtAudio :: getStreamSampleRate( void ) { return rtapi_->getStreamSampleRate(); }
842 inline double RtAudio :: getStreamTime( void ) { return rtapi_->getStreamTime(); }
843 inline void RtAudio :: setStreamTime( double time ) { return rtapi_->setStreamTime( time ); }
844 inline void RtAudio :: showWarnings( bool value ) { rtapi_->showWarnings( value ); }
845
846 // RtApi Subclass prototypes.
847
848 #if defined(__MACOSX_CORE__)
849
850 #include <CoreAudio/AudioHardware.h>
851
852 class RtApiCore: public RtApi
853 {
854 public:
855
856 RtApiCore();
857 ~RtApiCore();
858 RtAudio::Api getCurrentApi( void ) { return RtAudio::MACOSX_CORE; }
859 unsigned int getDeviceCount( void );
860 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
861 unsigned int getDefaultOutputDevice( void );
862 unsigned int getDefaultInputDevice( void );
863 void closeStream( void );
864 void startStream( void );
865 void stopStream( void );
866 void abortStream( void );
867 long getStreamLatency( void );
868
869 // This function is intended for internal use only. It must be
870 // public because it is called by the internal callback handler,
871 // which is not a member of RtAudio. External use of this function
872 // will most likely produce highly undesireable results!
873 bool callbackEvent( AudioDeviceID deviceId,
874 const AudioBufferList *inBufferList,
875 const AudioBufferList *outBufferList );
876
877 private:
878
879 bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
880 unsigned int firstChannel, unsigned int sampleRate,
881 RtAudioFormat format, unsigned int *bufferSize,
882 RtAudio::StreamOptions *options );
883 static const char* getErrorCode( OSStatus code );
884 };
885
886 #endif
887
888 #if defined(__UNIX_JACK__)
889
890 class RtApiJack: public RtApi
891 {
892 public:
893
894 RtApiJack();
895 ~RtApiJack();
896 RtAudio::Api getCurrentApi( void ) { return RtAudio::UNIX_JACK; }
897 unsigned int getDeviceCount( void );
898 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
899 void closeStream( void );
900 void startStream( void );
901 void stopStream( void );
902 void abortStream( void );
903 long getStreamLatency( void );
904
905 // This function is intended for internal use only. It must be
906 // public because it is called by the internal callback handler,
907 // which is not a member of RtAudio. External use of this function
908 // will most likely produce highly undesireable results!
909 bool callbackEvent( unsigned long nframes );
910
911 private:
912
913 bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
914 unsigned int firstChannel, unsigned int sampleRate,
915 RtAudioFormat format, unsigned int *bufferSize,
916 RtAudio::StreamOptions *options );
917
918 bool shouldAutoconnect_;
919 };
920
921 #endif
922
923 #if defined(__WINDOWS_ASIO__)
924
925 class RtApiAsio: public RtApi
926 {
927 public:
928
929 RtApiAsio();
930 ~RtApiAsio();
931 RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_ASIO; }
932 unsigned int getDeviceCount( void );
933 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
934 void closeStream( void );
935 void startStream( void );
936 void stopStream( void );
937 void abortStream( void );
938 long getStreamLatency( void );
939
940 // This function is intended for internal use only. It must be
941 // public because it is called by the internal callback handler,
942 // which is not a member of RtAudio. External use of this function
943 // will most likely produce highly undesireable results!
944 bool callbackEvent( long bufferIndex );
945
946 private:
947
948 std::vector<RtAudio::DeviceInfo> devices_;
949 void saveDeviceInfo( void );
950 bool coInitialized_;
951 bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
952 unsigned int firstChannel, unsigned int sampleRate,
953 RtAudioFormat format, unsigned int *bufferSize,
954 RtAudio::StreamOptions *options );
955 };
956
957 #endif
958
959 #if defined(__WINDOWS_DS__)
960
961 class RtApiDs: public RtApi
962 {
963 public:
964
965 RtApiDs();
966 ~RtApiDs();
967 RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_DS; }
968 unsigned int getDeviceCount( void );
969 unsigned int getDefaultOutputDevice( void );
970 unsigned int getDefaultInputDevice( void );
971 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
972 void closeStream( void );
973 void startStream( void );
974 void stopStream( void );
975 void abortStream( void );
976 long getStreamLatency( void );
977
978 // This function is intended for internal use only. It must be
979 // public because it is called by the internal callback handler,
980 // which is not a member of RtAudio. External use of this function
981 // will most likely produce highly undesireable results!
982 void callbackEvent( void );
983
984 private:
985
986 bool coInitialized_;
987 bool buffersRolling;
988 long duplexPrerollBytes;
989 std::vector<struct DsDevice> dsDevices;
990 bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
991 unsigned int firstChannel, unsigned int sampleRate,
992 RtAudioFormat format, unsigned int *bufferSize,
993 RtAudio::StreamOptions *options );
994 };
995
996 #endif
997
998 #if defined(__WINDOWS_WASAPI__)
999
1000 struct IMMDeviceEnumerator;
1001
1002 class RtApiWasapi : public RtApi
1003 {
1004 public:
1005 RtApiWasapi();
1006 ~RtApiWasapi();
1007
1008 RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_WASAPI; }
1009 unsigned int getDeviceCount( void );
1010 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
1011 unsigned int getDefaultOutputDevice( void );
1012 unsigned int getDefaultInputDevice( void );
1013 void closeStream( void );
1014 void startStream( void );
1015 void stopStream( void );
1016 void abortStream( void );
1017
1018 private:
1019 bool coInitialized_;
1020 IMMDeviceEnumerator* deviceEnumerator_;
1021
1022 bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
1023 unsigned int firstChannel, unsigned int sampleRate,
1024 RtAudioFormat format, unsigned int* bufferSize,
1025 RtAudio::StreamOptions* options );
1026
1027 static DWORD WINAPI runWasapiThread( void* wasapiPtr );
1028 static DWORD WINAPI stopWasapiThread( void* wasapiPtr );
1029 static DWORD WINAPI abortWasapiThread( void* wasapiPtr );
1030 void wasapiThread();
1031 };
1032
1033 #endif
1034
1035 #if defined(__LINUX_ALSA__)
1036
1037 class RtApiAlsa: public RtApi
1038 {
1039 public:
1040
1041 RtApiAlsa();
1042 ~RtApiAlsa();
1043 RtAudio::Api getCurrentApi() { return RtAudio::LINUX_ALSA; }
1044 unsigned int getDeviceCount( void );
1045 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
1046 void closeStream( void );
1047 void startStream( void );
1048 void stopStream( void );
1049 void abortStream( void );
1050
1051 // This function is intended for internal use only. It must be
1052 // public because it is called by the internal callback handler,
1053 // which is not a member of RtAudio. External use of this function
1054 // will most likely produce highly undesireable results!
1055 void callbackEvent( void );
1056
1057 private:
1058
1059 std::vector<RtAudio::DeviceInfo> devices_;
1060 void saveDeviceInfo( void );
1061 bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
1062 unsigned int firstChannel, unsigned int sampleRate,
1063 RtAudioFormat format, unsigned int *bufferSize,
1064 RtAudio::StreamOptions *options );
1065 };
1066
1067 #endif
1068
1069 #if defined(__LINUX_PULSE__)
1070
1071 class RtApiPulse: public RtApi
1072 {
1073 public:
1074 ~RtApiPulse();
1075 RtAudio::Api getCurrentApi() { return RtAudio::LINUX_PULSE; }
1076 unsigned int getDeviceCount( void );
1077 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
1078 void closeStream( void );
1079 void startStream( void );
1080 void stopStream( void );
1081 void abortStream( void );
1082
1083 // This function is intended for internal use only. It must be
1084 // public because it is called by the internal callback handler,
1085 // which is not a member of RtAudio. External use of this function
1086 // will most likely produce highly undesireable results!
1087 void callbackEvent( void );
1088
1089 private:
1090
1091 std::vector<RtAudio::DeviceInfo> devices_;
1092 void saveDeviceInfo( void );
1093 bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
1094 unsigned int firstChannel, unsigned int sampleRate,
1095 RtAudioFormat format, unsigned int *bufferSize,
1096 RtAudio::StreamOptions *options );
1097 };
1098
1099 #endif
1100
1101 #if defined(__LINUX_OSS__)
1102
1103 class RtApiOss: public RtApi
1104 {
1105 public:
1106
1107 RtApiOss();
1108 ~RtApiOss();
1109 RtAudio::Api getCurrentApi() { return RtAudio::LINUX_OSS; }
1110 unsigned int getDeviceCount( void );
1111 RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
1112 void closeStream( void );
1113 void startStream( void );
1114 void stopStream( void );
1115 void abortStream( void );
1116
1117 // This function is intended for internal use only. It must be
1118 // public because it is called by the internal callback handler,
1119 // which is not a member of RtAudio. External use of this function
1120 // will most likely produce highly undesireable results!
1121 void callbackEvent( void );
1122
1123 private:
1124
1125 bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
1126 unsigned int firstChannel, unsigned int sampleRate,
1127 RtAudioFormat format, unsigned int *bufferSize,
1128 RtAudio::StreamOptions *options );
1129 };
1130
1131 #endif
1132
1133 #if defined(__RTAUDIO_DUMMY__)
1134
1135 class RtApiDummy: public RtApi
1136 {
1137 public:
1138
1139 RtApiDummy() { errorText_ = "RtApiDummy: This class provides no functionality."; error( RtAudioError::WARNING ); }
1140 RtAudio::Api getCurrentApi( void ) { return RtAudio::RTAUDIO_DUMMY; }
1141 unsigned int getDeviceCount( void ) { return 0; }
1142 RtAudio::DeviceInfo getDeviceInfo( unsigned int /*device*/ ) { RtAudio::DeviceInfo info; return info; }
1143 void closeStream( void ) {}
1144 void startStream( void ) {}
1145 void stopStream( void ) {}
1146 void abortStream( void ) {}
1147
1148 private:
1149
1150 bool probeDeviceOpen( unsigned int /*device*/, StreamMode /*mode*/, unsigned int /*channels*/,
1151 unsigned int /*firstChannel*/, unsigned int /*sampleRate*/,
1152 RtAudioFormat /*format*/, unsigned int * /*bufferSize*/,
1153 RtAudio::StreamOptions * /*options*/ ) { return false; }
1154 };
1155
1156 #endif
1157
1158 #endif
1159
1160 // Indentation settings for Vim and Emacs
1161 //
1162 // Local Variables:
1163 // c-basic-offset: 2
1164 // indent-tabs-mode: nil
1165 // End:
1166 //
1167 // vim: et sts=2 sw=2

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