portaudio.hh

#ifndef __SDR_PORTAUDIO_HH__
#define __SDR_PORTAUDIO_HH__

#include <portaudio.h>

#include "buffer.hh"
#include "node.hh"
#include "config.hh"
#include "logger.hh"

namespace sdr {

class PortAudio {
public:
  static void init();
  static void terminate();

  static int numDevices();
  static int defaultInputDevice();
  static int defaultOutputDevice();
  static bool hasInputStream(int idx);
  static bool hasOutputStream(int idx);
  static std::string deviceName(int idx);
};


class PortSink: public SinkBase
{
public:
  PortSink();
  virtual ~PortSink();

  virtual void config(const Config &src_cfg);
  virtual void handleBuffer(const RawBuffer &buffer, bool allow_overwrite);

protected:
  PaStream *_stream;
  size_t _frame_size;
};


template <class Scalar>
class PortSource: public Source
{
public:
  PortSource(double sampleRate, size_t bufferSize, int dev=-1):
    Source(), _streamIsOpen(false), _stream(0), _sampleRate(sampleRate), _is_real(true)
  {
    // Allocate buffer
    _buffer = Buffer<Scalar>(bufferSize);
    _initializeStream(dev);
  }

  virtual ~PortSource() {
    // close stream
    if (0 != _stream) { Pa_CloseStream(_stream); }
    // unref buffer
    _buffer.unref();
  }

  void next() {
    Pa_ReadStream(_stream, _buffer.ptr(), _buffer.size());
    this->send(_buffer);
  }

  int deviceIndex() const { return _deviceIndex; }

  void setDeviceIndex(int idx=-1) {
    _initializeStream(idx);
  }

  bool hasSampleRate(double sampleRate) {
    PaStreamParameters params;
    params.device = _deviceIndex;
    params.channelCount = _is_real ? 1 : 2;
    params.sampleFormat = _fmt;
    params.hostApiSpecificStreamInfo = 0;
    return paFormatIsSupported == Pa_IsFormatSupported(&params, 0, sampleRate);
  }

  void setSampleRate(double sampleRate) {
    _sampleRate = sampleRate;
    _initializeStream(_deviceIndex);
  }

protected:
  void _initializeStream(int idx=-1) {
    // Stop and close stream if running
    if (_streamIsOpen) {
      Pa_StopStream(_stream); Pa_CloseStream(_stream); _streamIsOpen = false;
    }

    // Determine input stream format by scalar type
    switch (Config::typeId<Scalar>()) {
    case Config::Type_f32:
      _fmt = paFloat32;
      _is_real = true;
      break;
    case Config::Type_u16:
    case Config::Type_s16:
      _fmt = paInt16;
      _is_real = true;
      break;
    case Config::Type_cf32:
      _fmt = paFloat32;
      _is_real = false;
      break;
    case Config::Type_cu16:
    case Config::Type_cs16:
      _fmt = paInt16;
      _is_real = false;
      break;
    default:
      ConfigError err;
      err << "Can not configure PortAudio sink: Unsupported format " << Config::typeId<Scalar>()
          << " must be one of " << Config::Type_u16 << ", " << Config::Type_s16
          << ", " << Config::Type_f32 << ", " << Config::Type_cu16 << ", " << Config::Type_cs16
          << " or " << Config::Type_cf32 << ".";
      throw err;
    }

    // Assemble config:
    int numCh = _is_real ? 1 : 2;
    _deviceIndex = idx < 0 ? Pa_GetDefaultInputDevice() : idx;
    PaStreamParameters params;
    params.device = _deviceIndex;
    params.channelCount = numCh;
    params.sampleFormat = _fmt;
    params.suggestedLatency = Pa_GetDeviceInfo(_deviceIndex)->defaultHighInputLatency;
    params.hostApiSpecificStreamInfo = 0;

    // open stream
    PaError err = Pa_OpenStream(&_stream, &params, 0, _sampleRate, _buffer.size(), 0, 0, 0);

    // Check for errors
    if (0 > err) {
      ConfigError err;
      err << "Can not open PortAudio input stream!"; throw err;
    }
    // Mark stream as open
    _streamIsOpen = true;
    // Start stream
    Pa_StartStream(_stream);

    LogMessage msg(LOG_DEBUG);
    msg << "Configure PortAudio source: " << std::endl
        << " sample rate " << _sampleRate  << std::endl
        << " buffer size " << _buffer.size() << std::endl
        << " format " << Config::typeId<Scalar>() << std::endl
        << " num chanels " << numCh;
    Logger::get().log(msg);

    // Set config
    this->setConfig(Config(Config::typeId<Scalar>(), _sampleRate, _buffer.size(), 1));
  }


protected:
  bool _streamIsOpen;
  PaStream *_stream;
  PaSampleFormat _fmt;
  double _sampleRate;
  int _deviceIndex;
  bool _is_real;
  Buffer<Scalar> _buffer;
};

}

#endif // __SDR_PORTAUDIO_HH__