Stream.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream 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.

   GTK+ IOStream 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 have received a copy of the GNU General Public License
   along with GTK+ IOStream
*/
#ifndef STREAM_H
#define STREAM_H

#include <ALSA/ALSA.H>

namespace ALSA {
  class Stream : public Software {

  protected:
    bool block; 

  public:
    Stream() {
      block=1;
    }

    int init(const char *device, snd_pcm_stream_t streamType, bool blockIn) {
      block=blockIn;
      int ret=open(device, streamType, block ? 0 : SND_PCM_NONBLOCK);
      if (ret<0){
        std::cerr<<"Couldn't open device"<<std::endl;
        return ret;
      }

      // if ((ret=rateResample(1))<0){
      //   std::cerr<<"Couldn't rateResample"<<std::endl;
      //   return ret;
      // }
      if ((ret=setAccess(SND_PCM_ACCESS_RW_INTERLEAVED))<0){
        std::cerr<<"Couldn't setAccess"<<std::endl;
        return ret;
      }
      if ((ret=setFormat(ALSA_DEFAULT_FORMAT))<0){
        std::cerr<<"Couldn't setFormat"<<std::endl;
        return ret;
      }
      if ((ret=setChannels(ALSA_DEFAULT_CHANNELS))<0){
        std::cerr<<"Couldn't setChannels"<<std::endl;
        return ret;
      }

      unsigned int startRate=ALSA_DEFAULT_START_FS;
      if ((ret=setSampleRate(startRate))<0){
        std::cerr<<"Couldn't setSampleRate"<<std::endl;
        return ret;
      }
      return 0;
    }

    virtual ~Stream(){
    }

    const char *getFormatName(const snd_pcm_format_t format){
      return snd_pcm_format_name(format);
    }

    int open(const char *device, snd_pcm_stream_t streamType, const int block) {
      std::cout<<"opening the device "<<device<<std::endl;
        int ret;
        if ((ret=PCM::open(device, streamType, block))<0)
          return ALSADebug().evaluateError(ret);
        if ((ret=fillParams())<0)
          std::cerr<<"Couldn't fillParams "<<snd_strerror(ret)<<std::endl;
        return ret;
    }

    int setParams() {
      int err=setHWParams();
      if (err < 0) {
        return ALSADebug().evaluateError(err, "Stream:: setParams : Unable to set hw params ");
        return err;
      }

      if ((err = getSWParams()) < 0)
        return ALSADebug().evaluateError(err, "Stream:: setParams : Unable to determine current sParams ");

      if ((err = setSWThreshold(0x7fffffff)) < 0)
        return ALSADebug().evaluateError(err, "Stream:: setParams : Unable to set start threshold mode ");

      snd_pcm_uframes_t val = 4;
      if (block)
        getPeriodSize(&val);

      if ((err=setAvailMin(val))< 0)
        return ALSADebug().evaluateError(err, "Stream:: setParams : Unable to set avail min ");

      if ((err=setSWParams()) < 0)
        return ALSADebug().evaluateError(err, "Stream:: setParams : Unable to set sw params ");
      return err;
    }

    int setSilence(void *data, unsigned int samples){
      snd_pcm_format_t format;
      int ret=getFormat(format);
      if (ret<0)
      return ret;
      return snd_pcm_format_set_silence(format, data, samples);
    }

    int link(Stream &s){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return snd_pcm_link(getPCM(), *s.getPCMP());
    }

    int wait(int timeOut=1000) {
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return snd_pcm_wait(getPCM(), timeOut);
    }

    int getFormatBits(){
      snd_pcm_format_t format;
      int ret=getFormat(format);
      if (ret>=0)
      return snd_pcm_format_width(format);
      return ret;
    }
  };
}
#endif //STREAM_H