mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2026-05-30 21:37:53 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

spa: alsa: Add a mechanism for external volume control

Browse source 
Currently enabled at device creation and delegated to an external entity
via spa_device events.
This commit is contained in:
Julian Bouzas 2026-05-15 10:11:13 -04:00
parent 122bfd712b
commit ef6f5194e3
9 changed files with 867 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

1
spa/include/spa/monitor/event.h
View file

@ -19,6 +19,7 @@ extern "C" {
/* object id of SPA_TYPE_EVENT_Device */
enum spa_device_event {
SPA_DEVICE_EVENT_ObjectConfig,
SPA_DEVICE_EVENT_ExtVolumeControl,
};
#define SPA_DEVICE_EVENT_ID(ev) SPA_EVENT_ID(ev, SPA_TYPE_EVENT_Device)

1
spa/include/spa/monitor/type-info.h
View file

@ -26,6 +26,7 @@ extern "C" {
static const struct spa_type_info spa_type_device_event_id[] = {
{ SPA_DEVICE_EVENT_ObjectConfig, SPA_TYPE_EVENT_Device, SPA_TYPE_INFO_DEVICE_EVENT_ID_BASE "ObjectConfig", NULL },
{ SPA_DEVICE_EVENT_ExtVolumeControl, SPA_TYPE_EVENT_Device, SPA_TYPE_INFO_DEVICE_EVENT_ID_BASE "ExtVolumeControl", NULL },
{ 0, 0, NULL, NULL },
};

332
spa/plugins/alsa/acp/acp.c
View file

@ -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;
}

11
spa/plugins/alsa/acp/acp.h
View file

@ -11,6 +11,10 @@
#include <poll.h>
#include <string.h>
#include <spa/param/audio/volume.h>
#include "ext-volume.h"
#ifdef __cplusplus
extern "C" {
#else
@ -188,6 +192,8 @@ struct acp_card_events {
void (*volume_changed) (void *data, struct acp_device *dev);
void (*mute_changed) (void *data, struct acp_device *dev);
void (*ext_vol_event_available) (void *data, struct spa_event *event);
};
struct acp_port {
@ -239,6 +245,9 @@ struct acp_device {
int64_t latency_ns;
uint32_t codecs[32];
uint32_t n_codecs;
uint32_t ext_volume_flags;
};
struct acp_card_profile {
@ -277,6 +286,8 @@ struct acp_card {
struct acp_port **ports;
uint32_t preferred_input_port_index;
uint32_t preferred_output_port_index;
struct spa_acp_ext_volume ext_volume;
};
struct acp_card *acp_card_new(uint32_t index, const struct acp_dict *props);

2
spa/plugins/alsa/acp/card.h
View file

@ -68,6 +68,8 @@ struct pa_card {
const struct acp_card_events *events;
void *user_data;
bool ext_volume_ctrl;
};
bool pa_alsa_device_init_description(pa_proplist *p, pa_card *card);

298
spa/plugins/alsa/acp/ext-volume.c Normal file
View file

@ -0,0 +1,298 @@
/* External Volume Control */
/* SPDX-FileCopyrightText: Copyright © 2026 Arun Raghavan */
/* SPDX-FileCopyrightText: Copyright © 2026 Julian Bouzas */
/* SPDX-License-Identifier: MIT */
#include <spa/utils/cleanup.h>
#include <spa/utils/result.h>
#include <spa/pod/builder.h>
#include <spa/monitor/event.h>
#include <spa/param/props.h>
#include "alsa-mixer.h"
#include "channelmap.h"
#include "volume.h"
#include "ext-volume.h"
int
spa_acp_ext_volume_init(struct spa_acp_ext_volume *ext_volume, const char *device,
ext_volume_notifier_t notifier_cb, void *notifier_data)
{
struct spa_event *ev;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[3];
ext_volume->initialized = false;
ext_volume->flags = 0;
ext_volume->notifier_cb = notifier_cb;
ext_volume->notifier_data = notifier_data;
/* Create event */
spa_pod_builder_init(&b, buffer, sizeof(buffer));
spa_pod_builder_push_object(&b, &f[0],
SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ExtVolumeControl);
spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0);
spa_pod_builder_push_object(&b, &f[1],
SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props);
spa_pod_builder_prop(&b, SPA_PROP_params, 0);
spa_pod_builder_push_struct(&b, &f[2]);
spa_pod_builder_string(&b, "GetCapabilities");
spa_pod_builder_string(&b, device ? device : "");
spa_pod_builder_pop(&b, &f[2]);
spa_pod_builder_pop(&b, &f[1]);
ev = (struct spa_event *)spa_pod_builder_pop(&b, &f[0]);
pa_log_info("sending 'GetCapabilities' ext-vol-control event to %s", device);
/* Emit */
ext_volume->caps_reply.res = -EINVAL;
ext_volume->notifier_cb (ext_volume->notifier_data, ev);
pa_log_info("reply after emitting event: res:%d caps:%d",
ext_volume->caps_reply.res, ext_volume->caps_reply.caps);
/* Check reply */
if (ext_volume->caps_reply.res < 0)
return ext_volume->caps_reply.res;
ext_volume->flags = ext_volume->caps_reply.caps;
ext_volume->initialized = true;
return ext_volume->caps_reply.res;
}
int
spa_acp_ext_volume_read_volume(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, pa_cvolume *cvol)
{
struct spa_event *ev;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[3];
/* Create event */
spa_pod_builder_init(&b, buffer, sizeof(buffer));
spa_pod_builder_push_object(&b, &f[0],
SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ExtVolumeControl);
spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0);
spa_pod_builder_push_object(&b, &f[1],
SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props);
spa_pod_builder_prop(&b, SPA_PROP_params, 0);
spa_pod_builder_push_struct(&b, &f[2]);
spa_pod_builder_string(&b, "ReadVolume");
spa_pod_builder_string(&b, device ? device : "");
spa_pod_builder_string(&b, port_name ? port_name : "");
spa_pod_builder_pop(&b, &f[2]);
spa_pod_builder_pop(&b, &f[1]);
ev = (struct spa_event *)spa_pod_builder_pop(&b, &f[0]);
pa_log_info("sending 'ReadVolume' ext-vol-control event to %s on port %s", device, port_name);
/* Emit */
ext_volume->vols_replies[port_index].res = -EINVAL;
ext_volume->notifier_cb (ext_volume->notifier_data, ev);
pa_log_info("reply after emitting event: res:%d channels:%u",
ext_volume->vols_replies[port_index].res, ext_volume->vols_replies[port_index].channels);
/* Check reply */
if (ext_volume->vols_replies[port_index].res < 0)
return ext_volume->vols_replies[port_index].res;
cvol->channels = ext_volume->vols_replies[port_index].channels;
for (uint32_t i = 0; i < cvol->channels && i < PA_CHANNELS_MAX && i < SPA_AUDIO_MAX_CHANNELS; i++) {
double v = ext_volume->vols_replies[port_index].values[i];
cvol->values[i] = lrint(v * PA_VOLUME_NORM);
}
return ext_volume->vols_replies[port_index].res;
}
int
spa_acp_ext_volume_write_volume_absolute(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, pa_cvolume *cvol)
{
struct spa_event *ev;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[4];
/* Create event */
spa_pod_builder_init(&b, buffer, sizeof(buffer));
spa_pod_builder_push_object(&b, &f[0],
SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ExtVolumeControl);
spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0);
spa_pod_builder_push_object(&b, &f[1],
SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props);
spa_pod_builder_prop(&b, SPA_PROP_params, 0);
spa_pod_builder_push_struct(&b, &f[2]);
spa_pod_builder_string(&b, "WriteVolumeAbsolute");
spa_pod_builder_string(&b, device ? device : "");
spa_pod_builder_string(&b, port_name ? port_name : "");
/* FIXME: scale to the range from capabilities */
spa_pod_builder_push_array(&b, &f[3]);
if (ext_volume->flags & SPA_AUDIO_VOLUME_CONTROL_WRITE_BALANCE) {
/* Write all channels */
for (uint32_t i = 0; i < cvol->channels; i++)
spa_pod_builder_double(&b, cvol->values[i] / PA_VOLUME_NORM);
} else {
/* Single volume */
spa_pod_builder_double(&b, pa_cvolume_max(cvol) / PA_VOLUME_NORM);
}
spa_pod_builder_pop(&b, &f[3]);
spa_pod_builder_pop(&b, &f[2]);
spa_pod_builder_pop(&b, &f[1]);
ev = (struct spa_event *)spa_pod_builder_pop(&b, &f[0]);
pa_log_info("sending 'WriteVolumeAbsolute' ext-vol-control event to %s on port %s", device, port_name);
/* Emit */
ext_volume->notifier_cb (ext_volume->notifier_data, ev);
return 0;
}
int
spa_acp_ext_volume_write_volume_relative(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, float step)
{
struct spa_event *ev;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[3];
/* Create event */
spa_pod_builder_init(&b, buffer, sizeof(buffer));
spa_pod_builder_push_object(&b, &f[0],
SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ExtVolumeControl);
spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0);
spa_pod_builder_push_object(&b, &f[1],
SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props);
spa_pod_builder_prop(&b, SPA_PROP_params, 0);
spa_pod_builder_push_struct(&b, &f[2]);
spa_pod_builder_string(&b, "WriteVolumeRelative");
spa_pod_builder_string(&b, device ? device : "");
spa_pod_builder_string(&b, port_name ? port_name : "");
spa_pod_builder_float(&b, step);
spa_pod_builder_pop(&b, &f[2]);
spa_pod_builder_pop(&b, &f[1]);
ev = (struct spa_event *)spa_pod_builder_pop(&b, &f[0]);
pa_log_info("sending 'WriteVolumeRelative' ext-vol-control event to %s on port %s", device, port_name);
/* Emit */
ext_volume->notifier_cb (ext_volume->notifier_data, ev);
return 0;
}
int
spa_acp_ext_volume_read_mute(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, bool *mute)
{
struct spa_event *ev;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[3];
/* Create event */
spa_pod_builder_init(&b, buffer, sizeof(buffer));
spa_pod_builder_push_object(&b, &f[0],
SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ExtVolumeControl);
spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0);
spa_pod_builder_push_object(&b, &f[1],
SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props);
spa_pod_builder_prop(&b, SPA_PROP_params, 0);
spa_pod_builder_push_struct(&b, &f[2]);
spa_pod_builder_string(&b, "ReadMute");
spa_pod_builder_string(&b, device ? device : "");
spa_pod_builder_string(&b, port_name ? port_name : "");
spa_pod_builder_pop(&b, &f[2]);
spa_pod_builder_pop(&b, &f[1]);
ev = (struct spa_event *)spa_pod_builder_pop(&b, &f[0]);
pa_log_info("sending 'ReadMute' ext-vol-control event to %s on port %s", device, port_name);
/* Emit */
ext_volume->mute_replies[port_index].res = EINVAL;
ext_volume->notifier_cb (ext_volume->notifier_data, ev);
pa_log_info("reply after emitting event: res:%d mute:%u",
ext_volume->mute_replies[port_index].res, ext_volume->mute_replies[port_index].mute);
/* Check reply */
if (ext_volume->mute_replies[port_index].res < 0)
return ext_volume->mute_replies[port_index].res;
*mute = ext_volume->mute_replies[port_index].mute;
return ext_volume->mute_replies[port_index].res;
}
int
spa_acp_ext_volume_write_mute_value(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, bool mute)
{
struct spa_event *ev;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[3];
/* Create event */
spa_pod_builder_init(&b, buffer, sizeof(buffer));
spa_pod_builder_push_object(&b, &f[0],
SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ExtVolumeControl);
spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0);
spa_pod_builder_push_object(&b, &f[1],
SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props);
spa_pod_builder_prop(&b, SPA_PROP_params, 0);
spa_pod_builder_push_struct(&b, &f[2]);
spa_pod_builder_string(&b, "WriteMuteValue");
spa_pod_builder_string(&b, device ? device : "");
spa_pod_builder_string(&b, port_name ? port_name : "");
spa_pod_builder_bool(&b, mute);
spa_pod_builder_pop(&b, &f[2]);
spa_pod_builder_pop(&b, &f[1]);
ev = (struct spa_event *)spa_pod_builder_pop(&b, &f[0]);
pa_log_info("sending 'WriteMuteValue' ext-vol-control event to %s on port %s", device, port_name);
/* Emit */
ext_volume->notifier_cb (ext_volume->notifier_data, ev);
return 0;
}
int
spa_acp_ext_volume_write_mute_toggle(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index)
{
struct spa_event *ev;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[3];
/* Create event */
spa_pod_builder_init(&b, buffer, sizeof(buffer));
spa_pod_builder_push_object(&b, &f[0],
SPA_TYPE_EVENT_Device, SPA_DEVICE_EVENT_ExtVolumeControl);
spa_pod_builder_prop(&b, SPA_EVENT_DEVICE_Props, 0);
spa_pod_builder_push_object(&b, &f[1],
SPA_TYPE_OBJECT_Props, SPA_EVENT_DEVICE_Props);
spa_pod_builder_prop(&b, SPA_PROP_params, 0);
spa_pod_builder_push_struct(&b, &f[2]);
spa_pod_builder_string(&b, "WriteMuteToggle");
spa_pod_builder_string(&b, device ? device : "");
spa_pod_builder_string(&b, port_name ? port_name : "");
spa_pod_builder_pop(&b, &f[2]);
spa_pod_builder_pop(&b, &f[1]);
ev = (struct spa_event *)spa_pod_builder_pop(&b, &f[0]);
pa_log_info("sending 'WriteMuteToggle' ext-vol-control event to %s on port %s", device, port_name);
/* Emit */
ext_volume->notifier_cb (ext_volume->notifier_data, ev);
return 0;
}

