mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2026-05-01 06:46:47 -04:00
spa: alsa: Add a mechanism for external volume control
Currently enabled at device creation and delegated to an external entity via a varlink protocol.
This commit is contained in:
Arun Raghavan
parent
6e1fe332ef
commit
ce6961bc08
9 changed files with 758 additions and 88 deletions
|
|
@ -5,18 +5,23 @@
|
|||
#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>
|
||||
#include <spa/utils/json-builder.h>
|
||||
#include <spa/utils/cleanup.h>
|
||||
#include <spa/param/audio/iec958-types.h>
|
||||
#include <spa/param/audio/raw.h>
|
||||
#include <spa/param/audio/volume.h>
|
||||
#include <spa/support/varlink.h>
|
||||
|
||||
int _acp_log_level = 1;
|
||||
acp_log_func _acp_log_func;
|
||||
void *_acp_log_data;
|
||||
|
||||
struct spa_i18n *acp_i18n;
|
||||
struct spa_varlink *acp_varlink;
|
||||
|
||||
#define DEFAULT_CHANNELS 255u
|
||||
#define DEFAULT_RATE 48000u
|
||||
|
|
@ -1245,6 +1250,30 @@ static void init_eld_ctls(pa_card *impl)
|
|||
}
|
||||
}
|
||||
|
||||
static void init_ext_volume(pa_card *impl)
|
||||
{
|
||||
struct acp_card *card = &impl->card;
|
||||
int res;
|
||||
|
||||
if (!impl->ext_volume_path)
|
||||
return;
|
||||
|
||||
if (!acp_varlink) {
|
||||
pa_log_error("External volume control requires support.varlink = true");
|
||||
return;
|
||||
}
|
||||
|
||||
res = spa_acp_ext_volume_init(&card->ext_volume, acp_varlink, impl->ext_volume_path, impl->name, NULL);
|
||||
if (res < 0) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
/* FIXME: Set up monitor callback */
|
||||
|
||||
error:
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t acp_card_find_best_profile_index(struct acp_card *card, const char *name)
|
||||
{
|
||||
uint32_t i;
|
||||
|
|
@ -1356,21 +1385,47 @@ static int read_volume(pa_alsa_device *dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (!dev->mixer_handle)
|
||||
if (impl->card.ext_volume.client &&
|
||||
(impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_READ_VOLUME)) {
|
||||
/* Externally managed volume */
|
||||
pa_cvolume ext_vol;
|
||||
|
||||
if ((res = spa_acp_ext_volume_read_volume(&impl->card.ext_volume, impl->name,
|
||||
dev->active_port->name, &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;
|
||||
|
|
@ -1393,12 +1448,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;
|
||||
|
|
@ -1407,52 +1460,99 @@ static void set_volume(pa_alsa_device *dev, const pa_cvolume *v)
|
|||
return;
|
||||
}
|
||||
|
||||
if (!dev->mixer_handle)
|
||||
return;
|
||||
if (impl->card.ext_volume.client) {
|
||||
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->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, 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1470,22 +1570,31 @@ static int read_mute(pa_alsa_device *dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (!dev->mixer_handle)
|
||||
if (impl->card.ext_volume.client &&
|
||||
(impl->card.ext_volume.flags & SPA_AUDIO_VOLUME_CONTROL_READ_MUTE)) {
|
||||
/* Externally managed mute state */
|
||||
if (spa_acp_ext_volume_read_mute(&impl->card.ext_volume, impl->name,
|
||||
dev->active_port->name, &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;
|
||||
|
||||
|
|
@ -1500,7 +1609,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)
|
||||
|
|
@ -1510,27 +1619,52 @@ static void set_mute(pa_alsa_device *dev, bool mute)
|
|||
return;
|
||||
}
|
||||
|
||||
if (!dev->mixer_handle)
|
||||
return;
|
||||
if (impl->card.ext_volume.client) {
|
||||
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, 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) < 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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1538,7 +1672,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_path) {
|
||||
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, "
|
||||
|
|
@ -1586,7 +1728,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_path) {
|
||||
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;
|
||||
|
|
@ -1596,7 +1746,7 @@ static void mixer_volume_init(pa_card *impl, pa_alsa_device *dev)
|
|||
dev->read_mute = read_mute;
|
||||
dev->set_mute = set_mute;
|
||||
pa_log_info("Using hardware %smute control.",
|
||||
dev->mixer_path->has_volume_mute ? "volume-" : "");
|
||||
dev->mixer_path->has_volume_mute ? "volume-" : NULL);
|
||||
dev->device.flags |= ACP_DEVICE_HW_MUTE;
|
||||
}
|
||||
}
|
||||
|
|
@ -1655,6 +1805,12 @@ static int setup_mixer(pa_card *impl, pa_alsa_device *dev, bool ignore_dB)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (impl->ext_volume_path) {
|
||||
/* 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? */
|
||||
|
|
@ -1677,6 +1833,7 @@ static int setup_mixer(pa_card *impl, pa_alsa_device *dev, bool ignore_dB)
|
|||
else
|
||||
pa_alsa_path_set_callback(dev->mixer_path, dev->mixer_handle, mixer_callback, dev);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1972,6 +2129,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_path = strdup(s);
|
||||
}
|
||||
|
||||
#if SND_LIB_VERSION < 0x10207
|
||||
|
|
@ -2057,6 +2216,7 @@ struct acp_card *acp_card_new(uint32_t index, const struct acp_dict *props)
|
|||
return &impl->card;
|
||||
error:
|
||||
pa_alsa_refcnt_dec();
|
||||
free(impl->ext_volume_path);
|
||||
free(impl);
|
||||
errno = -res;
|
||||
return NULL;
|
||||
|
|
@ -2089,6 +2249,10 @@ void acp_card_destroy(struct acp_card *card)
|
|||
pa_alsa_ucm_free(&impl->ucm);
|
||||
pa_proplist_free(impl->proplist);
|
||||
pa_alsa_refcnt_dec();
|
||||
if (impl->ext_volume_path) {
|
||||
spa_acp_ext_volume_destroy(&impl->card.ext_volume);
|
||||
free(impl->ext_volume_path);
|
||||
}
|
||||
free(impl);
|
||||
}
|
||||
|
||||
|
|
@ -2357,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