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

Type changes

Browse source 
Only allow properties inside objects, this makes it easier to
iterate the object, which is needed for efficiently processing
control streams.
Add a choice type to mark variable properties.
SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum
Make it easier to allocate and initialize properties on the stack
Make more efficient methods to make objects.
This commit is contained in:
Wim Taymans 2018-09-05 16:41:07 +02:00
parent 03fdabd155
commit cc842cbdc8
63 changed files with 2253 additions and 1880 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -32,6 +32,7 @@
#include <spa/support/loop.h>
#include <spa/support/plugin.h>
#include <spa/monitor/monitor.h>
#include <spa/debug/pod.h>
#define NAME "alsa-monitor"
@ -112,6 +113,19 @@ static const char *path_get_card_id(const char *path)
return e + 5;
}
static inline void add_dict(struct spa_pod_builder *builder, const char *key, ...)
{
va_list args;
va_start(args, key);
while (key) {
spa_pod_builder_string(builder, key);
spa_pod_builder_string(builder, va_arg(args, const char*));
key = va_arg(args, const char *);
}
va_end(args);
}
static int
fill_item(struct impl *this, snd_ctl_card_info_t *card_info,
snd_pcm_info_t *dev_info, struct card *card,
@ -160,57 +174,59 @@ fill_item(struct impl *this, snd_ctl_card_info_t *card_info,
if (!(name && *name))
name = "Unknown";
spa_pod_builder_add(builder,
"{", SPA_TYPE_OBJECT_MonitorItem, 0,
":", SPA_MONITOR_ITEM_id, "s", id,
":", SPA_MONITOR_ITEM_flags, "I", SPA_MONITOR_ITEM_FLAG_NONE,
":", SPA_MONITOR_ITEM_state, "I", SPA_MONITOR_ITEM_STATE_Available,
":", SPA_MONITOR_ITEM_name, "s", name,
":", SPA_MONITOR_ITEM_class, "s", klass,
":", SPA_MONITOR_ITEM_factory, "p", SPA_TYPE_INTERFACE_HandleFactory, factory,
":", SPA_MONITOR_ITEM_info, "[", NULL);
spa_pod_builder_push_object(builder, SPA_TYPE_OBJECT_MonitorItem, 0);
spa_pod_builder_props(builder,
SPA_MONITOR_ITEM_id, &SPA_POD_String(id, sizeof(id)),
SPA_MONITOR_ITEM_flags, &SPA_POD_Id(SPA_MONITOR_ITEM_FLAG_NONE),
SPA_MONITOR_ITEM_state, &SPA_POD_Id(SPA_MONITOR_ITEM_STATE_Available),
SPA_MONITOR_ITEM_name, &SPA_POD_Stringv(name),
SPA_MONITOR_ITEM_class, &SPA_POD_Stringv(klass),
SPA_MONITOR_ITEM_factory, &SPA_POD_Pointer(SPA_TYPE_INTERFACE_HandleFactory, factory),
0);
spa_pod_builder_add(builder,
"s", "alsa.card", "s", card->name,
"s", "alsa.device", "s", device_name,
"s", "alsa.card.id", "s", snd_ctl_card_info_get_id(card_info),
"s", "alsa.card.components", "s", snd_ctl_card_info_get_components(card_info),
"s", "alsa.card.driver", "s", snd_ctl_card_info_get_driver(card_info),
"s", "alsa.card.name", "s", snd_ctl_card_info_get_name(card_info),
"s", "alsa.card.longname", "s", snd_ctl_card_info_get_longname(card_info),
"s", "alsa.card.mixername", "s", snd_ctl_card_info_get_mixername(card_info),
"s", "udev-probed", "s", "1",
"s", "device.api", "s", "alsa",
"s", "device.name", "s", snd_ctl_card_info_get_id(card_info),
"s", "alsa.pcm.id", "s", snd_pcm_info_get_id(dev_info),
"s", "alsa.pcm.name", "s", snd_pcm_info_get_name(dev_info),
"s", "alsa.pcm.subname", "s", snd_pcm_info_get_subdevice_name(dev_info),
spa_pod_builder_prop(builder, SPA_MONITOR_ITEM_info, 0);
spa_pod_builder_push_struct(builder),
add_dict(builder,
"alsa.card", card->name,
"alsa.device", device_name,
"alsa.card.id", snd_ctl_card_info_get_id(card_info),
"alsa.card.components", snd_ctl_card_info_get_components(card_info),
"alsa.card.driver", snd_ctl_card_info_get_driver(card_info),
"alsa.card.name", snd_ctl_card_info_get_name(card_info),
"alsa.card.longname", snd_ctl_card_info_get_longname(card_info),
"alsa.card.mixername", snd_ctl_card_info_get_mixername(card_info),
"udev-probed", "1",
"device.api", "alsa",
"device.name", snd_ctl_card_info_get_id(card_info),
"alsa.pcm.id", snd_pcm_info_get_id(dev_info),
"alsa.pcm.name", snd_pcm_info_get_name(dev_info),
"alsa.pcm.subname", snd_pcm_info_get_subdevice_name(dev_info),
NULL);
if ((str = udev_device_get_property_value(dev, "SOUND_CLASS")) && *str) {
spa_pod_builder_add(builder, "s", "device.class", "s", str, NULL);
add_dict(builder, "device.class", str, NULL);
}
str = udev_device_get_property_value(dev, "ID_PATH");
if (!(str && *str))
str = udev_device_get_syspath(dev);
if (str && *str) {
spa_pod_builder_add(builder, "s", "device.bus_path", "s", str, 0);
add_dict(builder, "device.bus_path", str, 0);
}
if ((str = udev_device_get_syspath(dev)) && *str) {
spa_pod_builder_add(builder, "s", "sysfs.path", "s", str, 0);
add_dict(builder, "sysfs.path", str, 0);
}
if ((str = udev_device_get_property_value(dev, "ID_ID")) && *str) {
spa_pod_builder_add(builder, "s", "udev.id", "s", str, 0);
add_dict(builder, "udev.id", str, 0);
}
if ((str = udev_device_get_property_value(dev, "ID_BUS")) && *str) {
spa_pod_builder_add(builder, "s", "device.bus", "s", str, 0);
add_dict(builder, "device.bus", str, 0);
}
if ((str = udev_device_get_property_value(dev, "SUBSYSTEM")) && *str) {
spa_pod_builder_add(builder, "s", "device.subsystem", "s", str, 0);
add_dict(builder, "device.subsystem", str, 0);
}
if ((str = udev_device_get_property_value(dev, "ID_VENDOR_ID")) && *str) {
spa_pod_builder_add(builder, "s", "device.vendor.id", "s", str, 0);
add_dict(builder, "device.vendor.id", str, 0);
}
str = udev_device_get_property_value(dev, "ID_VENDOR_FROM_DATABASE");
if (!(str && *str)) {
@ -220,20 +236,23 @@ fill_item(struct impl *this, snd_ctl_card_info_t *card_info,
}
}
if (str && *str) {
spa_pod_builder_add(builder, "s", "device.vendor.name", "s", str, 0);
add_dict(builder, "device.vendor.name", str, 0);
}
if ((str = udev_device_get_property_value(dev, "ID_MODEL_ID")) && *str) {
spa_pod_builder_add(builder, "s", "device.product.id", "s", str, 0);
add_dict(builder, "device.product.id", str, 0);
}
spa_pod_builder_add(builder, "s", "device.product.name", "s", name, 0);
add_dict(builder, "device.product.name", name, 0);
if ((str = udev_device_get_property_value(dev, "ID_SERIAL")) && *str) {
spa_pod_builder_add(builder, "s", "device.serial", "s", str, 0);
add_dict(builder, "device.serial", str, 0);
}
if ((str = udev_device_get_property_value(dev, "SOUND_FORM_FACTOR")) && *str) {
spa_pod_builder_add(builder, "s", "device.form_factor", "s", str, 0);
add_dict(builder, "device.form_factor", str, 0);
}
*item = spa_pod_builder_add(builder, "]}", NULL);
spa_pod_builder_pop(builder);
*item = spa_pod_builder_pop(builder);
spa_debug_pod(0, NULL, *item);
return 0;
}
@ -347,7 +366,7 @@ static void impl_on_fd_events(struct spa_source *source)
struct impl *this = source->data;
struct udev_device *dev;
const char *action;
uint32_t id;
uint32_t type;
struct card *card;
struct spa_event *event;
@ -357,18 +376,18 @@ static void impl_on_fd_events(struct spa_source *source)
action = "change";
if (strcmp(action, "add") == 0) {
id = SPA_MONITOR_EVENT_Added;
type = SPA_MONITOR_EVENT_Added;
} else if (strcmp(action, "change") == 0) {
id = SPA_MONITOR_EVENT_Changed;
type = SPA_MONITOR_EVENT_Changed;
} else if (strcmp(action, "remove") == 0) {
id = SPA_MONITOR_EVENT_Removed;
type = SPA_MONITOR_EVENT_Removed;
} else
return;
if ((card = find_card(this, dev)) == NULL)
return;
if (id == SPA_MONITOR_EVENT_Removed) {
if (type == SPA_MONITOR_EVENT_Removed) {
int i;
for (i = 0; i < MAX_DEVICES; i++) {
@ -377,23 +396,24 @@ static void impl_on_fd_events(struct spa_source *source)
char id[64];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
if (SPA_FLAG_CHECK(device->flags, DEVICE_FLAG_PLAYBACK)) {
snprintf(id, 64, "%s,%d/P", card->name, device->id);
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, id);
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, type, 0);
spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_MonitorItem, 0,
":", SPA_MONITOR_ITEM_id, "s", id,
":", SPA_MONITOR_ITEM_name, "s", id);
SPA_MONITOR_ITEM_id, SPA_POD_Stringv(id),
SPA_MONITOR_ITEM_name, SPA_POD_Stringv(id),
0);
this->callbacks->event(this->callbacks_data, event);
}
if (SPA_FLAG_CHECK(device->flags, DEVICE_FLAG_RECORD)) {
snprintf(id, 64, "%s,%d/C", card->name, device->id);
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, id);
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, type, 0);
spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_MonitorItem, 0,
":", SPA_MONITOR_ITEM_id, "s", id,
":", SPA_MONITOR_ITEM_name, "s", id);
SPA_MONITOR_ITEM_id, SPA_POD_Stringv(id),
SPA_MONITOR_ITEM_name, SPA_POD_Stringv(id),
0);
this->callbacks->event(this->callbacks_data, event);
}
device->flags = 0;
@ -408,7 +428,7 @@ static void impl_on_fd_events(struct spa_source *source)
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
struct spa_pod *item;
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, id);
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, type, 0);
if (get_next_device(this, card, &item, &b) < 0)
break;

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

