mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2026-05-30 21:37:53 -04:00
spa: alsa: Add a mechanism for external volume control
Currently enabled at device creation and delegated to an external entity via spa_device events.
This commit is contained in:
Julian Bouzas
parent
122bfd712b
commit
ef6f5194e3
9 changed files with 867 additions and 86 deletions
|
|
@ -5,6 +5,7 @@
|
|||
#include "acp.h"
|
||||
#include "alsa-mixer.h"
|
||||
#include "alsa-ucm.h"
|
||||
#include "ext-volume.h"
|
||||
|
||||
#include <spa/utils/string.h>
|
||||
#include <spa/utils/json.h>
|
||||
|
|
@ -1246,6 +1247,28 @@ static void init_eld_ctls(pa_card *impl)
|
|||
}
|
||||
}
|
||||
|
||||
static void ext_volume_notifier_cb (void *data, struct spa_event *event) {
|
||||
struct pa_card *impl = data;
|
||||
|
||||
if (impl->events && impl->events->ext_vol_event_available)
|
||||
impl->events->ext_vol_event_available(impl->user_data, event);
|
||||
}
|
||||
|
||||
static void init_ext_volume(pa_card *impl)
|
||||
{
|
||||
struct acp_card *card = &impl->card;
|
||||
int res;
|
||||
|
||||
if (!impl->ext_volume_ctrl)
|
||||
return;
|
||||
|
||||
res = spa_acp_ext_volume_init(&card->ext_volume, impl->name, ext_volume_notifier_cb, impl);
|
||||
if (res < 0) {
|
||||
pa_log_notice("failed to init ACP external volume: %s", snd_strerror(res));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t acp_card_find_best_profile_index(struct acp_card *card, const char *name)
|
||||
{
|
||||
uint32_t i;
|
||||
|
|
@ -1357,21 +1380,50 @@ static int read_volume(pa_alsa_device *dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (!dev->mixer_handle)
|
||||
if (impl->card.ext_volume.initialized &&
|
||||
(impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_READ_VOLUME)) {
|
||||
pa_cvolume ext_vol;
|
||||
|
||||
if (!dev->active_port)
|
||||
return -EINVAL;
|
||||
|
||||
/* Externally managed volume */
|
||||
if ((res = spa_acp_ext_volume_read_volume(&impl->card.ext_volume, impl->name,
|
||||
dev->active_port->name, dev->active_port->port.index, &ext_vol)) < 0) {
|
||||
pa_log_error("Could not read volume: %s", snd_strerror(res));
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* FIXME: scale to the range from capabilities */
|
||||
if (ext_vol.channels == 1) {
|
||||
r.channels = dev->device.format.channels;
|
||||
for (unsigned int i = 0; i < r.channels; i++)
|
||||
r.values[i] = ext_vol.values[0];
|
||||
} else if (ext_vol.channels == dev->device.format.channels) {
|
||||
r = ext_vol;
|
||||
} else {
|
||||
pa_log_error("Mismatch channel count: device %u != volume %u",
|
||||
dev->device.format.channels, ext_vol.channels);
|
||||
return 0;
|
||||
}
|
||||
} else if (dev->mixer_handle) {
|
||||
/* ALSA mixer for volume */
|
||||
if (dev->mixer_path->has_volume_mute && dev->muted) {
|
||||
/* Shift up by the base volume */
|
||||
pa_sw_cvolume_divide_scalar(&r, &dev->hardware_volume, dev->base_volume);
|
||||
pa_log_debug("Reading cached volume only.");
|
||||
} else {
|
||||
if ((res = pa_alsa_path_get_volume(dev->mixer_path, dev->mixer_handle,
|
||||
&dev->mapping->channel_map, &r)) < 0)
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Shift down by the base volume, so that 0dB becomes maximum volume */
|
||||
pa_sw_cvolume_multiply_scalar(&r, &r, dev->base_volume);
|
||||
|
||||
} else
|
||||
return 0;
|
||||
|
||||
if (dev->mixer_path->has_volume_mute && dev->muted) {
|
||||
/* Shift up by the base volume */
|
||||
pa_sw_cvolume_divide_scalar(&r, &dev->hardware_volume, dev->base_volume);
|
||||
pa_log_debug("Reading cached volume only.");
|
||||
} else {
|
||||
if ((res = pa_alsa_path_get_volume(dev->mixer_path, dev->mixer_handle,
|
||||
&dev->mapping->channel_map, &r)) < 0)
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Shift down by the base volume, so that 0dB becomes maximum volume */
|
||||
pa_sw_cvolume_multiply_scalar(&r, &r, dev->base_volume);
|
||||
|
||||
if (pa_cvolume_equal(&dev->hardware_volume, &r))
|
||||
return 0;
|
||||
|
|
@ -1394,12 +1446,10 @@ static int read_volume(pa_alsa_device *dev)
|
|||
|
||||
static void set_volume(pa_alsa_device *dev, const pa_cvolume *v)
|
||||
{
|
||||
pa_card *impl = dev->card;
|
||||
pa_cvolume r;
|
||||
bool write_to_hw;
|
||||
|
||||
if (v != &dev->real_volume)
|
||||
dev->real_volume = *v;
|
||||
|
||||
if (dev->ucm_context) {
|
||||
if (!dev->active_port)
|
||||
return;
|
||||
|
|
@ -1408,52 +1458,100 @@ static void set_volume(pa_alsa_device *dev, const pa_cvolume *v)
|
|||
return;
|
||||
}
|
||||
|
||||
if (!dev->mixer_handle)
|
||||
return;
|
||||
if (impl->card.ext_volume.initialized) {
|
||||
if (!dev->active_port)
|
||||
return;
|
||||
if (impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_WRITE_VOLUME_VALUE) {
|
||||
/* External volume control by value */
|
||||
if (spa_acp_ext_volume_write_volume_absolute(&impl->card.ext_volume, impl->name,
|
||||
dev->active_port->name, dev->active_port->port.index, &dev->real_volume) < 0) {
|
||||
pa_log_error("Could not write volume");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Shift up by the base volume */
|
||||
pa_sw_cvolume_divide_scalar(&r, &dev->real_volume, dev->base_volume);
|
||||
/* Update volume if we were successful */
|
||||
if (v != &dev->real_volume)
|
||||
dev->real_volume = *v;
|
||||
} else if ((impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_READ_VOLUME) &&
|
||||
(impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_WRITE_VOLUME_UPDOWN)) {
|
||||
/* External volume control by increment/decrement only */
|
||||
pa_volume_t cur, new;
|
||||
float step;
|
||||
int i;
|
||||
|
||||
write_to_hw = !(dev->mixer_path->has_volume_mute && dev->muted);
|
||||
cur = pa_cvolume_max(&dev->real_volume);
|
||||
new = pa_cvolume_max(v);
|
||||
|
||||
if (pa_alsa_path_set_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map,
|
||||
&r, false, write_to_hw) < 0)
|
||||
return;
|
||||
if (cur < new)
|
||||
step = 1;
|
||||
else if (cur > new)
|
||||
step = -1;
|
||||
else
|
||||
return;
|
||||
|
||||
/* Shift down by the base volume, so that 0dB becomes maximum volume */
|
||||
pa_sw_cvolume_multiply_scalar(&r, &r, dev->base_volume);
|
||||
if (spa_acp_ext_volume_write_volume_relative(&impl->card.ext_volume, impl->name,
|
||||
dev->active_port->name, dev->active_port->port.index, step) < 0) {
|
||||
pa_log_error("Could not write volume");
|
||||
return;
|
||||
}
|
||||
|
||||
dev->hardware_volume = r;
|
||||
/* Update volume if we were successful */
|
||||
dev->real_volume.channels = v->channels;
|
||||
for (i = 0; i < (int)v->channels; i++)
|
||||
dev->real_volume.values[i] = v->values[i] + (int)step;
|
||||
} else {
|
||||
pa_log_debug("Ignoring volume setting, ext volume control does not support it");
|
||||
}
|
||||
} else if (dev->mixer_handle) {
|
||||
/* ALSA mixer control for volume */
|
||||
|
||||
if (dev->mixer_path->has_dB) {
|
||||
pa_cvolume new_soft_volume;
|
||||
bool accurate_enough;
|
||||
if (v != &dev->real_volume)
|
||||
dev->real_volume = *v;
|
||||
|
||||
/* Match exactly what the user requested by software */
|
||||
pa_sw_cvolume_divide(&new_soft_volume, &dev->real_volume, &dev->hardware_volume);
|
||||
/* Shift up by the base volume */
|
||||
pa_sw_cvolume_divide_scalar(&r, &dev->real_volume, dev->base_volume);
|
||||
|
||||
/* If the adjustment to do in software is only minimal we
|
||||
* can skip it. That saves us CPU at the expense of a bit of
|
||||
* accuracy */
|
||||
accurate_enough =
|
||||
(pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
|
||||
(pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
|
||||
write_to_hw = !(dev->mixer_path->has_volume_mute && dev->muted);
|
||||
|
||||
pa_log_debug("Requested volume: %d", pa_cvolume_max(&dev->real_volume));
|
||||
pa_log_debug("Got hardware volume: %d", pa_cvolume_max(&dev->hardware_volume));
|
||||
pa_log_debug("Calculated software volume: %d (accurate-enough=%s)",
|
||||
pa_cvolume_max(&new_soft_volume),
|
||||
pa_yes_no(accurate_enough));
|
||||
if (pa_alsa_path_set_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map,
|
||||
&r, false, write_to_hw) < 0)
|
||||
return;
|
||||
|
||||
if (accurate_enough)
|
||||
pa_cvolume_reset(&new_soft_volume, new_soft_volume.channels);
|
||||
/* Shift down by the base volume, so that 0dB becomes maximum volume */
|
||||
pa_sw_cvolume_multiply_scalar(&r, &r, dev->base_volume);
|
||||
|
||||
dev->soft_volume = new_soft_volume;
|
||||
} else {
|
||||
pa_log_debug("Wrote hardware volume: %d", pa_cvolume_max(&r));
|
||||
/* We can't match exactly what the user requested, hence let's
|
||||
* at least tell the user about it */
|
||||
dev->real_volume = r;
|
||||
dev->hardware_volume = r;
|
||||
|
||||
if (dev->mixer_path->has_dB) {
|
||||
pa_cvolume new_soft_volume;
|
||||
bool accurate_enough;
|
||||
|
||||
/* Match exactly what the user requested by software */
|
||||
pa_sw_cvolume_divide(&new_soft_volume, &dev->real_volume, &dev->hardware_volume);
|
||||
|
||||
/* If the adjustment to do in software is only minimal we
|
||||
* can skip it. That saves us CPU at the expense of a bit of
|
||||
* accuracy */
|
||||
accurate_enough =
|
||||
(pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
|
||||
(pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
|
||||
|
||||
pa_log_debug("Requested volume: %d", pa_cvolume_max(&dev->real_volume));
|
||||
pa_log_debug("Got hardware volume: %d", pa_cvolume_max(&dev->hardware_volume));
|
||||
pa_log_debug("Calculated software volume: %d (accurate-enough=%s)",
|
||||
pa_cvolume_max(&new_soft_volume),
|
||||
pa_yes_no(accurate_enough));
|
||||
|
||||
if (accurate_enough)
|
||||
pa_cvolume_reset(&new_soft_volume, new_soft_volume.channels);
|
||||
|
||||
dev->soft_volume = new_soft_volume;
|
||||
} else {
|
||||
pa_log_debug("Wrote hardware volume: %d", pa_cvolume_max(&r));
|
||||
/* We can't match exactly what the user requested, hence let's
|
||||
* at least tell the user about it */
|
||||
dev->real_volume = r;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1471,22 +1569,34 @@ static int read_mute(pa_alsa_device *dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (!dev->mixer_handle)
|
||||
if (impl->card.ext_volume.initialized &&
|
||||
(impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_READ_MUTE)) {
|
||||
if (!dev->active_port)
|
||||
return -EINVAL;
|
||||
|
||||
/* Externally managed mute state */
|
||||
if (spa_acp_ext_volume_read_mute(&impl->card.ext_volume, impl->name,
|
||||
dev->active_port->name, dev->active_port->port.index, &mute) < 0) {
|
||||
pa_log_error("Could not read mute state");
|
||||
return 0;
|
||||
}
|
||||
} else if (dev->mixer_handle) {
|
||||
/* ALSA mixer for mute state */
|
||||
if (dev->mixer_path->has_volume_mute) {
|
||||
pa_cvolume mute_vol;
|
||||
pa_cvolume r;
|
||||
|
||||
pa_cvolume_mute(&mute_vol, dev->mapping->channel_map.channels);
|
||||
if ((res = pa_alsa_path_get_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map, &r)) < 0)
|
||||
return res;
|
||||
mute = pa_cvolume_equal(&mute_vol, &r);
|
||||
} else {
|
||||
if ((res = pa_alsa_path_get_mute(dev->mixer_path, dev->mixer_handle, &mute)) < 0)
|
||||
return res;
|
||||
}
|
||||
} else
|
||||
return 0;
|
||||
|
||||
if (dev->mixer_path->has_volume_mute) {
|
||||
pa_cvolume mute_vol;
|
||||
pa_cvolume r;
|
||||
|
||||
pa_cvolume_mute(&mute_vol, dev->mapping->channel_map.channels);
|
||||
if ((res = pa_alsa_path_get_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map, &r)) < 0)
|
||||
return res;
|
||||
mute = pa_cvolume_equal(&mute_vol, &r);
|
||||
} else {
|
||||
if ((res = pa_alsa_path_get_mute(dev->mixer_path, dev->mixer_handle, &mute)) < 0)
|
||||
return res;
|
||||
}
|
||||
|
||||
if (mute == dev->muted)
|
||||
return 0;
|
||||
|
||||
|
|
@ -1501,7 +1611,7 @@ static int read_mute(pa_alsa_device *dev)
|
|||
|
||||
static void set_mute(pa_alsa_device *dev, bool mute)
|
||||
{
|
||||
dev->muted = mute;
|
||||
pa_card *impl = dev->card;
|
||||
|
||||
if (dev->ucm_context) {
|
||||
if (!dev->active_port)
|
||||
|
|
@ -1511,27 +1621,54 @@ static void set_mute(pa_alsa_device *dev, bool mute)
|
|||
return;
|
||||
}
|
||||
|
||||
if (!dev->mixer_handle)
|
||||
return;
|
||||
if (impl->card.ext_volume.initialized) {
|
||||
if (!dev->active_port)
|
||||
return;
|
||||
if ((impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_WRITE_MUTE_VALUE)) {
|
||||
/* Externally managed mute state by value*/
|
||||
if (spa_acp_ext_volume_write_mute_value(&impl->card.ext_volume, impl->name,
|
||||
dev->active_port->name, dev->active_port->port.index, mute) < 0) {
|
||||
pa_log_error("Could not write mute state");
|
||||
return;
|
||||
}
|
||||
|
||||
if (dev->mixer_path->has_volume_mute) {
|
||||
pa_cvolume r;
|
||||
dev->muted = mute;
|
||||
} else if ((impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_READ_MUTE) &&
|
||||
(impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_WRITE_MUTE_TOGGLE)) {
|
||||
/* Externally managed mute state toggle */
|
||||
if (spa_acp_ext_volume_write_mute_toggle(&impl->card.ext_volume, impl->name,
|
||||
dev->active_port->name, dev->active_port->port.index) < 0) {
|
||||
pa_log_error("Could not write mute toggle");
|
||||
return;
|
||||
}
|
||||
|
||||
if (mute) {
|
||||
pa_cvolume_mute(&r, dev->mapping->channel_map.channels);
|
||||
pa_alsa_path_set_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map,
|
||||
&r, false, true);
|
||||
dev->muted = mute;
|
||||
} else {
|
||||
/* Shift up by the base volume */
|
||||
pa_sw_cvolume_divide_scalar(&r, &dev->real_volume, dev->base_volume);
|
||||
pa_log_debug("Restoring volume: %d", pa_cvolume_max(&dev->real_volume));
|
||||
if (pa_alsa_path_set_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map,
|
||||
&r, false, true) < 0)
|
||||
pa_log_error("Unable to restore volume %d during unmute",
|
||||
pa_cvolume_max(&dev->real_volume));
|
||||
pa_log_debug("Ignoring mute setting, ext volume control does not support it");
|
||||
}
|
||||
} else if (dev->mixer_handle) {
|
||||
/* ALSA mixer for mute state */
|
||||
dev->muted = mute;
|
||||
|
||||
if (dev->mixer_path->has_volume_mute) {
|
||||
pa_cvolume r;
|
||||
|
||||
if (mute) {
|
||||
pa_cvolume_mute(&r, dev->mapping->channel_map.channels);
|
||||
pa_alsa_path_set_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map,
|
||||
&r, false, true);
|
||||
} else {
|
||||
/* Shift up by the base volume */
|
||||
pa_sw_cvolume_divide_scalar(&r, &dev->real_volume, dev->base_volume);
|
||||
pa_log_debug("Restoring volume: %d", pa_cvolume_max(&dev->real_volume));
|
||||
if (pa_alsa_path_set_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map,
|
||||
&r, false, true) < 0)
|
||||
pa_log_error("Unable to restore volume %d during unmute",
|
||||
pa_cvolume_max(&dev->real_volume));
|
||||
}
|
||||
} else {
|
||||
pa_alsa_path_set_mute(dev->mixer_path, dev->mixer_handle, mute);
|
||||
}
|
||||
} else {
|
||||
pa_alsa_path_set_mute(dev->mixer_path, dev->mixer_handle, mute);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1539,7 +1676,15 @@ static void mixer_volume_init(pa_card *impl, pa_alsa_device *dev)
|
|||
{
|
||||
pa_assert(dev);
|
||||
|
||||
if (impl->soft_mixer || !dev->mixer_path || !dev->mixer_path->has_volume) {
|
||||
if (impl->ext_volume_ctrl) {
|
||||
dev->device.flags |= ACP_DEVICE_HW_VOLUME;
|
||||
if (impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_READ_VOLUME)
|
||||
dev->read_volume = read_volume;
|
||||
if (impl->card.ext_volume.flags &
|
||||
(SPA_AUDIO_VOLUME_CONTROL_WRITE_VOLUME_VALUE |
|
||||
SPA_AUDIO_VOLUME_CONTROL_WRITE_VOLUME_UPDOWN))
|
||||
dev->set_volume = set_volume;
|
||||
} else if (impl->soft_mixer || !dev->mixer_path || !dev->mixer_path->has_volume) {
|
||||
dev->read_volume = NULL;
|
||||
dev->set_volume = NULL;
|
||||
pa_log_info("Driver does not support hardware volume control, "
|
||||
|
|
@ -1587,7 +1732,15 @@ static void mixer_volume_init(pa_card *impl, pa_alsa_device *dev)
|
|||
dev->device.base_volume = (float)pa_sw_volume_to_linear(dev->base_volume);
|
||||
dev->device.volume_step = 1.0f / dev->n_volume_steps;
|
||||
|
||||
if (impl->soft_mixer || !dev->mixer_path ||
|
||||
if (impl->ext_volume_ctrl) {
|
||||
dev->device.flags |= ACP_DEVICE_HW_MUTE;
|
||||
if (impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_READ_MUTE)
|
||||
dev->read_mute = read_mute;
|
||||
if (impl->card.ext_volume.flags &
|
||||
(SPA_AUDIO_VOLUME_CONTROL_WRITE_MUTE_VALUE |
|
||||
SPA_AUDIO_VOLUME_CONTROL_WRITE_MUTE_TOGGLE))
|
||||
dev->set_mute = set_mute;
|
||||
} else if (impl->soft_mixer || !dev->mixer_path ||
|
||||
(!dev->mixer_path->has_mute && !dev->mixer_path->has_volume_mute)) {
|
||||
dev->read_mute = NULL;
|
||||
dev->set_mute = NULL;
|
||||
|
|
@ -1656,6 +1809,12 @@ static int setup_mixer(pa_card *impl, pa_alsa_device *dev, bool ignore_dB)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (impl->ext_volume_ctrl) {
|
||||
/* We've been told to use an external service to manage volume */
|
||||
init_ext_volume(impl);
|
||||
dev->device.ext_volume_flags = impl->card.ext_volume.flags;
|
||||
}
|
||||
|
||||
mixer_volume_init(impl, dev);
|
||||
|
||||
/* Will we need to register callbacks? */
|
||||
|
|
@ -1975,6 +2134,8 @@ struct acp_card *acp_card_new(uint32_t index, const struct acp_dict *props)
|
|||
impl->disable_pro_audio = spa_atob(s);
|
||||
if ((s = acp_dict_lookup(props, "api.acp.use-eld-channels")) != NULL)
|
||||
impl->use_eld_channels = spa_atob(s);
|
||||
if ((s = acp_dict_lookup(props, "api.alsa.external-volume-control")) != NULL)
|
||||
impl->ext_volume_ctrl = spa_atob(s);
|
||||
}
|
||||
|
||||
#if SND_LIB_VERSION < 0x10207
|
||||
|
|
@ -2360,6 +2521,7 @@ int acp_device_set_mute(struct acp_device *dev, bool mute)
|
|||
|
||||
if (d->set_mute) {
|
||||
d->set_mute(d, mute);
|
||||
mute = d->muted;
|
||||
} else {
|
||||
d->muted = mute;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue