PCM.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 PCM_H
#define PCM_H

#include <ALSA/ALSA.H>

namespace ALSA {

  class PCM {
  protected:
    snd_output_t *log; 
    snd_pcm_t *handle; 
  public:
    PCM(){
      log=NULL;
      handle=NULL;
    }

    virtual ~PCM(){
      if (log)
        snd_output_close(log);
      close();
    }

    virtual snd_pcm_t *getPCM(){
      return handle;
    }

    snd_pcm_t **getPCMP(){
      return &handle;
    }

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

    int close(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      int ret=0;
      drop();
      snd_pcm_hw_free(getPCM());
      ret=snd_pcm_close(getPCM());
      *getPCMP()=NULL;
      return ret;
    }

    int drop(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      int ret=0;
      if (running())
        ret=snd_pcm_drop(getPCM());
      else
        std::cout<<"PCM::drop can't drop, not running"<<std::endl;
      return ret;
    }

    int drain(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return snd_pcm_drain(getPCM());
    }

    int reset(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return snd_pcm_reset(getPCM());
    }

    void enableLog(){
      snd_output_stdio_attach(&log, stdout, 0);
    }

    int logEnabled(){
      if (log)
        return 1;
      else
        printf("errorlogging not enabled, call enableLog first.\n");
      return 0;
    }

    int dumpStatus(){
      int err=0;
      if (logEnabled()){
        snd_pcm_status_t *status;
        snd_pcm_status_alloca(&status);
        if ((err = snd_pcm_status(getPCM(), status)) < 0)
                printf("Stream status error: %s\n", snd_strerror(err));
        else
          snd_pcm_status_dump(status, log);
      }
      return err;
    }

    int dumpPCM(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      int ret=0;
      if (!logEnabled())
        return ret;
      return snd_pcm_dump(getPCM(), log);
    }

    int dumpSetup(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      int ret=0;
      if (!logEnabled())
        return ret;
      return snd_pcm_dump_setup(getPCM(), log);
    }

    int dumpHWSetup(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      int ret=0;
      if (!logEnabled())
        return ret;
      return snd_pcm_dump_hw_setup(getPCM(), log);
    }

    int dumpSWSetup(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      int ret=0;
      if (!logEnabled())
        return ret;
      return snd_pcm_dump_sw_setup(getPCM(), log);
    }

    int start(){
      PCM_NOT_OPEN_CHECK_NO_PRINT(getPCM(), int) // check pcm is open
      return snd_pcm_start(getPCM());

    }
    snd_pcm_state_t getState(){
      PCM_NOT_OPEN_CHECK_NO_PRINT(getPCM(), snd_pcm_state_t) // check pcm is open
      return snd_pcm_state(getPCM());
    }

    const char *getStateName(){
        PCM_NOT_OPEN_CHECK_STRING(getPCM()) // check pcm is open
       return snd_pcm_state_name(getState());
    }
    bool prepared(){
      PCM_NOT_OPEN_CHECK_NO_PRINT(getPCM(), bool) // check pcm is open
      return getState()==SND_PCM_STATE_PREPARED;
    }

    bool opened(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return getState()==SND_PCM_STATE_OPEN;
    }

    bool isSetup(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return getState()==SND_PCM_STATE_SETUP;
    }

    bool running(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return getState()==SND_PCM_STATE_RUNNING;
    }

    bool hasXrun(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return getState()==SND_PCM_STATE_XRUN;
    }

    bool draining(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return getState()==SND_PCM_STATE_DRAINING;
    }

    bool paused(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return getState()==SND_PCM_STATE_PAUSED;
    }

    bool suspended(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return getState()==SND_PCM_STATE_SUSPENDED;
    }

    bool disconnected(){
      PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
      return getState()==SND_PCM_STATE_DISCONNECTED;
    }
  };
}
#endif //PCM_H