mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-01 22:58:50 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

alsa: rework monitor

Browse source 
Enumerate all playback and capture devices
This commit is contained in:
Wim Taymans 2017-04-05 18:37:12 +02:00
parent 22070ecbf8
commit 8594d28f59
4 changed files with 195 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

13
pinos/server/link.c
View file

@ -346,10 +346,6 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
asprintf (&error, "error get input port info: %d", res); asprintf (&error, "error get input port info: %d", res);
goto error; goto error;
} }
if (pinos_log_level_enabled (SPA_LOG_LEVEL_DEBUG)) {
spa_debug_port_info (oinfo, this->core->type.map);
spa_debug_port_info (iinfo, this->core->type.map);
}
in_flags = iinfo->flags; in_flags = iinfo->flags;
out_flags = oinfo->flags; out_flags = oinfo->flags;
@ -388,8 +384,15 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
} else if (out_state == SPA_NODE_STATE_READY && in_state > SPA_NODE_STATE_READY) { } else if (out_state == SPA_NODE_STATE_READY && in_state > SPA_NODE_STATE_READY) {
in_flags &= ~SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS; in_flags &= ~SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
out_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS; out_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
} else } else {
pinos_log_debug ("link %p: delay allocation, state %d %d", this, in_state, out_state);
return SPA_RESULT_OK; return SPA_RESULT_OK;
}
if (pinos_log_level_enabled (SPA_LOG_LEVEL_DEBUG)) {
spa_debug_port_info (oinfo, this->core->type.map);
spa_debug_port_info (iinfo, this->core->type.map);
}
if (impl->buffers == NULL) { if (impl->buffers == NULL) {
SpaAllocParam *in_alloc, *out_alloc; SpaAllocParam *in_alloc, *out_alloc;

296
spa/plugins/alsa/alsa-monitor.c
View file

@ -38,11 +38,6 @@ extern const SpaHandleFactory spa_alsa_source_factory;
typedef struct _SpaALSAMonitor SpaALSAMonitor; typedef struct _SpaALSAMonitor SpaALSAMonitor;
typedef struct {
SpaMonitorItem *item;
struct udev_device *udevice;
} ALSAItem;
typedef struct { typedef struct {
uint32_t handle_factory; uint32_t handle_factory;
SpaTypeMonitor monitor; SpaTypeMonitor monitor;
@ -72,9 +67,15 @@ struct _SpaALSAMonitor {
struct udev_enumerate *enumerate; struct udev_enumerate *enumerate;
uint32_t index; uint32_t index;
struct udev_list_entry *devices; struct udev_list_entry *devices;
uint8_t item_buffer[4096];
ALSAItem uitem; uint8_t item_buffer[4096];
SpaMonitorItem *item;
snd_ctl_t *ctl_hndl;
struct udev_device *dev;
char card_name[64];
int dev_idx;
int stream_idx;
int fd; int fd;
SpaSource source; SpaSource source;
@ -108,81 +109,43 @@ path_get_card_id (const char *path)
return e + 5; return e + 5;
} }
#define CHECK(s,msg) if ((err = (s)) < 0) { spa_log_error (state->log, msg ": %s", snd_strerror(err)); return err; }
static int static int
fill_item (SpaALSAMonitor *this, ALSAItem *item, struct udev_device *udevice) fill_item (SpaALSAMonitor *this,
snd_ctl_card_info_t *card_info,
snd_pcm_info_t *dev_info,
struct udev_device *dev)
{ {
int err;
const char *str, *name, *klass = NULL; const char *str, *name, *klass = NULL;
snd_pcm_t *hndl; SpaPODBuilder b = SPA_POD_BUILDER_INIT (this->item_buffer, sizeof (this->item_buffer));
char device[64];
SpaPODBuilder b = { NULL, };
const SpaHandleFactory *factory = NULL; const SpaHandleFactory *factory = NULL;
SpaPODFrame f[3]; SpaPODFrame f[3];
if (item->udevice) switch (snd_pcm_info_get_stream (dev_info)) {
udev_device_unref (item->udevice); case SND_PCM_STREAM_PLAYBACK:
item->udevice = udevice; factory = &spa_alsa_sink_factory;
if (udevice == NULL) klass = "Audio/Sink";
return -1; break;
case SND_PCM_STREAM_CAPTURE:
if (udev_device_get_property_value (udevice, "PULSE_IGNORE"))
return -1;
if ((str = udev_device_get_property_value (udevice, "SOUND_CLASS")) &&
strcmp (str, "modem") == 0)
return -1;
if ((str = path_get_card_id (udev_device_get_property_value (udevice, "DEVPATH"))) == NULL)
return -1;
snprintf (device, 63, "hw:%s", str);
if ((err = snd_pcm_open (&hndl,
device,
SND_PCM_STREAM_PLAYBACK,
SND_PCM_NONBLOCK |
SND_PCM_NO_AUTO_RESAMPLE |
SND_PCM_NO_AUTO_CHANNELS |
SND_PCM_NO_AUTO_FORMAT)) < 0) {
spa_log_error (this->log, "PLAYBACK open failed: %s", snd_strerror(err));
if ((err = snd_pcm_open (&hndl,
device,
SND_PCM_STREAM_CAPTURE,
SND_PCM_NONBLOCK |
SND_PCM_NO_AUTO_RESAMPLE |
SND_PCM_NO_AUTO_CHANNELS |
SND_PCM_NO_AUTO_FORMAT)) < 0) {
spa_log_error (this->log, "CAPTURE open failed: %s", snd_strerror(err));
return -1;
} else {
factory = &spa_alsa_source_factory; factory = &spa_alsa_source_factory;
klass = "Audio/Source"; klass = "Audio/Source";
snd_pcm_close (hndl); break;
} default:
} else { return -1;
klass = "Audio/Sink";
factory = &spa_alsa_sink_factory;
snd_pcm_close (hndl);
} }
name = udev_device_get_property_value (item->udevice, "ID_MODEL_FROM_DATABASE"); name = udev_device_get_property_value (dev, "ID_MODEL_FROM_DATABASE");
if (!(name && *name)) { if (!(name && *name)) {
name = udev_device_get_property_value (item->udevice, "ID_MODEL_ENC"); name = udev_device_get_property_value (dev, "ID_MODEL_ENC");
if (!(name && *name)) { if (!(name && *name)) {
name = udev_device_get_property_value (item->udevice, "ID_MODEL"); name = udev_device_get_property_value (dev, "ID_MODEL");
} }
} }
if (!(str && *str)) if (!(name && *name))
name = "Unknown"; name = "Unknown";
spa_pod_builder_init (&b, this->item_buffer, sizeof (this->item_buffer));
spa_pod_builder_push_object (&b, &f[0], 0, this->type.monitor.MonitorItem);
spa_pod_builder_add (&b, spa_pod_builder_add (&b,
SPA_POD_PROP (&f[1], this->type.monitor.id, 0, SPA_POD_TYPE_STRING, 1, udev_device_get_syspath (item->udevice)), SPA_POD_TYPE_OBJECT, &f[0], 0, this->type.monitor.MonitorItem,
SPA_POD_PROP (&f[1], this->type.monitor.id, 0, SPA_POD_TYPE_STRING, 1, name),
SPA_POD_PROP (&f[1], this->type.monitor.flags, 0, SPA_POD_TYPE_INT, 1, 0), SPA_POD_PROP (&f[1], this->type.monitor.flags, 0, SPA_POD_TYPE_INT, 1, 0),
SPA_POD_PROP (&f[1], this->type.monitor.state, 0, SPA_POD_TYPE_INT, 1, SPA_MONITOR_ITEM_STATE_AVAILABLE), SPA_POD_PROP (&f[1], this->type.monitor.state, 0, SPA_POD_TYPE_INT, 1, SPA_MONITOR_ITEM_STATE_AVAILABLE),
SPA_POD_PROP (&f[1], this->type.monitor.name, 0, SPA_POD_TYPE_STRING, 1, name), SPA_POD_PROP (&f[1], this->type.monitor.name, 0, SPA_POD_TYPE_STRING, 1, name),
@ -196,66 +159,166 @@ fill_item (SpaALSAMonitor *this, ALSAItem *item, struct udev_device *udevice)
SPA_POD_TYPE_STRUCT, 1, &f[2], 0); SPA_POD_TYPE_STRUCT, 1, &f[2], 0);
spa_pod_builder_add (&b, spa_pod_builder_add (&b,
SPA_POD_TYPE_STRING, "alsa.card", SPA_POD_TYPE_STRING, str, SPA_POD_TYPE_STRING, "alsa.card", SPA_POD_TYPE_STRING, this->card_name,
SPA_POD_TYPE_STRING, "alsa.card.id", SPA_POD_TYPE_STRING, snd_ctl_card_info_get_id (card_info),
SPA_POD_TYPE_STRING, "alsa.card.components", SPA_POD_TYPE_STRING, snd_ctl_card_info_get_components (card_info),
SPA_POD_TYPE_STRING, "alsa.card.driver", SPA_POD_TYPE_STRING, snd_ctl_card_info_get_driver (card_info),
SPA_POD_TYPE_STRING, "alsa.card.name", SPA_POD_TYPE_STRING, snd_ctl_card_info_get_name (card_info),
SPA_POD_TYPE_STRING, "alsa.card.longname", SPA_POD_TYPE_STRING, snd_ctl_card_info_get_longname (card_info),
SPA_POD_TYPE_STRING, "alsa.card.mixername", SPA_POD_TYPE_STRING, snd_ctl_card_info_get_mixername (card_info),
SPA_POD_TYPE_STRING, "udev-probed", SPA_POD_TYPE_STRING, "1", SPA_POD_TYPE_STRING, "udev-probed", SPA_POD_TYPE_STRING, "1",
SPA_POD_TYPE_STRING, "device.api", SPA_POD_TYPE_STRING, "alsa", SPA_POD_TYPE_STRING, "device.api", SPA_POD_TYPE_STRING, "alsa",
SPA_POD_TYPE_STRING, "alsa.pcm.id", SPA_POD_TYPE_STRING, snd_pcm_info_get_id (dev_info),
SPA_POD_TYPE_STRING, "alsa.pcm.name", SPA_POD_TYPE_STRING, snd_pcm_info_get_name (dev_info),
SPA_POD_TYPE_STRING, "alsa.pcm.subname", SPA_POD_TYPE_STRING, snd_pcm_info_get_subdevice_name (dev_info),
0); 0);
if ((str = udev_device_get_property_value (udevice, "SOUND_CLASS")) && *str) { if ((str = udev_device_get_property_value (dev, "SOUND_CLASS")) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.class", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.class", SPA_POD_TYPE_STRING, str, 0);
} }
str = udev_device_get_property_value (item->udevice, "ID_PATH"); str = udev_device_get_property_value (dev, "ID_PATH");
if (!(str && *str)) if (!(str && *str))
str = udev_device_get_syspath (item->udevice); str = udev_device_get_syspath (dev);
if (str && *str) { if (str && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.bus_path", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.bus_path", SPA_POD_TYPE_STRING, str, 0);
} }
if ((str = udev_device_get_syspath (item->udevice)) && *str) { if ((str = udev_device_get_syspath (dev)) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "sysfs.path", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "sysfs.path", SPA_POD_TYPE_STRING, str, 0);
} }
if ((str = udev_device_get_property_value (item->udevice, "ID_ID")) && *str) { if ((str = udev_device_get_property_value (dev, "ID_ID")) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "udev.id", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "udev.id", SPA_POD_TYPE_STRING, str, 0);
} }
if ((str = udev_device_get_property_value (item->udevice, "ID_BUS")) && *str) { if ((str = udev_device_get_property_value (dev, "ID_BUS")) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.bus", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.bus", SPA_POD_TYPE_STRING, str, 0);
} }
if ((str = udev_device_get_property_value (item->udevice, "SUBSYSTEM")) && *str) { if ((str = udev_device_get_property_value (dev, "SUBSYSTEM")) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.subsystem", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.subsystem", SPA_POD_TYPE_STRING, str, 0);
} }
if ((str = udev_device_get_property_value (item->udevice, "ID_VENDOR_ID")) && *str) { if ((str = udev_device_get_property_value (dev, "ID_VENDOR_ID")) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.vendor.id", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.vendor.id", SPA_POD_TYPE_STRING, str, 0);
} }
str = udev_device_get_property_value (item->udevice, "ID_VENDOR_FROM_DATABASE"); str = udev_device_get_property_value (dev, "ID_VENDOR_FROM_DATABASE");
if (!(str && *str)) { if (!(str && *str)) {
str = udev_device_get_property_value (item->udevice, "ID_VENDOR_ENC"); str = udev_device_get_property_value (dev, "ID_VENDOR_ENC");
if (!(str && *str)) { if (!(str && *str)) {
str = udev_device_get_property_value (item->udevice, "ID_VENDOR"); str = udev_device_get_property_value (dev, "ID_VENDOR");
} }
} }
if (str && *str) { if (str && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.vendor.name", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.vendor.name", SPA_POD_TYPE_STRING, str, 0);
} }
if ((str = udev_device_get_property_value (item->udevice, "ID_MODEL_ID")) && *str) { if ((str = udev_device_get_property_value (dev, "ID_MODEL_ID")) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.product.id", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.product.id", SPA_POD_TYPE_STRING, str, 0);
} }
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.product.name", SPA_POD_TYPE_STRING, name, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.product.name", SPA_POD_TYPE_STRING, name, 0);
if ((str = udev_device_get_property_value (item->udevice, "ID_SERIAL")) && *str) { if ((str = udev_device_get_property_value (dev, "ID_SERIAL")) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.serial", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.serial", SPA_POD_TYPE_STRING, str, 0);
} }
if ((str = udev_device_get_property_value (item->udevice, "SOUND_FORM_FACTOR")) && *str) { if ((str = udev_device_get_property_value (dev, "SOUND_FORM_FACTOR")) && *str) {
spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.form_factor", SPA_POD_TYPE_STRING, str, 0); spa_pod_builder_add (&b, SPA_POD_TYPE_STRING, "device.form_factor", SPA_POD_TYPE_STRING, str, 0);
} }
spa_pod_builder_add (&b, spa_pod_builder_add (&b,
-SPA_POD_TYPE_STRUCT, &f[2], -SPA_POD_TYPE_STRUCT, &f[2],
-SPA_POD_TYPE_PROP, &f[1], -SPA_POD_TYPE_PROP, &f[1],
-SPA_POD_TYPE_OBJECT, &f[0],
0); 0);
spa_pod_builder_pop (&b, &f[0]); this->item = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaMonitorItem);
item->item = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaMonitorItem); return 0;
}
static void
close_card (SpaALSAMonitor *this)
{
if (this->ctl_hndl)
snd_ctl_close (this->ctl_hndl);
this->ctl_hndl = NULL;
}
static int
open_card (SpaALSAMonitor *this, struct udev_device *dev)
{
int err;
const char *str;
if (this->ctl_hndl)
return 0;
if (udev_device_get_property_value (dev, "PULSE_IGNORE"))
return -1;
if ((str = udev_device_get_property_value (dev, "SOUND_CLASS")) &&
strcmp (str, "modem") == 0)
return -1;
if ((str = path_get_card_id (udev_device_get_property_value (dev, "DEVPATH"))) == NULL)
return -1;
snprintf (this->card_name, 63, "hw:%s", str);
printf ("open card %s\n", this->card_name);
if ((err = snd_ctl_open (&this->ctl_hndl, this->card_name, 0)) < 0) {
spa_log_error (this->log, "can't open control for card %s: %s", this->card_name, snd_strerror (err));
return err;
}
this->dev_idx = -1;
this->stream_idx = -1;
return 0;
}
static int
get_next_device (SpaALSAMonitor *this, struct udev_device *dev)
{
int err;
snd_pcm_info_t *dev_info;
snd_ctl_card_info_t *card_info;
if (this->stream_idx == -1) {
printf ("next device %d\n", this->dev_idx);
if ((err = snd_ctl_pcm_next_device (this->ctl_hndl, &this->dev_idx)) < 0) {
spa_log_error (this->log, "error iterating devices: %s", snd_strerror (err));
return err;
}
if (this->dev_idx < 0)
return -1;
this->stream_idx = 0;
}
snd_pcm_info_alloca (&dev_info);
snd_pcm_info_set_device (dev_info, this->dev_idx);
snd_pcm_info_set_subdevice (dev_info, 0);
again:
printf ("stream %d\n", this->stream_idx);
switch (this->stream_idx++) {
case 0:
snd_pcm_info_set_stream (dev_info, SND_PCM_STREAM_PLAYBACK);
break;
case 1:
snd_pcm_info_set_stream (dev_info, SND_PCM_STREAM_CAPTURE);
break;
default:
return -1;
}
snd_ctl_card_info_alloca (&card_info);
if ((err = snd_ctl_card_info (this->ctl_hndl, card_info)) < 0) {
spa_log_error (this->log, "can't get card info for device: %s", snd_strerror (err));
return err;
}
if ((err = snd_ctl_pcm_info (this->ctl_hndl, dev_info)) < 0)
goto again;
fill_item (this, card_info, dev_info, dev);
printf ("got item\n");
return 0; return 0;
} }
@ -265,35 +328,40 @@ alsa_on_fd_events (SpaSource *source)
{ {
SpaALSAMonitor *this = source->data; SpaALSAMonitor *this = source->data;
struct udev_device *dev; struct udev_device *dev;
SpaEvent *event; const char *action;
const char *str;
uint32_t type; uint32_t type;
SpaPODBuilder b = { NULL, };
SpaPODFrame f[1];
uint8_t buffer[4096];
dev = udev_monitor_receive_device (this->umonitor); dev = udev_monitor_receive_device (this->umonitor);
if (fill_item (this, &this->uitem, dev) < 0)
return;
if ((str = udev_device_get_action (dev)) == NULL) if ((action = udev_device_get_action (dev)) == NULL)
str = "change"; action = "change";
if (strcmp (str, "add") == 0) { if (strcmp (action, "add") == 0) {
type = this->type.monitor.Added; type = this->type.monitor.Added;
} else if (strcmp (str, "change") == 0) { } else if (strcmp (action, "change") == 0) {
type = this->type.monitor.Changed; type = this->type.monitor.Changed;
} else if (strcmp (str, "remove") == 0) { } else if (strcmp (action, "remove") == 0) {
type = this->type.monitor.Removed; type = this->type.monitor.Removed;
} else } else
return; return;
spa_pod_builder_init (&b, buffer, sizeof (buffer)); if (open_card (this, dev) < 0)
spa_pod_builder_object (&b, &f[0], 0, type, return;
SPA_POD_TYPE_POD, this->uitem.item);
event = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaEventMonitor); while (true) {
this->event_cb (&this->monitor, event, this->user_data); uint8_t buffer[4096];
SpaPODBuilder b = SPA_POD_BUILDER_INIT (buffer, sizeof (buffer));
SpaPODFrame f[1];
SpaEventMonitor *event;
if (get_next_device (this, dev) < 0)
break;
spa_pod_builder_object (&b, &f[0], 0, type, SPA_POD_TYPE_POD, this->item);
event = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaEventMonitor);
this->event_cb (&this->monitor, event, this->user_data);
}
close_card (this);
} }
static SpaResult static SpaResult
@ -345,7 +413,6 @@ spa_alsa_monitor_enum_items (SpaMonitor *monitor,
{ {
SpaResult res; SpaResult res;
SpaALSAMonitor *this; SpaALSAMonitor *this;
struct udev_device *dev;
spa_return_val_if_fail (monitor != NULL, SPA_RESULT_INVALID_ARGUMENTS); spa_return_val_if_fail (monitor != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (item != NULL, SPA_RESULT_INVALID_ARGUMENTS); spa_return_val_if_fail (item != NULL, SPA_RESULT_INVALID_ARGUMENTS);
@ -371,22 +438,29 @@ spa_alsa_monitor_enum_items (SpaMonitor *monitor,
this->index++; this->index++;
} }
again: again:
if (this->devices == NULL) { if (this->devices == NULL)
fill_item (this, &this->uitem, NULL);
return SPA_RESULT_ENUM_END; return SPA_RESULT_ENUM_END;
if (this->dev == NULL) {
this->dev = udev_device_new_from_syspath (this->udev,
udev_list_entry_get_name (this->devices));
if (open_card (this, this->dev) < 0) {
udev_device_unref (this->dev);
next:
this->dev = NULL;
this->devices = udev_list_entry_get_next (this->devices);
goto again;
}
}
if (get_next_device (this, this->dev) < 0) {
close_card (this);
goto next;
} }
dev = udev_device_new_from_syspath (this->udev,
udev_list_entry_get_name (this->devices));
this->devices = udev_list_entry_get_next (this->devices);
if (fill_item (this, &this->uitem, dev) < 0)
goto again;
this->index++; this->index++;
*item = this->uitem.item; *item = this->item;
return SPA_RESULT_OK; return SPA_RESULT_OK;
} }

2
spa/plugins/alsa/alsa-sink.c
View file

@ -721,7 +721,7 @@ alsa_sink_init (const SpaHandleFactory *factory,
for (i = 0; info && i < info->n_items; i++) { for (i = 0; info && i < info->n_items; i++) {
if (!strcmp (info->items[i].key, "alsa.card")) { if (!strcmp (info->items[i].key, "alsa.card")) {
snprintf (this->props.device, 63, "hw:%s", info->items[i].value); snprintf (this->props.device, 63, "%s", info->items[i].value);
} }
} }

2
spa/plugins/alsa/alsa-source.c
View file

@ -797,7 +797,7 @@ alsa_source_init (const SpaHandleFactory *factory,
for (i = 0; info && i < info->n_items; i++) { for (i = 0; info && i < info->n_items; i++) {
if (!strcmp (info->items[i].key, "alsa.card")) { if (!strcmp (info->items[i].key, "alsa.card")) {
snprintf (this->props.device, 63, "hw:%s", info->items[i].value); snprintf (this->props.device, 63, "%s", info->items[i].value);
} }
} }