From b125e1c9d579d47865fb0e4015b8e1f2d15b152b Mon Sep 17 00:00:00 2001 From: Pierre Ossman Date: Sun, 26 Feb 2006 17:57:58 +0000 Subject: Hardware volume support in ALSA modules. git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@604 fefdeb5f-60dc-0310-8127-8f9354f1896f --- src/modules/alsa-util.c | 39 +++++++++++ src/modules/alsa-util.h | 3 + src/modules/module-alsa-sink.c | 140 +++++++++++++++++++++++++++++++++++++++ src/modules/module-alsa-source.c | 140 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 322 insertions(+) (limited to 'src/modules') diff --git a/src/modules/alsa-util.c b/src/modules/alsa-util.c index 1b254f51..4e1db545 100644 --- a/src/modules/alsa-util.c +++ b/src/modules/alsa-util.c @@ -128,3 +128,42 @@ void pa_free_io_events(pa_mainloop_api* m, pa_io_event **io_events, unsigned n_i m->io_free(*ios); pa_xfree(io_events); } + +int pa_alsa_prepare_mixer(snd_mixer_t *mixer, const char *dev) { + int err; + + assert(mixer && dev); + + if ((err = snd_mixer_attach(mixer, dev)) < 0) { + pa_log_warn(__FILE__": Unable to attach to mixer %s: %s", dev, snd_strerror(err)); + return -1; + } + + if ((err = snd_mixer_selem_register(mixer, NULL, NULL)) < 0) { + pa_log_warn(__FILE__": Unable to register mixer: %s", snd_strerror(err)); + return -1; + } + + if ((err = snd_mixer_load(mixer)) < 0) { + pa_log_warn(__FILE__": Unable to load mixer: %s", snd_strerror(err)); + return -1; + } + + return 0; +} + +snd_mixer_elem_t *pa_alsa_find_elem(snd_mixer_t *mixer, const char *name) { + snd_mixer_elem_t *elem; + snd_mixer_selem_id_t *sid; + snd_mixer_selem_id_alloca(&sid); + + assert(mixer && name); + + snd_mixer_selem_id_set_name(sid, name); + + elem = snd_mixer_find_selem(mixer, sid); + if (!elem) + pa_log_warn(__FILE__": Cannot find mixer control %s", snd_mixer_selem_id_get_name(sid)); + + return elem; +} diff --git a/src/modules/alsa-util.h b/src/modules/alsa-util.h index 5d6d6634..489704c7 100644 --- a/src/modules/alsa-util.h +++ b/src/modules/alsa-util.h @@ -32,4 +32,7 @@ int pa_alsa_set_hw_params(snd_pcm_t *pcm_handle, const pa_sample_spec *ss, uint3 int pa_create_io_events(snd_pcm_t *pcm_handle, pa_mainloop_api *m, pa_io_event ***io_events, unsigned *n_io_events, void (*cb)(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t events, void *userdata), void *userdata); void pa_free_io_events(pa_mainloop_api* m, pa_io_event **io_sources, unsigned n_io_sources); +int pa_alsa_prepare_mixer(snd_mixer_t *mixer, const char *dev); +snd_mixer_elem_t *pa_alsa_find_elem(snd_mixer_t *mixer, const char *name); + #endif diff --git a/src/modules/module-alsa-sink.c b/src/modules/module-alsa-sink.c index e37367c8..68a03615 100644 --- a/src/modules/module-alsa-sink.c +++ b/src/modules/module-alsa-sink.c @@ -54,9 +54,12 @@ PA_MODULE_USAGE("sink_name= device= format=userdata; + long vol; + int err; + + assert(u && u->mixer_elem); + + if (snd_mixer_selem_has_playback_volume_joined(u->mixer_elem)) { + err = snd_mixer_selem_get_playback_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_playback_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 sink_set_hw_volume_cb(pa_sink *s) { + struct userdata *u = s->userdata; + int err; + pa_volume_t vol; + + assert(u && u->mixer_elem); + + if (snd_mixer_selem_has_playback_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_playback_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_playback_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 sink_get_hw_mute_cb(pa_sink *s) { + struct userdata *u = s->userdata; + int err, sw; + + assert(u && u->mixer_elem); + + err = snd_mixer_selem_get_playback_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 sink_set_hw_mute_cb(pa_sink *s) { + struct userdata *u = s->userdata; + int err; + + assert(u && u->mixer_elem); + + err = snd_mixer_selem_set_playback_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; @@ -220,10 +327,34 @@ 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, "PCM"))) { + snd_mixer_close(u->mixer_handle); + u->mixer_handle = NULL; + } + u->sink = pa_sink_new(c, __FILE__, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss, NULL); assert(u->sink); u->sink->get_latency = sink_get_latency_cb; + if (u->mixer_handle) { + assert(u->mixer_elem); + if (snd_mixer_selem_has_playback_volume(u->mixer_elem)) { + u->sink->get_hw_volume = sink_get_hw_volume_cb; + u->sink->set_hw_volume = sink_set_hw_volume_cb; + snd_mixer_selem_get_playback_volume_range( + u->mixer_elem, &u->hw_volume_min, &u->hw_volume_max); + } + if (snd_mixer_selem_has_playback_switch(u->mixer_elem)) { + u->sink->get_hw_mute = sink_get_hw_mute_cb; + u->sink->set_hw_mute = sink_set_hw_mute_cb; + } + } u->sink->userdata = u; pa_sink_set_owner(u->sink, m); u->sink->description = pa_sprintf_malloc("Advanced Linux Sound Architecture PCM on '%s'", dev); @@ -251,6 +382,12 @@ int pa__init(pa_core *c, pa_module*m) { finish: if (ma) pa_modargs_free(ma); + + /* Get initial mixer settings */ + if (u->sink->get_hw_volume) + u->sink->get_hw_volume(u->sink); + if (u->sink->get_hw_mute) + u->sink->get_hw_mute(u->sink); return ret; @@ -277,6 +414,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); snd_pcm_close(u->pcm_handle); 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= 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); -- cgit