Mixer.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 MIXER_H_
#define MIXER_H_

#include <ALSA/MixerElement.H>

namespace ALSA {
  class Mixer {
    snd_mixer_t *handle;
    std::vector<MixerElement> mixerElements; 

  public:
    Mixer(){
      handle=NULL;
    }

    virtual ~Mixer(){
      if (handle)
        close();
    }

    int open(){
      int err;
      if ((err = snd_mixer_open(&handle, 0)) < 0) {
        handle=NULL;
                        return ALSADebug().evaluateError(err);
      }
      return 0;
    }

    int close(){
      MIXER_NOT_OPEN_CHECK(handle)
      int err;
      if ((err = snd_mixer_close(handle)) < 0) {
        handle=NULL;
                        return ALSADebug().evaluateError(err);
      }
      handle=NULL;
      return 0;
    }

    int attach(std::string card){
      MIXER_NOT_OPEN_CHECK(handle)
      int err;
      if ((err = snd_mixer_attach(handle, card.c_str())) < 0) {
        snd_mixer_close(handle);
        std::string msg="Mixer attach "; msg+=card;
        return ALSADebug().evaluateError(err, msg);
      }
      return 0;
    }

    int registerMixer(){
      MIXER_NOT_OPEN_CHECK(handle)
      int err;
      if ((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0) {
        snd_mixer_close(handle);
        return ALSADebug().evaluateError(err, "Mixer register ");
      }
      return 0;
    }

    int load(){
      MIXER_NOT_OPEN_CHECK(handle)
      int err;
      if ((err = snd_mixer_load(handle)) < 0) {
        snd_mixer_close(handle);
        return ALSADebug().evaluateError(err, "Mixer load ");
      }
      return 0;
    }

    int openCard(std::string card){
      int err=0;
      if (handle)
        if ((err=close())<0)
          return err;
      if ((err=open())<0)
        return err;
      if ((err=attach(card))<0)
        return err;
      if ((err=registerMixer())<0)
        return err;
      if ((err=load())<0)
        return err;
      return err;
    }

    void scanMixer(){
      if (!handle)
        ALSADebug().evaluateError(ALSA_MIXER_NOT_OPEN_ERROR);
      else {
        mixerElements.resize(0);
        for (snd_mixer_elem_t *elem = snd_mixer_first_elem(handle); elem; elem = snd_mixer_elem_next(elem)){
          mixerElements.push_back(MixerElement(elem));
        }
      }
    }

    friend std::ostream &operator<<(std::ostream &os, Mixer &m){
      os<<"[\n";
      for (int i=0; i<m.mixerElements.size(); i++)
        os<<m.mixerElements[i]<< ((i<m.mixerElements.size()-1) ? ",\n" : "\n");
      os<<"]\n";
      return os;
    }

    std::string getState(){
      std::ostringstream oss;
      oss<<*this;
      return oss.str();
    }

    std::string getElementState(std::string name){
      int i=getElementIndex(name);
      std::ostringstream oss;
      if (i<0)
        oss<<"{\"name\":\""<<name<<"\",\"error\":"<< ALSA_MIXER_FIND_ELEMENT_ERROR <<"}";
      else
        oss<<mixerElements[i];
      return oss.str();
    }

    int getElementIndex(std::string name){
      for (int i=0; i<mixerElements.size(); i++)
        if (name.compare(mixerElements[i].name)==0)
          return i;
      return -1;
    }

    long setPlaybackVol(std::string name, long v){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setPlaybackVol(v);
    }

    long setPlaybackChVol(std::string name, snd_mixer_selem_channel_id_t channel, long v){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setPlaybackVol(channel, v);
    }

    std::string setPlaybackVolJSON(std::string name, long v){
      long val=setPlaybackVol(name, v);
      std::ostringstream ret;
      if (val<0)
        ret<<"{\"name\":\""<<name<<"\",\"error\":"<< val <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"val\":"<<val<<"}";
      return ret.str();
    }

    std::string setPlaybackChVolJSON(std::string name, snd_mixer_selem_channel_id_t channel, long v){
      long val=setPlaybackChVol(name, channel, v);
      std::ostringstream ret;
      if (val<0)
        ret<<"{\"name\":\""<<name<<"\",\"channel\":"<< channel<<",\"error\":"<< val <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"channel\":"<< channel<<",\"val\":"<<val<<"}";
      return ret.str();
    }

    std::string setPlaybackChVolJSON(std::string name, int channel, long v){
      return setPlaybackChVolJSON(name, (snd_mixer_selem_channel_id_t) channel, v);
    }

    int setPlaybackVolDB(std::string name, double &dB){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setPlaybackVolDB(dB);
    }

    int setPlaybackChVolDB(std::string name, snd_mixer_selem_channel_id_t channel, double &dB){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setPlaybackVolDB(channel, dB);
    }

    std::string setPlaybackVolDBJSON(std::string name, double dB){
      int err=setPlaybackVolDB(name, dB);
      std::ostringstream ret;
      if (err<0)
        ret<<"{\"name\":\""<<name<<"\",\"error\":"<< err <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"val\":"<< dB <<"}";
      return ret.str();
    }

    std::string setPlaybackChVolDBJSON(std::string name, snd_mixer_selem_channel_id_t channel, double dB){
      int err=setPlaybackChVolDB(name, channel, dB);
      std::ostringstream ret;
      if (err<0)
        ret<<"{\"name\":\""<<name<<"\",\"channel\":"<< channel<<",\"error\":"<< err <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"channel\":"<< channel<<",\"val\":"<< dB <<"}";
      return ret.str();
    }

    std::string setPlaybackChVolDBJSON(std::string name, int channel, double dB){
      return setPlaybackChVolDBJSON(name, (snd_mixer_selem_channel_id_t) channel, dB);
    }

    int setPlaybackSwitch(std::string name, int v){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setPlaybackSwitch(v);
    }

    std::string setPlaybackSwitchJSON(std::string name, int v){
      int err=setPlaybackSwitch(name, v);
      std::ostringstream ret;
      if (err<0)
        ret<<"{\"name\":\""<<name<<"\",\"error\":"<< err <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"switch\":"<< err <<"}";
      return ret.str();
    }

    long setCaptureVol(std::string name, long v){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setCaptureVol(v);
    }

    long setCaptureVol(std::string name, snd_mixer_selem_channel_id_t channel, long v){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setCaptureVol(channel, v);
    }

    std::string setCaptureVolJSON(std::string name, long v){
      long val=setCaptureVol(name, v);
      std::ostringstream ret;
      if (val<0)
        ret<<"{\"name\":\""<<name<<"\",\"error\":"<< val <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"val\":"<<val<<"}";
      return ret.str();
    }

    std::string setCaptureChVolJSON(std::string name, snd_mixer_selem_channel_id_t channel, long v){
      long val=setCaptureVol(name, channel, v);
      std::ostringstream ret;
      if (val<0)
        ret<<"{\"name\":\""<<name<<"\",\"channel\":"<< channel<<",\"error\":"<< val <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"channel\":"<< channel<<",\"val\":"<<val<<"}";
      return ret.str();
    }

    std::string setCaptureChVolJSON(std::string name, int channel, long v){
      return setCaptureChVolJSON(name, (snd_mixer_selem_channel_id_t) channel, v);
    }

    int setCaptureVolDB(std::string name, double &dB){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setCaptureVolDB(dB);
    }

    int setCaptureChVolDB(std::string name, snd_mixer_selem_channel_id_t channel, double &dB){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setCaptureVolDB(channel, dB);
    }

    std::string setCaptureVolDBJSON(std::string name, double dB){
      int err=setCaptureVolDB(name, dB);
      std::ostringstream ret;
      if (err<0)
        ret<<"{\"name\":\""<<name<<"\",\"error\":"<< err <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"val\":"<< dB <<"}";
      return ret.str();
    }

    std::string setCaptureChVolDBJSON(std::string name, snd_mixer_selem_channel_id_t channel, double dB){
      int err=setCaptureChVolDB(name, channel, dB);
      std::ostringstream ret;
      if (err<0)
        ret<<"{\"name\":\""<<name<<"\",\"channel\":"<< channel<<",\"error\":"<< err <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"channel\":"<< channel<<",\"val\":"<< dB <<"}";
      return ret.str();
    }

    std::string setCaptureChVolDBJSON(std::string name, int channel, double dB){
      return setCaptureChVolDBJSON(name, (snd_mixer_selem_channel_id_t) channel, dB);
    }
    int setCaptureSwitch(std::string name, int v){
      int i=getElementIndex(name);
      if (i<0)
        return ALSADebug().evaluateError(ALSA_MIXER_FIND_ELEMENT_ERROR, name+'\n');
      return mixerElements[i].setCaptureSwitch(v);
    }

    std::string setCaptureSwitchJSON(std::string name, int v){
      int err=setCaptureSwitch(name, v);
      std::ostringstream ret;
      if (err<0)
        ret<<"{\"name\":\""<<name<<"\",\"error\":"<< err <<"}";
      else
        ret<<"{\"name\":\""<<name<<"\",\"switch\":"<< err <<"}";
      return ret.str();
    }
  };
}
#endif // MIXER_H_