@ -69,8 +69,10 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b, SPA_TYPE_OBJECT_ParamList, id,
":", SPA_PARAM_LIST_id, "I", list[*index]);
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
else
return 0;
break;
@ -83,39 +85,42 @@ static int impl_node_enum_params(struct spa_node *node,
case 0:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_device,
":", SPA_PROP_INFO_name, "s", "The ALSA device",
":", SPA_PROP_INFO_type, "S", p->device, sizeof(p->device));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_device),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA device"),
SPA_PROP_INFO_type, &SPA_POD_String(p->device, sizeof(p->device)),
0);
break;
case 1:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_deviceName,
":", SPA_PROP_INFO_name, "s", "The ALSA device name",
":", SPA_PROP_INFO_type, "S-r", p->device_name, sizeof(p->device_name));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_deviceName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA device name"),
SPA_PROP_INFO_type, &SPA_POD_String(p->device_name, sizeof(p->device_name)),
0);
break;
case 2:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_cardName,
":", SPA_PROP_INFO_name, "s", "The ALSA card name",
":", SPA_PROP_INFO_type, "S-r", p->card_name, sizeof(p->card_name));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_cardName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA card name"),
SPA_PROP_INFO_type, &SPA_POD_String(p->card_name, sizeof(p->card_name)),
0);
break;
case 3:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_minLatency,
":", SPA_PROP_INFO_name, "s", "The minimum latency",
":", SPA_PROP_INFO_type, "ir", p->min_latency,
SPA_POD_PROP_MIN_MAX(1, INT32_MAX));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_minLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The minimum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX),
0);
break;
case 4:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_maxLatency,
":", SPA_PROP_INFO_name, "s", "The maximum latency",
":", SPA_PROP_INFO_type, "ir", p->max_latency,
SPA_POD_PROP_MIN_MAX(1, INT32_MAX));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_maxLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The maximum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX),
0);
break;
default:
return 0;
@ -130,11 +135,12 @@ static int impl_node_enum_params(struct spa_node *node,
case 0:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_Props, id,
":", SPA_PROP_device, "S", p->device, sizeof(p->device),
":", SPA_PROP_deviceName, "S-r", p->device_name, sizeof(p->device_name),
":", SPA_PROP_cardName, "S-r", p->card_name, sizeof(p->card_name),
":", SPA_PROP_minLatency, "i", p->min_latency,
":", SPA_PROP_maxLatency, "i", p->max_latency);
SPA_PROP_device, &SPA_POD_String(p->device, sizeof(p->device)),
SPA_PROP_deviceName, &SPA_POD_String(p->device_name, sizeof(p->device_name)),
SPA_PROP_cardName, &SPA_POD_String(p->card_name, sizeof(p->card_name)),
SPA_PROP_minLatency, &SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, &SPA_POD_Int(p->max_latency),
0);
break;
default:
return 0;
@ -327,8 +333,10 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO, };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b, SPA_TYPE_OBJECT_ParamList, id,
":", SPA_PARAM_LIST_id, "I", list[*index]);
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
else
return 0;
break;
@ -353,15 +361,15 @@ impl_node_port_enum_params(struct spa_node *node,
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
":", SPA_PARAM_BUFFERS_buffers, "ir", 1,
SPA_POD_PROP_MIN_MAX(1, MAX_BUFFERS),
":", SPA_PARAM_BUFFERS_blocks, "i", 1,
":", SPA_PARAM_BUFFERS_size, "iru",
this->props.max_latency * this->frame_size,
SPA_POD_PROP_MIN_MAX(this->props.min_latency * this->frame_size,
INT32_MAX),
":", SPA_PARAM_BUFFERS_stride, "i", 0,
":", SPA_PARAM_BUFFERS_align, "i", 16);
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
this->props.max_latency * this->frame_size,
this->props.min_latency * this->frame_size,
INT32_MAX),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
break;
case SPA_PARAM_Meta:
@ -372,8 +380,9 @@ impl_node_port_enum_params(struct spa_node *node,
case 0:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
":", SPA_PARAM_META_type, "I", SPA_META_Header,
":", SPA_PARAM_META_size, "i", sizeof(struct spa_meta_header));
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
break;
default:
return 0;
@ -385,20 +394,23 @@ impl_node_port_enum_params(struct spa_node *node,
case 0:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
":", SPA_PARAM_IO_id, "I", SPA_IO_Buffers,
":", SPA_PARAM_IO_size, "i", sizeof(struct spa_io_buffers));
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
break;
case 1:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
":", SPA_PARAM_IO_id, "I", SPA_IO_Range,
":", SPA_PARAM_IO_size, "i", sizeof(struct spa_io_range));
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_range)),
0);
break;
case 2:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
":", SPA_PARAM_IO_id, "I", SPA_IO_Clock,
":", SPA_PARAM_IO_size, "i", sizeof(struct spa_io_clock));
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_clock)),
0);
break;
default:
return 0;

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

