MixerElement.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 MIXERELEMENT_H_
#define MIXERELEMENT_H_

#include <ALSA/ALSA.H>
#include <string>
#include <sstream>

namespace ALSA {

  class ChannelElement {
  protected:
    long volDB; 
  public:
    long vol; 
    double dB; 
    int sw; 
    snd_mixer_selem_channel_id_t channel;

    ChannelElement(snd_mixer_selem_channel_id_t ch){
      vol=volDB=0;
      dB=0.;
      channel=ch;
    }

    virtual ~ChannelElement(){}

    double toDB(long v) const {
      return (double)v/100.;
    }

    long fromDB(double d) const {
      return (long)(d*100.);
    }

    void outputLevel(std::ostream &os){
      os<<"{\"channel\": "<<channel<<", "<<"\"level\":"<<vol<<", \"dB\":"<<dB<<"}";
    }

    void outputSwitch(std::ostream &os){
      os<<"{\"channel\": "<<channel<<", "<<"\"switch\":"<<sw<<"}";
    }

    void outputLevelAndSwitch(std::ostream &os){
      os<<"{\"channel\": "<<channel<<", "<<"\"level\":"<<vol<<", \"dB\":"<<dB
            <<", "<<"\"switch\":"<<sw<<"}";
    }
  };

  class ChannelPlaybackElement : public ChannelElement {
  public:
    ChannelPlaybackElement(snd_mixer_selem_channel_id_t ch) : ChannelElement(ch) {}

    virtual ~ChannelPlaybackElement(){}

