alsa_mix.c

   1 /* Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
   2
   3 /** \file alsa_mix.c The ALSA mixer plugin. */
   4
   5 #include <regex.h>
   6 #include <alsa/asoundlib.h>
   7
   8 #include "para.h"
   9 #include "error.h"
  10 #include "mix.h"
  11 #include "string.h"
  12
  13 struct mixer_handle {
  14         /* The ALSA mixer handle */
  15         snd_mixer_t *mixer;
  16         /* Copy of the alsa device name, e.g. "hw:0". */
  17         char *card;
  18         /* ALSA's representation of the given mixer channel. */
  19         snd_mixer_elem_t *elem;
  20         /* Set in ->set_channel(), used for ->get() and ->set(). */
  21         long pmin, pmax;
  22 };
  23
  24 static void alsa_mix_close(struct mixer_handle **handle)
  25 {
  26         struct mixer_handle *h;
  27
  28         if (!handle)
  29                 return;
  30         h = *handle;
  31         if (h) {
  32                 PARA_INFO_LOG("closing mixer handle\n");
  33                 if (h->mixer) /* nec. */
  34                         snd_mixer_close(h->mixer);
  35                 free(h->card);
  36                 free(h);
  37                 /*
  38                  * The global ALSA configuration is cached for next usage,
  39                  * which causes valgrind to report many memory leaks. Calling
  40                  * snd_config_update_free_global() frees the cache.
  41                  */
  42                 snd_config_update_free_global();
  43         }
  44         *handle = NULL;
  45 }
  46
  47 static int alsa_mix_open(const char *dev, struct mixer_handle **handle)
  48 {
  49         int ret;
  50         char *msg;
  51         struct mixer_handle *h;
  52
  53         PARA_INFO_LOG("snd_mixer_{open,attach,register,load}\n");
  54         *handle = NULL;
  55         h = zalloc(sizeof(*h));
  56         h->card = para_strdup(dev? dev : "hw:0");
  57         ret = snd_mixer_open(&h->mixer, 0);
  58         if (ret < 0) {
  59                 msg = make_message("snd_mixer_open() failed: %s",
  60                         snd_strerror(ret));
  61                 goto fail;
  62         }
  63         ret = snd_mixer_attach(h->mixer, h->card);
  64         if (ret < 0) {
  65                 msg = make_message("mixer attach error (%s): %s", h->card,
  66                         snd_strerror(ret));
  67                 goto fail;
  68         }
  69         ret = snd_mixer_selem_register(h->mixer, NULL, NULL);
  70         if (ret < 0) {
  71                 msg = make_message("mixer register error (%s): %s", h->card,
  72                         snd_strerror(ret));
  73                 goto fail;
  74         }
  75         ret = snd_mixer_load(h->mixer);
  76         if (ret < 0) {
  77                 msg = make_message("mixer load error (%s): %s", h->card,
  78                         snd_strerror(ret));
  79                 goto fail;
  80         }
  81         /* success */
  82         *handle = h;
  83         return 1;
  84 fail:
  85         PARA_NOTICE_LOG("%s\n", msg);
  86         free(msg);
  87         alsa_mix_close(&h);
  88         return -E_ALSA_MIX_OPEN;
  89 }
  90
  91 static bool channel_has_playback(snd_mixer_selem_channel_id_t chn,
  92                 snd_mixer_elem_t *elem)
  93 {
  94         return snd_mixer_selem_has_playback_channel(elem, chn);
  95 }
  96
  97 static char *alsa_mix_get_channels(struct mixer_handle *handle)
  98 {
  99         int ret;
 100         char *list = NULL;
 101         snd_mixer_selem_id_t *sid;
 102         snd_mixer_elem_t *elem;
 103
 104         ret = snd_mixer_selem_id_malloc(&sid);
 105         assert(ret >= 0);
 106         elem = snd_mixer_first_elem(handle->mixer);
 107         for (; elem; elem = snd_mixer_elem_next(elem)) {
 108                 char *tmp = list;
 109                 const char *name;
 110
 111                 if (!channel_has_playback(0, elem))
 112                         continue;
 113                 if (!snd_mixer_selem_has_playback_volume(elem))
 114                         continue;
 115                 snd_mixer_selem_get_id(elem, sid);
 116                 name = snd_mixer_selem_id_get_name(sid);
 117                 list = make_message("%s%s%s",
 118                         list? list : "",
 119                         list? ", " : "",
 120                         name);
 121                 free(tmp);
 122         }
 123         snd_mixer_selem_id_free(sid);
 124         return list;
 125 }
 126
 127 static int alsa_mix_set_channel(struct mixer_handle *h,
 128                 const char *mixer_channel)
 129 {
 130         int ret, selem_id = 0;
 131         snd_mixer_selem_id_t *sid;
 132
 133         if (!mixer_channel)
 134                 mixer_channel = "Master";
 135         ret = snd_mixer_selem_id_malloc(&sid);
 136         assert(ret >= 0);
 137         snd_mixer_selem_id_set_index(sid, selem_id);
 138         snd_mixer_selem_id_set_name(sid, mixer_channel);
 139         h->elem = snd_mixer_find_selem(h->mixer, sid);
 140         if (!h->elem) {
 141                 PARA_NOTICE_LOG("unable to find simple control '%s',%u\n",
 142                         snd_mixer_selem_id_get_name(sid),
 143                         snd_mixer_selem_id_get_index(sid));
 144                 ret = -E_BAD_CHANNEL;
 145                 goto out;
 146         }
 147         ret = snd_mixer_selem_get_playback_volume_range(h->elem,
 148                 &h->pmin, &h->pmax);
 149         if (ret < 0) {
 150                 PARA_NOTICE_LOG("unable to get %s range (%s): %s\n",
 151                         mixer_channel, h->card, snd_strerror(ret));
 152                 ret = -E_ALSA_MIX_RANGE;
 153                 goto out;
 154         }
 155         if (h->pmin >= h->pmax) {
 156                 PARA_NOTICE_LOG("alsa reported %s range %ld-%ld (%s)\n",
 157                         mixer_channel, h->pmin, h->pmax, h->card);
 158                 ret = -E_ALSA_MIX_RANGE;
 159                 goto out;
 160         }
 161         ret = 1;
 162 out:
 163         snd_mixer_selem_id_free(sid);
 164         return ret;
 165 }
 166
 167 static int alsa_mix_get(struct mixer_handle *h)
 168 {
 169         snd_mixer_selem_channel_id_t chn;
 170         int n = 0;
 171         float avg = 0;
 172
 173         /* compute average over all channels */
 174         for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++) {
 175                 long val;
 176                 int ret;
 177
 178                 if (!channel_has_playback(chn, h->elem))
 179                         continue;
 180                 ret = snd_mixer_selem_get_playback_volume(h->elem, chn, &val);
 181                 if (ret < 0) {
 182                         PARA_NOTICE_LOG("unable to get value for channel %d (%s): %s\n",
 183                                 (int)chn, h->card, snd_strerror(ret));
 184                         return -E_ALSA_MIX_GET_VAL;
 185                 }
 186                 /* update the rolling average */
 187                 avg = (val + n * avg) / (n + 1);
 188                 n++;
 189         }
 190         /* scale to 0..100 */
 191         avg = 100 * (avg - h->pmin) / (h->pmax - h->pmin);
 192         return avg;
 193 }
 194
 195 static int alsa_mix_set(struct mixer_handle *h, int val)
 196 {
 197         int ret;
 198         snd_mixer_selem_channel_id_t chn;
 199         long scaled = val / 100.0 * (h->pmax - h->pmin) + h->pmin;
 200
 201         PARA_INFO_LOG("new value: %d\n", val);
 202         for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++) {
 203                 if (!channel_has_playback(chn, h->elem))
 204                         continue;
 205                 ret = snd_mixer_selem_set_playback_volume(h->elem, chn, scaled);
 206                 if (ret < 0) {
 207                         PARA_NOTICE_LOG("unable to set value for channel %d (%s): %s\n",
 208                                 (int)chn, h->card, snd_strerror(ret));
 209                         return -E_ALSA_MIX_SET_VAL;
 210                 }
 211         }
 212         return 1;
 213 }
 214
 215 /** The mixer operations for the ALSA mixer. */
 216 const struct mixer alsa_mixer = {
 217         .name = "alsa",
 218         .open = alsa_mix_open,
 219         .get_channels = alsa_mix_get_channels,
 220         .set_channel = alsa_mix_set_channel,
 221         .close = alsa_mix_close,
 222         .get = alsa_mix_get,
 223         .set = alsa_mix_set
 224 };