69
spa/plugins/alsa/acp/ext-volume.h Normal file
View file

@ -0,0 +1,69 @@
/* External Volume Control */
/* SPDX-FileCopyrightText: Copyright © 2026 Arun Raghavan */
/* SPDX-FileCopyrightText: Copyright © 2026 Julian Bouzas */
/* SPDX-License-Identifier: MIT */
#ifndef ACP_EXT_VOLUME_H
#define ACP_EXT_VOLUME_H
#include <stdint.h>
#include <spa/param/audio/volume.h>
#include <spa/pod/event.h>
#define MAX_PORTS 256
typedef struct pa_cvolume pa_cvolume;
typedef void (*ext_volume_notifier_t) (void *data, struct spa_event *event);
struct caps_reply {
int res;
enum spa_audio_volume_control_flags caps;
};
struct mute_reply {
int res;
bool mute;
};
struct vols_reply {
int res;
uint32_t channels;
double values[SPA_AUDIO_MAX_CHANNELS];
};
struct spa_acp_ext_volume {
bool initialized;
enum spa_audio_volume_control_flags flags;
ext_volume_notifier_t notifier_cb;
void *notifier_data;
struct caps_reply caps_reply;
struct mute_reply mute_replies[MAX_PORTS];
struct vols_reply vols_replies[MAX_PORTS];
};
int spa_acp_ext_volume_init(struct spa_acp_ext_volume *ext_volume, const char *device,
ext_volume_notifier_t notifier_cb, void *notifier_data);
int spa_acp_ext_volume_read_volume(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, pa_cvolume *cvol);
int spa_acp_ext_volume_write_volume_absolute(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, pa_cvolume *cvol);
int spa_acp_ext_volume_write_volume_relative(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, float step);
int spa_acp_ext_volume_read_mute(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, bool *mute);
int spa_acp_ext_volume_write_mute_value(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index, bool mute);
int spa_acp_ext_volume_write_mute_toggle(struct spa_acp_ext_volume *ext_volume,
const char *device, const char *port_name, uint32_t port_index);
#endif /* ACP_EXT_VOLUME_H */

