---

RtAudio.h

/******************************************/
/*
  RtAudio - realtime sound I/O C++ class
  by Gary P. Scavone, 2001-2002.
*/
/******************************************/

#if !defined(__RTAUDIO_H)
#define __RTAUDIO_H

#include <map>

#if defined(__LINUX_ALSA__)
  #include <alsa/asoundlib.h>
  #include <pthread.h>
  #include <unistd.h>

  #define THREAD_TYPE
  typedef snd_pcm_t *AUDIO_HANDLE;
  typedef int DEVICE_ID;
  typedef pthread_t THREAD_HANDLE;
  typedef pthread_mutex_t MUTEX;

#elif defined(__LINUX_OSS__)
  #include <pthread.h>
  #include <unistd.h>

  #define THREAD_TYPE
  typedef int AUDIO_HANDLE;
  typedef int DEVICE_ID;
  typedef pthread_t THREAD_HANDLE;
  typedef pthread_mutex_t MUTEX;

#elif defined(__WINDOWS_DS__)
  #include <windows.h>
  #include <process.h>

  // The following struct is used to hold the extra variables
  // specific to the DirectSound implementation.
  typedef struct {
    void * object;
    void * buffer;
    UINT bufferPointer;
  } AUDIO_HANDLE;

  #define THREAD_TYPE __stdcall
  typedef LPGUID DEVICE_ID;
  typedef unsigned long THREAD_HANDLE;
  typedef CRITICAL_SECTION MUTEX;

#elif defined(__IRIX_AL__)
  #include <dmedia/audio.h>
  #include <pthread.h>
  #include <unistd.h>

  #define THREAD_TYPE
  typedef ALport AUDIO_HANDLE;
  typedef int DEVICE_ID;
  typedef pthread_t THREAD_HANDLE;
  typedef pthread_mutex_t MUTEX;

#endif


// *************************************************** //
//
// RtError class declaration.
//
// *************************************************** //

class RtError
{
public:
  enum TYPE {
    WARNING,
    DEBUG_WARNING,
    UNSPECIFIED,
    NO_DEVICES_FOUND,
    INVALID_DEVICE,
    INVALID_STREAM,
    MEMORY_ERROR,
    INVALID_PARAMETER,
    DRIVER_ERROR,
    SYSTEM_ERROR,
    THREAD_ERROR
  };

protected:
  char error_message[256];
  TYPE type;

public:
  RtError(const char *p, TYPE tipe = RtError::UNSPECIFIED);

  virtual ~RtError(void);

  virtual void printMessage(void);

  virtual const TYPE& getType(void) { return type; }

  virtual const char *getMessage(void) { return error_message; }
};


// *************************************************** //
//
// RtAudio class declaration.
//
// *************************************************** //

class RtAudio
{
public:

  // Support for signed integers and floats.  Audio data fed to/from
  // the tickStream() routine is assumed to ALWAYS be in host
  // byte order.  The internal routines will automatically take care of
  // any necessary byte-swapping between the host format and the
  // soundcard.  Thus, endian-ness is not a concern in the following
  // format definitions.
  typedef unsigned long RTAUDIO_FORMAT;
  static const RTAUDIO_FORMAT RTAUDIO_SINT8;
  static const RTAUDIO_FORMAT RTAUDIO_SINT16;
  static const RTAUDIO_FORMAT RTAUDIO_SINT24; 
  static const RTAUDIO_FORMAT RTAUDIO_SINT32;
  static const RTAUDIO_FORMAT RTAUDIO_FLOAT32; 
  static const RTAUDIO_FORMAT RTAUDIO_FLOAT64; 

  //static const int MAX_SAMPLE_RATES = 14;
  enum { MAX_SAMPLE_RATES = 14 };

  typedef int (*RTAUDIO_CALLBACK)(char *buffer, int bufferSize, void *userData);

