laudio/laudio.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef LAUDIO_HH
#define LAUDIO_HH

//
//  Starting implementation will assume the solaris devaudio API. For the
//  future I think that the OSS API looks promising.
#ifdef sun
#define SOLARIS_AUDIO
#else
#define OPEN_SOUND_SYSTEM
#endif

#ifndef __CINT__
#include <string>
#include <stdexcept>
#include <iosfwd>
#else
namespace std {
  class runtime_error;
}
#endif

#ifdef SOLARIS_AUDIO
struct audio_info;
struct audio_prinfo;
#endif

class LAudio {
public:

  typedef unsigned int count_t;

  enum iomode {m_listen, m_sing, m_monitor, m_converse};

  enum ioport {p_Speaker=1, p_Phone=2, p_Line=4};

  LAudio(void);

  LAudio(const char* device);

  ~LAudio(void);

  void close(void);

  void drain(void) throw(std::runtime_error);

  void dumpStatus(std::ostream& out) const;

  std::string getDevice(void) const;

  const char* getEncoding(void) const throw(std::runtime_error);

  count_t getMonitorGain(void) const throw(std::runtime_error);

  count_t getPrecision(void) const throw(std::runtime_error);

  count_t getSpeed(void) const throw(std::runtime_error);

  double getVolume(void) const throw(std::runtime_error);

  bool isOpen(void) const;

  void mute(bool mute) throw(std::runtime_error);

  void open(const char* device=0, iomode mode=m_sing);

  void reSample(double freq, short data[], count_t length);

  void reSample(double freq, float data[], count_t length);

  void setEncoding(const char* encode) throw(std::runtime_error);

  void setInputTransform(double bias, double scale);

  void setPorts(count_t mask) throw(std::runtime_error);

  void setMonitorGain(count_t gain) throw(std::runtime_error);

  void setSpeed(count_t rate) throw(std::runtime_error);

  void setPrecision(count_t bits) throw(std::runtime_error);

  void setVolume(double volume) throw(std::runtime_error);

  void sing(short data[], count_t length);

private:
  int Encode(const std::string& x) const throw(std::runtime_error);
  const char* Encode(int x) const;

#ifdef SOLARIS_AUDIO
  void dumpChannel(std::ostream& out, const char* title, 
                   const audio_prinfo& info) const throw(std::runtime_error);
  void getStatus(audio_info* info) const throw(std::runtime_error);
  void setStatus(const audio_info* info) throw(std::runtime_error);
#endif
  short transform(double) const;

private:
  struct DspStatus {
      DspStatus(void);
      bool valid;
      int sample_rate;    //  Sample rate.
      int format;         //  Data encoding.
      int precision;      //  Data precision (bits)
      int buffer_size;    //  Buffer size in bytes
      double gain;        //  Gain
      int samples;        //  Number of samples transferred
  };

private:
  int    mFD;
  iomode mMode;
  bool   mBigEnd;
  DspStatus mInStat;
  DspStatus mOutStat;
  double mOutputSPS;
  int    mOutputVal;

  double mDt;

  double mBias;
  double mScale;
};

inline short
LAudio::transform(double x) const {
     return short((x-mBias)*mScale);
}

#endif  // LAUDIO_HH

---