RtAudio.hxx

Go to the documentation of this file.

/*
 * Copyright (c) 2004 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/************************************************************************/
/************************************************************************/

#if !defined(__RTAUDIO_H)
#define __RTAUDIO_H

#include <map>

#if defined(__LINUX_ALSA__)

  /* alsa 0.9 backward compat for alsa 1.0 */
  #define ALSA_PCM_OLD_HW_PARAMS_API
  #define ALSA_PCM_OLD_SW_PARAMS_API

  #include <alsa/asoundlib.h>
  #include <pthread.h>
  #include <unistd.h>

  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>

  typedef int AUDIO_HANDLE;
  typedef int DEVICE_ID;
  typedef pthread_t THREAD_HANDLE;
  typedef pthread_mutex_t MUTEX;

#elif defined(__WINDOWS_DS__)
  #include "CLAM_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;

  typedef LPGUID DEVICE_ID;
  typedef unsigned long THREAD_HANDLE;
  typedef CRITICAL_SECTION MUTEX;

#elif defined(__WINDOWS_ASIO__)
  #include "CLAM_windows.h"
  #include <process.h>

  typedef int AUDIO_HANDLE;
  typedef int 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>

  typedef ALport AUDIO_HANDLE;
  typedef long DEVICE_ID;
  typedef pthread_t THREAD_HANDLE;
  typedef pthread_mutex_t MUTEX;

#elif defined(__MACOSX_CORE__)

  #include <CoreAudio/AudioHardware.h>
  #include <pthread.h>

  typedef unsigned int AUDIO_HANDLE;
  typedef AudioDeviceID DEVICE_ID;
  typedef pthread_t THREAD_HANDLE;
  typedef pthread_mutex_t MUTEX;

#endif


/************************************************************************/
/************************************************************************/

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; }
};


// This public structure type is used to pass callback information
// between the private RtAudio stream structure and global callback
// handling functions.
typedef struct {
  void *object;  // Used as a "this" pointer.
  int streamId;
  DEVICE_ID device[2];
  THREAD_HANDLE thread;
  void *callback;
  void *buffers;
  unsigned long waitTime;
  bool blockTick;
  bool stopStream;
  bool usingCallback;
  void *userData;
} CALLBACK_INFO;


// *************************************************** //
//
// 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];  /* No value reported by getDeviceInfo(). */
    bool probed;       
    int maxOutputChannels; 
    int maxInputChannels;  
    int maxDuplexChannels; 
    int minOutputChannels; 
    int minInputChannels;  
    int minDuplexChannels; 
    bool hasDuplexSupport; 
    bool isDefault;        
    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);

#if (defined(__MACOSX_CORE__) || defined(__WINDOWS_ASIO__))
  // 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(int streamId, DEVICE_ID deviceId, void *inData, void *outData);
#endif

protected:

private:

  static const unsigned int SAMPLE_RATES[MAX_SAMPLE_RATES];

  enum { FAILURE, SUCCESS };

  enum STREAM_MODE {
    OUTPUT,
    INPUT,
    DUPLEX,
    UNINITIALIZED = -75
  };

  enum STREAM_STATE {
    STREAM_STOPPED,
    STREAM_RUNNING
  };

  typedef struct {
    int device[2];          // Playback and record, respectively.
    STREAM_MODE mode;       // OUTPUT, INPUT, 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.
    MUTEX mutex;
    CALLBACK_INFO callbackInfo;
  } 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);

  int getDefaultInputDevice(void);

  int getDefaultOutputDevice(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);
};

// Define the following flag to have extra information spewed to stderr.
//#define __RTAUDIO_DEBUG__

#endif