Hardware volume support in ALSA modules.

git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@604 fefdeb5f-60dc-0310-8127-8f9354f1896f

1 files changed, 140 insertions, 0 deletions

diff --git a/src/modules/module-alsa-source.c b/src/modules/module-alsa-source.c
index bf031350..e2dbc8bf 100644
--- a/src/modules/module-alsa-source.c
+++ b/src/modules/module-alsa-source.c
@@ -54,9 +54,12 @@ PA_MODULE_USAGE("source_name=<name for the source> device=<ALSA device> format=<
 
 struct userdata {
     snd_pcm_t *pcm_handle;
+    snd_mixer_t *mixer_handle;
+    snd_mixer_elem_t *mixer_elem;
     pa_source *source;
     pa_io_event **io_events;
     unsigned n_io_events;
+    long hw_volume_max, hw_volume_min;
 
     size_t frame_size, fragment_size;
     pa_memchunk memchunk;
@@ -165,6 +168,110 @@ static pa_usec_t source_get_latency_cb(pa_source *s) {
     return pa_bytes_to_usec(frames * u->frame_size, &s->sample_spec);
 }
 
+static int source_get_hw_volume_cb(pa_source *s) {
+    struct userdata *u = s->userdata;
+    long vol;
+    int err;
+
+    assert(u && u->mixer_elem);
+
+    if (snd_mixer_selem_has_capture_volume_joined(u->mixer_elem)) {
+        err = snd_mixer_selem_get_capture_volume(u->mixer_elem, 0, &vol);
+        if (err < 0)
+            goto fail;
+        pa_cvolume_set(&s->hw_volume, s->hw_volume.channels,
+            (vol - u->hw_volume_min) * PA_VOLUME_NORM / (u->hw_volume_max - u->hw_volume_min));
+    } else {
+        int i;
+
+        for (i = 0;i < s->hw_volume.channels;i++) {
+            err = snd_mixer_selem_get_capture_volume(u->mixer_elem, i, &vol);
+            if (err < 0)
+                goto fail;
+            s->hw_volume.values[i] =
+                (vol - u->hw_volume_min) * PA_VOLUME_NORM / (u->hw_volume_max - u->hw_volume_min);
+        }
+    }
+
+    return 0;
+
+fail:
+    pa_log_error(__FILE__": Unable to read volume: %s", snd_strerror(err));
+    s->get_hw_volume = NULL;
+    s->set_hw_volume = NULL;
+    return -1;
+}
+
+static int source_set_hw_volume_cb(pa_source *s) {
+    struct userdata *u = s->userdata;
+    int err;
+    pa_volume_t vol;
+
+    assert(u && u->mixer_elem);
+
+    if (snd_mixer_selem_has_capture_volume_joined(u->mixer_elem)) {
+        vol = pa_cvolume_avg(&s->hw_volume) * (u->hw_volume_max - u->hw_volume_min) /
+            PA_VOLUME_NORM + u->hw_volume_min;
+        err = snd_mixer_selem_set_capture_volume_all(u->mixer_elem, vol);
+        if (err < 0)
+            goto fail;
+    } else {
+        int i;
+
+        for (i = 0;i < s->hw_volume.channels;i++) {
+            vol = s->hw_volume.values[i] * (u->hw_volume_max - u->hw_volume_min) /
+                PA_VOLUME_NORM + u->hw_volume_min;
+            err = snd_mixer_selem_set_capture_volume(u->mixer_elem, i, vol);
+            if (err < 0)
+                goto fail;
+        }
+    }
+
+    return 0;
+
+fail:
+    pa_log_error(__FILE__": Unable to set volume: %s", snd_strerror(err));
+    s->get_hw_volume = NULL;
+    s->set_hw_volume = NULL;
+    return -1;
+}
+
+static int source_get_hw_mute_cb(pa_source *s) {
+    struct userdata *u = s->userdata;
+    int err, sw;
+
+    assert(u && u->mixer_elem);
+
+    err = snd_mixer_selem_get_capture_switch(u->mixer_elem, 0, &sw);
+    if (err) {
+        pa_log_error(__FILE__": Unable to get switch: %s", snd_strerror(err));
+        s->get_hw_mute = NULL;
+        s->set_hw_mute = NULL;
+        return -1;
+    }
+
+    s->hw_muted = !sw;
+
+    return 0;
+}
+
+static int source_set_hw_mute_cb(pa_source *s) {
+    struct userdata *u = s->userdata;
+    int err;
+
+    assert(u && u->mixer_elem);
+
+    err = snd_mixer_selem_set_capture_switch_all(u->mixer_elem, !s->hw_muted);
+    if (err) {
+        pa_log_error(__FILE__": Unable to set switch: %s", snd_strerror(err));
+        s->get_hw_mute = NULL;
+        s->set_hw_mute = NULL;
+        return -1;
+    }
+
+    return 0;
+}
+
 int pa__init(pa_core *c, pa_module*m) {
     pa_modargs *ma = NULL;
     int ret = -1;
@@ -211,11 +318,35 @@ int pa__init(pa_core *c, pa_module*m) {
         goto fail;
     }
 
+    if ((err = snd_mixer_open(&u->mixer_handle, 0)) < 0) {
+        pa_log(__FILE__": Error opening mixer: %s", snd_strerror(err));
+        goto fail;
+    }
+
+    if ((pa_alsa_prepare_mixer(u->mixer_handle, dev) < 0) ||
+        !(u->mixer_elem = pa_alsa_find_elem(u->mixer_handle, "Capture"))) {
+        snd_mixer_close(u->mixer_handle);
+        u->mixer_handle = NULL;
+    }
+
     u->source = pa_source_new(c, __FILE__, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME), 0, &ss, NULL);
     assert(u->source);
 
     u->source->userdata = u;
     u->source->get_latency = source_get_latency_cb;
+    if (u->mixer_handle) {
+        assert(u->mixer_elem);
+        if (snd_mixer_selem_has_capture_volume(u->mixer_elem)) {
+            u->source->get_hw_volume = source_get_hw_volume_cb;
+            u->source->set_hw_volume = source_set_hw_volume_cb;
+            snd_mixer_selem_get_capture_volume_range(
+                u->mixer_elem, &u->hw_volume_min, &u->hw_volume_max);
+        }
+        if (snd_mixer_selem_has_capture_switch(u->mixer_elem)) {
+            u->source->get_hw_mute = source_get_hw_mute_cb;
+            u->source->set_hw_mute = source_set_hw_mute_cb;
+        }
+    }
     pa_source_set_owner(u->source, m);
     u->source->description = pa_sprintf_malloc("Advanced Linux Sound Architecture PCM on '%s'", dev);
 
@@ -239,6 +370,12 @@ int pa__init(pa_core *c, pa_module*m) {
 finish:
      if (ma)
          pa_modargs_free(ma);
+
+    /* Get initial mixer settings */
+    if (u->source->get_hw_volume)
+        u->source->get_hw_volume(u->source);
+    if (u->source->get_hw_mute)
+        u->source->get_hw_mute(u->source);
     
     return ret;
 
@@ -264,6 +401,9 @@ void pa__done(pa_core *c, pa_module*m) {
     
     if (u->io_events)
         pa_free_io_events(c->mainloop, u->io_events, u->n_io_events);
+
+    if (u->mixer_handle)
+        snd_mixer_close(u->mixer_handle);
     
     if (u->pcm_handle) {
         snd_pcm_drop(u->pcm_handle);