@ -73,8 +73,10 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props, };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b, SPA_TYPE_OBJECT_ParamList, id,
":", SPA_PARAM_LIST_id, "I", list[*index]);
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
else
return 0;
break;
@ -84,39 +86,42 @@ static int impl_node_enum_params(struct spa_node *node,
case 0:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_device,
":", SPA_PROP_INFO_name, "s", "The ALSA device",
":", SPA_PROP_INFO_type, "S", p->device, sizeof(p->device));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_device),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA device"),
SPA_PROP_INFO_type, &SPA_POD_String(p->device, sizeof(p->device)),
0);
break;
case 1:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_deviceName,
":", SPA_PROP_INFO_name, "s", "The ALSA device name",
":", SPA_PROP_INFO_type, "S-r", p->device_name, sizeof(p->device_name));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_deviceName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA device name"),
SPA_PROP_INFO_type, &SPA_POD_String(p->device_name, sizeof(p->device_name)),
0);
break;
case 2:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_cardName,
":", SPA_PROP_INFO_name, "s", "The ALSA card name",
":", SPA_PROP_INFO_type, "S-r", p->card_name, sizeof(p->card_name));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_cardName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA card name"),
SPA_PROP_INFO_type, &SPA_POD_String(p->card_name, sizeof(p->card_name)),
0);
break;
case 3:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_minLatency,
":", SPA_PROP_INFO_name, "s", "The minimum latency",
":", SPA_PROP_INFO_type, "ir", p->min_latency,
SPA_POD_PROP_MIN_MAX(1, INT32_MAX));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_minLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The minimum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX),
0);
break;
case 4:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
":", SPA_PROP_INFO_id, "I", SPA_PROP_maxLatency,
":", SPA_PROP_INFO_name, "s", "The maximum latency",
":", SPA_PROP_INFO_type, "ir", p->max_latency,
SPA_POD_PROP_MIN_MAX(1, INT32_MAX));
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_maxLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The maximum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX),
0);
break;
default:
return 0;
@ -128,11 +133,12 @@ static int impl_node_enum_params(struct spa_node *node,
case 0:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_Props, id,
":", SPA_PROP_device, "S", p->device, sizeof(p->device),
":", SPA_PROP_deviceName, "S-r", p->device_name, sizeof(p->device_name),
":", SPA_PROP_cardName, "S-r", p->card_name, sizeof(p->card_name),
":", SPA_PROP_minLatency, "i", p->min_latency,
":", SPA_PROP_maxLatency, "i", p->max_latency);
SPA_PROP_device, &SPA_POD_String(p->device, sizeof(p->device)),
SPA_PROP_deviceName, &SPA_POD_String(p->device_name, sizeof(p->device_name)),
SPA_PROP_cardName, &SPA_POD_String(p->card_name, sizeof(p->card_name)),
SPA_PROP_minLatency, &SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, &SPA_POD_Int(p->max_latency),
0);
break;
default:
return 0;
@ -338,8 +344,10 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_Meta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b, SPA_TYPE_OBJECT_ParamList, id,
":", SPA_PARAM_LIST_id, "I", list[*index]);
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
else
return 0;
break;
@ -364,15 +372,15 @@ impl_node_port_enum_params(struct spa_node *node,
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
":", SPA_PARAM_BUFFERS_buffers, "ir", 2,
SPA_POD_PROP_MIN_MAX(1, MAX_BUFFERS),
":", SPA_PARAM_BUFFERS_blocks, "i", 1,
":", SPA_PARAM_BUFFERS_size, "iru", this->props.max_latency *
this->frame_size,
SPA_POD_PROP_MIN_MAX(this->props.min_latency * this->frame_size,
INT32_MAX),
":", SPA_PARAM_BUFFERS_stride, "i", this->frame_size,
":", SPA_PARAM_BUFFERS_align, "i", 16);
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
this->props.max_latency * this->frame_size,
this->props.min_latency * this->frame_size,
INT32_MAX),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(this->frame_size),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
break;
case SPA_PARAM_Meta:
@ -383,8 +391,9 @@ impl_node_port_enum_params(struct spa_node *node,
case 0:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
":", SPA_PARAM_META_type, "I", SPA_META_Header,
":", SPA_PARAM_META_size, "i", sizeof(struct spa_meta_header));
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
break;
default:
return 0;
@ -396,14 +405,16 @@ impl_node_port_enum_params(struct spa_node *node,
case 0:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
":", SPA_PARAM_IO_id, "I", SPA_IO_Buffers,
":", SPA_PARAM_IO_size, "i", sizeof(struct spa_io_buffers));
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
break;
case 1:
param = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
":", SPA_PARAM_IO_id, "I", SPA_IO_Clock,
":", SPA_PARAM_IO_size, "i", sizeof(struct spa_io_clock));
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_clock)),
0);
break;
default:
return 0;

