mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-12-14 08:56:37 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

clean up types

Browse source
This commit is contained in:
Wim Taymans 2017-03-23 21:15:52 +01:00
parent d9a51b5d14
commit acedfe71c0
64 changed files with 756 additions and 752 deletions
Download patch file Download diff file Expand all files Collapse all files

8
pinos/client/context.c
View file

@ -307,7 +307,7 @@ registry_event_global (void *object,
pinos_log_debug ("got global %u %s", id, type); pinos_log_debug ("got global %u %s", id, type);
if (!strcmp (type, PINOS_NODE_URI)) { if (!strcmp (type, PINOS_TYPE__Node)) {
proxy = pinos_proxy_new (this, proxy = pinos_proxy_new (this,
SPA_ID_INVALID, SPA_ID_INVALID,
this->uri.node); this->uri.node);
@ -315,7 +315,7 @@ registry_event_global (void *object,
goto no_mem; goto no_mem;
proxy->implementation = &node_events; proxy->implementation = &node_events;
} else if (!strcmp (type, PINOS_MODULE_URI)) { } else if (!strcmp (type, PINOS_TYPE__Module)) {
proxy = pinos_proxy_new (this, proxy = pinos_proxy_new (this,
SPA_ID_INVALID, SPA_ID_INVALID,
this->uri.module); this->uri.module);
@ -323,7 +323,7 @@ registry_event_global (void *object,
goto no_mem; goto no_mem;
proxy->implementation = &module_events; proxy->implementation = &module_events;
} else if (!strcmp (type, PINOS_CLIENT_URI)) { } else if (!strcmp (type, PINOS_TYPE__Client)) {
proxy = pinos_proxy_new (this, proxy = pinos_proxy_new (this,
SPA_ID_INVALID, SPA_ID_INVALID,
this->uri.client); this->uri.client);
@ -331,7 +331,7 @@ registry_event_global (void *object,
goto no_mem; goto no_mem;
proxy->implementation = &client_events; proxy->implementation = &client_events;
} else if (!strcmp (type, PINOS_LINK_URI)) { } else if (!strcmp (type, PINOS_TYPE__Link)) {
proxy = pinos_proxy_new (this, proxy = pinos_proxy_new (this,
SPA_ID_INVALID, SPA_ID_INVALID,
this->uri.link); this->uri.link);

38
pinos/client/stream.c
View file

@ -354,12 +354,12 @@ send_need_input (PinosStream *stream)
{ {
#if 0 #if 0
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this); PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
SpaNodeEventNeedInput ni; SpaEventNodeNeedInput ni;
uint64_t cmd = 1; uint64_t cmd = 1;
pinos_log_debug ("stream %p: need input", stream); pinos_log_debug ("stream %p: need input", stream);
ni.event.type = SPA_NODE_EVENT_NEED_INPUT; ni.event.type = SPA_EVENT_NODE_NEED_INPUT;
ni.event.size = sizeof (ni); ni.event.size = sizeof (ni);
pinos_transport_add_event (impl->trans, &ni.event); pinos_transport_add_event (impl->trans, &ni.event);
write (impl->rtfd, &cmd, 8); write (impl->rtfd, &cmd, 8);
@ -371,12 +371,12 @@ send_have_output (PinosStream *stream)
{ {
#if 0 #if 0
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this); PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
SpaNodeEventHaveOutput ho; SpaEventNodeHaveOutput ho;
uint64_t cmd = 1; uint64_t cmd = 1;
pinos_log_debug ("stream %p: have output", stream); pinos_log_debug ("stream %p: have output", stream);
ho.event.type = SPA_NODE_EVENT_HAVE_OUTPUT; ho.event.type = SPA_EVENT_NODE_HAVE_OUTPUT;
ho.event.size = sizeof (ho); ho.event.size = sizeof (ho);
pinos_transport_add_event (impl->trans, &ho.event); pinos_transport_add_event (impl->trans, &ho.event);
write (impl->rtfd, &cmd, 8); write (impl->rtfd, &cmd, 8);
@ -387,9 +387,9 @@ static void
add_request_clock_update (PinosStream *stream, bool flush) add_request_clock_update (PinosStream *stream, bool flush)
{ {
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this); PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
SpaNodeEventRequestClockUpdate rcu = SpaEventNodeRequestClockUpdate rcu =
SPA_NODE_EVENT_REQUEST_CLOCK_UPDATE_INIT (stream->context->uri.node_events.RequestClockUpdate, SPA_EVENT_NODE_REQUEST_CLOCK_UPDATE_INIT (stream->context->uri.event_node.RequestClockUpdate,
SPA_NODE_EVENT_REQUEST_CLOCK_UPDATE_TIME, 0, 0); SPA_EVENT_NODE_REQUEST_CLOCK_UPDATE_TIME, 0, 0);
pinos_client_node_do_event (impl->node_proxy, (SpaEvent*)&rcu); pinos_client_node_do_event (impl->node_proxy, (SpaEvent*)&rcu);
} }
@ -401,8 +401,8 @@ add_async_complete (PinosStream *stream,
bool flush) bool flush)
{ {
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this); PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
SpaNodeEventAsyncComplete ac = SpaEventNodeAsyncComplete ac =
SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (stream->context->uri.node_events.AsyncComplete, SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (stream->context->uri.event_node.AsyncComplete,
seq, res); seq, res);
pinos_client_node_do_event (impl->node_proxy, (SpaEvent*)&ac); pinos_client_node_do_event (impl->node_proxy, (SpaEvent*)&ac);
} }
@ -470,7 +470,7 @@ handle_rtnode_event (PinosStream *stream,
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this); PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
PinosContext *context = impl->this.context; PinosContext *context = impl->this.context;
if (SPA_EVENT_TYPE (event) == context->uri.node_events.HaveOutput) { if (SPA_EVENT_TYPE (event) == context->uri.event_node.HaveOutput) {
int i; int i;
//pinos_log_debug ("stream %p: have output", stream); //pinos_log_debug ("stream %p: have output", stream);
@ -486,12 +486,12 @@ handle_rtnode_event (PinosStream *stream,
} }
send_need_input (stream); send_need_input (stream);
} }
else if (SPA_EVENT_TYPE (event) == context->uri.node_events.NeedInput) { else if (SPA_EVENT_TYPE (event) == context->uri.event_node.NeedInput) {
//pinos_log_debug ("stream %p: need input", stream); //pinos_log_debug ("stream %p: need input", stream);
pinos_signal_emit (&stream->need_buffer, stream); pinos_signal_emit (&stream->need_buffer, stream);
} }
else if (SPA_EVENT_TYPE (event) == context->uri.node_events.ReuseBuffer) { else if (SPA_EVENT_TYPE (event) == context->uri.event_node.ReuseBuffer) {
SpaNodeEventReuseBuffer *p = (SpaNodeEventReuseBuffer *) event; SpaEventNodeReuseBuffer *p = (SpaEventNodeReuseBuffer *) event;
BufferId *bid; BufferId *bid;
if (p->body.port_id.value != impl->port_id) if (p->body.port_id.value != impl->port_id)
@ -580,14 +580,14 @@ handle_node_command (PinosStream *stream,
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this); PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
PinosContext *context = stream->context; PinosContext *context = stream->context;
if (SPA_COMMAND_TYPE (command) == context->uri.node_commands.Pause) { if (SPA_COMMAND_TYPE (command) == context->uri.command_node.Pause) {
pinos_log_debug ("stream %p: pause %d", stream, seq); pinos_log_debug ("stream %p: pause %d", stream, seq);
add_state_change (stream, SPA_NODE_STATE_PAUSED, false); add_state_change (stream, SPA_NODE_STATE_PAUSED, false);
add_async_complete (stream, seq, SPA_RESULT_OK, true); add_async_complete (stream, seq, SPA_RESULT_OK, true);
stream_set_state (stream, PINOS_STREAM_STATE_PAUSED, NULL); stream_set_state (stream, PINOS_STREAM_STATE_PAUSED, NULL);
} }
else if (SPA_COMMAND_TYPE (command) == context->uri.node_commands.Start) { else if (SPA_COMMAND_TYPE (command) == context->uri.command_node.Start) {
pinos_log_debug ("stream %p: start %d", stream, seq); pinos_log_debug ("stream %p: start %d", stream, seq);
add_state_change (stream, SPA_NODE_STATE_STREAMING, false); add_state_change (stream, SPA_NODE_STATE_STREAMING, false);
add_async_complete (stream, seq, SPA_RESULT_OK, true); add_async_complete (stream, seq, SPA_RESULT_OK, true);
@ -597,9 +597,9 @@ handle_node_command (PinosStream *stream,
stream_set_state (stream, PINOS_STREAM_STATE_STREAMING, NULL); stream_set_state (stream, PINOS_STREAM_STATE_STREAMING, NULL);
} }
else if (SPA_COMMAND_TYPE (command) == context->uri.node_commands.ClockUpdate) { else if (SPA_COMMAND_TYPE (command) == context->uri.command_node.ClockUpdate) {
SpaNodeCommandClockUpdate *cu = (SpaNodeCommandClockUpdate *) command; SpaCommandNodeClockUpdate *cu = (SpaCommandNodeClockUpdate *) command;
if (cu->body.flags.value & SPA_NODE_COMMAND_CLOCK_UPDATE_FLAG_LIVE) { if (cu->body.flags.value & SPA_COMMAND_NODE_CLOCK_UPDATE_FLAG_LIVE) {
pinos_properties_set (stream->properties, pinos_properties_set (stream->properties,
"pinos.latency.is-live", "1"); "pinos.latency.is-live", "1");
pinos_properties_setf (stream->properties, pinos_properties_setf (stream->properties,
@ -1125,7 +1125,7 @@ pinos_stream_recycle_buffer (PinosStream *stream,
uint32_t id) uint32_t id)
{ {
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this); PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
SpaNodeEventReuseBuffer rb = SPA_NODE_EVENT_REUSE_BUFFER_INIT (stream->context->uri.node_events.ReuseBuffer, SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (stream->context->uri.event_node.ReuseBuffer,
impl->port_id, id); impl->port_id, id);
uint64_t cmd = 1; uint64_t cmd = 1;

24
pinos/client/subscribe.h
View file

@ -26,21 +26,23 @@
extern "C" { extern "C" {
#endif #endif
#define PINOS_CORE_URI "http://pinos.org/ns/core" #define PINOS_TYPE__Core "Pinos:Object:Core"
#define PINOS_CORE_PREFIX PINOS_CORE_URI "#" #define PINOS_TYPE_CORE_BASE PINOS_TYPE__Core ":"
#define PINOS_CORE_REGISTRY PINOS_CORE_PREFIX "Registry"
#define PINOS_NODE_URI "http://pinos.org/ns/node" #define PINOS_TYPE__Registry "Pinos:Object:Registry"
#define PINOS_NODE_PREFIX PINOS_NODE_URI "#" #define PINOS_TYPE_REGISYRY_BASE PINOS_TYPE__Registry ":"
#define PINOS_CLIENT_URI "http://pinos.org/ns/client" #define PINOS_TYPE__Node "Pinos:Object:Node"
#define PINOS_CLIENT_PREFIX PINOS_CLIENT_URI "#" #define PINOS_TYPE_NODE_BASE PINOS_TYPE__Node ":"
#define PINOS_LINK_URI "http://pinos.org/ns/link" #define PINOS_TYPE__Client "Pinos:Object:Client"
#define PINOS_LINK_PREFIX PINOS_LINK_URI "#" #define PINOS_TYPE_CLIENT_BASE PINOS_TYPE__Client ":"
#define PINOS_MODULE_URI "http://pinos.org/ns/module" #define PINOS_TYPE__Link "Pinos:Object:Link"
#define PINOS_MODULE_PREFIX PINOS_MODULE_URI "#" #define PINOS_TYPE_LINK_BASE PINOS_TYPE__Link ":"
#define PINOS_TYPE__Module "Pinos:Object:Module"
#define PINOS_TYPE_MODULE_BASE PINOS_TYPE__Module ":"
typedef enum { typedef enum {
PINOS_SUBSCRIPTION_EVENT_NEW = 0, PINOS_SUBSCRIPTION_EVENT_NEW = 0,

26
pinos/client/uri.c
View file

@ -36,21 +36,21 @@ pinos_uri_init (PinosURI *uri)
{ {
uri->map = pinos_id_map_get_default(); uri->map = pinos_id_map_get_default();
uri->core = spa_id_map_get_id (uri->map, PINOS_CORE_URI); uri->core = spa_id_map_get_id (uri->map, PINOS_TYPE__Core);
uri->registry = spa_id_map_get_id (uri->map, PINOS_CORE_REGISTRY); uri->registry = spa_id_map_get_id (uri->map, PINOS_TYPE__Registry);
uri->node = spa_id_map_get_id (uri->map, PINOS_NODE_URI); uri->node = spa_id_map_get_id (uri->map, PINOS_TYPE__Node);
uri->node_factory = spa_id_map_get_id (uri->map, PINOS_NODE_FACTORY_URI); uri->node_factory = spa_id_map_get_id (uri->map, PINOS_TYPE__NodeFactory);
uri->link = spa_id_map_get_id (uri->map, PINOS_LINK_URI); uri->link = spa_id_map_get_id (uri->map, PINOS_TYPE__Link);
uri->client = spa_id_map_get_id (uri->map, PINOS_CLIENT_URI); uri->client = spa_id_map_get_id (uri->map, PINOS_TYPE__Client);
uri->client_node = spa_id_map_get_id (uri->map, PINOS_CLIENT_NODE_URI); uri->client_node = spa_id_map_get_id (uri->map, PINOS_TYPE__ClientNode);
uri->module = spa_id_map_get_id (uri->map, PINOS_MODULE_URI); uri->module = spa_id_map_get_id (uri->map, PINOS_TYPE__Module);
uri->spa_node = spa_id_map_get_id (uri->map, SPA_NODE_URI); uri->spa_node = spa_id_map_get_id (uri->map, SPA_TYPE__Node);
uri->spa_clock = spa_id_map_get_id (uri->map, SPA_CLOCK_URI); uri->spa_clock = spa_id_map_get_id (uri->map, SPA_TYPE__Clock);
uri->spa_monitor = spa_id_map_get_id (uri->map, SPA_MONITOR_URI); uri->spa_monitor = spa_id_map_get_id (uri->map, SPA_TYPE__Monitor);
spa_node_events_map (uri->map, &uri->node_events); spa_event_node_map (uri->map, &uri->event_node);
spa_node_commands_map (uri->map, &uri->node_commands); spa_command_node_map (uri->map, &uri->command_node);
spa_monitor_types_map (uri->map, &uri->monitor_types); spa_monitor_types_map (uri->map, &uri->monitor_types);
spa_alloc_param_buffers_map (uri->map, &uri->alloc_param_buffers); spa_alloc_param_buffers_map (uri->map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (uri->map, &uri->alloc_param_meta_enable); spa_alloc_param_meta_enable_map (uri->map, &uri->alloc_param_meta_enable);

8
pinos/client/uri.h
View file

@ -24,8 +24,8 @@
extern "C" { extern "C" {
#endif #endif
#define PINOS_URI_URI "http://pinos.org/ns/uri" #define PINOS_TYPE__Uri "Pinos:Object:Uri"
#define PINOS_URI_PREFIX PINOS_URI_URI "#" #define PINOS_TYPE_URI_BASE PINOS_TYPE__Uri ":"
#include <pinos/client/map.h> #include <pinos/client/map.h>
#include <spa/include/spa/id-map.h> #include <spa/include/spa/id-map.h>
@ -55,8 +55,8 @@ struct _PinosURI {
uint32_t spa_clock; uint32_t spa_clock;
uint32_t spa_monitor; uint32_t spa_monitor;
SpaNodeEvents node_events; SpaEventNode event_node;
SpaNodeCommands node_commands; SpaCommandNode command_node;
SpaMonitorTypes monitor_types; SpaMonitorTypes monitor_types;
SpaAllocParamBuffers alloc_param_buffers; SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable; SpaAllocParamMetaEnable alloc_param_meta_enable;

6
pinos/gst/gstpinosformat.c
View file

@ -52,7 +52,7 @@ ensure_types (void)
{ {
SpaIDMap *map = spa_id_map_get_default (); SpaIDMap *map = spa_id_map_get_default ();
format_type = spa_id_map_get_id (map, SPA_FORMAT_URI); format_type = spa_id_map_get_id (map, SPA_TYPE__Format);
spa_media_types_fill (&media_types, map); spa_media_types_fill (&media_types, map);
spa_media_subtypes_map (map, &media_subtypes); spa_media_subtypes_map (map, &media_subtypes);
spa_media_subtypes_video_map (map, &media_subtypes_video); spa_media_subtypes_video_map (map, &media_subtypes_video);
@ -602,7 +602,7 @@ gst_caps_from_format (const SpaFormat *format)
const char * str = spa_id_map_get_uri (spa_id_map_get_default (), f.info.raw.format); const char * str = spa_id_map_get_uri (spa_id_map_get_default (), f.info.raw.format);
res = gst_caps_new_simple ("video/x-raw", res = gst_caps_new_simple ("video/x-raw",
"format", G_TYPE_STRING, strstr (str, "#") + 1, "format", G_TYPE_STRING, rindex (str, ':') + 1,
"width", G_TYPE_INT, f.info.raw.size.width, "width", G_TYPE_INT, f.info.raw.size.width,
"height", G_TYPE_INT, f.info.raw.size.height, "height", G_TYPE_INT, f.info.raw.size.height,
"framerate", GST_TYPE_FRACTION, f.info.raw.framerate.num, f.info.raw.framerate.denom, "framerate", GST_TYPE_FRACTION, f.info.raw.framerate.num, f.info.raw.framerate.denom,
@ -634,7 +634,7 @@ gst_caps_from_format (const SpaFormat *format)
const char * str = spa_id_map_get_uri (spa_id_map_get_default (), f.info.raw.format); const char * str = spa_id_map_get_uri (spa_id_map_get_default (), f.info.raw.format);
res = gst_caps_new_simple ("audio/x-raw", res = gst_caps_new_simple ("audio/x-raw",
"format", G_TYPE_STRING, strstr (str, "#") + 1, "format", G_TYPE_STRING, rindex (str, ':') + 1,
"layout", G_TYPE_STRING, "interleaved", "layout", G_TYPE_STRING, "interleaved",
"rate", G_TYPE_INT, f.info.raw.rate, "rate", G_TYPE_INT, f.info.raw.rate,
"channels", G_TYPE_INT, f.info.raw.channels, "channels", G_TYPE_INT, f.info.raw.channels,

6
pinos/modules/spa/module.c
View file

@ -40,9 +40,9 @@ setup_video_node (PinosCore *core, SpaNode *spa_node, PinosProperties *pinos_pro
/* Retrieve pattern property */ /* Retrieve pattern property */
pattern = pinos_properties_get (pinos_props, "pattern"); pattern = pinos_properties_get (pinos_props, "pattern");
if (strcmp (pattern, "smpte-snow") == 0) { if (strcmp (pattern, "smpte-snow") == 0) {
pattern_uri = SPA_PROPS__patternType ":smpte-snow"; pattern_uri = SPA_TYPE_PROPS__patternType ":smpte-snow";
} else if (strcmp (pattern, "snow") == 0) { } else if (strcmp (pattern, "snow") == 0) {
pattern_uri = SPA_PROPS__patternType ":snow"; pattern_uri = SPA_TYPE_PROPS__patternType ":snow";
} else { } else {
pinos_log_debug ("Unrecognized pattern"); pinos_log_debug ("Unrecognized pattern");
return SPA_RESULT_ERROR; return SPA_RESULT_ERROR;
@ -53,7 +53,7 @@ setup_video_node (PinosCore *core, SpaNode *spa_node, PinosProperties *pinos_pro
return SPA_RESULT_ERROR; return SPA_RESULT_ERROR;
} }
if ((prop = spa_pod_object_find_prop (props, spa_id_map_get_id (core->uri.map, SPA_PROPS__patternType)))) { if ((prop = spa_pod_object_find_prop (props, spa_id_map_get_id (core->uri.map, SPA_TYPE_PROPS__patternType)))) {
if (prop->body.value.type == SPA_POD_TYPE_URI) if (prop->body.value.type == SPA_POD_TYPE_URI)
SPA_POD_VALUE (SpaPODURI, &prop->body.value) = spa_id_map_get_id (core->uri.map, pattern_uri); SPA_POD_VALUE (SpaPODURI, &prop->body.value) = spa_id_map_get_id (core->uri.map, pattern_uri);
} }

2
pinos/modules/spa/spa-monitor.c
View file

@ -163,7 +163,7 @@ remove_item (PinosSpaMonitor *this, SpaMonitorItem *item)
static void static void
on_monitor_event (SpaMonitor *monitor, on_monitor_event (SpaMonitor *monitor,
SpaMonitorEvent *event, SpaEventMonitor *event,
void *user_data) void *user_data)
{ {
PinosSpaMonitor *this = user_data; PinosSpaMonitor *this = user_data;

4
pinos/server/access.h
View file

@ -24,8 +24,8 @@
extern "C" { extern "C" {
#endif #endif
#define PINOS_ACCESS_URI "http://pinos.org/ns/access" #define PINOS_TYPE__Access "Pinos:Object:Access"
#define PINOS_ACCESS_PREFIX PINOS_ACCESS_URI "#" #define PINOS_TYPE_ACCESS_BASE PINOS_TYPE__Access ":"
#include <pinos/client/sig.h> #include <pinos/client/sig.h>

22
pinos/server/client-node.c
View file

@ -93,7 +93,7 @@ struct _SpaProxy
SpaLoop *main_loop; SpaLoop *main_loop;
SpaLoop *data_loop; SpaLoop *data_loop;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
PinosResource *resource; PinosResource *resource;
@ -130,7 +130,7 @@ static void
send_async_complete (SpaProxy *this, uint32_t seq, SpaResult res) send_async_complete (SpaProxy *this, uint32_t seq, SpaResult res)
{ {
PinosCore *core = this->pnode->core; PinosCore *core = this->pnode->core;
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (core->uri.node_events.AsyncComplete, SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (core->uri.event_node.AsyncComplete,
seq, res); seq, res);
this->event_cb (&this->node, (SpaEvent *)&ac, this->user_data); this->event_cb (&this->node, (SpaEvent *)&ac, this->user_data);
} }
@ -166,7 +166,7 @@ static void
send_need_input (SpaProxy *this) send_need_input (SpaProxy *this)
{ {
PinosNode *pnode = this->pnode; PinosNode *pnode = this->pnode;
SpaEvent event = SPA_EVENT_INIT (pnode->core->uri.node_events.NeedInput); SpaEvent event = SPA_EVENT_INIT (pnode->core->uri.event_node.NeedInput);
uint64_t cmd = 1; uint64_t cmd = 1;
pinos_transport_add_event (pnode->transport, &event); pinos_transport_add_event (pnode->transport, &event);
@ -177,7 +177,7 @@ static void
send_have_output (SpaProxy *this) send_have_output (SpaProxy *this)
{ {
PinosNode *pnode = this->pnode; PinosNode *pnode = this->pnode;
SpaEvent event = SPA_EVENT_INIT (pnode->core->uri.node_events.HaveOutput); SpaEvent event = SPA_EVENT_INIT (pnode->core->uri.event_node.HaveOutput);
uint64_t cmd = 1; uint64_t cmd = 1;
pinos_transport_add_event (pnode->transport, &event); pinos_transport_add_event (pnode->transport, &event);
@ -202,7 +202,7 @@ spa_proxy_node_send_command (SpaNode *node,
core = this->pnode->core; core = this->pnode->core;
if (SPA_COMMAND_TYPE (command) == core->uri.node_commands.ClockUpdate) { if (SPA_COMMAND_TYPE (command) == core->uri.command_node.ClockUpdate) {
pinos_client_node_notify_node_command (this->resource, pinos_client_node_notify_node_command (this->resource,
this->seq++, this->seq++,
command); command);
@ -212,7 +212,7 @@ spa_proxy_node_send_command (SpaNode *node,
pinos_client_node_notify_node_command (this->resource, pinos_client_node_notify_node_command (this->resource,
this->seq, this->seq,
command); command);
if (SPA_COMMAND_TYPE (command) == core->uri.node_commands.Start) if (SPA_COMMAND_TYPE (command) == core->uri.command_node.Start)
send_need_input (this); send_need_input (this);
res = SPA_RESULT_RETURN_ASYNC (this->seq++); res = SPA_RESULT_RETURN_ASYNC (this->seq++);
@ -222,7 +222,7 @@ spa_proxy_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_proxy_node_set_event_callback (SpaNode *node, spa_proxy_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaProxy *this; SpaProxy *this;
@ -770,7 +770,7 @@ spa_proxy_node_port_reuse_buffer (SpaNode *node,
return SPA_RESULT_INVALID_PORT; return SPA_RESULT_INVALID_PORT;
{ {
SpaNodeEventReuseBuffer rb = SPA_NODE_EVENT_REUSE_BUFFER_INIT (pnode->core->uri.node_events.ReuseBuffer, SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (pnode->core->uri.event_node.ReuseBuffer,
port_id, buffer_id); port_id, buffer_id);
pinos_transport_add_event (pnode->transport, (SpaEvent *)&rb); pinos_transport_add_event (pnode->transport, (SpaEvent *)&rb);
//write (this->data_source.fd, &cmd, 8); //write (this->data_source.fd, &cmd, 8);
@ -999,11 +999,11 @@ proxy_init (SpaProxy *this,
uint32_t i; uint32_t i;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_LOG_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__MainLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data; this->main_loop = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__DataLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data; this->data_loop = support[i].data;
} }
if (this->data_loop == NULL) { if (this->data_loop == NULL) {

4
pinos/server/client-node.h
View file

@ -26,8 +26,8 @@
extern "C" { extern "C" {
#endif #endif
#define PINOS_CLIENT_NODE_URI "http://pinos.org/ns/client-node" #define PINOS_TYPE__ClientNode "Pinos:Object:ClientNode"
#define PINOS_CLIENT_NODE_PREFIX PINOS_CLIENT_NODE_URI "#" #define PINOS_TYPE_CLIENT_NODE_BASE PINOS_TYPE__ClientNode ":"
typedef struct _PinosClientNode PinosClientNode; typedef struct _PinosClientNode PinosClientNode;

8
pinos/server/core.c
View file

@ -295,13 +295,13 @@ pinos_core_new (PinosMainLoop *main_loop,
pinos_access_init (&this->access); pinos_access_init (&this->access);
pinos_map_init (&this->objects, 128, 32); pinos_map_init (&this->objects, 128, 32);
impl->support[0].uri = SPA_ID_MAP_URI; impl->support[0].uri = SPA_TYPE__IDMap;
impl->support[0].data = this->uri.map; impl->support[0].data = this->uri.map;
impl->support[1].uri = SPA_LOG_URI; impl->support[1].uri = SPA_TYPE__Log;
impl->support[1].data = pinos_log_get (); impl->support[1].data = pinos_log_get ();
impl->support[2].uri = SPA_LOOP__DataLoop; impl->support[2].uri = SPA_TYPE_LOOP__DataLoop;
impl->support[2].data = this->data_loop->loop->loop; impl->support[2].data = this->data_loop->loop->loop;
impl->support[3].uri = SPA_LOOP__MainLoop; impl->support[3].uri = SPA_TYPE_LOOP__MainLoop;
impl->support[3].data = this->main_loop->loop->loop; impl->support[3].data = this->main_loop->loop->loop;
this->support = impl->support; this->support = impl->support;
this->n_support = 4; this->n_support = 4;

4
pinos/server/node-factory.h
View file

@ -24,8 +24,8 @@
extern "C" { extern "C" {
#endif #endif
#define PINOS_NODE_FACTORY_URI "http://pinos.org/ns/node-factory" #define PINOS_TYPE__NodeFactory "Pinos:Object:NodeFactory"
#define PINOS_NODE_FACTORY_PREFIX PINOS_NODE_FACTORY_URI "#" #define PINOS_TYPE_NODE_FACTORY_BASE PINOS_TYPE__NodeFactory ":"
typedef struct _PinosNodeFactory PinosNodeFactory; typedef struct _PinosNodeFactory PinosNodeFactory;

30
pinos/server/node.c
View file

@ -169,7 +169,7 @@ pause_node (PinosNode *this)
pinos_log_debug ("node %p: pause node", this); pinos_log_debug ("node %p: pause node", this);
{ {
SpaCommand cmd = SPA_COMMAND_INIT (this->core->uri.node_commands.Pause); SpaCommand cmd = SPA_COMMAND_INIT (this->core->uri.command_node.Pause);
if ((res = spa_node_send_command (this->node, &cmd)) < 0) if ((res = spa_node_send_command (this->node, &cmd)) < 0)
pinos_log_debug ("got error %d", res); pinos_log_debug ("got error %d", res);
} }
@ -183,7 +183,7 @@ start_node (PinosNode *this)
pinos_log_debug ("node %p: start node", this); pinos_log_debug ("node %p: start node", this);
{ {
SpaCommand cmd = SPA_COMMAND_INIT (this->core->uri.node_commands.Start); SpaCommand cmd = SPA_COMMAND_INIT (this->core->uri.command_node.Start);
if ((res = spa_node_send_command (this->node, &cmd)) < 0) if ((res = spa_node_send_command (this->node, &cmd)) < 0)
pinos_log_debug ("got error %d", res); pinos_log_debug ("got error %d", res);
} }
@ -224,13 +224,13 @@ static void
send_clock_update (PinosNode *this) send_clock_update (PinosNode *this)
{ {
SpaResult res; SpaResult res;
SpaNodeCommandClockUpdate cu = SpaCommandNodeClockUpdate cu =
SPA_NODE_COMMAND_CLOCK_UPDATE_INIT( SPA_COMMAND_NODE_CLOCK_UPDATE_INIT(
this->core->uri.node_commands.ClockUpdate, this->core->uri.command_node.ClockUpdate,
SPA_NODE_COMMAND_CLOCK_UPDATE_TIME | SPA_COMMAND_NODE_CLOCK_UPDATE_TIME |
SPA_NODE_COMMAND_CLOCK_UPDATE_SCALE | SPA_COMMAND_NODE_CLOCK_UPDATE_SCALE |
SPA_NODE_COMMAND_CLOCK_UPDATE_STATE | SPA_COMMAND_NODE_CLOCK_UPDATE_STATE |
SPA_NODE_COMMAND_CLOCK_UPDATE_LATENCY, /* change_mask */ SPA_COMMAND_NODE_CLOCK_UPDATE_LATENCY, /* change_mask */
1, /* rate */ 1, /* rate */
0, /* ticks */ 0, /* ticks */
0, /* monotonic_time */ 0, /* monotonic_time */
@ -241,7 +241,7 @@ send_clock_update (PinosNode *this)
0); /* latency */ 0); /* latency */
if (this->clock && this->live) { if (this->clock && this->live) {
cu.body.flags.value = SPA_NODE_COMMAND_CLOCK_UPDATE_FLAG_LIVE; cu.body.flags.value = SPA_COMMAND_NODE_CLOCK_UPDATE_FLAG_LIVE;
res = spa_clock_get_time (this->clock, res = spa_clock_get_time (this->clock,
&cu.body.rate.value, &cu.body.rate.value,
&cu.body.ticks.value, &cu.body.ticks.value,
@ -258,15 +258,15 @@ on_node_event (SpaNode *node, SpaEvent *event, void *user_data)
PinosNode *this = user_data; PinosNode *this = user_data;
PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this); PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this);
if (SPA_EVENT_TYPE (event) == this->core->uri.node_events.AsyncComplete) { if (SPA_EVENT_TYPE (event) == this->core->uri.event_node.AsyncComplete) {
SpaNodeEventAsyncComplete *ac = (SpaNodeEventAsyncComplete *) event; SpaEventNodeAsyncComplete *ac = (SpaEventNodeAsyncComplete *) event;
pinos_log_debug ("node %p: async complete event %d %d", this, ac->body.seq.value, ac->body.res.value); pinos_log_debug ("node %p: async complete event %d %d", this, ac->body.seq.value, ac->body.res.value);
if (!pinos_work_queue_complete (impl->work, this, ac->body.seq.value, ac->body.res.value)) { if (!pinos_work_queue_complete (impl->work, this, ac->body.seq.value, ac->body.res.value)) {
pinos_signal_emit (&this->async_complete, this, ac->body.seq.value, ac->body.res.value); pinos_signal_emit (&this->async_complete, this, ac->body.seq.value, ac->body.res.value);
} }
} }
else if (SPA_EVENT_TYPE (event) == this->core->uri.node_events.NeedInput) { else if (SPA_EVENT_TYPE (event) == this->core->uri.event_node.NeedInput) {
SpaResult res; SpaResult res;
int i; int i;
bool processed = false; bool processed = false;
@ -310,7 +310,7 @@ on_node_event (SpaNode *node, SpaEvent *event, void *user_data)
pinos_log_warn ("node %p: got process input %d", this, res); pinos_log_warn ("node %p: got process input %d", this, res);
} }
} }
else if (SPA_EVENT_TYPE (event) == this->core->uri.node_events.HaveOutput) { else if (SPA_EVENT_TYPE (event) == this->core->uri.event_node.HaveOutput) {
SpaResult res; SpaResult res;
int i; int i;
bool processed = false; bool processed = false;
@ -353,7 +353,7 @@ on_node_event (SpaNode *node, SpaEvent *event, void *user_data)
pinos_log_warn ("node %p: got process output %d", this, res); pinos_log_warn ("node %p: got process output %d", this, res);
} }
} }
else if (SPA_EVENT_TYPE (event) == this->core->uri.node_events.RequestClockUpdate) { else if (SPA_EVENT_TYPE (event) == this->core->uri.event_node.RequestClockUpdate) {
send_clock_update (this); send_clock_update (this);
} }
} }

4
pinos/server/node.h
View file

@ -24,8 +24,8 @@
extern "C" { extern "C" {
#endif #endif
#define PINOS_NODE_URI "http://pinos.org/ns/node" #define PINOS_TYPE__Node "Pinos:Object:Node"
#define PINOS_NODE_PREFIX PINOS_NODE_URI "#" #define PINOS_TYPE_NODE_BASE PINOS_TYPE__Node ":"
typedef struct _PinosNode PinosNode; typedef struct _PinosNode PinosNode;

2
pinos/server/port.c
View file

@ -206,7 +206,7 @@ no_mem:
static SpaResult static SpaResult
pinos_port_pause (PinosPort *port) pinos_port_pause (PinosPort *port)
{ {
SpaCommand cmd = SPA_COMMAND_INIT (port->node->core->uri.node_commands.Pause); SpaCommand cmd = SPA_COMMAND_INIT (port->node->core->uri.command_node.Pause);
return spa_node_port_send_command (port->node->node, return spa_node_port_send_command (port->node->node,
port->direction, port->direction,
port->port_id, port->port_id,

4
pinos/server/port.h
View file

@ -24,8 +24,8 @@
extern "C" { extern "C" {
#endif #endif
#define PINOS_PORT_URI "http://pinos.org/ns/port" #define PINOS_TYPE__Port "Pinos:Object:Port"
#define PINOS_PORT_PREFIX PINOS_PORT_URI "#" #define PINOS_TYPE_PORT_BASE PINOS_TYPE__Port ":"
typedef struct _PinosPort PinosPort; typedef struct _PinosPort PinosPort;

4
pinos/server/resource.h
View file

@ -24,8 +24,8 @@
extern "C" { extern "C" {
#endif #endif
#define PINOS_RESOURCE_URI "http://pinos.org/ns/resource" #define PINOS_TYPE__Resource "Pinos:Object:Resource"
#define PINOS_RESOURCE_PREFIX PINOS_RESOURCE_URI "#" #define PINOS_TYPE_RESOURCE_BASE PINOS_TYPE__Resource ":"
typedef struct _PinosResource PinosResource; typedef struct _PinosResource PinosResource;

10
pinos/tools/pinos-monitor.c
View file

@ -65,7 +65,7 @@ dump_core_info (PinosContext *c,
return; return;
printf ("\tid: %u\n", info->id); printf ("\tid: %u\n", info->id);
printf ("\ttype: %s\n", PINOS_CORE_URI); printf ("\ttype: %s\n", PINOS_TYPE__Core);
if (data->print_all) { if (data->print_all) {
printf ("%c\tuser-name: \"%s\"\n", MARK_CHANGE (0), info->user_name); printf ("%c\tuser-name: \"%s\"\n", MARK_CHANGE (0), info->user_name);
printf ("%c\thost-name: \"%s\"\n", MARK_CHANGE (1), info->host_name); printf ("%c\thost-name: \"%s\"\n", MARK_CHANGE (1), info->host_name);
@ -88,7 +88,7 @@ dump_client_info (PinosContext *c,
return; return;
printf ("\tid: %u\n", info->id); printf ("\tid: %u\n", info->id);
printf ("\ttype: %s\n", PINOS_CLIENT_URI); printf ("\ttype: %s\n", PINOS_TYPE__Client);
if (data->print_all) { if (data->print_all) {
print_properties (info->props, MARK_CHANGE (0)); print_properties (info->props, MARK_CHANGE (0));
} }
@ -109,7 +109,7 @@ dump_node_info (PinosContext *c,
} }
printf ("\tid: %u\n", info->id); printf ("\tid: %u\n", info->id);
printf ("\ttype: %s\n", PINOS_NODE_URI); printf ("\ttype: %s\n", PINOS_TYPE__Node);
if (data->print_all) { if (data->print_all) {
int i; int i;
@ -148,7 +148,7 @@ dump_module_info (PinosContext *c,
} }
printf ("\tid: %u\n", info->id); printf ("\tid: %u\n", info->id);
printf ("\ttype: %s\n", PINOS_MODULE_URI); printf ("\ttype: %s\n", PINOS_TYPE__Module);
if (data->print_all) { if (data->print_all) {
printf ("%c\tname: \"%s\"\n", MARK_CHANGE (0), info->name); printf ("%c\tname: \"%s\"\n", MARK_CHANGE (0), info->name);
printf ("%c\tfilename: \"%s\"\n", MARK_CHANGE (1), info->filename); printf ("%c\tfilename: \"%s\"\n", MARK_CHANGE (1), info->filename);
@ -172,7 +172,7 @@ dump_link_info (PinosContext *c,
} }
printf ("\tid: %u\n", info->id); printf ("\tid: %u\n", info->id);
printf ("\ttype: %s\n", PINOS_LINK_URI); printf ("\ttype: %s\n", PINOS_TYPE__Link);
if (data->print_all) { if (data->print_all) {
printf ("%c\toutput-node-id: %u\n", MARK_CHANGE (0), info->output_node_id); printf ("%c\toutput-node-id: %u\n", MARK_CHANGE (0), info->output_node_id);
printf ("%c\toutput-port-id: %u\n", MARK_CHANGE (1), info->output_port_id); printf ("%c\toutput-port-id: %u\n", MARK_CHANGE (1), info->output_port_id);

12
spa/include/spa/audio/format-utils.h
View file

@ -41,12 +41,12 @@ static inline void
spa_prop_audio_map (SpaIDMap *map, SpaPropAudio *types) spa_prop_audio_map (SpaIDMap *map, SpaPropAudio *types)
{ {
if (types->format == 0) { if (types->format == 0) {
types->format = spa_id_map_get_id (map, SPA_PROP_AUDIO__format); types->format = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__format);
types->flags = spa_id_map_get_id (map, SPA_PROP_AUDIO__flags); types->flags = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__flags);
types->layout = spa_id_map_get_id (map, SPA_PROP_AUDIO__layout); types->layout = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__layout);
types->rate = spa_id_map_get_id (map, SPA_PROP_AUDIO__rate); types->rate = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__rate);
types->channels = spa_id_map_get_id (map, SPA_PROP_AUDIO__channels); types->channels = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__channels);
types->channel_mask = spa_id_map_get_id (map, SPA_PROP_AUDIO__channelMask); types->channel_mask = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__channelMask);
} }
} }

16
spa/include/spa/audio/format.h
View file

@ -29,15 +29,15 @@ extern "C" {
typedef struct _SpaAudioInfo SpaAudioInfo; typedef struct _SpaAudioInfo SpaAudioInfo;
#define SPA_PROP_AUDIO_URI "http://spaplug.in/ns/prop-audio" #define SPA_TYPE_PROP__Audio "Spa:Prop:Audio"
#define SPA_PROP_AUDIO_PREFIX SPA_PROP_AUDIO_URI "#" #define SPA_TYPE_PROP_AUDIO_BASE SPA_TYPE_PROP__Audio ":"
#define SPA_PROP_AUDIO__format SPA_PROP_AUDIO_PREFIX "format" #define SPA_TYPE_PROP_AUDIO__format SPA_TYPE_PROP_AUDIO_BASE "format"
#define SPA_PROP_AUDIO__flags SPA_PROP_AUDIO_PREFIX "flags" #define SPA_TYPE_PROP_AUDIO__flags SPA_TYPE_PROP_AUDIO_BASE "flags"
#define SPA_PROP_AUDIO__layout SPA_PROP_AUDIO_PREFIX "layout" #define SPA_TYPE_PROP_AUDIO__layout SPA_TYPE_PROP_AUDIO_BASE "layout"
#define SPA_PROP_AUDIO__rate SPA_PROP_AUDIO_PREFIX "rate" #define SPA_TYPE_PROP_AUDIO__rate SPA_TYPE_PROP_AUDIO_BASE "rate"
#define SPA_PROP_AUDIO__channels SPA_PROP_AUDIO_PREFIX "channels" #define SPA_TYPE_PROP_AUDIO__channels SPA_TYPE_PROP_AUDIO_BASE "channels"
#define SPA_PROP_AUDIO__channelMask SPA_PROP_AUDIO_PREFIX "channel-mask" #define SPA_TYPE_PROP_AUDIO__channelMask SPA_TYPE_PROP_AUDIO_BASE "channel-mask"
struct _SpaAudioInfo { struct _SpaAudioInfo {
uint32_t media_type; uint32_t media_type;

14
spa/include/spa/audio/raw-utils.h
View file

@ -28,11 +28,11 @@ extern "C" {
#include <spa/audio/raw.h> #include <spa/audio/raw.h>
#if __BYTE_ORDER == __BIG_ENDIAN #if __BYTE_ORDER == __BIG_ENDIAN
#define _SPA_AUDIO_FORMAT_NE(fmt) SPA_AUDIO_FORMAT_PREFIX fmt "BE" #define _SPA_AUDIO_FORMAT_NE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "BE"
#define _SPA_AUDIO_FORMAT_OE(fmt) SPA_AUDIO_FORMAT_PREFIX fmt "LE" #define _SPA_AUDIO_FORMAT_OE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "LE"
#elif __BYTE_ORDER == __LITTLE_ENDIAN #elif __BYTE_ORDER == __LITTLE_ENDIAN
#define _SPA_AUDIO_FORMAT_NE(fmt) SPA_AUDIO_FORMAT_PREFIX fmt "LE" #define _SPA_AUDIO_FORMAT_NE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "LE"
#define _SPA_AUDIO_FORMAT_OE(fmt) SPA_AUDIO_FORMAT_PREFIX fmt "BE" #define _SPA_AUDIO_FORMAT_OE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "BE"
#endif #endif
typedef struct { typedef struct {
@ -75,10 +75,10 @@ spa_audio_formats_map (SpaIDMap *map, SpaAudioFormats *types)
{ {
if (types->ENCODED == 0) { if (types->ENCODED == 0) {
types->UNKNOWN = 0; types->UNKNOWN = 0;
types->ENCODED = spa_id_map_get_id (map, SPA_AUDIO_FORMAT__ENCODED); types->ENCODED = spa_id_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__ENCODED);
types->S8 = spa_id_map_get_id (map, SPA_AUDIO_FORMAT__S8); types->S8 = spa_id_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__S8);
types->U8 = spa_id_map_get_id (map, SPA_AUDIO_FORMAT__U8); types->U8 = spa_id_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__U8);
types->S16 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("S16")); types->S16 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("S16"));
types->U16 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("U16")); types->U16 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("U16"));

68
spa/include/spa/audio/raw.h
View file

@ -28,41 +28,41 @@ typedef struct _SpaAudioInfoRaw SpaAudioInfoRaw;
#include <endian.h> #include <endian.h>
#define SPA_AUDIO_FORMAT_URI "http://spaplug.in/ns/audio-format" #define SPA_TYPE_AudioFormat "Spa:Enum:AudioFormat"
#define SPA_AUDIO_FORMAT_PREFIX SPA_AUDIO_FORMAT_URI "#" #define SPA_TYPE_AUDIO_FORMAT_BASE SPA_TYPE_AudioFormat ":"
#define SPA_AUDIO_FORMAT__UNKNOWN SPA_AUDIO_FORMAT_PREFIX "UNKNOWN" #define SPA_TYPE_AUDIO_FORMAT__UNKNOWN SPA_TYPE_AUDIO_FORMAT_BASE "UNKNOWN"
#define SPA_AUDIO_FORMAT__ENCODED SPA_AUDIO_FORMAT_PREFIX "ENCODED" #define SPA_TYPE_AUDIO_FORMAT__ENCODED SPA_TYPE_AUDIO_FORMAT_BASE "ENCODED"
#define SPA_AUDIO_FORMAT__S8 SPA_AUDIO_FORMAT_PREFIX "S8" #define SPA_TYPE_AUDIO_FORMAT__S8 SPA_TYPE_AUDIO_FORMAT_BASE "S8"
#define SPA_AUDIO_FORMAT__U8 SPA_AUDIO_FORMAT_PREFIX "U8" #define SPA_TYPE_AUDIO_FORMAT__U8 SPA_TYPE_AUDIO_FORMAT_BASE "U8"
#define SPA_AUDIO_FORMAT__S16LE SPA_AUDIO_FORMAT_PREFIX "S16LE" #define SPA_TYPE_AUDIO_FORMAT__S16LE SPA_TYPE_AUDIO_FORMAT_BASE "S16LE"
#define SPA_AUDIO_FORMAT__S16BE SPA_AUDIO_FORMAT_PREFIX "S16BE" #define SPA_TYPE_AUDIO_FORMAT__S16BE SPA_TYPE_AUDIO_FORMAT_BASE "S16BE"
#define SPA_AUDIO_FORMAT__U16LE SPA_AUDIO_FORMAT_PREFIX "U16LE" #define SPA_TYPE_AUDIO_FORMAT__U16LE SPA_TYPE_AUDIO_FORMAT_BASE "U16LE"
#define SPA_AUDIO_FORMAT__U16BE SPA_AUDIO_FORMAT_PREFIX "U16BE" #define SPA_TYPE_AUDIO_FORMAT__U16BE SPA_TYPE_AUDIO_FORMAT_BASE "U16BE"
#define SPA_AUDIO_FORMAT__S24_32LE SPA_AUDIO_FORMAT_PREFIX "S24_32LE" #define SPA_TYPE_AUDIO_FORMAT__S24_32LE SPA_TYPE_AUDIO_FORMAT_BASE "S24_32LE"
#define SPA_AUDIO_FORMAT__S24_32BE SPA_AUDIO_FORMAT_PREFIX "S24_32BE" #define SPA_TYPE_AUDIO_FORMAT__S24_32BE SPA_TYPE_AUDIO_FORMAT_BASE "S24_32BE"
#define SPA_AUDIO_FORMAT__U24_32LE SPA_AUDIO_FORMAT_PREFIX "U24_32LE" #define SPA_TYPE_AUDIO_FORMAT__U24_32LE SPA_TYPE_AUDIO_FORMAT_BASE "U24_32LE"
#define SPA_AUDIO_FORMAT__U24_32BE SPA_AUDIO_FORMAT_PREFIX "U24_32BE" #define SPA_TYPE_AUDIO_FORMAT__U24_32BE SPA_TYPE_AUDIO_FORMAT_BASE "U24_32BE"
#define SPA_AUDIO_FORMAT__S32LE SPA_AUDIO_FORMAT_PREFIX "S32LE" #define SPA_TYPE_AUDIO_FORMAT__S32LE SPA_TYPE_AUDIO_FORMAT_BASE "S32LE"
#define SPA_AUDIO_FORMAT__S32BE SPA_AUDIO_FORMAT_PREFIX "S32BE" #define SPA_TYPE_AUDIO_FORMAT__S32BE SPA_TYPE_AUDIO_FORMAT_BASE "S32BE"
#define SPA_AUDIO_FORMAT__U32LE SPA_AUDIO_FORMAT_PREFIX "U32LE" #define SPA_TYPE_AUDIO_FORMAT__U32LE SPA_TYPE_AUDIO_FORMAT_BASE "U32LE"
#define SPA_AUDIO_FORMAT__U32BE SPA_AUDIO_FORMAT_PREFIX "U32BE" #define SPA_TYPE_AUDIO_FORMAT__U32BE SPA_TYPE_AUDIO_FORMAT_BASE "U32BE"
#define SPA_AUDIO_FORMAT__S24LE SPA_AUDIO_FORMAT_PREFIX "S24LE" #define SPA_TYPE_AUDIO_FORMAT__S24LE SPA_TYPE_AUDIO_FORMAT_BASE "S24LE"
#define SPA_AUDIO_FORMAT__S24BE SPA_AUDIO_FORMAT_PREFIX "S24BE" #define SPA_TYPE_AUDIO_FORMAT__S24BE SPA_TYPE_AUDIO_FORMAT_BASE "S24BE"
#define SPA_AUDIO_FORMAT__U24LE SPA_AUDIO_FORMAT_PREFIX "U24LE" #define SPA_TYPE_AUDIO_FORMAT__U24LE SPA_TYPE_AUDIO_FORMAT_BASE "U24LE"
#define SPA_AUDIO_FORMAT__U24BE SPA_AUDIO_FORMAT_PREFIX "U24BE" #define SPA_TYPE_AUDIO_FORMAT__U24BE SPA_TYPE_AUDIO_FORMAT_BASE "U24BE"
#define SPA_AUDIO_FORMAT__S20LE SPA_AUDIO_FORMAT_PREFIX "S20LE" #define SPA_TYPE_AUDIO_FORMAT__S20LE SPA_TYPE_AUDIO_FORMAT_BASE "S20LE"
#define SPA_AUDIO_FORMAT__S20BE SPA_AUDIO_FORMAT_PREFIX "S20BE" #define SPA_TYPE_AUDIO_FORMAT__S20BE SPA_TYPE_AUDIO_FORMAT_BASE "S20BE"
#define SPA_AUDIO_FORMAT__U20LE SPA_AUDIO_FORMAT_PREFIX "U20LE" #define SPA_TYPE_AUDIO_FORMAT__U20LE SPA_TYPE_AUDIO_FORMAT_BASE "U20LE"
#define SPA_AUDIO_FORMAT__U20BE SPA_AUDIO_FORMAT_PREFIX "U20BE" #define SPA_TYPE_AUDIO_FORMAT__U20BE SPA_TYPE_AUDIO_FORMAT_BASE "U20BE"
#define SPA_AUDIO_FORMAT__S18LE SPA_AUDIO_FORMAT_PREFIX "S18LE" #define SPA_TYPE_AUDIO_FORMAT__S18LE SPA_TYPE_AUDIO_FORMAT_BASE "S18LE"
#define SPA_AUDIO_FORMAT__S18BE SPA_AUDIO_FORMAT_PREFIX "S18BE" #define SPA_TYPE_AUDIO_FORMAT__S18BE SPA_TYPE_AUDIO_FORMAT_BASE "S18BE"
#define SPA_AUDIO_FORMAT__U18LE SPA_AUDIO_FORMAT_PREFIX "U18LE" #define SPA_TYPE_AUDIO_FORMAT__U18LE SPA_TYPE_AUDIO_FORMAT_BASE "U18LE"
#define SPA_AUDIO_FORMAT__U18BE SPA_AUDIO_FORMAT_PREFIX "U18BE" #define SPA_TYPE_AUDIO_FORMAT__U18BE SPA_TYPE_AUDIO_FORMAT_BASE "U18BE"
#define SPA_AUDIO_FORMAT__F32LE SPA_AUDIO_FORMAT_PREFIX "F32LE" #define SPA_TYPE_AUDIO_FORMAT__F32LE SPA_TYPE_AUDIO_FORMAT_BASE "F32LE"
#define SPA_AUDIO_FORMAT__F32BE SPA_AUDIO_FORMAT_PREFIX "F32BE" #define SPA_TYPE_AUDIO_FORMAT__F32BE SPA_TYPE_AUDIO_FORMAT_BASE "F32BE"
#define SPA_AUDIO_FORMAT__F64LE SPA_AUDIO_FORMAT_PREFIX "F64LE" #define SPA_TYPE_AUDIO_FORMAT__F64LE SPA_TYPE_AUDIO_FORMAT_BASE "F64LE"
#define SPA_AUDIO_FORMAT__F64BE SPA_AUDIO_FORMAT_PREFIX "F64BE" #define SPA_TYPE_AUDIO_FORMAT__F64BE SPA_TYPE_AUDIO_FORMAT_BASE "F64BE"
/** /**
* SpaAudioFlags: * SpaAudioFlags:

4
spa/include/spa/buffer.h
View file

@ -26,8 +26,8 @@ extern "C" {
typedef struct _SpaBuffer SpaBuffer; typedef struct _SpaBuffer SpaBuffer;
#define SPA_BUFFER_URI "http://spaplug.in/ns/buffer" #define SPA_TYPE__Buffer "Spa:Pointer:Buffer"
#define SPA_BUFFER_PREFIX SPA_BUFFER_URI "#" #define SPA_TYPE_BUFFER_BASE SPA_TYPE__Buffer ":"
/** /**
* SpaMetaType: * SpaMetaType:

4
spa/include/spa/clock.h
View file

@ -26,8 +26,8 @@ extern "C" {
typedef struct _SpaClock SpaClock; typedef struct _SpaClock SpaClock;
#define SPA_CLOCK_URI "http://spaplug.in/ns/clock" #define SPA_TYPE__Clock "Spa:Interface:Clock"
#define SPA_CLOCK_PREFIX SPA_CLOCK_URI "#" #define SPA_TYPE_CLOCK_BASE SPA_TYPE__Clock ":"
/** /**
* SpaClockState: * SpaClockState:

4
spa/include/spa/command.h
View file

@ -29,8 +29,8 @@ typedef struct _SpaCommand SpaCommand;
#include <spa/defs.h> #include <spa/defs.h>
#include <spa/pod.h> #include <spa/pod.h>
#define SPA_COMMAND_URI "http://spaplug.in/ns/command" #define SPA_TYPE__Command "Spa:Object:Command"
#define SPA_COMMAND_PREFIX SPA_COMMAND_URI "#" #define SPA_TYPE_COMMAND_BASE SPA_TYPE__Command ":"
typedef struct { typedef struct {
SpaPODObjectBody body; SpaPODObjectBody body;

3
spa/include/spa/dict.h
View file

@ -26,6 +26,9 @@ extern "C" {
typedef struct _SpaDict SpaDict; typedef struct _SpaDict SpaDict;
#define SPA_TYPE__Dict "Spa:Pointer:Dict"
#define SPA_TYPE_DICT_BASE SPA_TYPE__Dict ":"
#include <string.h> #include <string.h>
#include <spa/defs.h> #include <spa/defs.h>

4
spa/include/spa/event.h
View file

@ -29,8 +29,8 @@ typedef struct _SpaEvent SpaEvent;
#include <spa/defs.h> #include <spa/defs.h>
#include <spa/pod.h> #include <spa/pod.h>
#define SPA_EVENT_URI "http://spaplug.in/ns/event" #define SPA_TYPE__Event "Spa:Object:Event"
#define SPA_EVENT_PREFIX SPA_EVENT_URI "#" #define SPA_TYPE_EVENT_BASE SPA_TYPE__Event ":"
typedef struct { typedef struct {
SpaPODObjectBody body; SpaPODObjectBody body;

60
spa/include/spa/format-utils.h
View file

@ -40,9 +40,9 @@ static inline void
spa_media_types_fill (SpaMediaTypes *types, SpaIDMap *map) spa_media_types_fill (SpaMediaTypes *types, SpaIDMap *map)
{ {
if (types->audio == 0) { if (types->audio == 0) {
types->audio = spa_id_map_get_id (map, SPA_MEDIA_TYPE__audio); types->audio = spa_id_map_get_id (map, SPA_TYPE_MEDIA_TYPE__audio);
types->video = spa_id_map_get_id (map, SPA_MEDIA_TYPE__video); types->video = spa_id_map_get_id (map, SPA_TYPE_MEDIA_TYPE__video);
types->image = spa_id_map_get_id (map, SPA_MEDIA_TYPE__image); types->image = spa_id_map_get_id (map, SPA_TYPE_MEDIA_TYPE__image);
} }
} }
@ -54,7 +54,7 @@ static inline void
spa_media_subtypes_map (SpaIDMap *map, SpaMediaSubtypes *types) spa_media_subtypes_map (SpaIDMap *map, SpaMediaSubtypes *types)
{ {
if (types->raw == 0) { if (types->raw == 0) {
types->raw = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__raw); types->raw = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__raw);
} }
} }
@ -79,20 +79,20 @@ static inline void
spa_media_subtypes_video_map (SpaIDMap *map, SpaMediaSubtypesVideo *types) spa_media_subtypes_video_map (SpaIDMap *map, SpaMediaSubtypesVideo *types)
{ {
if (types->h264 == 0) { if (types->h264 == 0) {
types->h264 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__h264); types->h264 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__h264);
types->mjpg = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__mjpg); types->mjpg = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mjpg);
types->dv = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__dv); types->dv = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__dv);
types->mpegts = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__mpegts); types->mpegts = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpegts);
types->h263 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__h263); types->h263 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__h263);
types->mpeg1 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__mpeg1); types->mpeg1 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg1);
types->mpeg2 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__mpeg2); types->mpeg2 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg2);
types->mpeg4 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__mpeg4); types->mpeg4 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg4);
types->xvid = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__xvid); types->xvid = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__xvid);
types->vc1 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__vc1); types->vc1 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vc1);
types->vp8 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__vp8); types->vp8 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vp8);
types->vp9 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__vp9); types->vp9 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vp9);
types->jpeg = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__jpeg); types->jpeg = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__jpeg);
types->bayer = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__bayer); types->bayer = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__bayer);
} }
} }
@ -115,18 +115,18 @@ static inline void
spa_media_subtypes_audio_map (SpaIDMap *map, SpaMediaSubtypesAudio *types) spa_media_subtypes_audio_map (SpaIDMap *map, SpaMediaSubtypesAudio *types)
{ {
if (types->mp3 == 0) { if (types->mp3 == 0) {
types->mp3 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__mp3); types->mp3 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mp3);
types->aac = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__aac); types->aac = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__aac);
types->vorbis = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__vorbis); types->vorbis = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vorbis);
types->wma = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__wma); types->wma = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__wma);
types->ra = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__ra); types->ra = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__ra);
types->sbc = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__sbc); types->sbc = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__sbc);
types->adpcm = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__adpcm); types->adpcm = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__adpcm);
types->g723 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__g723); types->g723 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g723);
types->g726 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__g726); types->g726 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g726);
types->g729 = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__g729); types->g729 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g729);
types->amr = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__amr); types->amr = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__amr);
types->gsm = spa_id_map_get_id (map, SPA_MEDIA_SUBTYPE__gsm); types->gsm = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__gsm);
} }
} }

72
spa/include/spa/format.h
View file

@ -24,56 +24,56 @@
extern "C" { extern "C" {
#endif #endif
#define SPA_FORMAT_URI "http://spaplug.in/ns/format" #define SPA_TYPE__Format "Spa:Object:Format"
#define SPA_FORMAT_PREFIX SPA_FORMAT_URI "#" #define SPA_TYPE_FORMAT_BASE SPA_TYPE__Format ":"
typedef struct _SpaFormat SpaFormat; typedef struct _SpaFormat SpaFormat;
#include <spa/defs.h> #include <spa/defs.h>
#include <spa/pod.h> #include <spa/pod.h>
#define SPA_MEDIA_TYPE_URI "http://spaplug.in/ns/media-type" #define SPA_TYPE__MediaType "Spa:Enum:MediaType"
#define SPA_MEDIA_TYPE_PREFIX SPA_MEDIA_TYPE_URI "#" #define SPA_TYPE_MEDIA_TYPE_BASE SPA_TYPE__MediaType ":"
#define SPA_MEDIA_TYPE__audio SPA_MEDIA_TYPE_PREFIX "audio" #define SPA_TYPE_MEDIA_TYPE__audio SPA_TYPE_MEDIA_TYPE_BASE "audio"
#define SPA_MEDIA_TYPE__video SPA_MEDIA_TYPE_PREFIX "video" #define SPA_TYPE_MEDIA_TYPE__video SPA_TYPE_MEDIA_TYPE_BASE "video"
#define SPA_MEDIA_TYPE__image SPA_MEDIA_TYPE_PREFIX "image" #define SPA_TYPE_MEDIA_TYPE__image SPA_TYPE_MEDIA_TYPE_BASE "image"
#define SPA_MEDIA_SUBTYPE_URI "http://spaplug.in/ns/media-subtype" #define SPA_TYPE__MediaSubtype "Spa:Enum:MediaSubtype"
#define SPA_MEDIA_SUBTYPE_PREFIX SPA_MEDIA_TYPE_URI "#" #define SPA_TYPE_MEDIA_SUBTYPE_BASE SPA_TYPE__MediaSubtype ":"
/* generic subtypes */ /* generic subtypes */
#define SPA_MEDIA_SUBTYPE__raw SPA_MEDIA_TYPE_PREFIX "raw" #define SPA_TYPE_MEDIA_SUBTYPE__raw SPA_TYPE_MEDIA_SUBTYPE_BASE "raw"
/* video subtypes */ /* video subtypes */
#define SPA_MEDIA_SUBTYPE__h264 SPA_MEDIA_SUBTYPE_PREFIX "h264" #define SPA_TYPE_MEDIA_SUBTYPE__h264 SPA_TYPE_MEDIA_SUBTYPE_BASE "h264"
#define SPA_MEDIA_SUBTYPE__mjpg SPA_MEDIA_SUBTYPE_PREFIX "mjpg" #define SPA_TYPE_MEDIA_SUBTYPE__mjpg SPA_TYPE_MEDIA_SUBTYPE_BASE "mjpg"
#define SPA_MEDIA_SUBTYPE__dv SPA_MEDIA_SUBTYPE_PREFIX "dv" #define SPA_TYPE_MEDIA_SUBTYPE__dv SPA_TYPE_MEDIA_SUBTYPE_BASE "dv"
#define SPA_MEDIA_SUBTYPE__mpegts SPA_MEDIA_SUBTYPE_PREFIX "mpegts" #define SPA_TYPE_MEDIA_SUBTYPE__mpegts SPA_TYPE_MEDIA_SUBTYPE_BASE "mpegts"
#define SPA_MEDIA_SUBTYPE__h263 SPA_MEDIA_SUBTYPE_PREFIX "h263" #define SPA_TYPE_MEDIA_SUBTYPE__h263 SPA_TYPE_MEDIA_SUBTYPE_BASE "h263"
#define SPA_MEDIA_SUBTYPE__mpeg1 SPA_MEDIA_SUBTYPE_PREFIX "mpeg1" #define SPA_TYPE_MEDIA_SUBTYPE__mpeg1 SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg1"
#define SPA_MEDIA_SUBTYPE__mpeg2 SPA_MEDIA_SUBTYPE_PREFIX "mpeg2" #define SPA_TYPE_MEDIA_SUBTYPE__mpeg2 SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg2"
#define SPA_MEDIA_SUBTYPE__mpeg4 SPA_MEDIA_SUBTYPE_PREFIX "mpeg4" #define SPA_TYPE_MEDIA_SUBTYPE__mpeg4 SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg4"
#define SPA_MEDIA_SUBTYPE__xvid SPA_MEDIA_SUBTYPE_PREFIX "xvid" #define SPA_TYPE_MEDIA_SUBTYPE__xvid SPA_TYPE_MEDIA_SUBTYPE_BASE "xvid"
#define SPA_MEDIA_SUBTYPE__vc1 SPA_MEDIA_SUBTYPE_PREFIX "vc1" #define SPA_TYPE_MEDIA_SUBTYPE__vc1 SPA_TYPE_MEDIA_SUBTYPE_BASE "vc1"
#define SPA_MEDIA_SUBTYPE__vp8 SPA_MEDIA_SUBTYPE_PREFIX "vp8" #define SPA_TYPE_MEDIA_SUBTYPE__vp8 SPA_TYPE_MEDIA_SUBTYPE_BASE "vp8"
#define SPA_MEDIA_SUBTYPE__vp9 SPA_MEDIA_SUBTYPE_PREFIX "vp9" #define SPA_TYPE_MEDIA_SUBTYPE__vp9 SPA_TYPE_MEDIA_SUBTYPE_BASE "vp9"
#define SPA_MEDIA_SUBTYPE__jpeg SPA_MEDIA_SUBTYPE_PREFIX "jpeg" #define SPA_TYPE_MEDIA_SUBTYPE__jpeg SPA_TYPE_MEDIA_SUBTYPE_BASE "jpeg"
#define SPA_MEDIA_SUBTYPE__bayer SPA_MEDIA_SUBTYPE_PREFIX "bayer" #define SPA_TYPE_MEDIA_SUBTYPE__bayer SPA_TYPE_MEDIA_SUBTYPE_BASE "bayer"
/* audio subtypes */ /* audio subtypes */
#define SPA_MEDIA_SUBTYPE__mp3 SPA_MEDIA_SUBTYPE_PREFIX "mp3" #define SPA_TYPE_MEDIA_SUBTYPE__mp3 SPA_TYPE_MEDIA_SUBTYPE_BASE "mp3"
#define SPA_MEDIA_SUBTYPE__aac SPA_MEDIA_SUBTYPE_PREFIX "aac" #define SPA_TYPE_MEDIA_SUBTYPE__aac SPA_TYPE_MEDIA_SUBTYPE_BASE "aac"
#define SPA_MEDIA_SUBTYPE__vorbis SPA_MEDIA_SUBTYPE_PREFIX "vorbis" #define SPA_TYPE_MEDIA_SUBTYPE__vorbis SPA_TYPE_MEDIA_SUBTYPE_BASE "vorbis"
#define SPA_MEDIA_SUBTYPE__wma SPA_MEDIA_SUBTYPE_PREFIX "wma" #define SPA_TYPE_MEDIA_SUBTYPE__wma SPA_TYPE_MEDIA_SUBTYPE_BASE "wma"
#define SPA_MEDIA_SUBTYPE__ra SPA_MEDIA_SUBTYPE_PREFIX "ra" #define SPA_TYPE_MEDIA_SUBTYPE__ra SPA_TYPE_MEDIA_SUBTYPE_BASE "ra"
#define SPA_MEDIA_SUBTYPE__sbc SPA_MEDIA_SUBTYPE_PREFIX "sbc" #define SPA_TYPE_MEDIA_SUBTYPE__sbc SPA_TYPE_MEDIA_SUBTYPE_BASE "sbc"
#define SPA_MEDIA_SUBTYPE__adpcm SPA_MEDIA_SUBTYPE_PREFIX "adpcm" #define SPA_TYPE_MEDIA_SUBTYPE__adpcm SPA_TYPE_MEDIA_SUBTYPE_BASE "adpcm"
#define SPA_MEDIA_SUBTYPE__g723 SPA_MEDIA_SUBTYPE_PREFIX "g723" #define SPA_TYPE_MEDIA_SUBTYPE__g723 SPA_TYPE_MEDIA_SUBTYPE_BASE "g723"
#define SPA_MEDIA_SUBTYPE__g726 SPA_MEDIA_SUBTYPE_PREFIX "g726" #define SPA_TYPE_MEDIA_SUBTYPE__g726 SPA_TYPE_MEDIA_SUBTYPE_BASE "g726"
#define SPA_MEDIA_SUBTYPE__g729 SPA_MEDIA_SUBTYPE_PREFIX "g729" #define SPA_TYPE_MEDIA_SUBTYPE__g729 SPA_TYPE_MEDIA_SUBTYPE_BASE "g729"
#define SPA_MEDIA_SUBTYPE__amr SPA_MEDIA_SUBTYPE_PREFIX "amr" #define SPA_TYPE_MEDIA_SUBTYPE__amr SPA_TYPE_MEDIA_SUBTYPE_BASE "amr"
#define SPA_MEDIA_SUBTYPE__gsm SPA_MEDIA_SUBTYPE_PREFIX "gsm" #define SPA_TYPE_MEDIA_SUBTYPE__gsm SPA_TYPE_MEDIA_SUBTYPE_BASE "gsm"
typedef struct { typedef struct {
SpaPODObjectBody obj_body; SpaPODObjectBody obj_body;

3
spa/include/spa/id-map.h
View file

@ -29,7 +29,8 @@ typedef struct _SpaIDMap SpaIDMap;
#include <spa/defs.h> #include <spa/defs.h>
#include <spa/plugin.h> #include <spa/plugin.h>
#define SPA_ID_MAP_URI "http://spaplug.in/ns/id-map" #define SPA_TYPE__IDMap "Spa:Interface:IDMap"
#define SPA_TYPE_ID_MAP_BASE SPA_TYPE__IDMap ":"
/** /**
* SpaIDMap: * SpaIDMap:

4
spa/include/spa/log.h
View file

@ -26,8 +26,8 @@ extern "C" {
typedef struct _SpaLog SpaLog; typedef struct _SpaLog SpaLog;
#define SPA_LOG_URI "http://spaplug.in/ns/log" #define SPA_TYPE__Log "Spa:Interface:Log"
#define SPA_LOG_PREFIX SPA_LOG_URI "#" #define SPA_TYPE_LOG_BASE SPA_TYPE__Log ":"
#include <stdarg.h> #include <stdarg.h>

13
spa/include/spa/loop.h
View file

@ -29,12 +29,13 @@ typedef struct _SpaSource SpaSource;
typedef struct _SpaLoopControl SpaLoopControl; typedef struct _SpaLoopControl SpaLoopControl;
typedef struct _SpaLoopUtils SpaLoopUtils; typedef struct _SpaLoopUtils SpaLoopUtils;
#define SPA_LOOP_URI "http://spaplug.in/ns/loop" #define SPA_TYPE__Loop "Spa:Interface:Loop"
#define SPA_LOOP_PREFIX SPA_LOOP_URI "#" #define SPA_TYPE__LoopControl "Spa:Interface:LoopControl"
#define SPA_LOOP__MainLoop SPA_LOOP_PREFIX "MainLoop" #define SPA_TYPE__LoopUtils "Spa:Interface:LoopUtils"
#define SPA_LOOP__DataLoop SPA_LOOP_PREFIX "DataLoop"
#define SPA_LOOP__Control SPA_LOOP_PREFIX "Control" #define SPA_TYPE_LOOP_BASE SPA_TYPE__Loop ":"
#define SPA_LOOP__Utils SPA_LOOP_PREFIX "Utils" #define SPA_TYPE_LOOP__MainLoop SPA_TYPE_LOOP_BASE "MainLoop"
#define SPA_TYPE_LOOP__DataLoop SPA_TYPE_LOOP_BASE "DataLoop"
#include <spa/defs.h> #include <spa/defs.h>

66
spa/include/spa/monitor.h
View file

@ -26,31 +26,31 @@ extern "C" {
typedef struct _SpaMonitor SpaMonitor; typedef struct _SpaMonitor SpaMonitor;
#define SPA_MONITOR_URI "http://spaplug.in/ns/monitor" #define SPA_TYPE__Monitor "Spa:Interface:Monitor"
#define SPA_MONITOR_PREFIX SPA_MONITOR_URI "#" #define SPA_TYPE_MONITOR_BASE SPA_TYPE__Monitor ":"
#include <spa/defs.h> #include <spa/defs.h>
#include <spa/dict.h> #include <spa/dict.h>
#include <spa/event.h> #include <spa/event.h>
typedef SpaEvent SpaMonitorEvent; typedef SpaEvent SpaEventMonitor;
#define SPA_MONITOR_EVENT_URI "http://spaplug.in/ns/monitor-event" #define SPA_TYPE_EVENT__Monitor SPA_TYPE_EVENT_BASE "Monitor"
#define SPA_MONITOR_EVENT_PREFIX SPA_MONITOR_EVENT_URI "#" #define SPA_TYPE_EVENT_MONITOR_BASE SPA_TYPE_EVENT__Monitor ":"
#define SPA_MONITOR_EVENT__Added SPA_MONITOR_EVENT_PREFIX "Added" #define SPA_TYPE_EVENT_MONITOR__Added SPA_TYPE_EVENT_MONITOR_BASE "Added"
#define SPA_MONITOR_EVENT__Removed SPA_MONITOR_EVENT_PREFIX "Removed" #define SPA_TYPE_EVENT_MONITOR__Removed SPA_TYPE_EVENT_MONITOR_BASE "Removed"
#define SPA_MONITOR_EVENT__Changed SPA_MONITOR_EVENT_PREFIX "Changed" #define SPA_TYPE_EVENT_MONITOR__Changed SPA_TYPE_EVENT_MONITOR_BASE "Changed"
typedef SpaPODObject SpaMonitorItem; typedef SpaPODObject SpaMonitorItem;
#define SPA_MONITOR_ITEM_URI "http://spaplug.in/ns/monitor-item" #define SPA_TYPE__MonitorItem "Spa:Object:MonitorItem"
#define SPA_MONITOR_ITEM_PREFIX SPA_MONITOR_ITEM_URI "#" #define SPA_TYPE_MONITOR_ITEM_BASE SPA_TYPE__MonitorItem ":"
#define SPA_MONITOR_ITEM__id SPA_MONITOR_ITEM_PREFIX "id" #define SPA_TYPE_MONITOR_ITEM__id SPA_TYPE_MONITOR_ITEM_BASE "id"
#define SPA_MONITOR_ITEM__flags SPA_MONITOR_ITEM_PREFIX "flags" #define SPA_TYPE_MONITOR_ITEM__flags SPA_TYPE_MONITOR_ITEM_BASE "flags"
#define SPA_MONITOR_ITEM__state SPA_MONITOR_ITEM_PREFIX "state" #define SPA_TYPE_MONITOR_ITEM__state SPA_TYPE_MONITOR_ITEM_BASE "state"
#define SPA_MONITOR_ITEM__name SPA_MONITOR_ITEM_PREFIX "name" #define SPA_TYPE_MONITOR_ITEM__name SPA_TYPE_MONITOR_ITEM_BASE "name"
#define SPA_MONITOR_ITEM__class SPA_MONITOR_ITEM_PREFIX "class" #define SPA_TYPE_MONITOR_ITEM__class SPA_TYPE_MONITOR_ITEM_BASE "class"
#define SPA_MONITOR_ITEM__info SPA_MONITOR_ITEM_PREFIX "info" #define SPA_TYPE_MONITOR_ITEM__info SPA_TYPE_MONITOR_ITEM_BASE "info"
#define SPA_MONITOR_ITEM__factory SPA_MONITOR_ITEM_PREFIX "factory" #define SPA_TYPE_MONITOR_ITEM__factory SPA_TYPE_MONITOR_ITEM_BASE "factory"
typedef struct { typedef struct {
uint32_t Monitor; uint32_t Monitor;
@ -73,18 +73,18 @@ static inline void
spa_monitor_types_map (SpaIDMap *map, SpaMonitorTypes *types) spa_monitor_types_map (SpaIDMap *map, SpaMonitorTypes *types)
{ {
if (types->Added == 0) { if (types->Added == 0) {
types->Monitor = spa_id_map_get_id (map, SPA_MONITOR_URI); types->Monitor = spa_id_map_get_id (map, SPA_TYPE__Monitor);
types->Added = spa_id_map_get_id (map, SPA_MONITOR_EVENT__Added); types->Added = spa_id_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Added);
types->Removed = spa_id_map_get_id (map, SPA_MONITOR_EVENT__Removed); types->Removed = spa_id_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Removed);
types->Changed = spa_id_map_get_id (map, SPA_MONITOR_EVENT__Changed); types->Changed = spa_id_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Changed);
types->MonitorItem = spa_id_map_get_id (map, SPA_MONITOR_ITEM_URI); types->MonitorItem = spa_id_map_get_id (map, SPA_TYPE__MonitorItem);
types->id = spa_id_map_get_id (map, SPA_MONITOR_ITEM__id); types->id = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__id);
types->flags = spa_id_map_get_id (map, SPA_MONITOR_ITEM__flags); types->flags = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__flags);
types->state = spa_id_map_get_id (map, SPA_MONITOR_ITEM__state); types->state = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__state);
types->name = spa_id_map_get_id (map, SPA_MONITOR_ITEM__name); types->name = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__name);
types->klass = spa_id_map_get_id (map, SPA_MONITOR_ITEM__class); types->klass = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__class);
types->info = spa_id_map_get_id (map, SPA_MONITOR_ITEM__info); types->info = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__info);
types->factory = spa_id_map_get_id (map, SPA_MONITOR_ITEM__factory); types->factory = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__factory);
} }
} }
@ -113,8 +113,8 @@ typedef enum {
* This will be called when a monitor event is notified * This will be called when a monitor event is notified
* on @monitor. * on @monitor.
*/ */
typedef void (*SpaMonitorEventCallback) (SpaMonitor *monitor, typedef void (*SpaEventMonitorCallback) (SpaMonitor *monitor,
SpaMonitorEvent *event, SpaEventMonitor *event,
void *user_data); void *user_data);
/** /**
@ -137,7 +137,7 @@ struct _SpaMonitor {
/** /**
* SpaMonitor::set_event_callback: * SpaMonitor::set_event_callback:
* @monitor: a #SpaMonitor * @monitor: a #SpaMonitor
* @callback: a #SpaMonitorEventCallback * @callback: a #SpaEventMonitorCallback
* @user_data: extra user data * @user_data: extra user data
* *
* Set an event callback to receive asynchronous notifications from * Set an event callback to receive asynchronous notifications from
@ -146,7 +146,7 @@ struct _SpaMonitor {
* Returns: #SPA_RESULT_OK on success * Returns: #SPA_RESULT_OK on success
*/ */
SpaResult (*set_event_callback) (SpaMonitor *monitor, SpaResult (*set_event_callback) (SpaMonitor *monitor,
SpaMonitorEventCallback callback, SpaEventMonitorCallback callback,
void *user_data); void *user_data);
SpaResult (*enum_items) (SpaMonitor *monitor, SpaResult (*enum_items) (SpaMonitor *monitor,

60
spa/include/spa/node-command.h
View file

@ -17,8 +17,8 @@
* Boston, MA 02110-1301, USA. * Boston, MA 02110-1301, USA.
*/ */
#ifndef __SPA_NODE_COMMAND_H__ #ifndef __SPA_COMMAND_NODE_H__
#define __SPA_NODE_COMMAND_H__ #define __SPA_COMMAND_NODE_H__
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -27,15 +27,15 @@ extern "C" {
#include <spa/id-map.h> #include <spa/id-map.h>
#include <spa/command.h> #include <spa/command.h>
#define SPA_NODE_COMMAND_URI "http://spaplug.in/ns/node-command" #define SPA_TYPE_COMMAND__Node SPA_TYPE_COMMAND_BASE "Node"
#define SPA_NODE_COMMAND_PREFIX SPA_NODE_COMMAND_URI "#" #define SPA_TYPE_COMMAND_NODE_BASE SPA_TYPE_COMMAND__Node ":"
#define SPA_NODE_COMMAND__Pause SPA_NODE_COMMAND_PREFIX "Pause" #define SPA_TYPE_COMMAND_NODE__Pause SPA_TYPE_COMMAND_NODE_BASE "Pause"
#define SPA_NODE_COMMAND__Start SPA_NODE_COMMAND_PREFIX "Start" #define SPA_TYPE_COMMAND_NODE__Start SPA_TYPE_COMMAND_NODE_BASE "Start"
#define SPA_NODE_COMMAND__Flush SPA_NODE_COMMAND_PREFIX "Flush" #define SPA_TYPE_COMMAND_NODE__Flush SPA_TYPE_COMMAND_NODE_BASE "Flush"
#define SPA_NODE_COMMAND__Drain SPA_NODE_COMMAND_PREFIX "Drain" #define SPA_TYPE_COMMAND_NODE__Drain SPA_TYPE_COMMAND_NODE_BASE "Drain"
#define SPA_NODE_COMMAND__Marker SPA_NODE_COMMAND_PREFIX "Marker" #define SPA_TYPE_COMMAND_NODE__Marker SPA_TYPE_COMMAND_NODE_BASE "Marker"
#define SPA_NODE_COMMAND__ClockUpdate SPA_NODE_COMMAND_PREFIX "ClockUpdate" #define SPA_TYPE_COMMAND_NODE__ClockUpdate SPA_TYPE_COMMAND_NODE_BASE "ClockUpdate"
typedef struct { typedef struct {
uint32_t Pause; uint32_t Pause;
@ -44,23 +44,23 @@ typedef struct {
uint32_t Drain; uint32_t Drain;
uint32_t Marker; uint32_t Marker;
uint32_t ClockUpdate; uint32_t ClockUpdate;
} SpaNodeCommands; } SpaCommandNode;
static inline void static inline void
spa_node_commands_map (SpaIDMap *map, SpaNodeCommands *types) spa_command_node_map (SpaIDMap *map, SpaCommandNode *types)
{ {
if (types->Pause == 0) { if (types->Pause == 0) {
types->Pause = spa_id_map_get_id (map, SPA_NODE_COMMAND__Pause); types->Pause = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Pause);
types->Start = spa_id_map_get_id (map, SPA_NODE_COMMAND__Start); types->Start = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Start);
types->Flush = spa_id_map_get_id (map, SPA_NODE_COMMAND__Flush); types->Flush = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Flush);
types->Drain = spa_id_map_get_id (map, SPA_NODE_COMMAND__Drain); types->Drain = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Drain);
types->Marker = spa_id_map_get_id (map, SPA_NODE_COMMAND__Marker); types->Marker = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Marker);
types->ClockUpdate = spa_id_map_get_id (map, SPA_NODE_COMMAND__ClockUpdate); types->ClockUpdate = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__ClockUpdate);
} }
} }
/** /**
* SpaNodeCommandClockUpdate: * SpaCommandNodeClockUpdate:
* @change_mask: marks which fields are updated * @change_mask: marks which fields are updated
* @rate: the number of @ticks per second * @rate: the number of @ticks per second
* @ticks: the new ticks, when @change_mask = 1<<0 * @ticks: the new ticks, when @change_mask = 1<<0
@ -73,10 +73,10 @@ spa_node_commands_map (SpaIDMap *map, SpaNodeCommands *types)
*/ */
typedef struct { typedef struct {
SpaPODObjectBody body; SpaPODObjectBody body;
#define SPA_NODE_COMMAND_CLOCK_UPDATE_TIME (1 << 0) #define SPA_COMMAND_NODE_CLOCK_UPDATE_TIME (1 << 0)
#define SPA_NODE_COMMAND_CLOCK_UPDATE_SCALE (1 << 1) #define SPA_COMMAND_NODE_CLOCK_UPDATE_SCALE (1 << 1)
#define SPA_NODE_COMMAND_CLOCK_UPDATE_STATE (1 << 2) #define SPA_COMMAND_NODE_CLOCK_UPDATE_STATE (1 << 2)
#define SPA_NODE_COMMAND_CLOCK_UPDATE_LATENCY (1 << 3) #define SPA_COMMAND_NODE_CLOCK_UPDATE_LATENCY (1 << 3)
SpaPODInt change_mask SPA_ALIGNED (8); SpaPODInt change_mask SPA_ALIGNED (8);
SpaPODInt rate SPA_ALIGNED (8); SpaPODInt rate SPA_ALIGNED (8);
SpaPODLong ticks SPA_ALIGNED (8); SpaPODLong ticks SPA_ALIGNED (8);
@ -84,18 +84,18 @@ typedef struct {
SpaPODLong offset SPA_ALIGNED (8); SpaPODLong offset SPA_ALIGNED (8);
SpaPODInt scale SPA_ALIGNED (8); SpaPODInt scale SPA_ALIGNED (8);
SpaPODInt state SPA_ALIGNED (8); SpaPODInt state SPA_ALIGNED (8);
#define SPA_NODE_COMMAND_CLOCK_UPDATE_FLAG_LIVE (1 << 0) #define SPA_COMMAND_NODE_CLOCK_UPDATE_FLAG_LIVE (1 << 0)
SpaPODInt flags SPA_ALIGNED (8); SpaPODInt flags SPA_ALIGNED (8);
SpaPODLong latency SPA_ALIGNED (8); SpaPODLong latency SPA_ALIGNED (8);
} SpaNodeCommandClockUpdateBody; } SpaCommandNodeClockUpdateBody;
typedef struct { typedef struct {
SpaPOD pod; SpaPOD pod;
SpaNodeCommandClockUpdateBody body; SpaCommandNodeClockUpdateBody body;
} SpaNodeCommandClockUpdate; } SpaCommandNodeClockUpdate;
#define SPA_NODE_COMMAND_CLOCK_UPDATE_INIT(type,change_mask,rate,ticks,monotonic_time,offset,scale,state,flags,latency) \ #define SPA_COMMAND_NODE_CLOCK_UPDATE_INIT(type,change_mask,rate,ticks,monotonic_time,offset,scale,state,flags,latency) \
SPA_COMMAND_INIT_COMPLEX (sizeof (SpaNodeCommandClockUpdateBody), type, \ SPA_COMMAND_INIT_COMPLEX (sizeof (SpaCommandNodeClockUpdateBody), type, \
SPA_POD_INT_INIT (change_mask), \ SPA_POD_INT_INIT (change_mask), \
SPA_POD_INT_INIT (rate), \ SPA_POD_INT_INIT (rate), \
SPA_POD_LONG_INIT (ticks), \ SPA_POD_LONG_INIT (ticks), \
@ -110,4 +110,4 @@ typedef struct {
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* __SPA_NODE_COMMAND_H__ */ #endif /* __SPA_COMMAND_NODE_H__ */

82
spa/include/spa/node-event.h
View file

@ -17,8 +17,8 @@
* Boston, MA 02110-1301, USA. * Boston, MA 02110-1301, USA.
*/ */
#ifndef __SPA_NODE_EVENT_H__ #ifndef __SPA_EVENT_NODE_H__
#define __SPA_NODE_EVENT_H__ #define __SPA_EVENT_NODE_H__
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -29,17 +29,17 @@ extern "C" {
#include <spa/id-map.h> #include <spa/id-map.h>
#include <spa/node.h> #include <spa/node.h>
#define SPA_NODE_EVENT_URI "http://spaplug.in/ns/node-event" #define SPA_TYPE_EVENT__Node SPA_TYPE_EVENT_BASE "Node"
#define SPA_NODE_EVENT_PREFIX SPA_NODE_EVENT_URI "#" #define SPA_TYPE_EVENT_NODE_BASE SPA_TYPE_EVENT__Node ":"
#define SPA_NODE_EVENT__AsyncComplete SPA_NODE_EVENT_PREFIX "AsyncComplete" #define SPA_TYPE_EVENT_NODE__AsyncComplete SPA_TYPE_EVENT_NODE_BASE "AsyncComplete"
#define SPA_NODE_EVENT__HaveOutput SPA_NODE_EVENT_PREFIX "HaveOutput" #define SPA_TYPE_EVENT_NODE__HaveOutput SPA_TYPE_EVENT_NODE_BASE "HaveOutput"
#define SPA_NODE_EVENT__NeedInput SPA_NODE_EVENT_PREFIX "NeedInput" #define SPA_TYPE_EVENT_NODE__NeedInput SPA_TYPE_EVENT_NODE_BASE "NeedInput"
#define SPA_NODE_EVENT__ReuseBuffer SPA_NODE_EVENT_PREFIX "ReuseBuffer" #define SPA_TYPE_EVENT_NODE__ReuseBuffer SPA_TYPE_EVENT_NODE_BASE "ReuseBuffer"
#define SPA_NODE_EVENT__Error SPA_NODE_EVENT_PREFIX "Error" #define SPA_TYPE_EVENT_NODE__Error SPA_TYPE_EVENT_NODE_BASE "Error"
#define SPA_NODE_EVENT__Buffering SPA_NODE_EVENT_PREFIX "Buffering" #define SPA_TYPE_EVENT_NODE__Buffering SPA_TYPE_EVENT_NODE_BASE "Buffering"
#define SPA_NODE_EVENT__RequestRefresh SPA_NODE_EVENT_PREFIX "RequestRefresh" #define SPA_TYPE_EVENT_NODE__RequestRefresh SPA_TYPE_EVENT_NODE_BASE "RequestRefresh"
#define SPA_NODE_EVENT__RequestClockUpdate SPA_NODE_EVENT_PREFIX "RequestClockUpdate" #define SPA_TYPE_EVENT_NODE__RequestClockUpdate SPA_TYPE_EVENT_NODE_BASE "RequestClockUpdate"
typedef struct { typedef struct {
uint32_t AsyncComplete; uint32_t AsyncComplete;
@ -50,20 +50,20 @@ typedef struct {
uint32_t Buffering; uint32_t Buffering;
uint32_t RequestRefresh; uint32_t RequestRefresh;
uint32_t RequestClockUpdate; uint32_t RequestClockUpdate;
} SpaNodeEvents; } SpaEventNode;
static inline void static inline void
spa_node_events_map (SpaIDMap *map, SpaNodeEvents *types) spa_event_node_map (SpaIDMap *map, SpaEventNode *types)
{ {
if (types->AsyncComplete == 0) { if (types->AsyncComplete == 0) {
types->AsyncComplete = spa_id_map_get_id (map, SPA_NODE_EVENT__AsyncComplete); types->AsyncComplete = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__AsyncComplete);
types->HaveOutput = spa_id_map_get_id (map, SPA_NODE_EVENT__HaveOutput); types->HaveOutput = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__HaveOutput);
types->NeedInput = spa_id_map_get_id (map, SPA_NODE_EVENT__NeedInput); types->NeedInput = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__NeedInput);
types->ReuseBuffer = spa_id_map_get_id (map, SPA_NODE_EVENT__ReuseBuffer); types->ReuseBuffer = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__ReuseBuffer);
types->Error = spa_id_map_get_id (map, SPA_NODE_EVENT__Error); types->Error = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__Error);
types->Buffering = spa_id_map_get_id (map, SPA_NODE_EVENT__Buffering); types->Buffering = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__Buffering);
types->RequestRefresh = spa_id_map_get_id (map, SPA_NODE_EVENT__RequestRefresh); types->RequestRefresh = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__RequestRefresh);
types->RequestClockUpdate = spa_id_map_get_id (map, SPA_NODE_EVENT__RequestClockUpdate); types->RequestClockUpdate = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__RequestClockUpdate);
} }
} }
@ -71,15 +71,15 @@ typedef struct {
SpaPODObjectBody body; SpaPODObjectBody body;
SpaPODInt seq SPA_ALIGNED (8); SpaPODInt seq SPA_ALIGNED (8);
SpaPODInt res SPA_ALIGNED (8); SpaPODInt res SPA_ALIGNED (8);
} SpaNodeEventAsyncCompleteBody; } SpaEventNodeAsyncCompleteBody;
typedef struct { typedef struct {
SpaPOD pod; SpaPOD pod;
SpaNodeEventAsyncCompleteBody body; SpaEventNodeAsyncCompleteBody body;
} SpaNodeEventAsyncComplete; } SpaEventNodeAsyncComplete;
#define SPA_NODE_EVENT_ASYNC_COMPLETE_INIT(type,seq,res) \ #define SPA_EVENT_NODE_ASYNC_COMPLETE_INIT(type,seq,res) \
SPA_EVENT_INIT_COMPLEX (sizeof (SpaNodeEventAsyncCompleteBody), type, \ SPA_EVENT_INIT_COMPLEX (sizeof (SpaEventNodeAsyncCompleteBody), type, \
SPA_POD_INT_INIT (seq), \ SPA_POD_INT_INIT (seq), \
SPA_POD_INT_INIT (res)) SPA_POD_INT_INIT (res))
@ -87,35 +87,35 @@ typedef struct {
SpaPODObjectBody body; SpaPODObjectBody body;
SpaPODInt port_id; SpaPODInt port_id;
SpaPODInt buffer_id; SpaPODInt buffer_id;
} SpaNodeEventReuseBufferBody; } SpaEventNodeReuseBufferBody;
typedef struct { typedef struct {
SpaPOD pod; SpaPOD pod;
SpaNodeEventReuseBufferBody body; SpaEventNodeReuseBufferBody body;
} SpaNodeEventReuseBuffer; } SpaEventNodeReuseBuffer;
#define SPA_NODE_EVENT_REUSE_BUFFER_INIT(type,port_id,buffer_id) \ #define SPA_EVENT_NODE_REUSE_BUFFER_INIT(type,port_id,buffer_id) \
SPA_EVENT_INIT_COMPLEX (sizeof (SpaNodeEventReuseBufferBody), type, \ SPA_EVENT_INIT_COMPLEX (sizeof (SpaEventNodeReuseBufferBody), type, \
SPA_POD_INT_INIT (port_id), \ SPA_POD_INT_INIT (port_id), \
SPA_POD_INT_INIT (buffer_id)) SPA_POD_INT_INIT (buffer_id))
typedef struct { typedef struct {
SpaPODObjectBody body; SpaPODObjectBody body;
#define SPA_NODE_EVENT_REQUEST_CLOCK_UPDATE_TIME (1 << 0) #define SPA_EVENT_NODE_REQUEST_CLOCK_UPDATE_TIME (1 << 0)
#define SPA_NODE_EVENT_REQUEST_CLOCK_UPDATE_SCALE (1 << 1) #define SPA_EVENT_NODE_REQUEST_CLOCK_UPDATE_SCALE (1 << 1)
#define SPA_NODE_EVENT_REQUEST_CLOCK_UPDATE_STATE (1 << 2) #define SPA_EVENT_NODE_REQUEST_CLOCK_UPDATE_STATE (1 << 2)
SpaPODInt update_mask SPA_ALIGNED (8); SpaPODInt update_mask SPA_ALIGNED (8);
SpaPODLong timestamp SPA_ALIGNED (8); SpaPODLong timestamp SPA_ALIGNED (8);
SpaPODLong offset SPA_ALIGNED (8); SpaPODLong offset SPA_ALIGNED (8);
} SpaNodeEventRequestClockUpdateBody; } SpaEventNodeRequestClockUpdateBody;
typedef struct { typedef struct {
SpaPOD pod; SpaPOD pod;
SpaNodeEventRequestClockUpdateBody body; SpaEventNodeRequestClockUpdateBody body;
} SpaNodeEventRequestClockUpdate; } SpaEventNodeRequestClockUpdate;
#define SPA_NODE_EVENT_REQUEST_CLOCK_UPDATE_INIT(type,update_mask,timestamp,offset) \ #define SPA_EVENT_NODE_REQUEST_CLOCK_UPDATE_INIT(type,update_mask,timestamp,offset) \
SPA_EVENT_INIT_COMPLEX (sizeof (SpaNodeEventRequestClockUpdateBody), type, \ SPA_EVENT_INIT_COMPLEX (sizeof (SpaEventNodeRequestClockUpdateBody), type, \
SPA_POD_INT_INIT (update_mask), \ SPA_POD_INT_INIT (update_mask), \
SPA_POD_LONG_INIT (timestamp), \ SPA_POD_LONG_INIT (timestamp), \
SPA_POD_LONG_INIT (offset)) SPA_POD_LONG_INIT (offset))
@ -124,4 +124,4 @@ typedef struct {
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* __SPA_NODE_EVENT_H__ */ #endif /* __SPA_EVENT_NODE_H__ */

10
spa/include/spa/node.h
View file

@ -26,8 +26,8 @@ extern "C" {
typedef struct _SpaNode SpaNode; typedef struct _SpaNode SpaNode;
#define SPA_NODE_URI "http://spaplug.in/ns/node" #define SPA_TYPE__Node "Spa:Interface:Node"
#define SPA_NODE_PREFIX SPA_NODE_URI "#" #define SPA_TYPE_NODE_BASE SPA_TYPE__Node ":"
/** /**
* SpaNodeState: * SpaNodeState:
@ -161,7 +161,7 @@ typedef struct {
} SpaPortInfo; } SpaPortInfo;
/** /**
* SpaNodeEventCallback: * SpaEventNodeCallback:
* @node: a #SpaNode emiting the event * @node: a #SpaNode emiting the event
* @event: the event that was emited * @event: the event that was emited
* @user_data: user data provided when registering the callback * @user_data: user data provided when registering the callback
@ -169,7 +169,7 @@ typedef struct {
* This will be called when an out-of-bound event is notified * This will be called when an out-of-bound event is notified
* on @node. * on @node.
*/ */
typedef void (*SpaNodeEventCallback) (SpaNode *node, typedef void (*SpaEventNodeCallback) (SpaNode *node,
SpaEvent *event, SpaEvent *event,
void *user_data); void *user_data);
@ -280,7 +280,7 @@ struct _SpaNode {
* #SPA_RESULT_INVALID_ARGUMENTS when node is %NULL * #SPA_RESULT_INVALID_ARGUMENTS when node is %NULL
*/ */
SpaResult (*set_event_callback) (SpaNode *node, SpaResult (*set_event_callback) (SpaNode *node,
SpaNodeEventCallback callback, SpaEventNodeCallback callback,
void *user_data); void *user_data);
/** /**
* SpaNode::get_n_ports: * SpaNode::get_n_ports:

4
spa/include/spa/plugin.h
View file

@ -27,8 +27,8 @@ extern "C" {
#include <spa/defs.h> #include <spa/defs.h>
#include <spa/dict.h> #include <spa/dict.h>
#define SPA_HANDLE_URI "http://spaplug.in/ns/handle" #define SPA_TYPE__Handle "Spa:Interface:Handle"
#define SPA_HANDLE_FACTORY_URI "http://spaplug.in/ns/handle-factory" #define SPA_TYPE__HandleFactory "Spa:Interface:HandleFactory"
typedef struct _SpaHandle SpaHandle; typedef struct _SpaHandle SpaHandle;
typedef struct _SpaHandleFactory SpaHandleFactory; typedef struct _SpaHandleFactory SpaHandleFactory;

3
spa/include/spa/pod.h
View file

@ -24,9 +24,6 @@
extern "C" { extern "C" {
#endif #endif
#define SPA_POD_URI "http://spaplug.in/ns/pod"
#define SPA_POD_PREFIX SPA_POD_URI "#"
#include <stdarg.h> #include <stdarg.h>
#include <spa/defs.h> #include <spa/defs.h>

32
spa/include/spa/props.h
View file

@ -29,23 +29,23 @@ extern "C" {
typedef SpaPODObject SpaProps; typedef SpaPODObject SpaProps;
#define SPA_PROPS_URI "http://spaplug.in/ns/props" #define SPA_TYPE__Props "Spa:Object:Props"
#define SPA_PROPS_PREFIX SPA_PROPS_URI "#" #define SPA_TYPE_PROPS_BASE SPA_TYPE__Props ":"
#define SPA_PROPS__device SPA_PROPS_PREFIX "device" #define SPA_TYPE_PROPS__device SPA_TYPE_PROPS_BASE "device"
#define SPA_PROPS__deviceName SPA_PROPS_PREFIX "deviceName" #define SPA_TYPE_PROPS__deviceName SPA_TYPE_PROPS_BASE "deviceName"
#define SPA_PROPS__deviceFd SPA_PROPS_PREFIX "deviceFd" #define SPA_TYPE_PROPS__deviceFd SPA_TYPE_PROPS_BASE "deviceFd"
#define SPA_PROPS__card SPA_PROPS_PREFIX "card" #define SPA_TYPE_PROPS__card SPA_TYPE_PROPS_BASE "card"
#define SPA_PROPS__cardName SPA_PROPS_PREFIX "cardName" #define SPA_TYPE_PROPS__cardName SPA_TYPE_PROPS_BASE "cardName"
#define SPA_PROPS__periods SPA_PROPS_PREFIX "periods" #define SPA_TYPE_PROPS__periods SPA_TYPE_PROPS_BASE "periods"
#define SPA_PROPS__periodSize SPA_PROPS_PREFIX "periodSize" #define SPA_TYPE_PROPS__periodSize SPA_TYPE_PROPS_BASE "periodSize"
#define SPA_PROPS__periodEvent SPA_PROPS_PREFIX "periodEvent" #define SPA_TYPE_PROPS__periodEvent SPA_TYPE_PROPS_BASE "periodEvent"
#define SPA_PROPS__live SPA_PROPS_PREFIX "live" #define SPA_TYPE_PROPS__live SPA_TYPE_PROPS_BASE "live"
#define SPA_PROPS__waveType SPA_PROPS_PREFIX "waveType" #define SPA_TYPE_PROPS__waveType SPA_TYPE_PROPS_BASE "waveType"
#define SPA_PROPS__frequency SPA_PROPS_PREFIX "frequency" #define SPA_TYPE_PROPS__frequency SPA_TYPE_PROPS_BASE "frequency"
#define SPA_PROPS__volume SPA_PROPS_PREFIX "volume" #define SPA_TYPE_PROPS__volume SPA_TYPE_PROPS_BASE "volume"
#define SPA_PROPS__mute SPA_PROPS_PREFIX "mute" #define SPA_TYPE_PROPS__mute SPA_TYPE_PROPS_BASE "mute"
#define SPA_PROPS__patternType SPA_PROPS_PREFIX "patternType" #define SPA_TYPE_PROPS__patternType SPA_TYPE_PROPS_BASE "patternType"
static inline uint32_t static inline uint32_t
spa_pod_builder_push_props (SpaPODBuilder *builder, spa_pod_builder_push_props (SpaPODBuilder *builder,

36
spa/include/spa/video/format-utils.h
View file

@ -53,24 +53,24 @@ static inline void
spa_prop_video_map (SpaIDMap *map, SpaPropVideo *types) spa_prop_video_map (SpaIDMap *map, SpaPropVideo *types)
{ {
if (types->format == 0) { if (types->format == 0) {
types->format = spa_id_map_get_id (map, SPA_PROP_VIDEO__format); types->format = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__format);
types->size = spa_id_map_get_id (map, SPA_PROP_VIDEO__size); types->size = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__size);
types->framerate = spa_id_map_get_id (map, SPA_PROP_VIDEO__framerate); types->framerate = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__framerate);
types->max_framerate = spa_id_map_get_id (map, SPA_PROP_VIDEO__maxFramerate); types->max_framerate = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__maxFramerate);
types->views = spa_id_map_get_id (map, SPA_PROP_VIDEO__views); types->views = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__views);
types->interlace_mode = spa_id_map_get_id (map, SPA_PROP_VIDEO__interlaceMode); types->interlace_mode = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__interlaceMode);
types->pixel_aspect_ratio = spa_id_map_get_id (map, SPA_PROP_VIDEO__pixelAspectRatio); types->pixel_aspect_ratio = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__pixelAspectRatio);
types->multiview_mode = spa_id_map_get_id (map, SPA_PROP_VIDEO__multiviewMode); types->multiview_mode = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__multiviewMode);
types->multiview_flags = spa_id_map_get_id (map, SPA_PROP_VIDEO__multiviewFlags); types->multiview_flags = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__multiviewFlags);
types->chroma_site = spa_id_map_get_id (map, SPA_PROP_VIDEO__chromaSite); types->chroma_site = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__chromaSite);
types->color_range = spa_id_map_get_id (map, SPA_PROP_VIDEO__colorRange); types->color_range = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorRange);
types->color_matrix = spa_id_map_get_id (map, SPA_PROP_VIDEO__colorMatrix); types->color_matrix = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorMatrix);
types->transfer_function = spa_id_map_get_id (map, SPA_PROP_VIDEO__transferFunction); types->transfer_function = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__transferFunction);
types->color_primaries = spa_id_map_get_id (map, SPA_PROP_VIDEO__colorPrimaries); types->color_primaries = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorPrimaries);
types->profile = spa_id_map_get_id (map, SPA_PROP_VIDEO__profile); types->profile = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__profile);
types->level = spa_id_map_get_id (map, SPA_PROP_VIDEO__level); types->level = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__level);
types->stream_format = spa_id_map_get_id (map, SPA_PROP_VIDEO__streamFormat); types->stream_format = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__streamFormat);
types->alignment = spa_id_map_get_id (map, SPA_PROP_VIDEO__alignment); types->alignment = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__alignment);
} }
} }

40
spa/include/spa/video/format.h
View file

@ -30,27 +30,27 @@ extern "C" {
typedef struct _SpaVideoInfo SpaVideoInfo; typedef struct _SpaVideoInfo SpaVideoInfo;
#define SPA_PROP_VIDEO_URI "http://spaplug.in/ns/prop-video" #define SPA_TYPE_PROP__Video "Spa:Prop:Video"
#define SPA_PROP_VIDEO_PREFIX SPA_PROP_VIDEO_URI "#" #define SPA_TYPE_PROP_VIDEO_BASE SPA_TYPE_PROP__Video ":"
#define SPA_PROP_VIDEO__format SPA_PROP_VIDEO_PREFIX "format" #define SPA_TYPE_PROP_VIDEO__format SPA_TYPE_PROP_VIDEO_BASE "format"
#define SPA_PROP_VIDEO__size SPA_PROP_VIDEO_PREFIX "size" #define SPA_TYPE_PROP_VIDEO__size SPA_TYPE_PROP_VIDEO_BASE "size"
#define SPA_PROP_VIDEO__framerate SPA_PROP_VIDEO_PREFIX "framerate" #define SPA_TYPE_PROP_VIDEO__framerate SPA_TYPE_PROP_VIDEO_BASE "framerate"
#define SPA_PROP_VIDEO__maxFramerate SPA_PROP_VIDEO_PREFIX "max-framerate" #define SPA_TYPE_PROP_VIDEO__maxFramerate SPA_TYPE_PROP_VIDEO_BASE "max-framerate"
#define SPA_PROP_VIDEO__views SPA_PROP_VIDEO_PREFIX "views" #define SPA_TYPE_PROP_VIDEO__views SPA_TYPE_PROP_VIDEO_BASE "views"
#define SPA_PROP_VIDEO__interlaceMode SPA_PROP_VIDEO_PREFIX "interlace-mode" #define SPA_TYPE_PROP_VIDEO__interlaceMode SPA_TYPE_PROP_VIDEO_BASE "interlace-mode"
#define SPA_PROP_VIDEO__pixelAspectRatio SPA_PROP_VIDEO_PREFIX "pixel-aspect-ratio" #define SPA_TYPE_PROP_VIDEO__pixelAspectRatio SPA_TYPE_PROP_VIDEO_BASE "pixel-aspect-ratio"
#define SPA_PROP_VIDEO__multiviewMode SPA_PROP_VIDEO_PREFIX "multiview-mode" #define SPA_TYPE_PROP_VIDEO__multiviewMode SPA_TYPE_PROP_VIDEO_BASE "multiview-mode"
#define SPA_PROP_VIDEO__multiviewFlags SPA_PROP_VIDEO_PREFIX "multiview-flags" #define SPA_TYPE_PROP_VIDEO__multiviewFlags SPA_TYPE_PROP_VIDEO_BASE "multiview-flags"
#define SPA_PROP_VIDEO__chromaSite SPA_PROP_VIDEO_PREFIX "chroma-site" #define SPA_TYPE_PROP_VIDEO__chromaSite SPA_TYPE_PROP_VIDEO_BASE "chroma-site"
#define SPA_PROP_VIDEO__colorRange SPA_PROP_VIDEO_PREFIX "color-range" #define SPA_TYPE_PROP_VIDEO__colorRange SPA_TYPE_PROP_VIDEO_BASE "color-range"
#define SPA_PROP_VIDEO__colorMatrix SPA_PROP_VIDEO_PREFIX "color-matrix" #define SPA_TYPE_PROP_VIDEO__colorMatrix SPA_TYPE_PROP_VIDEO_BASE "color-matrix"
#define SPA_PROP_VIDEO__transferFunction SPA_PROP_VIDEO_PREFIX "transfer-function" #define SPA_TYPE_PROP_VIDEO__transferFunction SPA_TYPE_PROP_VIDEO_BASE "transfer-function"
#define SPA_PROP_VIDEO__colorPrimaries SPA_PROP_VIDEO_PREFIX "color-primaries" #define SPA_TYPE_PROP_VIDEO__colorPrimaries SPA_TYPE_PROP_VIDEO_BASE "color-primaries"
#define SPA_PROP_VIDEO__profile SPA_PROP_VIDEO_PREFIX "profile" #define SPA_TYPE_PROP_VIDEO__profile SPA_TYPE_PROP_VIDEO_BASE "profile"
#define SPA_PROP_VIDEO__level SPA_PROP_VIDEO_PREFIX "level" #define SPA_TYPE_PROP_VIDEO__level SPA_TYPE_PROP_VIDEO_BASE "level"
#define SPA_PROP_VIDEO__streamFormat SPA_PROP_VIDEO_PREFIX "stream-format" #define SPA_TYPE_PROP_VIDEO__streamFormat SPA_TYPE_PROP_VIDEO_BASE "stream-format"
#define SPA_PROP_VIDEO__alignment SPA_PROP_VIDEO_PREFIX "alignment" #define SPA_TYPE_PROP_VIDEO__alignment SPA_TYPE_PROP_VIDEO_BASE "alignment"
struct _SpaVideoInfo { struct _SpaVideoInfo {
uint32_t media_type; uint32_t media_type;

128
spa/include/spa/video/raw-utils.h
View file

@ -103,70 +103,70 @@ spa_video_formats_map (SpaIDMap *map, SpaVideoFormats *types)
{ {
if (types->ENCODED == 0) { if (types->ENCODED == 0) {
types->UNKNOWN = 0; types->UNKNOWN = 0;
types->ENCODED = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__ENCODED); types->ENCODED = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ENCODED);
types->I420 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I420); types->I420 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420);
types->YV12 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YV12); types->YV12 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YV12);
types->YUY2 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YUY2); types->YUY2 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YUY2);
types->UYVY = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__UYVY); types->UYVY = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__UYVY);
types->AYUV = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__AYUV); types->AYUV = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__AYUV);
types->RGBx = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGBx); types->RGBx = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGBx);
types->BGRx = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGRx); types->BGRx = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGRx);
types->xRGB = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__xRGB); types->xRGB = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__xRGB);
types->xBGR = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__xBGR); types->xBGR = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__xBGR);
types->RGBA = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGBA); types->RGBA = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGBA);
types->BGRA = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGRA); types->BGRA = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGRA);
types->ARGB = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__ARGB); types->ARGB = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ARGB);
types->ABGR = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__ABGR); types->ABGR = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ABGR);
types->RGB = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGB); types->RGB = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB);
types->BGR = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGR); types->BGR = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR);
types->Y41B = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y41B); types->Y41B = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y41B);
types->Y42B = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y42B); types->Y42B = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y42B);
types->YVYU = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YVYU); types->YVYU = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YVYU);
types->Y444 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y444); types->Y444 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444);
types->v210 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__v210); types->v210 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v210);
types->v216 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__v216); types->v216 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v216);
types->NV12 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV12); types->NV12 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV12);
types->NV21 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV21); types->NV21 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV21);
types->GRAY8 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GRAY8); types->GRAY8 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY8);
types->GRAY16_BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GRAY16_BE); types->GRAY16_BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY16_BE);
types->GRAY16_LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GRAY16_LE); types->GRAY16_LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY16_LE);
types->v308 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__v308); types->v308 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v308);
types->RGB16 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGB16); types->RGB16 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB16);
types->BGR16 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGR16); types->BGR16 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR16);
types->RGB15 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGB15); types->RGB15 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB15);
types->BGR15 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGR15); types->BGR15 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR15);
types->UYVP = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__UYVP); types->UYVP = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__UYVP);
types->A420 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A420); types->A420 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420);
types->RGB8P = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGB8P); types->RGB8P = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB8P);
types->YUV9 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YUV9); types->YUV9 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YUV9);
types->YVU9 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YVU9); types->YVU9 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YVU9);
types->IYU1 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__IYU1); types->IYU1 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__IYU1);
types->ARGB64 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__ARGB64); types->ARGB64 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ARGB64);
types->AYUV64 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__AYUV64); types->AYUV64 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__AYUV64);
types->r210 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__r210); types->r210 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__r210);
types->I420_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I420_10BE); types->I420_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420_10BE);
types->I420_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I420_10LE); types->I420_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420_10LE);
types->I422_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I422_10BE); types->I422_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I422_10BE);
types->I422_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I422_10LE); types->I422_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I422_10LE);
types->Y444_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y444_10BE); types->Y444_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444_10BE);
types->Y444_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y444_10LE); types->Y444_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444_10LE);
types->GBR = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GBR); types->GBR = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR);
types->GBR_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GBR_10BE); types->GBR_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR_10BE);
types->GBR_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GBR_10LE); types->GBR_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR_10LE);
types->NV16 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV16); types->NV16 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV16);
types->NV24 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV24); types->NV24 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV24);
types->NV12_64Z32 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV12_64Z32); types->NV12_64Z32 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV12_64Z32);
types->A420_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A420_10BE); types->A420_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420_10BE);
types->A420_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A420_10LE); types->A420_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420_10LE);
types->A422_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A422_10BE); types->A422_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A422_10BE);
types->A422_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A422_10LE); types->A422_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A422_10LE);
types->A444_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A444_10BE); types->A444_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A444_10BE);
types->A444_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A444_10LE); types->A444_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A444_10LE);
types->NV61 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV61); types->NV61 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV61);
types->P010_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__P010_10BE); types->P010_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__P010_10BE);
types->P010_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__P010_10LE); types->P010_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__P010_10LE);
types->IYU2 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__IYU2); types->IYU2 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__IYU2);
types->VYUY = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__VYUY); types->VYUY = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__VYUY);
} }
} }

132
spa/include/spa/video/raw.h
View file

@ -35,73 +35,73 @@ typedef struct _SpaVideoInfoRaw SpaVideoInfoRaw;
#define SPA_VIDEO_MAX_PLANES 4 #define SPA_VIDEO_MAX_PLANES 4
#define SPA_VIDEO_MAX_COMPONENTS 4 #define SPA_VIDEO_MAX_COMPONENTS 4
#define SPA_VIDEO_FORMAT_URI "http://spaplug.in/ns/video-format" #define SPA_TYPE__VideoFormat "Spa:Enum:VideoFormat"
#define SPA_VIDEO_FORMAT_PREFIX SPA_VIDEO_FORMAT_URI "#" #define SPA_TYPE_VIDEO_FORMAT_BASE SPA_TYPE__VideoFormat ":"
#define SPA_VIDEO_FORMAT__ENCODED SPA_VIDEO_FORMAT_PREFIX "encoded" #define SPA_TYPE_VIDEO_FORMAT__ENCODED SPA_TYPE_VIDEO_FORMAT_BASE "encoded"
#define SPA_VIDEO_FORMAT__I420 SPA_VIDEO_FORMAT_PREFIX "I420" #define SPA_TYPE_VIDEO_FORMAT__I420 SPA_TYPE_VIDEO_FORMAT_BASE "I420"
#define SPA_VIDEO_FORMAT__YV12 SPA_VIDEO_FORMAT_PREFIX "YV12" #define SPA_TYPE_VIDEO_FORMAT__YV12 SPA_TYPE_VIDEO_FORMAT_BASE "YV12"
#define SPA_VIDEO_FORMAT__YUY2 SPA_VIDEO_FORMAT_PREFIX "YUY2" #define SPA_TYPE_VIDEO_FORMAT__YUY2 SPA_TYPE_VIDEO_FORMAT_BASE "YUY2"
#define SPA_VIDEO_FORMAT__UYVY SPA_VIDEO_FORMAT_PREFIX "UYVY" #define SPA_TYPE_VIDEO_FORMAT__UYVY SPA_TYPE_VIDEO_FORMAT_BASE "UYVY"
#define SPA_VIDEO_FORMAT__AYUV SPA_VIDEO_FORMAT_PREFIX "AYUV" #define SPA_TYPE_VIDEO_FORMAT__AYUV SPA_TYPE_VIDEO_FORMAT_BASE "AYUV"
#define SPA_VIDEO_FORMAT__RGBx SPA_VIDEO_FORMAT_PREFIX "RGBx" #define SPA_TYPE_VIDEO_FORMAT__RGBx SPA_TYPE_VIDEO_FORMAT_BASE "RGBx"
#define SPA_VIDEO_FORMAT__BGRx SPA_VIDEO_FORMAT_PREFIX "BGRx" #define SPA_TYPE_VIDEO_FORMAT__BGRx SPA_TYPE_VIDEO_FORMAT_BASE "BGRx"
#define SPA_VIDEO_FORMAT__xRGB SPA_VIDEO_FORMAT_PREFIX "xRGB" #define SPA_TYPE_VIDEO_FORMAT__xRGB SPA_TYPE_VIDEO_FORMAT_BASE "xRGB"
#define SPA_VIDEO_FORMAT__xBGR SPA_VIDEO_FORMAT_PREFIX "xBGR" #define SPA_TYPE_VIDEO_FORMAT__xBGR SPA_TYPE_VIDEO_FORMAT_BASE "xBGR"
#define SPA_VIDEO_FORMAT__RGBA SPA_VIDEO_FORMAT_PREFIX "RGBA" #define SPA_TYPE_VIDEO_FORMAT__RGBA SPA_TYPE_VIDEO_FORMAT_BASE "RGBA"
#define SPA_VIDEO_FORMAT__BGRA SPA_VIDEO_FORMAT_PREFIX "BGRA" #define SPA_TYPE_VIDEO_FORMAT__BGRA SPA_TYPE_VIDEO_FORMAT_BASE "BGRA"
#define SPA_VIDEO_FORMAT__ARGB SPA_VIDEO_FORMAT_PREFIX "ARGB" #define SPA_TYPE_VIDEO_FORMAT__ARGB SPA_TYPE_VIDEO_FORMAT_BASE "ARGB"
#define SPA_VIDEO_FORMAT__ABGR SPA_VIDEO_FORMAT_PREFIX "ABGR" #define SPA_TYPE_VIDEO_FORMAT__ABGR SPA_TYPE_VIDEO_FORMAT_BASE "ABGR"
#define SPA_VIDEO_FORMAT__RGB SPA_VIDEO_FORMAT_PREFIX "RGB" #define SPA_TYPE_VIDEO_FORMAT__RGB SPA_TYPE_VIDEO_FORMAT_BASE "RGB"
#define SPA_VIDEO_FORMAT__BGR SPA_VIDEO_FORMAT_PREFIX "BGR" #define SPA_TYPE_VIDEO_FORMAT__BGR SPA_TYPE_VIDEO_FORMAT_BASE "BGR"
#define SPA_VIDEO_FORMAT__Y41B SPA_VIDEO_FORMAT_PREFIX "Y41B" #define SPA_TYPE_VIDEO_FORMAT__Y41B SPA_TYPE_VIDEO_FORMAT_BASE "Y41B"
#define SPA_VIDEO_FORMAT__Y42B SPA_VIDEO_FORMAT_PREFIX "Y42B" #define SPA_TYPE_VIDEO_FORMAT__Y42B SPA_TYPE_VIDEO_FORMAT_BASE "Y42B"
#define SPA_VIDEO_FORMAT__YVYU SPA_VIDEO_FORMAT_PREFIX "YVYU" #define SPA_TYPE_VIDEO_FORMAT__YVYU SPA_TYPE_VIDEO_FORMAT_BASE "YVYU"
#define SPA_VIDEO_FORMAT__Y444 SPA_VIDEO_FORMAT_PREFIX "Y444" #define SPA_TYPE_VIDEO_FORMAT__Y444 SPA_TYPE_VIDEO_FORMAT_BASE "Y444"
#define SPA_VIDEO_FORMAT__v210 SPA_VIDEO_FORMAT_PREFIX "v210" #define SPA_TYPE_VIDEO_FORMAT__v210 SPA_TYPE_VIDEO_FORMAT_BASE "v210"
#define SPA_VIDEO_FORMAT__v216 SPA_VIDEO_FORMAT_PREFIX "v216" #define SPA_TYPE_VIDEO_FORMAT__v216 SPA_TYPE_VIDEO_FORMAT_BASE "v216"
#define SPA_VIDEO_FORMAT__NV12 SPA_VIDEO_FORMAT_PREFIX "NV12" #define SPA_TYPE_VIDEO_FORMAT__NV12 SPA_TYPE_VIDEO_FORMAT_BASE "NV12"
#define SPA_VIDEO_FORMAT__NV21 SPA_VIDEO_FORMAT_PREFIX "NV21" #define SPA_TYPE_VIDEO_FORMAT__NV21 SPA_TYPE_VIDEO_FORMAT_BASE "NV21"
#define SPA_VIDEO_FORMAT__GRAY8 SPA_VIDEO_FORMAT_PREFIX "GRAY8" #define SPA_TYPE_VIDEO_FORMAT__GRAY8 SPA_TYPE_VIDEO_FORMAT_BASE "GRAY8"
#define SPA_VIDEO_FORMAT__GRAY16_BE SPA_VIDEO_FORMAT_PREFIX "GRAY16_BE" #define SPA_TYPE_VIDEO_FORMAT__GRAY16_BE SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_BE"
#define SPA_VIDEO_FORMAT__GRAY16_LE SPA_VIDEO_FORMAT_PREFIX "GRAY16_LE" #define SPA_TYPE_VIDEO_FORMAT__GRAY16_LE SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_LE"
#define SPA_VIDEO_FORMAT__v308 SPA_VIDEO_FORMAT_PREFIX "v308" #define SPA_TYPE_VIDEO_FORMAT__v308 SPA_TYPE_VIDEO_FORMAT_BASE "v308"
#define SPA_VIDEO_FORMAT__RGB16 SPA_VIDEO_FORMAT_PREFIX "RGB16" #define SPA_TYPE_VIDEO_FORMAT__RGB16 SPA_TYPE_VIDEO_FORMAT_BASE "RGB16"
#define SPA_VIDEO_FORMAT__BGR16 SPA_VIDEO_FORMAT_PREFIX "BGR16" #define SPA_TYPE_VIDEO_FORMAT__BGR16 SPA_TYPE_VIDEO_FORMAT_BASE "BGR16"
#define SPA_VIDEO_FORMAT__RGB15 SPA_VIDEO_FORMAT_PREFIX "RGB15" #define SPA_TYPE_VIDEO_FORMAT__RGB15 SPA_TYPE_VIDEO_FORMAT_BASE "RGB15"
#define SPA_VIDEO_FORMAT__BGR15 SPA_VIDEO_FORMAT_PREFIX "BGR15" #define SPA_TYPE_VIDEO_FORMAT__BGR15 SPA_TYPE_VIDEO_FORMAT_BASE "BGR15"
#define SPA_VIDEO_FORMAT__UYVP SPA_VIDEO_FORMAT_PREFIX "UYVP" #define SPA_TYPE_VIDEO_FORMAT__UYVP SPA_TYPE_VIDEO_FORMAT_BASE "UYVP"
#define SPA_VIDEO_FORMAT__A420 SPA_VIDEO_FORMAT_PREFIX "A420" #define SPA_TYPE_VIDEO_FORMAT__A420 SPA_TYPE_VIDEO_FORMAT_BASE "A420"
#define SPA_VIDEO_FORMAT__RGB8P SPA_VIDEO_FORMAT_PREFIX "RGB8P" #define SPA_TYPE_VIDEO_FORMAT__RGB8P SPA_TYPE_VIDEO_FORMAT_BASE "RGB8P"
#define SPA_VIDEO_FORMAT__YUV9 SPA_VIDEO_FORMAT_PREFIX "YUV9" #define SPA_TYPE_VIDEO_FORMAT__YUV9 SPA_TYPE_VIDEO_FORMAT_BASE "YUV9"
#define SPA_VIDEO_FORMAT__YVU9 SPA_VIDEO_FORMAT_PREFIX "YVU9" #define SPA_TYPE_VIDEO_FORMAT__YVU9 SPA_TYPE_VIDEO_FORMAT_BASE "YVU9"
#define SPA_VIDEO_FORMAT__IYU1 SPA_VIDEO_FORMAT_PREFIX "IYU1" #define SPA_TYPE_VIDEO_FORMAT__IYU1 SPA_TYPE_VIDEO_FORMAT_BASE "IYU1"
#define SPA_VIDEO_FORMAT__ARGB64 SPA_VIDEO_FORMAT_PREFIX "ARGB64" #define SPA_TYPE_VIDEO_FORMAT__ARGB64 SPA_TYPE_VIDEO_FORMAT_BASE "ARGB64"
#define SPA_VIDEO_FORMAT__AYUV64 SPA_VIDEO_FORMAT_PREFIX "AYUV64" #define SPA_TYPE_VIDEO_FORMAT__AYUV64 SPA_TYPE_VIDEO_FORMAT_BASE "AYUV64"
#define SPA_VIDEO_FORMAT__r210 SPA_VIDEO_FORMAT_PREFIX "r210" #define SPA_TYPE_VIDEO_FORMAT__r210 SPA_TYPE_VIDEO_FORMAT_BASE "r210"
#define SPA_VIDEO_FORMAT__I420_10BE SPA_VIDEO_FORMAT_PREFIX "I420_10BE" #define SPA_TYPE_VIDEO_FORMAT__I420_10BE SPA_TYPE_VIDEO_FORMAT_BASE "I420_10BE"
#define SPA_VIDEO_FORMAT__I420_10LE SPA_VIDEO_FORMAT_PREFIX "I420_10LE" #define SPA_TYPE_VIDEO_FORMAT__I420_10LE SPA_TYPE_VIDEO_FORMAT_BASE "I420_10LE"
#define SPA_VIDEO_FORMAT__I422_10BE SPA_VIDEO_FORMAT_PREFIX "I422_10BE" #define SPA_TYPE_VIDEO_FORMAT__I422_10BE SPA_TYPE_VIDEO_FORMAT_BASE "I422_10BE"
#define SPA_VIDEO_FORMAT__I422_10LE SPA_VIDEO_FORMAT_PREFIX "I422_10LE" #define SPA_TYPE_VIDEO_FORMAT__I422_10LE SPA_TYPE_VIDEO_FORMAT_BASE "I422_10LE"
#define SPA_VIDEO_FORMAT__Y444_10BE SPA_VIDEO_FORMAT_PREFIX "Y444_10BE" #define SPA_TYPE_VIDEO_FORMAT__Y444_10BE SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10BE"
#define SPA_VIDEO_FORMAT__Y444_10LE SPA_VIDEO_FORMAT_PREFIX "Y444_10LE" #define SPA_TYPE_VIDEO_FORMAT__Y444_10LE SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10LE"
#define SPA_VIDEO_FORMAT__GBR SPA_VIDEO_FORMAT_PREFIX "GBR" #define SPA_TYPE_VIDEO_FORMAT__GBR SPA_TYPE_VIDEO_FORMAT_BASE "GBR"
#define SPA_VIDEO_FORMAT__GBR_10BE SPA_VIDEO_FORMAT_PREFIX "GBR_10BE" #define SPA_TYPE_VIDEO_FORMAT__GBR_10BE SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10BE"
#define SPA_VIDEO_FORMAT__GBR_10LE SPA_VIDEO_FORMAT_PREFIX "GBR_10LE" #define SPA_TYPE_VIDEO_FORMAT__GBR_10LE SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10LE"
#define SPA_VIDEO_FORMAT__NV16 SPA_VIDEO_FORMAT_PREFIX "NV16" #define SPA_TYPE_VIDEO_FORMAT__NV16 SPA_TYPE_VIDEO_FORMAT_BASE "NV16"
#define SPA_VIDEO_FORMAT__NV24 SPA_VIDEO_FORMAT_PREFIX "NV24" #define SPA_TYPE_VIDEO_FORMAT__NV24 SPA_TYPE_VIDEO_FORMAT_BASE "NV24"
#define SPA_VIDEO_FORMAT__NV12_64Z32 SPA_VIDEO_FORMAT_PREFIX "NV12_64Z32" #define SPA_TYPE_VIDEO_FORMAT__NV12_64Z32 SPA_TYPE_VIDEO_FORMAT_BASE "NV12_64Z32"
#define SPA_VIDEO_FORMAT__A420_10BE SPA_VIDEO_FORMAT_PREFIX "A420_10BE" #define SPA_TYPE_VIDEO_FORMAT__A420_10BE SPA_TYPE_VIDEO_FORMAT_BASE "A420_10BE"
#define SPA_VIDEO_FORMAT__A420_10LE SPA_VIDEO_FORMAT_PREFIX "A420_10LE" #define SPA_TYPE_VIDEO_FORMAT__A420_10LE SPA_TYPE_VIDEO_FORMAT_BASE "A420_10LE"
#define SPA_VIDEO_FORMAT__A422_10BE SPA_VIDEO_FORMAT_PREFIX "A422_10BE" #define SPA_TYPE_VIDEO_FORMAT__A422_10BE SPA_TYPE_VIDEO_FORMAT_BASE "A422_10BE"
#define SPA_VIDEO_FORMAT__A422_10LE SPA_VIDEO_FORMAT_PREFIX "A422_10LE" #define SPA_TYPE_VIDEO_FORMAT__A422_10LE SPA_TYPE_VIDEO_FORMAT_BASE "A422_10LE"
#define SPA_VIDEO_FORMAT__A444_10BE SPA_VIDEO_FORMAT_PREFIX "A444_10BE" #define SPA_TYPE_VIDEO_FORMAT__A444_10BE SPA_TYPE_VIDEO_FORMAT_BASE "A444_10BE"
#define SPA_VIDEO_FORMAT__A444_10LE SPA_VIDEO_FORMAT_PREFIX "A444_10LE" #define SPA_TYPE_VIDEO_FORMAT__A444_10LE SPA_TYPE_VIDEO_FORMAT_BASE "A444_10LE"
#define SPA_VIDEO_FORMAT__NV61 SPA_VIDEO_FORMAT_PREFIX "NV61" #define SPA_TYPE_VIDEO_FORMAT__NV61 SPA_TYPE_VIDEO_FORMAT_BASE "NV61"
#define SPA_VIDEO_FORMAT__P010_10BE SPA_VIDEO_FORMAT_PREFIX "P010_10BE" #define SPA_TYPE_VIDEO_FORMAT__P010_10BE SPA_TYPE_VIDEO_FORMAT_BASE "P010_10BE"
#define SPA_VIDEO_FORMAT__P010_10LE SPA_VIDEO_FORMAT_PREFIX "P010_10LE" #define SPA_TYPE_VIDEO_FORMAT__P010_10LE SPA_TYPE_VIDEO_FORMAT_BASE "P010_10LE"
#define SPA_VIDEO_FORMAT__IYU2 SPA_VIDEO_FORMAT_PREFIX "IYU2" #define SPA_TYPE_VIDEO_FORMAT__IYU2 SPA_TYPE_VIDEO_FORMAT_BASE "IYU2"
#define SPA_VIDEO_FORMAT__VYUY SPA_VIDEO_FORMAT_PREFIX "VYUY" #define SPA_TYPE_VIDEO_FORMAT__VYUY SPA_TYPE_VIDEO_FORMAT_BASE "VYUY"
/** /**
* SpaVideoFlags: * SpaVideoFlags:

6
spa/lib/debug.c
View file

@ -338,7 +338,7 @@ print_format_value (uint32_t size, uint32_t type, void *body)
{ {
const char *str = spa_id_map_get_uri (spa_id_map_get_default(), *(int32_t*)body); const char *str = spa_id_map_get_uri (spa_id_map_get_default(), *(int32_t*)body);
if (str) { if (str) {
const char *h = strstr (str, "#"); const char *h = rindex (str, ':');
if (h) if (h)
str = h + 1; str = h + 1;
} else { } else {
@ -403,7 +403,7 @@ spa_debug_format (const SpaFormat *format)
media_type = spa_id_map_get_uri (spa_id_map_get_default (), mtype); media_type = spa_id_map_get_uri (spa_id_map_get_default (), mtype);
media_subtype = spa_id_map_get_uri (spa_id_map_get_default (), mstype); media_subtype = spa_id_map_get_uri (spa_id_map_get_default (), mstype);
fprintf (stderr, "%-6s %s/%s\n", "", strstr (media_type, "#")+1, strstr (media_subtype, "#")+1); fprintf (stderr, "%-6s %s/%s\n", "", rindex (media_type, ':')+1, rindex (media_subtype, ':')+1);
SPA_FORMAT_FOREACH (format, prop) { SPA_FORMAT_FOREACH (format, prop) {
const char *key; const char *key;
@ -414,7 +414,7 @@ spa_debug_format (const SpaFormat *format)
key = spa_id_map_get_uri (spa_id_map_get_default (), prop->body.key); key = spa_id_map_get_uri (spa_id_map_get_default (), prop->body.key);
fprintf (stderr, " %20s : (%s) ", strstr (key, "#")+1, pod_type_names[prop->body.value.type].name); fprintf (stderr, " %20s : (%s) ", rindex (key, ':')+1, pod_type_names[prop->body.value.type].name);
if (!(prop->body.flags & SPA_POD_PROP_FLAG_UNSET)) { if (!(prop->body.flags & SPA_POD_PROP_FLAG_UNSET)) {
print_format_value (prop->body.value.size, prop->body.value.type, SPA_POD_BODY (&prop->body.value)); print_format_value (prop->body.value.size, prop->body.value.type, SPA_POD_BODY (&prop->body.value));

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

@ -57,7 +57,7 @@ struct _SpaALSAMonitor {
SpaLog *log; SpaLog *log;
SpaLoop *main_loop; SpaLoop *main_loop;
SpaMonitorEventCallback event_cb; SpaEventMonitorCallback event_cb;
void *user_data; void *user_data;
struct udev* udev; struct udev* udev;
@ -283,13 +283,13 @@ alsa_on_fd_events (SpaSource *source)
spa_pod_builder_object (&b, &f[0], 0, type, spa_pod_builder_object (&b, &f[0], 0, type,
SPA_POD_TYPE_POD, this->uitem.item); SPA_POD_TYPE_POD, this->uitem.item);
event = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaMonitorEvent); event = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaEventMonitor);
this->event_cb (&this->monitor, event, this->user_data); this->event_cb (&this->monitor, event, this->user_data);
} }
static SpaResult static SpaResult
spa_alsa_monitor_set_event_callback (SpaMonitor *monitor, spa_alsa_monitor_set_event_callback (SpaMonitor *monitor,
SpaMonitorEventCallback callback, SpaEventMonitorCallback callback,
void *user_data) void *user_data)
{ {
SpaResult res; SpaResult res;
@ -435,11 +435,11 @@ alsa_monitor_init (const SpaHandleFactory *factory,
this = (SpaALSAMonitor *) handle; this = (SpaALSAMonitor *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__MainLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data; this->main_loop = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -450,7 +450,7 @@ alsa_monitor_init (const SpaHandleFactory *factory,
spa_log_error (this->log, "a main-loop is needed"); spa_log_error (this->log, "a main-loop is needed");
return SPA_RESULT_ERROR; return SPA_RESULT_ERROR;
} }
this->uri.handle_factory = spa_id_map_get_id (this->map, SPA_HANDLE_FACTORY_URI); this->uri.handle_factory = spa_id_map_get_id (this->map, SPA_TYPE__HandleFactory);
spa_monitor_types_map (this->map, &this->uri.monitor_types); spa_monitor_types_map (this->map, &this->uri.monitor_types);
this->monitor = alsamonitor; this->monitor = alsamonitor;
@ -460,7 +460,7 @@ alsa_monitor_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo alsa_monitor_interfaces[] = static const SpaInterfaceInfo alsa_monitor_interfaces[] =
{ {
{ SPA_MONITOR_URI, }, { SPA_TYPE__Monitor, },
}; };
static SpaResult static SpaResult

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

@ -147,8 +147,8 @@ do_command (SpaLoop *loop,
SpaResult res; SpaResult res;
SpaCommand *cmd = data; SpaCommand *cmd = data;
if (SPA_COMMAND_TYPE (cmd) == this->uri.node_commands.Start || if (SPA_COMMAND_TYPE (cmd) == this->uri.command_node.Start ||
SPA_COMMAND_TYPE (cmd) == this->uri.node_commands.Pause) { SPA_COMMAND_TYPE (cmd) == this->uri.command_node.Pause) {
res = spa_node_port_send_command (&this->node, res = spa_node_port_send_command (&this->node,
SPA_DIRECTION_INPUT, SPA_DIRECTION_INPUT,
0, 0,
@ -158,7 +158,7 @@ do_command (SpaLoop *loop,
res = SPA_RESULT_NOT_IMPLEMENTED; res = SPA_RESULT_NOT_IMPLEMENTED;
if (async) { if (async) {
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (this->uri.node_events.AsyncComplete, SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
seq, res); seq, res);
spa_loop_invoke (this->main_loop, spa_loop_invoke (this->main_loop,
do_send_event, do_send_event,
@ -181,8 +181,8 @@ spa_alsa_sink_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaALSASink, node); this = SPA_CONTAINER_OF (node, SpaALSASink, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start || if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start ||
SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (!this->have_format) if (!this->have_format)
return SPA_RESULT_NO_FORMAT; return SPA_RESULT_NO_FORMAT;
@ -203,7 +203,7 @@ spa_alsa_sink_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_alsa_sink_node_set_event_callback (SpaNode *node, spa_alsa_sink_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaALSASink *this; SpaALSASink *this;
@ -612,12 +612,12 @@ spa_alsa_sink_node_port_send_command (SpaNode *node,
if (port_id != 0) if (port_id != 0)
return SPA_RESULT_INVALID_PORT; return SPA_RESULT_INVALID_PORT;
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) { if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) {
update_state (this, SPA_NODE_STATE_PAUSED); update_state (this, SPA_NODE_STATE_PAUSED);
} }
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_RESULT_IS_OK (res = spa_alsa_start (this, false))) { if (SPA_RESULT_IS_OK (res = spa_alsa_start (this, false))) {
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
@ -753,13 +753,13 @@ alsa_sink_init (const SpaHandleFactory *factory,
this = (SpaALSASink *) handle; this = (SpaALSASink *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__DataLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data; this->data_loop = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__MainLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data; this->main_loop = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -787,7 +787,7 @@ alsa_sink_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo alsa_sink_interfaces[] = static const SpaInterfaceInfo alsa_sink_interfaces[] =
{ {
{ SPA_NODE_URI, }, { SPA_TYPE__Node, },
}; };
static SpaResult static SpaResult

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

@ -154,7 +154,7 @@ do_start (SpaLoop *loop,
} }
if (async) { if (async) {
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (this->uri.node_events.AsyncComplete, SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
seq, res); seq, res);
spa_loop_invoke (this->main_loop, spa_loop_invoke (this->main_loop,
do_send_event, do_send_event,
@ -182,7 +182,7 @@ do_pause (SpaLoop *loop,
} }
if (async) { if (async) {
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (this->uri.node_events.AsyncComplete, SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
seq, res); seq, res);
spa_loop_invoke (this->main_loop, spa_loop_invoke (this->main_loop,
do_send_event, do_send_event,
@ -205,7 +205,7 @@ spa_alsa_source_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaALSASource, node); this = SPA_CONTAINER_OF (node, SpaALSASource, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (!this->have_format) if (!this->have_format)
return SPA_RESULT_NO_FORMAT; return SPA_RESULT_NO_FORMAT;
@ -219,7 +219,7 @@ spa_alsa_source_node_send_command (SpaNode *node,
NULL, NULL,
this); this);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (!this->have_format) if (!this->have_format)
return SPA_RESULT_NO_FORMAT; return SPA_RESULT_NO_FORMAT;
@ -241,7 +241,7 @@ spa_alsa_source_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_alsa_source_node_set_event_callback (SpaNode *node, spa_alsa_source_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaALSASource *this; SpaALSASource *this;
@ -671,11 +671,11 @@ spa_alsa_source_node_port_send_command (SpaNode *node,
if (port_id != 0) if (port_id != 0)
return SPA_RESULT_INVALID_PORT; return SPA_RESULT_INVALID_PORT;
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) { if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) {
update_state (this, SPA_NODE_STATE_PAUSED); update_state (this, SPA_NODE_STATE_PAUSED);
} }
} else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { } else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_RESULT_IS_OK (res = spa_alsa_start (this, false))) { if (SPA_RESULT_IS_OK (res = spa_alsa_start (this, false))) {
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
@ -818,13 +818,13 @@ alsa_source_init (const SpaHandleFactory *factory,
this = (SpaALSASource *) handle; this = (SpaALSASource *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__DataLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data; this->data_loop = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__MainLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data; this->main_loop = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -854,8 +854,8 @@ alsa_source_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo alsa_source_interfaces[] = static const SpaInterfaceInfo alsa_source_interfaces[] =
{ {
{ SPA_NODE_URI, }, { SPA_TYPE__Node, },
{ SPA_CLOCK_URI, }, { SPA_TYPE__Clock, },
}; };
static SpaResult static SpaResult

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

@ -270,7 +270,7 @@ pull_frames_queue (SpaALSAState *state,
snd_pcm_uframes_t frames) snd_pcm_uframes_t frames)
{ {
if (spa_list_is_empty (&state->ready)) { if (spa_list_is_empty (&state->ready)) {
SpaEvent event = SPA_EVENT_INIT (state->uri.node_events.NeedInput); SpaEvent event = SPA_EVENT_INIT (state->uri.event_node.NeedInput);
state->event_cb (&state->node, &event, state->user_data); state->event_cb (&state->node, &event, state->user_data);
} }
if (!spa_list_is_empty (&state->ready)) { if (!spa_list_is_empty (&state->ready)) {
@ -294,7 +294,7 @@ pull_frames_queue (SpaALSAState *state,
state->ready_offset += n_bytes; state->ready_offset += n_bytes;
if (state->ready_offset >= size) { if (state->ready_offset >= size) {
SpaNodeEventReuseBuffer rb = SPA_NODE_EVENT_REUSE_BUFFER_INIT (state->uri.node_events.ReuseBuffer, SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (state->uri.event_node.ReuseBuffer,
0, b->outbuf->id); 0, b->outbuf->id);
spa_list_remove (&b->link); spa_list_remove (&b->link);
@ -349,7 +349,7 @@ pull_frames_ringbuffer (SpaALSAState *state,
b->outstanding = true; b->outstanding = true;
{ {
SpaNodeEventReuseBuffer rb = SPA_NODE_EVENT_REUSE_BUFFER_INIT (state->uri.node_events.ReuseBuffer, SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (state->uri.event_node.ReuseBuffer,
0, b->outbuf->id); 0, b->outbuf->id);
state->event_cb (&state->node, (SpaEvent*)&rb, state->user_data); state->event_cb (&state->node, (SpaEvent*)&rb, state->user_data);
} }
@ -498,7 +498,7 @@ mmap_read (SpaALSAState *state)
output->status = SPA_RESULT_OK; output->status = SPA_RESULT_OK;
} }
{ {
SpaEvent event = SPA_EVENT_INIT (state->uri.node_events.HaveOutput); SpaEvent event = SPA_EVENT_INIT (state->uri.event_node.HaveOutput);
state->event_cb (&state->node, &event, state->user_data); state->event_cb (&state->node, &event, state->user_data);
} }
} }

30
spa/plugins/alsa/alsa-utils.h
View file

@ -76,8 +76,8 @@ typedef struct {
SpaMediaSubtypesAudio media_subtypes_audio; SpaMediaSubtypesAudio media_subtypes_audio;
SpaPropAudio prop_audio; SpaPropAudio prop_audio;
SpaAudioFormats audio_formats; SpaAudioFormats audio_formats;
SpaNodeEvents node_events; SpaEventNode event_node;
SpaNodeCommands node_commands; SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers; SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable; SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI; } URI;
@ -85,24 +85,24 @@ typedef struct {
static inline void static inline void
init_uri (URI *uri, SpaIDMap *map) init_uri (URI *uri, SpaIDMap *map)
{ {
uri->node = spa_id_map_get_id (map, SPA_NODE_URI); uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->clock = spa_id_map_get_id (map, SPA_CLOCK_URI); uri->clock = spa_id_map_get_id (map, SPA_TYPE__Clock);
uri->format = spa_id_map_get_id (map, SPA_FORMAT_URI); uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_PROPS_URI); uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_device = spa_id_map_get_id (map, SPA_PROPS__device); uri->prop_device = spa_id_map_get_id (map, SPA_TYPE_PROPS__device);
uri->prop_device_name = spa_id_map_get_id (map, SPA_PROPS__deviceName); uri->prop_device_name = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceName);
uri->prop_card_name = spa_id_map_get_id (map, SPA_PROPS__cardName); uri->prop_card_name = spa_id_map_get_id (map, SPA_TYPE_PROPS__cardName);
uri->prop_period_size = spa_id_map_get_id (map, SPA_PROPS__periodSize); uri->prop_period_size = spa_id_map_get_id (map, SPA_TYPE_PROPS__periodSize);
uri->prop_periods = spa_id_map_get_id (map, SPA_PROPS__periods); uri->prop_periods = spa_id_map_get_id (map, SPA_TYPE_PROPS__periods);
uri->prop_period_event = spa_id_map_get_id (map, SPA_PROPS__periodEvent); uri->prop_period_event = spa_id_map_get_id (map, SPA_TYPE_PROPS__periodEvent);
spa_media_types_fill (&uri->media_types, map); spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes); spa_media_subtypes_map (map, &uri->media_subtypes);
spa_media_subtypes_audio_map (map, &uri->media_subtypes_audio); spa_media_subtypes_audio_map (map, &uri->media_subtypes_audio);
spa_prop_audio_map (map, &uri->prop_audio); spa_prop_audio_map (map, &uri->prop_audio);
spa_audio_formats_map (map, &uri->audio_formats); spa_audio_formats_map (map, &uri->audio_formats);
spa_node_events_map (map, &uri->node_events); spa_event_node_map (map, &uri->event_node);
spa_node_commands_map (map, &uri->node_commands); spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers); spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable); spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
} }
@ -123,7 +123,7 @@ struct _SpaALSAState {
snd_pcm_stream_t stream; snd_pcm_stream_t stream;
snd_output_t *output; snd_output_t *output;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
uint8_t props_buffer[1024]; uint8_t props_buffer[1024];

20
spa/plugins/audiomixer/audiomixer.c
View file

@ -58,14 +58,14 @@ typedef struct {
typedef struct { typedef struct {
uint32_t node; uint32_t node;
SpaNodeCommands node_commands; SpaCommandNode command_node;
} URI; } URI;
static inline void static inline void
init_uri (URI *uri, SpaIDMap *map) init_uri (URI *uri, SpaIDMap *map)
{ {
uri->node = spa_id_map_get_id (map, SPA_NODE_URI); uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
spa_node_commands_map (map, &uri->node_commands); spa_command_node_map (map, &uri->command_node);
} }
struct _SpaAudioMixer { struct _SpaAudioMixer {
@ -76,7 +76,7 @@ struct _SpaAudioMixer {
SpaIDMap *map; SpaIDMap *map;
SpaLog *log; SpaLog *log;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
int port_count; int port_count;
@ -125,10 +125,10 @@ spa_audiomixer_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaAudioMixer, node); this = SPA_CONTAINER_OF (node, SpaAudioMixer, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
update_state (this, SPA_NODE_STATE_PAUSED); update_state (this, SPA_NODE_STATE_PAUSED);
} }
else else
@ -139,7 +139,7 @@ spa_audiomixer_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_audiomixer_node_set_event_callback (SpaNode *node, spa_audiomixer_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaAudioMixer *this; SpaAudioMixer *this;
@ -692,9 +692,9 @@ spa_audiomixer_init (const SpaHandleFactory *factory,
this = (SpaAudioMixer *) handle; this = (SpaAudioMixer *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -714,7 +714,7 @@ spa_audiomixer_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo audiomixer_interfaces[] = static const SpaInterfaceInfo audiomixer_interfaces[] =
{ {
{ SPA_NODE_URI, }, { SPA_TYPE__Node, },
}; };
static SpaResult static SpaResult

48
spa/plugins/audiotestsrc/audiotestsrc.c
View file

@ -52,8 +52,8 @@ typedef struct {
SpaMediaSubtypes media_subtypes; SpaMediaSubtypes media_subtypes;
SpaPropAudio prop_audio; SpaPropAudio prop_audio;
SpaAudioFormats audio_formats; SpaAudioFormats audio_formats;
SpaNodeEvents node_events; SpaEventNode event_node;
SpaNodeCommands node_commands; SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers; SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable; SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI; } URI;
@ -61,22 +61,22 @@ typedef struct {
static inline void static inline void
init_uri (URI *uri, SpaIDMap *map) init_uri (URI *uri, SpaIDMap *map)
{ {
uri->node = spa_id_map_get_id (map, SPA_NODE_URI); uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->clock = spa_id_map_get_id (map, SPA_CLOCK_URI); uri->clock = spa_id_map_get_id (map, SPA_TYPE__Clock);
uri->format = spa_id_map_get_id (map, SPA_FORMAT_URI); uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_PROPS_URI); uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_live = spa_id_map_get_id (map, SPA_PROPS__live); uri->prop_live = spa_id_map_get_id (map, SPA_TYPE_PROPS__live);
uri->prop_wave = spa_id_map_get_id (map, SPA_PROPS__waveType); uri->prop_wave = spa_id_map_get_id (map, SPA_TYPE_PROPS__waveType);
uri->prop_freq = spa_id_map_get_id (map, SPA_PROPS__frequency); uri->prop_freq = spa_id_map_get_id (map, SPA_TYPE_PROPS__frequency);
uri->prop_volume = spa_id_map_get_id (map, SPA_PROPS__volume); uri->prop_volume = spa_id_map_get_id (map, SPA_TYPE_PROPS__volume);
uri->wave_sine = spa_id_map_get_id (map, SPA_PROPS__waveType ":sine"); uri->wave_sine = spa_id_map_get_id (map, SPA_TYPE_PROPS__waveType ":sine");
uri->wave_square = spa_id_map_get_id (map, SPA_PROPS__waveType ":square"); uri->wave_square = spa_id_map_get_id (map, SPA_TYPE_PROPS__waveType ":square");
spa_media_types_fill (&uri->media_types, map); spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes); spa_media_subtypes_map (map, &uri->media_subtypes);
spa_prop_audio_map (map, &uri->prop_audio); spa_prop_audio_map (map, &uri->prop_audio);
spa_audio_formats_map (map, &uri->audio_formats); spa_audio_formats_map (map, &uri->audio_formats);
spa_node_events_map (map, &uri->node_events); spa_event_node_map (map, &uri->event_node);
spa_node_commands_map (map, &uri->node_commands); spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers); spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable); spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
} }
@ -116,7 +116,7 @@ struct _SpaAudioTestSrc {
uint8_t props_buffer[512]; uint8_t props_buffer[512];
SpaAudioTestSrcProps props; SpaAudioTestSrcProps props;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
SpaSource timer_source; SpaSource timer_source;
@ -240,7 +240,7 @@ send_have_output (SpaAudioTestSrc *this)
{ {
if (this->event_cb) { if (this->event_cb) {
SpaEvent event = SPA_EVENT_INIT (this->uri.node_events.HaveOutput); SpaEvent event = SPA_EVENT_INIT (this->uri.event_node.HaveOutput);
this->event_cb (&this->node, &event, this->user_data); this->event_cb (&this->node, &event, this->user_data);
} }
@ -334,7 +334,7 @@ spa_audiotestsrc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaAudioTestSrc, node); this = SPA_CONTAINER_OF (node, SpaAudioTestSrc, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
struct timespec now; struct timespec now;
if (!this->have_format) if (!this->have_format)
@ -358,7 +358,7 @@ spa_audiotestsrc_node_send_command (SpaNode *node,
set_timer (this, true); set_timer (this, true);
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (!this->have_format) if (!this->have_format)
return SPA_RESULT_NO_FORMAT; return SPA_RESULT_NO_FORMAT;
@ -380,7 +380,7 @@ spa_audiotestsrc_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_audiotestsrc_node_set_event_callback (SpaNode *node, spa_audiotestsrc_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event_cb, SpaEventNodeCallback event_cb,
void *user_data) void *user_data)
{ {
SpaAudioTestSrc *this; SpaAudioTestSrc *this;
@ -953,11 +953,11 @@ audiotestsrc_init (const SpaHandleFactory *factory,
this = (SpaAudioTestSrc *) handle; this = (SpaAudioTestSrc *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__DataLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data; this->data_loop = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -998,8 +998,8 @@ audiotestsrc_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo audiotestsrc_interfaces[] = static const SpaInterfaceInfo audiotestsrc_interfaces[] =
{ {
{ SPA_NODE_URI, }, { SPA_TYPE__Node, },
{ SPA_CLOCK_URI, }, { SPA_TYPE__Clock, },
}; };
static SpaResult static SpaResult

18
spa/plugins/ffmpeg/ffmpeg-dec.c
View file

@ -52,7 +52,7 @@ typedef struct {
typedef struct { typedef struct {
uint32_t node; uint32_t node;
SpaNodeCommands node_commands; SpaCommandNode command_node;
} URI; } URI;
struct _SpaFFMpegDec { struct _SpaFFMpegDec {
@ -63,7 +63,7 @@ struct _SpaFFMpegDec {
SpaIDMap *map; SpaIDMap *map;
SpaLog *log; SpaLog *log;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
SpaFFMpegPort in_ports[1]; SpaFFMpegPort in_ports[1];
@ -105,10 +105,10 @@ spa_ffmpeg_dec_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaFFMpegDec, node); this = SPA_CONTAINER_OF (node, SpaFFMpegDec, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
update_state (this, SPA_NODE_STATE_PAUSED); update_state (this, SPA_NODE_STATE_PAUSED);
} }
else else
@ -119,7 +119,7 @@ spa_ffmpeg_dec_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_ffmpeg_dec_node_set_event_callback (SpaNode *node, spa_ffmpeg_dec_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaFFMpegDec *this; SpaFFMpegDec *this;
@ -513,19 +513,19 @@ spa_ffmpeg_dec_init (SpaHandle *handle,
this = (SpaFFMpegDec *) handle; this = (SpaFFMpegDec *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed"); spa_log_error (this->log, "an id-map is needed");
return SPA_RESULT_ERROR; return SPA_RESULT_ERROR;
} }
this->uri.node = spa_id_map_get_id (this->map, SPA_NODE_URI); this->uri.node = spa_id_map_get_id (this->map, SPA_TYPE__Node);
this->node = ffmpeg_dec_node; this->node = ffmpeg_dec_node;
spa_node_commands_map (this->map, &this->uri.node_commands); spa_command_node_map (this->map, &this->uri.command_node);
this->in_ports[0].info.flags = SPA_PORT_INFO_FLAG_NONE; this->in_ports[0].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->out_ports[0].info.flags = SPA_PORT_INFO_FLAG_NONE; this->out_ports[0].info.flags = SPA_PORT_INFO_FLAG_NONE;

18
spa/plugins/ffmpeg/ffmpeg-enc.c
View file

@ -59,7 +59,7 @@ typedef struct {
uint32_t node; uint32_t node;
SpaMediaTypes media_types; SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes; SpaMediaSubtypes media_subtypes;
SpaNodeCommands node_commands; SpaCommandNode command_node;
} URI; } URI;
struct _SpaFFMpegEnc { struct _SpaFFMpegEnc {
@ -70,7 +70,7 @@ struct _SpaFFMpegEnc {
SpaIDMap *map; SpaIDMap *map;
SpaLog *log; SpaLog *log;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
SpaFFMpegPort in_ports[1]; SpaFFMpegPort in_ports[1];
@ -112,10 +112,10 @@ spa_ffmpeg_enc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaFFMpegEnc, node); this = SPA_CONTAINER_OF (node, SpaFFMpegEnc, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
update_state (this, SPA_NODE_STATE_PAUSED); update_state (this, SPA_NODE_STATE_PAUSED);
} }
else else
@ -126,7 +126,7 @@ spa_ffmpeg_enc_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_ffmpeg_enc_node_set_event_callback (SpaNode *node, spa_ffmpeg_enc_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaFFMpegEnc *this; SpaFFMpegEnc *this;
@ -526,19 +526,19 @@ spa_ffmpeg_enc_init (SpaHandle *handle,
this = (SpaFFMpegEnc *) handle; this = (SpaFFMpegEnc *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed"); spa_log_error (this->log, "an id-map is needed");
return SPA_RESULT_ERROR; return SPA_RESULT_ERROR;
} }
this->uri.node = spa_id_map_get_id (this->map, SPA_NODE_URI); this->uri.node = spa_id_map_get_id (this->map, SPA_TYPE__Node);
spa_media_types_fill (&this->uri.media_types, this->map); spa_media_types_fill (&this->uri.media_types, this->map);
spa_media_subtypes_map (this->map, &this->uri.media_subtypes); spa_media_subtypes_map (this->map, &this->uri.media_subtypes);
spa_node_commands_map (this->map, &this->uri.node_commands); spa_command_node_map (this->map, &this->uri.command_node);
this->node = ffmpeg_enc_node; this->node = ffmpeg_enc_node;

2
spa/plugins/ffmpeg/ffmpeg.c
View file

@ -56,7 +56,7 @@ ffmpeg_enc_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo ffmpeg_interfaces[] = static const SpaInterfaceInfo ffmpeg_interfaces[] =
{ {
{ SPA_NODE_URI, { SPA_TYPE__Node,
}, },
}; };

16
spa/plugins/v4l2/v4l2-monitor.c
View file

@ -54,7 +54,7 @@ struct _SpaV4l2Monitor {
SpaLog *log; SpaLog *log;
SpaLoop *main_loop; SpaLoop *main_loop;
SpaMonitorEventCallback event_cb; SpaEventMonitorCallback event_cb;
void *user_data; void *user_data;
struct udev* udev; struct udev* udev;
@ -216,13 +216,13 @@ v4l2_on_fd_events (SpaSource *source)
spa_pod_builder_object (&b, &f[0], 0, type, spa_pod_builder_object (&b, &f[0], 0, type,
SPA_POD_TYPE_POD, this->uitem.item); SPA_POD_TYPE_POD, this->uitem.item);
event = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaMonitorEvent); event = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaEventMonitor);
this->event_cb (&this->monitor, event, this->user_data); this->event_cb (&this->monitor, event, this->user_data);
} }
static SpaResult static SpaResult
spa_v4l2_monitor_set_event_callback (SpaMonitor *monitor, spa_v4l2_monitor_set_event_callback (SpaMonitor *monitor,
SpaMonitorEventCallback callback, SpaEventMonitorCallback callback,
void *user_data) void *user_data)
{ {
SpaResult res; SpaResult res;
@ -366,11 +366,11 @@ v4l2_monitor_init (const SpaHandleFactory *factory,
this = (SpaV4l2Monitor *) handle; this = (SpaV4l2Monitor *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__MainLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data; this->main_loop = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -381,7 +381,7 @@ v4l2_monitor_init (const SpaHandleFactory *factory,
spa_log_error (this->log, "a main-loop is needed"); spa_log_error (this->log, "a main-loop is needed");
return SPA_RESULT_ERROR; return SPA_RESULT_ERROR;
} }
this->uri.handle_factory = spa_id_map_get_id (this->map, SPA_HANDLE_FACTORY_URI); this->uri.handle_factory = spa_id_map_get_id (this->map, SPA_TYPE__HandleFactory);
spa_monitor_types_map (this->map, &this->uri.monitor_types); spa_monitor_types_map (this->map, &this->uri.monitor_types);
this->monitor = v4l2monitor; this->monitor = v4l2monitor;
@ -391,7 +391,7 @@ v4l2_monitor_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo v4l2_monitor_interfaces[] = static const SpaInterfaceInfo v4l2_monitor_interfaces[] =
{ {
{ SPA_MONITOR_URI, }, { SPA_TYPE__Monitor, },
}; };
static SpaResult static SpaResult

56
spa/plugins/v4l2/v4l2-source.c
View file

@ -76,8 +76,8 @@ typedef struct {
SpaMediaSubtypesVideo media_subtypes_video; SpaMediaSubtypesVideo media_subtypes_video;
SpaPropVideo prop_video; SpaPropVideo prop_video;
SpaVideoFormats video_formats; SpaVideoFormats video_formats;
SpaNodeEvents node_events; SpaEventNode event_node;
SpaNodeCommands node_commands; SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers; SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable; SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI; } URI;
@ -85,20 +85,20 @@ typedef struct {
static inline void static inline void
init_uri (URI *uri, SpaIDMap *map) init_uri (URI *uri, SpaIDMap *map)
{ {
uri->node = spa_id_map_get_id (map, SPA_NODE_URI); uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->clock = spa_id_map_get_id (map, SPA_CLOCK_URI); uri->clock = spa_id_map_get_id (map, SPA_TYPE__Clock);
uri->format = spa_id_map_get_id (map, SPA_FORMAT_URI); uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_PROPS_URI); uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_device = spa_id_map_get_id (map, SPA_PROPS__device); uri->prop_device = spa_id_map_get_id (map, SPA_TYPE_PROPS__device);
uri->prop_device_name = spa_id_map_get_id (map, SPA_PROPS__deviceName); uri->prop_device_name = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceName);
uri->prop_device_fd = spa_id_map_get_id (map, SPA_PROPS__deviceFd); uri->prop_device_fd = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceFd);
spa_media_types_fill (&uri->media_types, map); spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes); spa_media_subtypes_map (map, &uri->media_subtypes);
spa_media_subtypes_video_map (map, &uri->media_subtypes_video); spa_media_subtypes_video_map (map, &uri->media_subtypes_video);
spa_prop_video_map (map, &uri->prop_video); spa_prop_video_map (map, &uri->prop_video);
spa_video_formats_map (map, &uri->video_formats); spa_video_formats_map (map, &uri->video_formats);
spa_node_events_map (map, &uri->node_events); spa_event_node_map (map, &uri->event_node);
spa_node_commands_map (map, &uri->node_commands); spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers); spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable); spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
} }
@ -157,7 +157,7 @@ struct _SpaV4l2Source {
uint8_t props_buffer[512]; uint8_t props_buffer[512];
SpaV4l2SourceProps props; SpaV4l2SourceProps props;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
SpaV4l2State state[1]; SpaV4l2State state[1];
@ -247,7 +247,7 @@ do_pause_done (SpaLoop *loop,
{ {
SpaV4l2Source *this = user_data; SpaV4l2Source *this = user_data;
SpaV4l2State *state = &this->state[0]; SpaV4l2State *state = &this->state[0];
SpaNodeEventAsyncComplete *ac = data; SpaEventNodeAsyncComplete *ac = data;
if (SPA_RESULT_IS_OK (ac->body.res.value)) if (SPA_RESULT_IS_OK (ac->body.res.value))
ac->body.res.value = spa_v4l2_stream_off (this); ac->body.res.value = spa_v4l2_stream_off (this);
@ -279,7 +279,7 @@ do_pause (SpaLoop *loop,
cmd); cmd);
if (async) { if (async) {
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (this->uri.node_events.AsyncComplete, SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
seq, res); seq, res);
spa_loop_invoke (this->state[0].main_loop, spa_loop_invoke (this->state[0].main_loop,
do_pause_done, do_pause_done,
@ -301,7 +301,7 @@ do_start_done (SpaLoop *loop,
{ {
SpaV4l2Source *this = user_data; SpaV4l2Source *this = user_data;
SpaV4l2State *state = &this->state[0]; SpaV4l2State *state = &this->state[0];
SpaNodeEventAsyncComplete *ac = data; SpaEventNodeAsyncComplete *ac = data;
if (SPA_RESULT_IS_OK (ac->body.res.value)) { if (SPA_RESULT_IS_OK (ac->body.res.value)) {
state->started = true; state->started = true;
@ -330,7 +330,7 @@ do_start (SpaLoop *loop,
cmd); cmd);
if (async) { if (async) {
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (this->uri.node_events.AsyncComplete, SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
seq, res); seq, res);
spa_loop_invoke (this->state[0].main_loop, spa_loop_invoke (this->state[0].main_loop,
do_start_done, do_start_done,
@ -354,7 +354,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaV4l2Source, node); this = SPA_CONTAINER_OF (node, SpaV4l2Source, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
SpaV4l2State *state = &this->state[0]; SpaV4l2State *state = &this->state[0];
SpaResult res; SpaResult res;
@ -377,7 +377,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
command, command,
this); this);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
SpaV4l2State *state = &this->state[0]; SpaV4l2State *state = &this->state[0];
if (!state->have_format) if (!state->have_format)
@ -396,7 +396,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
command, command,
this); this);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.ClockUpdate) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.ClockUpdate) {
return SPA_RESULT_OK; return SPA_RESULT_OK;
} }
else else
@ -405,7 +405,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_v4l2_source_node_set_event_callback (SpaNode *node, spa_v4l2_source_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaV4l2Source *this; SpaV4l2Source *this;
@ -807,10 +807,10 @@ spa_v4l2_source_node_port_send_command (SpaNode *node,
if (port_id != 0) if (port_id != 0)
return SPA_RESULT_INVALID_PORT; return SPA_RESULT_INVALID_PORT;
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
res = spa_v4l2_port_set_enabled (this, false); res = spa_v4l2_port_set_enabled (this, false);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
res = spa_v4l2_port_set_enabled (this, true); res = spa_v4l2_port_set_enabled (this, true);
} else } else
res = SPA_RESULT_NOT_IMPLEMENTED; res = SPA_RESULT_NOT_IMPLEMENTED;
@ -954,13 +954,13 @@ v4l2_source_init (const SpaHandleFactory *factory,
this = (SpaV4l2Source *) handle; this = (SpaV4l2Source *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__MainLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
this->state[0].main_loop = support[i].data; this->state[0].main_loop = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__DataLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
this->state[0].data_loop = support[i].data; this->state[0].data_loop = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -998,8 +998,8 @@ v4l2_source_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo v4l2_source_interfaces[] = static const SpaInterfaceInfo v4l2_source_interfaces[] =
{ {
{ SPA_NODE_URI, }, { SPA_TYPE__Node, },
{ SPA_CLOCK_URI, }, { SPA_TYPE__Clock, },
}; };
static SpaResult static SpaResult

2
spa/plugins/v4l2/v4l2-utils.c
View file

@ -979,7 +979,7 @@ v4l2_on_fd_events (SpaSource *source)
return; return;
{ {
SpaEvent event = SPA_EVENT_INIT (this->uri.node_events.HaveOutput); SpaEvent event = SPA_EVENT_INIT (this->uri.event_node.HaveOutput);
this->event_cb (&this->node, &event, this->user_data); this->event_cb (&this->node, &event, this->user_data);
} }
} }

44
spa/plugins/videotestsrc/videotestsrc.c
View file

@ -50,8 +50,8 @@ typedef struct {
SpaMediaSubtypes media_subtypes; SpaMediaSubtypes media_subtypes;
SpaPropVideo prop_video; SpaPropVideo prop_video;
SpaVideoFormats video_formats; SpaVideoFormats video_formats;
SpaNodeEvents node_events; SpaEventNode event_node;
SpaNodeCommands node_commands; SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers; SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable; SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI; } URI;
@ -59,20 +59,20 @@ typedef struct {
static inline void static inline void
init_uri (URI *uri, SpaIDMap *map) init_uri (URI *uri, SpaIDMap *map)
{ {
uri->node = spa_id_map_get_id (map, SPA_NODE_URI); uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->clock = spa_id_map_get_id (map, SPA_CLOCK_URI); uri->clock = spa_id_map_get_id (map, SPA_TYPE__Clock);
uri->format = spa_id_map_get_id (map, SPA_FORMAT_URI); uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_PROPS_URI); uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_live = spa_id_map_get_id (map, SPA_PROPS__live); uri->prop_live = spa_id_map_get_id (map, SPA_TYPE_PROPS__live);
uri->prop_pattern = spa_id_map_get_id (map, SPA_PROPS__patternType); uri->prop_pattern = spa_id_map_get_id (map, SPA_TYPE_PROPS__patternType);
uri->pattern_smpte_snow = spa_id_map_get_id (map, SPA_PROPS__patternType ":smpte-snow"); uri->pattern_smpte_snow = spa_id_map_get_id (map, SPA_TYPE_PROPS__patternType ":smpte-snow");
uri->pattern_snow = spa_id_map_get_id (map, SPA_PROPS__patternType ":snow"); uri->pattern_snow = spa_id_map_get_id (map, SPA_TYPE_PROPS__patternType ":snow");
spa_media_types_fill (&uri->media_types, map); spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes); spa_media_subtypes_map (map, &uri->media_subtypes);
spa_prop_video_map (map, &uri->prop_video); spa_prop_video_map (map, &uri->prop_video);
spa_video_formats_map (map, &uri->video_formats); spa_video_formats_map (map, &uri->video_formats);
spa_node_events_map (map, &uri->node_events); spa_event_node_map (map, &uri->event_node);
spa_node_commands_map (map, &uri->node_commands); spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers); spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable); spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
} }
@ -110,7 +110,7 @@ struct _SpaVideoTestSrc {
uint8_t props_buffer[512]; uint8_t props_buffer[512];
SpaVideoTestSrcProps props; SpaVideoTestSrcProps props;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
SpaSource timer_source; SpaSource timer_source;
@ -227,7 +227,7 @@ send_have_output (SpaVideoTestSrc *this)
{ {
if (this->event_cb) { if (this->event_cb) {
SpaEvent event = SPA_EVENT_INIT (this->uri.node_events.HaveOutput); SpaEvent event = SPA_EVENT_INIT (this->uri.event_node.HaveOutput);
this->event_cb (&this->node, &event, this->user_data); this->event_cb (&this->node, &event, this->user_data);
} }
return SPA_RESULT_OK; return SPA_RESULT_OK;
@ -315,7 +315,7 @@ spa_videotestsrc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaVideoTestSrc, node); this = SPA_CONTAINER_OF (node, SpaVideoTestSrc, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
struct timespec now; struct timespec now;
if (!this->have_format) if (!this->have_format)
@ -339,7 +339,7 @@ spa_videotestsrc_node_send_command (SpaNode *node,
set_timer (this, true); set_timer (this, true);
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (!this->have_format) if (!this->have_format)
return SPA_RESULT_NO_FORMAT; return SPA_RESULT_NO_FORMAT;
@ -361,7 +361,7 @@ spa_videotestsrc_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_videotestsrc_node_set_event_callback (SpaNode *node, spa_videotestsrc_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event_cb, SpaEventNodeCallback event_cb,
void *user_data) void *user_data)
{ {
SpaVideoTestSrc *this; SpaVideoTestSrc *this;
@ -953,11 +953,11 @@ videotestsrc_init (const SpaHandleFactory *factory,
this = (SpaVideoTestSrc *) handle; this = (SpaVideoTestSrc *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_LOOP__DataLoop) == 0) else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data; this->data_loop = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -998,8 +998,8 @@ videotestsrc_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo videotestsrc_interfaces[] = static const SpaInterfaceInfo videotestsrc_interfaces[] =
{ {
{ SPA_NODE_URI, }, { SPA_TYPE__Node, },
{ SPA_CLOCK_URI, }, { SPA_TYPE__Clock, },
}; };
static SpaResult static SpaResult

34
spa/plugins/volume/volume.c
View file

@ -71,8 +71,8 @@ typedef struct {
SpaMediaSubtypes media_subtypes; SpaMediaSubtypes media_subtypes;
SpaPropAudio prop_audio; SpaPropAudio prop_audio;
SpaAudioFormats audio_formats; SpaAudioFormats audio_formats;
SpaNodeEvents node_events; SpaEventNode event_node;
SpaNodeCommands node_commands; SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers; SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable; SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI; } URI;
@ -80,17 +80,17 @@ typedef struct {
static inline void static inline void
init_uri (URI *uri, SpaIDMap *map) init_uri (URI *uri, SpaIDMap *map)
{ {
uri->node = spa_id_map_get_id (map, SPA_NODE_URI); uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->format = spa_id_map_get_id (map, SPA_FORMAT_URI); uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_PROPS_URI); uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_volume = spa_id_map_get_id (map, SPA_PROPS__volume); uri->prop_volume = spa_id_map_get_id (map, SPA_TYPE_PROPS__volume);
uri->prop_mute = spa_id_map_get_id (map, SPA_PROPS__mute); uri->prop_mute = spa_id_map_get_id (map, SPA_TYPE_PROPS__mute);
spa_media_types_fill (&uri->media_types, map); spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes); spa_media_subtypes_map (map, &uri->media_subtypes);
spa_prop_audio_map (map, &uri->prop_audio); spa_prop_audio_map (map, &uri->prop_audio);
spa_audio_formats_map (map, &uri->audio_formats); spa_audio_formats_map (map, &uri->audio_formats);
spa_node_events_map (map, &uri->node_events); spa_event_node_map (map, &uri->event_node);
spa_node_commands_map (map, &uri->node_commands); spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers); spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable); spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
} }
@ -106,7 +106,7 @@ struct _SpaVolume {
uint8_t props_buffer[512]; uint8_t props_buffer[512];
SpaVolumeProps props; SpaVolumeProps props;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
uint8_t format_buffer[1024]; uint8_t format_buffer[1024];
@ -207,10 +207,10 @@ spa_volume_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaVolume, node); this = SPA_CONTAINER_OF (node, SpaVolume, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
update_state (this, SPA_NODE_STATE_PAUSED); update_state (this, SPA_NODE_STATE_PAUSED);
} }
else else
@ -221,7 +221,7 @@ spa_volume_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_volume_node_set_event_callback (SpaNode *node, spa_volume_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaVolume *this; SpaVolume *this;
@ -662,7 +662,7 @@ find_free_buffer (SpaVolume *this, SpaVolumePort *port)
static void static void
release_buffer (SpaVolume *this, SpaBuffer *buffer) release_buffer (SpaVolume *this, SpaBuffer *buffer)
{ {
SpaNodeEventReuseBuffer rb = SPA_NODE_EVENT_REUSE_BUFFER_INIT (this->uri.node_events.ReuseBuffer, SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (this->uri.event_node.ReuseBuffer,
0, buffer->id); 0, buffer->id);
this->event_cb (&this->node, (SpaEvent *)&rb, this->user_data); this->event_cb (&this->node, (SpaEvent *)&rb, this->user_data);
} }
@ -844,9 +844,9 @@ volume_init (const SpaHandleFactory *factory,
this = (SpaVolume *) handle; this = (SpaVolume *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -871,7 +871,7 @@ volume_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo volume_interfaces[] = static const SpaInterfaceInfo volume_interfaces[] =
{ {
{ SPA_NODE_URI, }, { SPA_TYPE__Node, },
}; };
static SpaResult static SpaResult

28
spa/plugins/xv/xv-sink.c
View file

@ -77,20 +77,20 @@ typedef struct {
uint32_t prop_device_fd; uint32_t prop_device_fd;
SpaMediaTypes media_types; SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes; SpaMediaSubtypes media_subtypes;
SpaNodeCommands node_commands; SpaCommandNode command_node;
} URI; } URI;
static inline void static inline void
init_uri (URI *uri, SpaIDMap *map) init_uri (URI *uri, SpaIDMap *map)
{ {
uri->node = spa_id_map_get_id (map, SPA_NODE_URI); uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->props = spa_id_map_get_id (map, SPA_PROPS_URI); uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_device = spa_id_map_get_id (map, SPA_PROPS__device); uri->prop_device = spa_id_map_get_id (map, SPA_TYPE_PROPS__device);
uri->prop_device_name = spa_id_map_get_id (map, SPA_PROPS__deviceName); uri->prop_device_name = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceName);
uri->prop_device_fd = spa_id_map_get_id (map, SPA_PROPS__deviceFd); uri->prop_device_fd = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceFd);
spa_media_types_fill (&uri->media_types, map); spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes); spa_media_subtypes_map (map, &uri->media_subtypes);
spa_node_commands_map (map, &uri->node_commands); spa_command_node_map (map, &uri->command_node);
} }
struct _SpaXvSink { struct _SpaXvSink {
@ -104,7 +104,7 @@ struct _SpaXvSink {
uint8_t props_buffer[512]; uint8_t props_buffer[512];
SpaXvSinkProps props; SpaXvSinkProps props;
SpaNodeEventCallback event_cb; SpaEventNodeCallback event_cb;
void *user_data; void *user_data;
bool have_format; bool have_format;
@ -187,12 +187,12 @@ spa_xv_sink_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaXvSink, node); this = SPA_CONTAINER_OF (node, SpaXvSink, node);
if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Start) { if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
spa_xv_start (this); spa_xv_start (this);
update_state (this, SPA_NODE_STATE_STREAMING); update_state (this, SPA_NODE_STATE_STREAMING);
} }
else if (SPA_COMMAND_TYPE (command) == this->uri.node_commands.Pause) { else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
spa_xv_stop (this); spa_xv_stop (this);
update_state (this, SPA_NODE_STATE_PAUSED); update_state (this, SPA_NODE_STATE_PAUSED);
@ -205,7 +205,7 @@ spa_xv_sink_node_send_command (SpaNode *node,
static SpaResult static SpaResult
spa_xv_sink_node_set_event_callback (SpaNode *node, spa_xv_sink_node_set_event_callback (SpaNode *node,
SpaNodeEventCallback event, SpaEventNodeCallback event,
void *user_data) void *user_data)
{ {
SpaXvSink *this; SpaXvSink *this;
@ -564,9 +564,9 @@ xv_sink_init (const SpaHandleFactory *factory,
this = (SpaXvSink *) handle; this = (SpaXvSink *) handle;
for (i = 0; i < n_support; i++) { for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_ID_MAP_URI) == 0) if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
this->map = support[i].data; this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_LOG_URI) == 0) else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
this->log = support[i].data; this->log = support[i].data;
} }
if (this->map == NULL) { if (this->map == NULL) {
@ -585,7 +585,7 @@ xv_sink_init (const SpaHandleFactory *factory,
static const SpaInterfaceInfo xv_sink_interfaces[] = static const SpaInterfaceInfo xv_sink_interfaces[] =
{ {
{ SPA_NODE_URI, }, { SPA_TYPE__Node, },
}; };
static SpaResult static SpaResult

2
spa/tests/test-props.c
View file

@ -151,7 +151,7 @@ main (int argc, char *argv[])
SpaFormat *fmt; SpaFormat *fmt;
SpaIDMap *map = spa_id_map_get_default(); SpaIDMap *map = spa_id_map_get_default();
format_type = spa_id_map_get_id (map, SPA_FORMAT_URI); format_type = spa_id_map_get_id (map, SPA_TYPE__Format);
spa_media_types_fill (&media_types, map); spa_media_types_fill (&media_types, map);
spa_media_subtypes_map (map, &media_subtypes); spa_media_subtypes_map (map, &media_subtypes);
spa_prop_video_map (map, &prop_video); spa_prop_video_map (map, &prop_video);

12
spa/tools/spa-inspect.c
View file

@ -196,18 +196,18 @@ main (int argc, char *argv[])
data.loop.update_source = do_update_source; data.loop.update_source = do_update_source;
data.loop.remove_source = do_remove_source; data.loop.remove_source = do_remove_source;
data.support[0].uri = SPA_ID_MAP_URI; data.support[0].uri = SPA_TYPE__IDMap;
data.support[0].data = data.map; data.support[0].data = data.map;
data.support[1].uri = SPA_LOG_URI; data.support[1].uri = SPA_TYPE__Log;
data.support[1].data = data.log; data.support[1].data = data.log;
data.support[2].uri = SPA_LOOP__MainLoop; data.support[2].uri = SPA_TYPE_LOOP__MainLoop;
data.support[2].data = &data.loop; data.support[2].data = &data.loop;
data.support[3].uri = SPA_LOOP__DataLoop; data.support[3].uri = SPA_TYPE_LOOP__DataLoop;
data.support[3].data = &data.loop; data.support[3].data = &data.loop;
data.n_support = 4; data.n_support = 4;
data.uri.node = spa_id_map_get_id (data.map, SPA_NODE_URI); data.uri.node = spa_id_map_get_id (data.map, SPA_TYPE__Node);
data.uri.clock = spa_id_map_get_id (data.map, SPA_CLOCK_URI); data.uri.clock = spa_id_map_get_id (data.map, SPA_TYPE__Clock);
if ((handle = dlopen (argv[1], RTLD_NOW)) == NULL) { if ((handle = dlopen (argv[1], RTLD_NOW)) == NULL) {
printf ("can't load %s\n", argv[1]); printf ("can't load %s\n", argv[1]);

8
spa/tools/spa-monitor.c
View file

@ -176,11 +176,11 @@ main (int argc, char *argv[])
data.main_loop.update_source = do_update_source; data.main_loop.update_source = do_update_source;
data.main_loop.remove_source = do_remove_source; data.main_loop.remove_source = do_remove_source;
data.support[0].uri = SPA_ID_MAP_URI; data.support[0].uri = SPA_TYPE__IDMap;
data.support[0].data = data.map; data.support[0].data = data.map;
data.support[1].uri = SPA_LOG_URI; data.support[1].uri = SPA_TYPE__Log;
data.support[1].data = data.log; data.support[1].data = data.log;
data.support[2].uri = SPA_LOOP__MainLoop; data.support[2].uri = SPA_TYPE_LOOP__MainLoop;
data.support[2].data = &data.main_loop; data.support[2].data = &data.main_loop;
data.n_support = 3; data.n_support = 3;
@ -219,7 +219,7 @@ main (int argc, char *argv[])
break; break;
} }
if (!strcmp (info->uri, SPA_MONITOR_URI)) { if (!strcmp (info->uri, SPA_TYPE__Monitor)) {
SpaHandle *handle; SpaHandle *handle;
void *interface; void *interface;