1
spa/plugins/alsa/acp/meson.build
View file

@ -5,6 +5,7 @@ acp_sources = [
'alsa-ucm.c',
'alsa-util.c',
'conf-parser.c',
'ext-volume.c',
]
acp_c_args = [

238
spa/plugins/alsa/alsa-acp-device.c
View file

@ -70,7 +70,8 @@ struct impl {
#define IDX_Profile 1
#define IDX_EnumRoute 2
#define IDX_Route 3
struct spa_param_info params[4];
#define IDX_Props 4
struct spa_param_info params[5];
struct spa_hook_list hooks;
@ -490,6 +491,11 @@ static struct spa_pod *build_route(struct spa_pod_builder *b, uint32_t id,
dev->n_codecs, dev->codecs);
}
if (dev->ext_volume_flags) {
spa_pod_builder_prop(b, SPA_PROP_volumeControlFlags, 0);
spa_pod_builder_id(b, dev->ext_volume_flags);
}
spa_pod_builder_pop(b, &f[1]);
}
spa_pod_builder_prop(b, SPA_PARAM_ROUTE_devices, 0);
@ -507,6 +513,41 @@ static struct spa_pod *build_route(struct spa_pod_builder *b, uint32_t id,
return spa_pod_builder_pop(b, &f[0]);
}
static struct spa_pod *build_props(struct spa_pod_builder *b, struct acp_card *card, struct acp_port *p)
{
struct spa_pod_frame f[4];
spa_pod_builder_push_object(b, &f[0], SPA_TYPE_OBJECT_Props, SPA_PARAM_Props);
spa_pod_builder_prop(b, SPA_PROP_params, 0);
spa_pod_builder_push_struct(b, &f[1]);
spa_pod_builder_string(b, "ext-control-caps-reply");
spa_pod_builder_push_struct(b, &f[2]);
spa_pod_builder_int(b, card->ext_volume.caps_reply.res);
spa_pod_builder_int(b, card->ext_volume.caps_reply.caps);
spa_pod_builder_pop(b, &f[2]);
spa_pod_builder_string(b, "ext-control-vols-reply");
spa_pod_builder_push_struct(b, &f[2]);
spa_pod_builder_string(b, p->name);
spa_pod_builder_int(b, card->ext_volume.vols_replies[p->index].res);
spa_pod_builder_push_array(b, &f[3]);
for (uint32_t i = 0; i < card->ext_volume.vols_replies[p->index].channels; i++)
spa_pod_builder_double(b, card->ext_volume.vols_replies[p->index].values[i]);
spa_pod_builder_pop(b, &f[3]);
spa_pod_builder_pop(b, &f[2]);
spa_pod_builder_string(b, "ext-control-mute-reply");
spa_pod_builder_push_struct(b, &f[2]);
spa_pod_builder_string(b, p->name);
spa_pod_builder_int(b, card->ext_volume.mute_replies[p->index].res);
spa_pod_builder_bool(b, card->ext_volume.mute_replies[p->index].mute);
spa_pod_builder_pop(b, &f[2]);
spa_pod_builder_pop(b, &f[1]);
return spa_pod_builder_pop(b, &f[0]);
}
static struct acp_port *find_port_for_device(struct acp_card *card, struct acp_device *dev)
{
uint32_t i;
@ -601,6 +642,16 @@ static int impl_enum_params(void *object, int seq,
return -errno;
break;
case SPA_PARAM_Props:
if (result.index >= card->n_ports)
return 0;
p = card->ports[result.index];
if (SPA_FLAG_IS_SET(p->flags, ACP_PORT_HIDDEN))
goto next;
param = build_props(&b.b, card, p);
break;
default:
return -ENOENT;
}
@ -793,6 +844,165 @@ static bool check_active_profile_port(struct impl *this, uint32_t device, uint32
return true;
}
static int parse_ext_control_caps_reply (struct acp_card *card, struct spa_pod_struct *reply)
{
int changed = 0;
struct spa_pod *it;
bool res_parsed = false, caps_parsed = false;
int res = 0, caps = 0;
int field = 0;
SPA_POD_STRUCT_FOREACH(reply, it) {
switch (field++) {
case 0:
if (spa_pod_get_int(it, &res) >= 0)
res_parsed = true;
break;
case 1:
if (spa_pod_get_int(it, &caps) >= 0)
caps_parsed = true;
break;
default:
break;
}
}
if (res_parsed && caps_parsed) {
card->ext_volume.caps_reply.res = res;
card->ext_volume.caps_reply.caps = caps;
changed++;
}
return changed;
}
static int parse_ext_control_vols_reply (struct acp_card *card, struct spa_pod_struct *reply)
{
int changed = 0;
struct spa_pod *it;
const char *route_name = NULL;
bool res_parsed = false, vols_parsed = false;
int res = 0;
uint32_t channels;
int64_t *vols;
uint32_t port_index = ACP_INVALID_INDEX;
int field = 0;
SPA_POD_STRUCT_FOREACH(reply, it) {
switch (field++) {
case 0:
spa_pod_get_string(it, &route_name);
break;
case 1:
if (spa_pod_get_int(it, &res) >= 0)
res_parsed = true;
break;
case 2:
vols_parsed = true;
channels = SPA_POD_ARRAY_N_VALUES(SPA_POD_BODY(it));
vols = SPA_POD_ARRAY_VALUES(SPA_POD_BODY(it));
break;
default:
break;
}
}
port_index = find_route_by_name(card, route_name);
if (port_index != ACP_INVALID_INDEX && res_parsed && vols_parsed) {
card->ext_volume.vols_replies[port_index].res = res;
card->ext_volume.vols_replies[port_index].channels = channels;
for (uint32_t i = 0; i < channels; i++)
card->ext_volume.vols_replies[port_index].values[i] = vols[i];
changed++;
}
return changed;
}
static int parse_ext_control_mute_reply (struct acp_card *card, struct spa_pod_struct *reply)
{
int changed = 0;
struct spa_pod *it;
const char *route_name = NULL;
bool res_parsed = false, mute_parsed = false, mute = false;
int res = 0;
uint32_t port_index = ACP_INVALID_INDEX;
int field = 0;
SPA_POD_STRUCT_FOREACH(reply, it) {
switch (field++) {
case 0:
spa_pod_get_string(it, &route_name);
break;
case 1:
if (spa_pod_get_int(it, &res) >= 0)
res_parsed = true;
break;
case 2:
if (spa_pod_get_bool(it, &mute) >= 0)
mute_parsed = true;
break;
default:
break;
}
}
port_index = find_route_by_name(card, route_name);
if (port_index != ACP_INVALID_INDEX && res_parsed && mute_parsed) {
card->ext_volume.mute_replies[port_index].res = res;
card->ext_volume.mute_replies[port_index].mute = mute;
changed++;
}
return changed;
}
static int parse_prop_params(struct impl *this, struct spa_pod *params)
{
struct acp_card *card = this->card;
struct spa_pod_parser prs;
struct spa_pod_frame f;
int changed = 0;
if (params == NULL)
return 0;
spa_pod_parser_pod(&prs, params);
if (spa_pod_parser_push_struct(&prs, &f) < 0)
return 0;
while (true) {
const char *name;
struct spa_pod *pod;
if (spa_pod_parser_get_string(&prs, &name) < 0)
break;
if (spa_pod_parser_get_pod(&prs, &pod) < 0)
break;
if (spa_streq(name, "ext-control-caps-reply") && spa_pod_is_struct(pod)) {
parse_ext_control_caps_reply(card, (struct spa_pod_struct *)pod);
} else if (spa_streq(name, "ext-control-vols-reply") && spa_pod_is_struct(pod)) {
parse_ext_control_vols_reply(card, (struct spa_pod_struct *)pod);
} else if (spa_streq(name, "ext-control-mute-reply") && spa_pod_is_struct(pod)) {
parse_ext_control_mute_reply(card, (struct spa_pod_struct *)pod);
} else
continue;
changed++;
}
if (changed > 0) {
this->info.change_mask |= SPA_DEVICE_CHANGE_MASK_PARAMS;
this->params[IDX_Props].user++;
}
return changed;
}
static int impl_set_param(void *object,
uint32_t id, uint32_t flags,
const struct spa_pod *param)
@ -879,6 +1089,25 @@ static int impl_set_param(void *object,
emit_info(this, false);
break;
}
case SPA_PARAM_Props:
{
struct spa_pod *params = NULL;
if (param == NULL)
return 0;
if ((res = spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_params, SPA_POD_OPT_Pod(&params))) < 0) {
spa_log_warn(this->log, "can't parse props");
spa_debug_log_pod(this->log, SPA_LOG_LEVEL_DEBUG, 0, NULL, param);
return res;
}
parse_prop_params(this, params);
break;
}
default:
return -ENOENT;
}
@ -1083,6 +1312,12 @@ static void on_mute_changed(void *data, struct acp_device *dev)
spa_device_emit_event(&this->hooks, event);
}
static void on_ext_vol_event_available(void *data, struct spa_event *event)
{
struct impl *this = data;
spa_device_emit_event(&this->hooks, event);
}
static const struct acp_card_events card_events = {
ACP_VERSION_CARD_EVENTS,
.props_changed = card_props_changed,
@ -1092,6 +1327,7 @@ static const struct acp_card_events card_events = {
.port_available = card_port_available,
.volume_changed = on_volume_changed,
.mute_changed = on_mute_changed,
.ext_vol_event_available = on_ext_vol_event_available,
};
static int impl_get_interface(struct spa_handle *handle, const char *type, void **interface)