  typedef struct {
    char name[128];
    DEVICE_ID id[2];  
    bool probed;       
    int maxOutputChannels;
    int maxInputChannels;
    int maxDuplexChannels;
    int minOutputChannels;
    int minInputChannels;
    int minDuplexChannels;
    bool hasDuplexSupport; 
    int nSampleRates;      
    int sampleRates[MAX_SAMPLE_RATES]; 
    RTAUDIO_FORMAT nativeFormats;     
  } RTAUDIO_DEVICE;


  RtAudio();


  RtAudio(int *streamId,
          int outputDevice, int outputChannels,
          int inputDevice, int inputChannels,
          RTAUDIO_FORMAT format, int sampleRate,
          int *bufferSize, int numberOfBuffers);


  ~RtAudio();


  int openStream(int outputDevice, int outputChannels,
                 int inputDevice, int inputChannels,
                 RTAUDIO_FORMAT format, int sampleRate,
                 int *bufferSize, int numberOfBuffers);


  void setStreamCallback(int streamId, RTAUDIO_CALLBACK callback, void *userData);


  void cancelStreamCallback(int streamId);

  int getDeviceCount(void);


  void getDeviceInfo(int device, RTAUDIO_DEVICE *info);


  char * const getStreamBuffer(int streamId);


  void tickStream(int streamId);


  void closeStream(int streamId);


  void startStream(int streamId);


  void stopStream(int streamId);


  void abortStream(int streamId);


  int streamWillBlock(int streamId);

protected:

private:

  static const unsigned int SAMPLE_RATES[MAX_SAMPLE_RATES];

  enum { FAILURE, SUCCESS };

  enum STREAM_MODE {
    PLAYBACK,
    RECORD,
    DUPLEX,
    UNINITIALIZED = -75
  };

  enum STREAM_STATE {
    STREAM_STOPPED,
    STREAM_RUNNING
  };

  typedef struct {
    int device[2];          // Playback and record, respectively.
    STREAM_MODE mode;       // PLAYBACK, RECORD, or DUPLEX.
    AUDIO_HANDLE handle[2]; // Playback and record handles, respectively.
    STREAM_STATE state;     // STOPPED or RUNNING
    char *userBuffer;
    char *deviceBuffer;
    bool doConvertBuffer[2]; // Playback and record, respectively.
    bool deInterleave[2];    // Playback and record, respectively.
    bool doByteSwap[2];      // Playback and record, respectively.
    int sampleRate;
    int bufferSize;
    int nBuffers;
    int nUserChannels[2];    // Playback and record, respectively.
    int nDeviceChannels[2];  // Playback and record channels, respectively.
    RTAUDIO_FORMAT userFormat;
    RTAUDIO_FORMAT deviceFormat[2]; // Playback and record, respectively.
    bool usingCallback;
    THREAD_HANDLE thread;
    MUTEX mutex;
    RTAUDIO_CALLBACK callback;
    void *userData;
  } RTAUDIO_STREAM;

  typedef signed short INT16;
  typedef signed int INT32;
  typedef float FLOAT32;
  typedef double FLOAT64;

  char message[256];
  int nDevices;
  RTAUDIO_DEVICE *devices;

  std::map<int, void *> streams;

  void error(RtError::TYPE type);

  void initialize(void);

  void clearDeviceInfo(RTAUDIO_DEVICE *info);

  void probeDeviceInfo(RTAUDIO_DEVICE *info);

  bool probeDeviceOpen(int device, RTAUDIO_STREAM *stream,
                       STREAM_MODE mode, int channels, 
                       int sampleRate, RTAUDIO_FORMAT format,
                       int *bufferSize, int numberOfBuffers);

  void *verifyStream(int streamId);

  void convertStreamBuffer(RTAUDIO_STREAM *stream, STREAM_MODE mode);

  void byteSwapBuffer(char *buffer, int samples, RTAUDIO_FORMAT format);

  int formatBytes(RTAUDIO_FORMAT format);
};

// Uncomment the following definition to have extra information spewed to stderr.
//#define RTAUDIO_DEBUG

#endif

---

The Synthesis ToolKit in C++ (STK)

©1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.