54
spa/plugins/alsa/alsa-utils.c
View file

@ -112,7 +112,7 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
unsigned int min, max;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
struct spa_pod_prop *prop;
struct spa_pod_choice *choice;
struct spa_pod *fmt;
int res;
bool opened;
@ -134,76 +134,82 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
CHECK(snd_pcm_hw_params_any(hndl, params), "Broken configuration: no configurations available");
spa_pod_builder_push_object(&b, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat);
spa_pod_builder_add(&b,
":", SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_audio,
":", SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_raw, 0);
spa_pod_builder_props(&b,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
0);
snd_pcm_format_mask_alloca(&fmask);
snd_pcm_hw_params_get_format_mask(params, fmask);
prop = spa_pod_builder_deref(&b,
spa_pod_builder_push_prop(&b, SPA_FORMAT_AUDIO_format,
SPA_POD_PROP_RANGE_NONE));
spa_pod_builder_prop(&b, SPA_FORMAT_AUDIO_format, 0);
choice = spa_pod_builder_deref(&b,
spa_pod_builder_push_choice(&b, SPA_CHOICE_None, 0));
for (i = 1, j = 0; i < SPA_N_ELEMENTS(format_info); i++) {
const struct format_info *fi = &format_info[i];
if (snd_pcm_format_mask_test(fmask, fi->format)) {
if (j++ == 0)
spa_pod_builder_enum(&b, fi->spa_format);
spa_pod_builder_enum(&b, fi->spa_format);
spa_pod_builder_id(&b, fi->spa_format);
spa_pod_builder_id(&b, fi->spa_format);
}
}
if (j > 1)
prop->body.flags |= SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET;
choice->body.type = SPA_CHOICE_Enum;
spa_pod_builder_pop(&b);
snd_pcm_access_mask_alloca(&amask);
snd_pcm_hw_params_get_access_mask(params, amask);
prop = spa_pod_builder_deref(&b,
spa_pod_builder_push_prop(&b, SPA_FORMAT_AUDIO_layout,
SPA_POD_PROP_RANGE_NONE));
spa_pod_builder_prop(&b, SPA_FORMAT_AUDIO_layout, 0);
choice = spa_pod_builder_deref(&b,
spa_pod_builder_push_choice(&b, SPA_CHOICE_None, 0));
j = 0;
if (snd_pcm_access_mask_test(amask, SND_PCM_ACCESS_MMAP_INTERLEAVED)) {
if (j++ == 0)
spa_pod_builder_enum(&b, SPA_AUDIO_LAYOUT_INTERLEAVED);
spa_pod_builder_enum(&b, SPA_AUDIO_LAYOUT_INTERLEAVED);
spa_pod_builder_id(&b, SPA_AUDIO_LAYOUT_INTERLEAVED);
spa_pod_builder_id(&b, SPA_AUDIO_LAYOUT_INTERLEAVED);
}
if (snd_pcm_access_mask_test(amask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
if (j++ == 0)
spa_pod_builder_enum(&b, SPA_AUDIO_LAYOUT_NON_INTERLEAVED);
spa_pod_builder_enum(&b, SPA_AUDIO_LAYOUT_NON_INTERLEAVED);
spa_pod_builder_id(&b, SPA_AUDIO_LAYOUT_NON_INTERLEAVED);
spa_pod_builder_id(&b, SPA_AUDIO_LAYOUT_NON_INTERLEAVED);
}
if (j > 1)
prop->body.flags |= SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET;
choice->body.type = SPA_CHOICE_Enum;
spa_pod_builder_pop(&b);
CHECK(snd_pcm_hw_params_get_rate_min(params, &min, &dir), "get_rate_min");
CHECK(snd_pcm_hw_params_get_rate_max(params, &max, &dir), "get_rate_max");
prop = spa_pod_builder_deref(&b,
spa_pod_builder_push_prop(&b, SPA_FORMAT_AUDIO_rate, SPA_POD_PROP_RANGE_NONE));
spa_pod_builder_prop(&b, SPA_FORMAT_AUDIO_rate, 0);
choice = spa_pod_builder_deref(&b,
spa_pod_builder_push_choice(&b, SPA_CHOICE_None, 0));
spa_pod_builder_int(&b, SPA_CLAMP(DEFAULT_RATE, min, max));
if (min != max) {
spa_pod_builder_int(&b, min);
spa_pod_builder_int(&b, max);
prop->body.flags |= SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET;
choice->body.type = SPA_CHOICE_Range;
}
spa_pod_builder_pop(&b);
CHECK(snd_pcm_hw_params_get_channels_min(params, &min), "get_channels_min");
CHECK(snd_pcm_hw_params_get_channels_max(params, &max), "get_channels_max");
prop = spa_pod_builder_deref(&b,
spa_pod_builder_push_prop(&b, SPA_FORMAT_AUDIO_channels, SPA_POD_PROP_RANGE_NONE));
spa_pod_builder_prop(&b, SPA_FORMAT_AUDIO_channels, 0);
choice = spa_pod_builder_deref(&b,
spa_pod_builder_push_choice(&b, SPA_CHOICE_None, 0));
spa_pod_builder_int(&b, SPA_CLAMP(DEFAULT_CHANNELS, min, max));
if (min != max) {
spa_pod_builder_int(&b, min);
spa_pod_builder_int(&b, max);
prop->body.flags |= SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET;
choice->body.type = SPA_CHOICE_Range;
}
spa_pod_builder_pop(&b);