    int getLevels(snd_mixer_elem_t *elem){
      int err=0;
      if ((err=snd_mixer_selem_get_playback_volume(elem, channel, &vol))<0)
        return ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "getting playback volume\n");
      if ((err=snd_mixer_selem_get_playback_dB(elem, channel, &volDB))<0)
        return ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "getting playback dB\n");
      dB=toDB(volDB); // convert it to a dB value
      return 0;
    }

    int getSwitch(snd_mixer_elem_t *elem){
      int err=0;
      if ((err=snd_mixer_selem_get_playback_switch(elem, channel, &sw))<0)
        return ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "getting playback switch\n");
      return 0;
    }
  };

  class ChannelCaptureElement : public ChannelElement {
  public:
    ChannelCaptureElement(snd_mixer_selem_channel_id_t ch) : ChannelElement(ch) {}
    virtual ~ChannelCaptureElement(){}

    int getLevels(snd_mixer_elem_t *elem){
      int err=0;
      if ((err=snd_mixer_selem_get_capture_volume(elem, channel, &vol))<0)
        return ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "getting capture volume\n");
      if ((err=snd_mixer_selem_get_capture_dB(elem, channel, &volDB))<0)
        return ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "getting capture dB\n");
      dB=toDB(volDB); // convert it to a dB value
      return 0;
    }

    int getSwitch(snd_mixer_elem_t *elem){
      int err=0;
      if ((err=snd_mixer_selem_get_capture_switch(elem, channel, &sw))<0)
        return ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "getting catpure switch\n");
      return 0;
    }
  };

  class MixerElement {
  public:
    std::string name; 
    snd_mixer_elem_t *elem; 
    unsigned int index; 
    bool hasCommonVolume; 
    bool hasPlaybackVolume; 
    bool hasPlaybackVolumeJoined; 
    bool hasCaptureVolume; 
    bool hasCaptureVolumeJoined; 
    bool hasCommonSwitch; 
    bool hasPlaybackSwitch; 
    bool hasPlaybackSwitchJoined; 
    bool hasCaptureSwitch; 
    bool hasCaptureSwitchJoined; 
    bool hasCaptureSwitchExclusive; 
    long playbackVolMax;
    long playbackVolMin;
    double playbackVolMaxDB;
    double playbackVolMinDB;
    long captureVolMax;
    long captureVolMin;
    double captureVolMaxDB;
    double captureVolMinDB;

    std::vector<ChannelPlaybackElement> playbackVolumes; 
    std::vector<ChannelCaptureElement> captureVolumes; 
  public:
    MixerElement(){
      name="";
      index=0;
      elem=NULL;

      playbackVolMax=playbackVolMin=0;
      playbackVolMaxDB=playbackVolMinDB=0.;
      captureVolMax=captureVolMin=0;
      captureVolMaxDB=captureVolMinDB=0.;
      hasCommonVolume=false;
      hasPlaybackVolume=false;
      hasPlaybackVolumeJoined=false;
      hasCaptureVolume=false;
      hasCaptureVolumeJoined=false;
      hasCommonSwitch=false;
      hasPlaybackSwitch=false;
      hasPlaybackSwitchJoined=false;
      hasCaptureSwitch=false;
      hasCaptureSwitchJoined=false;
      hasCaptureSwitchExclusive=false;
    }

    MixerElement(snd_mixer_elem_t *e){
      elem=e;
      name=snd_mixer_selem_get_name(elem);
      index=snd_mixer_selem_get_index(elem);

      playbackVolMax=playbackVolMin=0;
      playbackVolMaxDB=playbackVolMinDB=0.;
      captureVolMax=captureVolMin=0;
      captureVolMaxDB=captureVolMinDB=0.;

      hasCommonVolume=snd_mixer_selem_has_common_volume(elem);
      hasPlaybackVolume=snd_mixer_selem_has_playback_volume(elem);
      hasPlaybackVolumeJoined=snd_mixer_selem_has_playback_volume_joined(elem);
      hasCaptureVolume=snd_mixer_selem_has_capture_volume(elem);
      hasCaptureVolumeJoined=snd_mixer_selem_has_capture_volume_joined(elem);
      hasCommonSwitch=snd_mixer_selem_has_common_switch(elem);
      hasPlaybackSwitch=snd_mixer_selem_has_playback_switch(elem);
      hasPlaybackSwitchJoined=snd_mixer_selem_has_playback_switch_joined(elem);
      hasCaptureSwitch=snd_mixer_selem_has_capture_switch(elem);
      hasCaptureSwitchJoined=snd_mixer_selem_has_capture_switch_joined(elem);
      hasCaptureSwitchExclusive=snd_mixer_selem_has_capture_switch_exclusive(elem);

      unsigned long chMask=1;
      for (int i=0; i<SND_MIXER_SCHN_LAST; i++){
        if (snd_mixer_selem_has_playback_channel(elem, (snd_mixer_selem_channel_id_t)i)>0){
          playbackVolumes.push_back(ChannelPlaybackElement((snd_mixer_selem_channel_id_t)i));
          if (hasPlaybackVolume || hasPlaybackVolumeJoined)
            playbackVolumes[playbackVolumes.size()-1].getLevels(elem);
          if (hasCommonSwitch || hasPlaybackSwitch || hasPlaybackSwitchJoined)
            playbackVolumes[playbackVolumes.size()-1].getSwitch(elem);
        }
      }

      for (int i=0; i<SND_MIXER_SCHN_LAST; i++)
        if (snd_mixer_selem_has_capture_channel(elem, (snd_mixer_selem_channel_id_t)i)>0){
          captureVolumes.push_back(ChannelCaptureElement((snd_mixer_selem_channel_id_t)i));
          if (hasCaptureVolume || hasCaptureVolumeJoined)
            captureVolumes[captureVolumes.size()-1].getLevels(elem);
          if (hasCommonSwitch || hasCaptureSwitch || hasCaptureSwitchJoined)
            captureVolumes[captureVolumes.size()-1].getSwitch(elem);
        }

        if (hasPlaybackVolume || hasPlaybackVolumeJoined){
          if (snd_mixer_selem_get_playback_volume_range(elem, &playbackVolMin, &playbackVolMax))
            ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "playback volume range");
          long min, max;
          if (snd_mixer_selem_get_playback_dB_range(elem, &min, &max))
            ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "playback dB range");
          playbackVolMinDB=ChannelElement((snd_mixer_selem_channel_id_t)0).toDB(min); // dummy id
          playbackVolMaxDB=ChannelElement((snd_mixer_selem_channel_id_t)0).toDB(max); // dummy id
        }

        if (hasCaptureVolume || hasCaptureVolumeJoined){
          if (snd_mixer_selem_get_capture_volume_range(elem, &captureVolMin, &captureVolMax))
            ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "capture volume range");
          long min, max;
          if (snd_mixer_selem_get_capture_dB_range(elem, &min, &max))
            ALSADebug().evaluateError(ALSA_MIXER_QUERY_ERROR, "capture dB range");
          captureVolMinDB=ChannelElement((snd_mixer_selem_channel_id_t)0).toDB(min); // dummy id
          captureVolMaxDB=ChannelElement((snd_mixer_selem_channel_id_t)0).toDB(max); // dummy id
        }
    }

    virtual ~MixerElement(){
    }

    int setPlaybackSwitch(int v){
      int err;
      if (!hasCommonSwitch && !hasPlaybackSwitch && !hasPlaybackSwitchJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a playback switch and I tried to set it\n");
      for (int i=0; i<playbackVolumes.size(); i++){
        if ((err=snd_mixer_selem_set_playback_switch(elem, playbackVolumes[i].channel, v))<0)
          return ALSADebug().evaluateError(err, name+" setting playback switches"+'\n');
        if ((err=playbackVolumes[i].getSwitch(elem))<0) // refresh the playback level
          return ALSADebug().evaluateError(err, name+" getting playback switches"+'\n');
      }
      return playbackVolumes[0].sw; // all channels have the same volume in this method
    }

    long setPlaybackVol(long v){
      int err;
      if (!hasPlaybackVolume && !hasPlaybackVolumeJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a playback volume and I tried to set it\n");
      for (int i=0; i<playbackVolumes.size(); i++){
        if ((err=snd_mixer_selem_set_playback_volume(elem, playbackVolumes[i].channel, v))<0)
          return ALSADebug().evaluateError(err, name+" setting playback levels"+'\n');
        if ((err=playbackVolumes[i].getLevels(elem))<0) // refresh the playback level
          return ALSADebug().evaluateError(err, name+" getting playback levels"+'\n');
      }
      return playbackVolumes[0].vol; // all channels have the same volume in this method
    }

    long setPlaybackVol(snd_mixer_selem_channel_id_t channel, long v){
      int err;
      if (!hasPlaybackVolume && !hasPlaybackVolumeJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a playback volume and I tried to set it\n");
      for (int i=0; i<playbackVolumes.size(); i++)
        if (channel==playbackVolumes[i].channel){
          if ((err=snd_mixer_selem_set_playback_volume (elem, playbackVolumes[i].channel, v))<0)
            return ALSADebug().evaluateError(err, name+" setting playback level for this channel"+'\n');
          if ((err=playbackVolumes[i].getLevels(elem))<0) // refresh the playback level
            return ALSADebug().evaluateError(err, name+" getting playback level for this channel"+'\n');
          return playbackVolumes[i].vol; // all channels have the same volume in this method
        }
      return ALSADebug().evaluateError(ALSA_MIXER_NO_CHANNEL_ERROR, name+" channel not found");
    }

    int setPlaybackVolDB(double &dB){
      int err;
      if (!hasPlaybackVolume && !hasPlaybackVolumeJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a playback volume and I tried to set it\n");
      for (int i=0; i<playbackVolumes.size(); i++){
        if ((err=snd_mixer_selem_set_playback_dB(elem, playbackVolumes[i].channel, ChannelElement((snd_mixer_selem_channel_id_t)0).fromDB(dB), 1))<0)
          return ALSADebug().evaluateError(err, name+" setting playback levels"+'\n');
        if ((err=playbackVolumes[i].getLevels(elem))<0) // refresh the playback level
          return ALSADebug().evaluateError(err, name+" getting playback levels"+'\n');
        dB=playbackVolumes[i].dB; // all channels have the same volume in this method
      }
      return 0;
    }

    long setPlaybackVolDB(snd_mixer_selem_channel_id_t channel, double &dB){
      int err;
      if (!hasPlaybackVolume && !hasPlaybackVolumeJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a playback volume and I tried to set it\n");
      for (int i=0; i<playbackVolumes.size(); i++)
        if (channel==playbackVolumes[i].channel){
          if ((err=snd_mixer_selem_set_playback_dB(elem, playbackVolumes[i].channel, ChannelElement((snd_mixer_selem_channel_id_t)0).fromDB(dB),1))<0) // dummy id
            return ALSADebug().evaluateError(err, name+" setting playback level for this channel"+'\n');
          if ((err=playbackVolumes[i].getLevels(elem))<0) // refresh the playback level
            return ALSADebug().evaluateError(err, name+" getting playback level for this channel"+'\n');
          dB=playbackVolumes[i].dB; // all channels have the same volume in this method
          return 0;
        }
      return ALSADebug().evaluateError(ALSA_MIXER_NO_CHANNEL_ERROR, name+" channel not found");
    }

    int setCaptureSwitch(int v){
      int err;
      if (!hasCommonSwitch && !hasCaptureSwitch && !hasCaptureSwitchJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a capture switch and I tried to set it\n");
      for (int i=0; i<captureVolumes.size(); i++){
        if ((err=snd_mixer_selem_set_capture_switch(elem, captureVolumes[i].channel, v))<0)
          return ALSADebug().evaluateError(err, name+" setting capture switches"+'\n');
        if ((err=captureVolumes[i].getSwitch(elem))<0) // refresh the capture level
          return ALSADebug().evaluateError(err, name+" getting capture switches"+'\n');
      }
      return captureVolumes[0].sw; // all channels have the same volume in this method
    }

    long setCaptureVol(long v){
      int err;
      if (!hasCaptureVolume && !hasCaptureVolumeJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a capture volume and I tried to set it\n");
      for (int i=0; i<captureVolumes.size(); i++){
        if ((err=snd_mixer_selem_set_capture_volume(elem, captureVolumes[i].channel, v))<0)
          return ALSADebug().evaluateError(err, name+" setting capture levels"+'\n');
        if ((err=captureVolumes[i].getLevels(elem))<0) // refresh the capture level
          return ALSADebug().evaluateError(err, name+" getting capture levels"+'\n');
      }
      return captureVolumes[0].vol; // all channels have the same volume in this method
    }

    long setCaptureVol(snd_mixer_selem_channel_id_t channel, long v){
      int err;
      if (!hasCaptureVolume && !hasCaptureVolumeJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a capture volume and I tried to set it\n");
      for (int i=0; i<captureVolumes.size(); i++)
        if (channel==captureVolumes[i].channel){
          if ((err=snd_mixer_selem_set_capture_volume (elem, captureVolumes[i].channel, v))<0)
            return ALSADebug().evaluateError(err, name+" setting capture level for this channel"+'\n');
          if ((err=captureVolumes[i].getLevels(elem))<0) // refresh the capture level
            return ALSADebug().evaluateError(err, name+" getting capture level for this channel"+'\n');
          return captureVolumes[i].vol; // all channels have the same volume in this method
        }
      return ALSADebug().evaluateError(ALSA_MIXER_NO_CHANNEL_ERROR, name+" channel not found");
    }

    int setCaptureVolDB(double &dB){
      int err;
      if (!hasCaptureVolume && !hasCaptureVolumeJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a capture volume and I tried to set it\n");
      for (int i=0; i<captureVolumes.size(); i++){
        if ((err=snd_mixer_selem_set_capture_dB(elem, captureVolumes[i].channel, ChannelElement((snd_mixer_selem_channel_id_t)0).fromDB(dB), 1))<0)
          return ALSADebug().evaluateError(err, name+" setting capture levels"+'\n');
        if ((err=captureVolumes[i].getLevels(elem))<0) // refresh the capture level
          return ALSADebug().evaluateError(err, name+" getting capture levels"+'\n');
        dB=captureVolumes[i].dB; // all channels have the same volume in this method
      }
      return 0;
    }

    long setCaptureVolDB(snd_mixer_selem_channel_id_t channel, double &dB){
      int err;
      if (!hasCaptureVolume && !hasCaptureVolumeJoined)
        return ALSADebug().evaluateError(ALSA_MIXER_NO_PLAYBACK_VOL_ERROR, name+" doesn't have a capture volume and I tried to set it\n");
      for (int i=0; i<captureVolumes.size(); i++)
        if (channel==captureVolumes[i].channel){
          if ((err=snd_mixer_selem_set_capture_dB(elem, captureVolumes[i].channel, ChannelElement((snd_mixer_selem_channel_id_t)0).fromDB(dB),1))<0) // dummy id
            return ALSADebug().evaluateError(err, name+" setting capture level for this channel"+'\n');
          if ((err=captureVolumes[i].getLevels(elem))<0) // refresh the capture level
            return ALSADebug().evaluateError(err, name+" getting capture level for this channel"+'\n');
          dB=captureVolumes[i].dB; // all channels have the same volume in this method
          return 0;
        }
      return ALSADebug().evaluateError(ALSA_MIXER_NO_CHANNEL_ERROR, name+" channel not found");
    }

    friend std::ostream &operator<<(std::ostream &os, MixerElement &me){
      os<<"{";
      os<<"\"name\":\""<<me.name<<"\",\n";
      os<<"\"index\":"<<me.index<<",\n";
      os<<"\"hasCommonVolume\":"<<me.hasCommonVolume<<",\n";
      os<<"\"hasPlaybackVolume\":"<<me.hasPlaybackVolume<<",\n";
      os<<"\"hasPlaybackVolumeJoined\":"<<me.hasPlaybackVolumeJoined<<",\n";
      os<<"\"hasCaptureVolume\":"<<me.hasCaptureVolume<<",\n";
      os<<"\"hasCaptureVolumeJoined\":"<<me.hasCaptureVolumeJoined<<",\n";
      os<<"\"hasCommonSwitch\":"<<me.hasCommonSwitch<<",\n";
      os<<"\"hasPlaybackSwitch\":"<<me.hasPlaybackSwitch<<",\n";
      os<<"\"hasPlaybackSwitchJoined\":"<<me.hasPlaybackSwitchJoined<<",\n";
      os<<"\"hasCaptureSwitch\":"<<me.hasCaptureSwitch<<",\n";
      os<<"\"hasCaptureSwitchJoined\":"<<me.hasCaptureSwitchJoined<<",\n";
      os<<"\"hasCaptureSwitchExclusive\":"<<me.hasCaptureSwitchExclusive<<"\n";

      if (me.hasPlaybackVolume || me.hasPlaybackVolumeJoined){
        os<<",\"playbackVolMax\":"<<me.playbackVolMax<<"\n";
        os<<",\"playbackVolMin\":"<<me.playbackVolMin<<"\n";
        os<<",\"playbackVolMaxDB\":"<<me.playbackVolMaxDB<<"\n";
        os<<",\"playbackVolMinDB\":"<<me.playbackVolMinDB<<"\n";
      }

      if (me.hasCaptureVolume || me.hasCaptureVolumeJoined){
        os<<",\"captureVolMax\":"<<me.captureVolMax<<"\n";
        os<<",\"captureVolMin\":"<<me.captureVolMin<<"\n";
        os<<",\"captureVolMaxDB\":"<<me.captureVolMaxDB<<"\n";
        os<<",\"captureVolMinDB\":"<<me.captureVolMinDB<<"\n";
      }

      if ((me.hasPlaybackVolume || me.hasPlaybackVolumeJoined) && (me.hasCommonSwitch || me.hasPlaybackSwitch || me.hasPlaybackSwitchJoined)){
        os<<",\"playbackVolumes\":[\n";
        for (int i=0; i<me.playbackVolumes.size(); i++){
          me.playbackVolumes[i].outputLevelAndSwitch(os);
          os<<((i<me.playbackVolumes.size()-1) ? ",\n" : "\n");
        }
        os<<"]\n";
      } else
          if (me.hasPlaybackVolume || me.hasPlaybackVolumeJoined){
            os<<",\"playbackVolumes\":[\n";
            for (int i=0; i<me.playbackVolumes.size(); i++){
              me.playbackVolumes[i].outputLevel(os);
              os<<((i<me.playbackVolumes.size()-1) ? ",\n" : "\n");
            }
            os<<"]\n";
          } else
            if (me.hasCommonSwitch || me.hasPlaybackSwitch || me.hasPlaybackSwitchJoined){
              os<<",\"playbackVolumes\":[\n";
              for (int i=0; i<me.playbackVolumes.size(); i++){
                me.playbackVolumes[i].outputSwitch(os);
                os<<((i<me.playbackVolumes.size()-1) ? ",\n" : "\n");
              }
              os<<"]\n";
            }

        if ((me.hasCaptureVolume || me.hasCaptureVolumeJoined) && (me.hasCommonSwitch || me.hasCaptureSwitch || me.hasCaptureSwitchJoined)){
          os<<",\"captureVolumes\":[\n";
          for (int i=0; i<me.captureVolumes.size(); i++){
            me.captureVolumes[i].outputLevelAndSwitch(os);
            os<<((i<me.captureVolumes.size()-1) ? ",\n" : "\n");
          }
          os<<"]\n";
        } else
            if (me.hasCaptureVolume || me.hasCaptureVolumeJoined){
              os<<",\"captureVolumes\":[\n";
              for (int i=0; i<me.captureVolumes.size(); i++){
                me.captureVolumes[i].outputLevel(os);
                os<<((i<me.captureVolumes.size()-1) ? ",\n" : "\n");
              }
              os<<"]\n";
            } else
              if (me.hasCommonSwitch || me.hasCaptureSwitch || me.hasCaptureSwitchJoined){
                os<<",\"captureVolumes\":[\n";
                for (int i=0; i<me.captureVolumes.size(); i++){
                  me.captureVolumes[i].outputSwitch(os);
                  os<<((i<me.captureVolumes.size()-1) ? ",\n" : "\n");
                }
                os<<"]\n";
              }
      os<<"}";
      return os;
    }
  };
}
#endif // MIXERELEMENT_H_