mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

types: work on types

Browse source 
Move static pod types to type system
work on type info for types
Move the event and command ids to an enum to make it easier to extend
later.
This commit is contained in:
Wim Taymans 2018-08-24 10:53:09 +02:00
parent fca3e1d85d
commit 805e3bb6c1
82 changed files with 812 additions and 924 deletions
Download patch file Download diff file Expand all files Collapse all files

6
spa/include/spa/buffer/buffer-types.h
View file

@ -39,9 +39,9 @@ extern "C" {
#define SPA_TYPE_DATA_FD_BASE SPA_TYPE_DATA__Fd ":" #define SPA_TYPE_DATA_FD_BASE SPA_TYPE_DATA__Fd ":"
static const struct spa_type_info spa_type_data_type[] = { static const struct spa_type_info spa_type_data_type[] = {
{ SPA_DATA_MemPtr, SPA_TYPE_DATA_BASE "MemPtr", SPA_POD_TYPE_INT, }, { SPA_DATA_MemPtr, SPA_TYPE_DATA_BASE "MemPtr", SPA_ID_INT, },
{ SPA_DATA_MemFd, SPA_TYPE_DATA_FD_BASE "MemFd", SPA_POD_TYPE_INT, }, { SPA_DATA_MemFd, SPA_TYPE_DATA_FD_BASE "MemFd", SPA_ID_INT, },
{ SPA_DATA_DmaBuf, SPA_TYPE_DATA_FD_BASE "DmaBuf", SPA_POD_TYPE_INT, }, { SPA_DATA_DmaBuf, SPA_TYPE_DATA_FD_BASE "DmaBuf", SPA_ID_INT, },
{ 0, NULL, }, { 0, NULL, },
}; };

6
spa/include/spa/buffer/meta-types.h
View file

@ -37,9 +37,9 @@ extern "C" {
#define SPA_TYPE_META_REGION_ARRAY_BASE SPA_TYPE_META__RegionArray ":" #define SPA_TYPE_META_REGION_ARRAY_BASE SPA_TYPE_META__RegionArray ":"
static const struct spa_type_info spa_type_meta_type[] = { static const struct spa_type_info spa_type_meta_type[] = {
{ SPA_META_Header, SPA_TYPE_META_BASE "Header", SPA_POD_TYPE_INT, }, { SPA_META_Header, SPA_TYPE_META_BASE "Header", SPA_ID_POINTER },
{ SPA_META_VideoCrop, SPA_TYPE_META_REGION_BASE "VideoCrop", SPA_POD_TYPE_INT, }, { SPA_META_VideoCrop, SPA_TYPE_META_REGION_BASE "VideoCrop", SPA_ID_POINTER },
{ SPA_META_VideoDamage, SPA_TYPE_META_REGION_ARRAY_BASE "VideoDamage", SPA_POD_TYPE_INT, }, { SPA_META_VideoDamage, SPA_TYPE_META_REGION_ARRAY_BASE "VideoDamage", SPA_ID_POINTER },
{ 0, NULL, }, { 0, NULL, },
}; };

66
spa/include/spa/debug/format.h
View file

@ -34,11 +34,11 @@ spa_debug_format_value(const struct spa_type_info *info,
uint32_t type, void *body, uint32_t size) uint32_t type, void *body, uint32_t size)
{ {
switch (type) { switch (type) {
case SPA_POD_TYPE_BOOL: case SPA_ID_Bool:
fprintf(stderr, "%s", *(int32_t *) body ? "true" : "false"); fprintf(stderr, "%s", *(int32_t *) body ? "true" : "false");
break; break;
case SPA_POD_TYPE_ID: case SPA_ID_Enum:
case SPA_POD_TYPE_INT: case SPA_ID_Int:
{ {
const char *str = spa_debug_type_find_name(info, *(int32_t *) body); const char *str = spa_debug_type_find_name(info, *(int32_t *) body);
char tmp[64]; char tmp[64];
@ -53,37 +53,38 @@ spa_debug_format_value(const struct spa_type_info *info,
fprintf(stderr, "%s", str); fprintf(stderr, "%s", str);
break; break;
} }
case SPA_POD_TYPE_LONG: case SPA_ID_Long:
fprintf(stderr, "%" PRIi64, *(int64_t *) body); fprintf(stderr, "%" PRIi64, *(int64_t *) body);
break; break;
case SPA_POD_TYPE_FLOAT: case SPA_ID_Float:
fprintf(stderr, "%f", *(float *) body); fprintf(stderr, "%f", *(float *) body);
break; break;
case SPA_POD_TYPE_DOUBLE: case SPA_ID_Double:
fprintf(stderr, "%g", *(double *) body); fprintf(stderr, "%g", *(double *) body);
break; break;
case SPA_POD_TYPE_STRING: case SPA_ID_String:
fprintf(stderr, "%s", (char *) body); fprintf(stderr, "%s", (char *) body);
break; break;
case SPA_POD_TYPE_RECTANGLE: case SPA_ID_Rectangle:
{ {
struct spa_rectangle *r = body; struct spa_rectangle *r = body;
fprintf(stderr, "%" PRIu32 "x%" PRIu32, r->width, r->height); fprintf(stderr, "%" PRIu32 "x%" PRIu32, r->width, r->height);
break; break;
} }
case SPA_POD_TYPE_FRACTION: case SPA_ID_Fraction:
{ {
struct spa_fraction *f = body; struct spa_fraction *f = body;
fprintf(stderr, "%" PRIu32 "/%" PRIu32, f->num, f->denom); fprintf(stderr, "%" PRIu32 "/%" PRIu32, f->num, f->denom);
break; break;
} }
case SPA_POD_TYPE_BITMAP: case SPA_ID_Bitmap:
fprintf(stderr, "Bitmap"); fprintf(stderr, "Bitmap");
break; break;
case SPA_POD_TYPE_BYTES: case SPA_ID_Bytes:
fprintf(stderr, "Bytes"); fprintf(stderr, "Bytes");
break; break;
default: default:
fprintf(stderr, "INVALID type %d", type);
break; break;
} }
return 0; return 0;
@ -98,29 +99,28 @@ static inline int spa_debug_format(int indent,
struct spa_pod *pod; struct spa_pod *pod;
uint32_t mtype, mstype; uint32_t mtype, mstype;
const char *pod_type_names[] = { const char *pod_type_names[] = {
[SPA_POD_TYPE_INVALID] = "invalid", [SPA_ID_None] = "none",
[SPA_POD_TYPE_NONE] = "none", [SPA_ID_Bool] = "bool",
[SPA_POD_TYPE_BOOL] = "bool", [SPA_ID_Enum] = "enum",
[SPA_POD_TYPE_ID] = "id", [SPA_ID_Int] = "int",
[SPA_POD_TYPE_INT] = "int", [SPA_ID_Long] = "long",
[SPA_POD_TYPE_LONG] = "long", [SPA_ID_Float] = "float",
[SPA_POD_TYPE_FLOAT] = "float", [SPA_ID_Double] = "double",
[SPA_POD_TYPE_DOUBLE] = "double", [SPA_ID_String] = "string",
[SPA_POD_TYPE_STRING] = "string", [SPA_ID_Bytes] = "bytes",
[SPA_POD_TYPE_BYTES] = "bytes", [SPA_ID_Rectangle] = "rectangle",
[SPA_POD_TYPE_RECTANGLE] = "rectangle", [SPA_ID_Fraction] = "fraction",
[SPA_POD_TYPE_FRACTION] = "fraction", [SPA_ID_Bitmap] = "bitmap",
[SPA_POD_TYPE_BITMAP] = "bitmap", [SPA_ID_Array] = "array",
[SPA_POD_TYPE_ARRAY] = "array", [SPA_ID_Struct] = "struct",
[SPA_POD_TYPE_STRUCT] = "struct", [SPA_ID_Object] = "object",
[SPA_POD_TYPE_OBJECT] = "object", [SPA_ID_Pointer] = "pointer",
[SPA_POD_TYPE_POINTER] = "pointer", [SPA_ID_Fd] = "fd",
[SPA_POD_TYPE_FD] = "fd", [SPA_ID_Prop] = "prop",
[SPA_POD_TYPE_PROP] = "prop", [SPA_ID_Pod] = "pod"
[SPA_POD_TYPE_POD] = "pod"
}; };
if (format == NULL || SPA_POD_TYPE(format) != SPA_POD_TYPE_OBJECT) if (format == NULL || SPA_POD_TYPE(format) != SPA_ID_Object)
return -EINVAL; return -EINVAL;
@ -143,7 +143,7 @@ static inline int spa_debug_format(int indent,
const char *key; const char *key;
const struct spa_type_info *ti; const struct spa_type_info *ti;
if (pod->type != SPA_POD_TYPE_PROP) if (pod->type != SPA_ID_Prop)
continue; continue;
prop = (struct spa_pod_prop *)pod; prop = (struct spa_pod_prop *)pod;

38
spa/include/spa/debug/pod.h
View file

@ -38,54 +38,54 @@ spa_debug_pod_value(int indent, const struct spa_type_info *info,
uint32_t type, void *body, uint32_t size) uint32_t type, void *body, uint32_t size)
{ {
switch (type) { switch (type) {
case SPA_POD_TYPE_BOOL: case SPA_ID_Bool:
spa_debug("%*s" "Bool %d", indent, "", *(int32_t *) body); spa_debug("%*s" "Bool %d", indent, "", *(int32_t *) body);
break; break;
case SPA_POD_TYPE_ID: case SPA_ID_Enum:
spa_debug("%*s" "Id %d %s", indent, "", *(int32_t *) body, spa_debug("%*s" "Enum %d %s", indent, "", *(int32_t *) body,
spa_debug_type_find_name(info, *(int32_t *) body)); spa_debug_type_find_name(info, *(int32_t *) body));
break; break;
case SPA_POD_TYPE_INT: case SPA_ID_Int:
spa_debug("%*s" "Int %d", indent, "", *(int32_t *) body); spa_debug("%*s" "Int %d", indent, "", *(int32_t *) body);
break; break;
case SPA_POD_TYPE_LONG: case SPA_ID_Long:
spa_debug("%*s" "Long %" PRIi64 "", indent, "", *(int64_t *) body); spa_debug("%*s" "Long %" PRIi64 "", indent, "", *(int64_t *) body);
break; break;
case SPA_POD_TYPE_FLOAT: case SPA_ID_Float:
spa_debug("%*s" "Float %f", indent, "", *(float *) body); spa_debug("%*s" "Float %f", indent, "", *(float *) body);
break; break;
case SPA_POD_TYPE_DOUBLE: case SPA_ID_Double:
spa_debug("%*s" "Double %f", indent, "", *(double *) body); spa_debug("%*s" "Double %f", indent, "", *(double *) body);
break; break;
case SPA_POD_TYPE_STRING: case SPA_ID_String:
spa_debug("%*s" "String \"%s\"", indent, "", (char *) body); spa_debug("%*s" "String \"%s\"", indent, "", (char *) body);
break; break;
case SPA_POD_TYPE_FD: case SPA_ID_Fd:
spa_debug("%*s" "Fd %d", indent, "", *(int *) body); spa_debug("%*s" "Fd %d", indent, "", *(int *) body);
break; break;
case SPA_POD_TYPE_POINTER: case SPA_ID_Pointer:
{ {
struct spa_pod_pointer_body *b = body; struct spa_pod_pointer_body *b = body;
spa_debug("%*s" "Pointer %s %p", indent, "", spa_debug("%*s" "Pointer %s %p", indent, "",
spa_debug_type_find_name(info, b->type), b->value); spa_debug_type_find_name(info, b->type), b->value);
break; break;
} }
case SPA_POD_TYPE_RECTANGLE: case SPA_ID_Rectangle:
{ {
struct spa_rectangle *r = body; struct spa_rectangle *r = body;
spa_debug("%*s" "Rectangle %dx%d", indent, "", r->width, r->height); spa_debug("%*s" "Rectangle %dx%d", indent, "", r->width, r->height);
break; break;
} }
case SPA_POD_TYPE_FRACTION: case SPA_ID_Fraction:
{ {
struct spa_fraction *f = body; struct spa_fraction *f = body;
spa_debug("%*s" "Fraction %d/%d", indent, "", f->num, f->denom); spa_debug("%*s" "Fraction %d/%d", indent, "", f->num, f->denom);
break; break;
} }
case SPA_POD_TYPE_BITMAP: case SPA_ID_Bitmap:
spa_debug("%*s" "Bitmap", indent, ""); spa_debug("%*s" "Bitmap", indent, "");
break; break;
case SPA_POD_TYPE_ARRAY: case SPA_ID_Array:
{ {
struct spa_pod_array_body *b = body; struct spa_pod_array_body *b = body;
void *p; void *p;
@ -96,7 +96,7 @@ spa_debug_pod_value(int indent, const struct spa_type_info *info,
spa_debug_pod_value(indent + 2, info, b->child.type, p, b->child.size); spa_debug_pod_value(indent + 2, info, b->child.type, p, b->child.size);
break; break;
} }
case SPA_POD_TYPE_STRUCT: case SPA_ID_Struct:
{ {
struct spa_pod *b = body, *p; struct spa_pod *b = body, *p;
spa_debug("%*s" "Struct: size %d", indent, "", size); spa_debug("%*s" "Struct: size %d", indent, "", size);
@ -104,7 +104,7 @@ spa_debug_pod_value(int indent, const struct spa_type_info *info,
spa_debug_pod_value(indent + 2, info, p->type, SPA_POD_BODY(p), p->size); spa_debug_pod_value(indent + 2, info, p->type, SPA_POD_BODY(p), p->size);
break; break;
} }
case SPA_POD_TYPE_OBJECT: case SPA_ID_Object:
{ {
struct spa_pod_object_body *b = body; struct spa_pod_object_body *b = body;
struct spa_pod *p; struct spa_pod *p;
@ -117,7 +117,7 @@ spa_debug_pod_value(int indent, const struct spa_type_info *info,
p->type, SPA_POD_BODY(p), p->size); p->type, SPA_POD_BODY(p), p->size);
break; break;
} }
case SPA_POD_TYPE_PROP: case SPA_ID_Prop:
{ {
struct spa_pod_prop_body *b = body; struct spa_pod_prop_body *b = body;
void *alt; void *alt;
@ -176,11 +176,11 @@ spa_debug_pod_value(int indent, const struct spa_type_info *info,
} }
break; break;
} }
case SPA_POD_TYPE_BYTES: case SPA_ID_Bytes:
spa_debug("%*s" "Bytes", indent, ""); spa_debug("%*s" "Bytes", indent, "");
spa_debug_mem(indent + 2, body, size); spa_debug_mem(indent + 2, body, size);
break; break;
case SPA_POD_TYPE_NONE: case SPA_ID_None:
spa_debug("%*s" "None", indent, ""); spa_debug("%*s" "None", indent, "");
spa_debug_mem(indent + 2, body, size); spa_debug_mem(indent + 2, body, size);
break; break;

9
spa/include/spa/debug/types.h
View file

@ -24,16 +24,11 @@
extern "C" { extern "C" {
#endif #endif
#include <spa/monitor/monitor-types.h> #include <spa/utils/type-info.h>
#include <spa/node/node-types.h>
#include <spa/param/buffers.h>
#include <spa/param/buffers-types.h>
static const struct spa_type_info spa_debug_types[] = static const struct spa_type_info spa_debug_types[] =
{ {
{ SPA_ID_INVALID, "", SPA_POD_TYPE_ID, spa_type_monitor }, { SPA_ID_INVALID, "", SPA_ID_Enum, spa_types },
{ SPA_ID_INVALID, "", SPA_POD_TYPE_ID, spa_type_node },
{ SPA_ID_INVALID, "", SPA_POD_TYPE_ID, spa_type_param_buffers },
{ 0, NULL, }, { 0, NULL, },
}; };

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

@ -31,6 +31,14 @@ struct spa_monitor;
#include <spa/pod/event.h> #include <spa/pod/event.h>
#include <spa/pod/builder.h> #include <spa/pod/builder.h>
enum spa_monitor_event {
SPA_MONITOR_EVENT_Added,
SPA_MONITOR_EVENT_Removed,
SPA_MONITOR_EVENT_Changed,
};
#define SPA_MONITOR_EVENT_ID(ev) SPA_EVENT_ID(ev, SPA_ID_EVENT_Monitor)
/** properties for SPA_ID_OBJECT_MonitorItem */ /** properties for SPA_ID_OBJECT_MonitorItem */
enum spa_monitor_item { enum spa_monitor_item {
SPA_MONITOR_ITEM_id, SPA_MONITOR_ITEM_id,

46
spa/include/spa/monitor/monitor-types.h → spa/include/spa/monitor/type-info.h
View file

@ -24,19 +24,14 @@
extern "C" { extern "C" {
#endif #endif
#include <spa/utils/type.h> #include <spa/utils/type-info.h>
#include <spa/monitor/monitor.h> #include <spa/monitor/monitor.h>
#include <spa/pod/event-types.h>
#define SPA_TYPE_EVENT__Monitor SPA_TYPE_EVENT_BASE "Monitor"
#define SPA_TYPE_EVENT_MONITOR_BASE SPA_TYPE_EVENT__Monitor ":"
#define SPA_TYPE__MonitorItemFlags SPA_TYPE_FLAGS_BASE "MonitorItemFlags" #define SPA_TYPE__MonitorItemFlags SPA_TYPE_FLAGS_BASE "MonitorItemFlags"
#define SPA_TYPE_MONITOR_ITEM_FLAGS_BASE SPA_TYPE__MonitorItemFlags ":" #define SPA_TYPE_MONITOR_ITEM_FLAGS_BASE SPA_TYPE__MonitorItemFlags ":"
static const struct spa_type_info spa_type_monitor_item_flags[] = { static const struct spa_type_info spa_type_monitor_item_flags[] = {
{ SPA_MONITOR_ITEM_FLAG_NONE, SPA_TYPE_MONITOR_ITEM_FLAGS_BASE "none", SPA_POD_TYPE_INT, }, { SPA_MONITOR_ITEM_FLAG_NONE, SPA_TYPE_MONITOR_ITEM_FLAGS_BASE "none", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };
@ -44,38 +39,25 @@ static const struct spa_type_info spa_type_monitor_item_flags[] = {
#define SPA_TYPE_MONITOR_ITEM_STATE_BASE SPA_TYPE__MonitorItemState ":" #define SPA_TYPE_MONITOR_ITEM_STATE_BASE SPA_TYPE__MonitorItemState ":"
static const struct spa_type_info spa_type_monitor_item_state[] = { static const struct spa_type_info spa_type_monitor_item_state[] = {
{ SPA_MONITOR_ITEM_STATE_AVAILABLE, SPA_TYPE_MONITOR_ITEM_STATE_BASE "available", SPA_POD_TYPE_INT, }, { SPA_MONITOR_ITEM_STATE_AVAILABLE, SPA_TYPE_MONITOR_ITEM_STATE_BASE "available", SPA_ID_Int, },
{ SPA_MONITOR_ITEM_STATE_DISABLED, SPA_TYPE_MONITOR_ITEM_STATE_BASE "disabled", SPA_POD_TYPE_INT, }, { SPA_MONITOR_ITEM_STATE_DISABLED, SPA_TYPE_MONITOR_ITEM_STATE_BASE "disabled", SPA_ID_Int, },
{ SPA_MONITOR_ITEM_STATE_UNAVAILABLE, SPA_TYPE_MONITOR_ITEM_STATE_BASE "unavailable", SPA_POD_TYPE_INT, }, { SPA_MONITOR_ITEM_STATE_UNAVAILABLE, SPA_TYPE_MONITOR_ITEM_STATE_BASE "unavailable", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };
#define SPA_TYPE__MonitorItem SPA_TYPE_POD_OBJECT_BASE "MonitorItem" #define SPA_TYPE__MonitorItem SPA_TYPE_OBJECT_BASE "MonitorItem"
#define SPA_TYPE_MONITOR_ITEM_BASE SPA_TYPE__MonitorItem ":" #define SPA_TYPE_MONITOR_ITEM_BASE SPA_TYPE__MonitorItem ":"
static const struct spa_type_info spa_type_monitor_item_ids[] = { static const struct spa_type_info spa_type_monitor_item[] = {
{ SPA_MONITOR_ITEM_id, SPA_TYPE_MONITOR_ITEM_BASE "id", SPA_POD_TYPE_STRING, }, { SPA_MONITOR_ITEM_id, SPA_TYPE_MONITOR_ITEM_BASE "id", SPA_ID_String, },
{ SPA_MONITOR_ITEM_flags, SPA_TYPE_MONITOR_ITEM_BASE "flags", SPA_POD_TYPE_INT, { SPA_MONITOR_ITEM_flags, SPA_TYPE_MONITOR_ITEM_BASE "flags", SPA_ID_Enum,
spa_type_monitor_item_flags }, spa_type_monitor_item_flags },
{ SPA_MONITOR_ITEM_state, SPA_TYPE_MONITOR_ITEM_BASE "state", SPA_POD_TYPE_INT, { SPA_MONITOR_ITEM_state, SPA_TYPE_MONITOR_ITEM_BASE "state", SPA_ID_Enum,
spa_type_monitor_item_state }, spa_type_monitor_item_state },
{ SPA_MONITOR_ITEM_name, SPA_TYPE_MONITOR_ITEM_BASE "name", SPA_POD_TYPE_STRING, }, { SPA_MONITOR_ITEM_name, SPA_TYPE_MONITOR_ITEM_BASE "name", SPA_ID_String, },
{ SPA_MONITOR_ITEM_class, SPA_TYPE_MONITOR_ITEM_BASE "class", SPA_POD_TYPE_STRING, }, { SPA_MONITOR_ITEM_class, SPA_TYPE_MONITOR_ITEM_BASE "class", SPA_ID_String, },
{ SPA_MONITOR_ITEM_info, SPA_TYPE_MONITOR_ITEM_BASE "info", SPA_POD_TYPE_POD, }, { SPA_MONITOR_ITEM_info, SPA_TYPE_MONITOR_ITEM_BASE "info", SPA_ID_Pod, },
{ SPA_MONITOR_ITEM_factory, SPA_TYPE_MONITOR_ITEM_BASE "factory", SPA_POD_TYPE_POINTER, }, { SPA_MONITOR_ITEM_factory, SPA_TYPE_MONITOR_ITEM_BASE "factory", SPA_ID_Pointer, },
{ 0, NULL, },
};
#define SPA_TYPE__Monitor SPA_TYPE_INTERFACE_BASE "Monitor"
#define SPA_TYPE_MONITOR_BASE SPA_TYPE__Monitor ":"
static const struct spa_type_info spa_type_monitor[] = {
{ SPA_ID_INTERFACE_Monitor, SPA_TYPE__Monitor, SPA_POD_TYPE_ID, },
{ SPA_ID_EVENT_MONITOR_Added, SPA_TYPE_EVENT_MONITOR_BASE "Added", SPA_POD_TYPE_ID, },
{ SPA_ID_EVENT_MONITOR_Removed, SPA_TYPE_EVENT_MONITOR_BASE "Removed", SPA_POD_TYPE_ID, },
{ SPA_ID_EVENT_MONITOR_Changed, SPA_TYPE_EVENT_MONITOR_BASE "Changed", SPA_POD_TYPE_ID, },
{ SPA_ID_OBJECT_MonitorItem, SPA_TYPE__MonitorItem, SPA_POD_TYPE_OBJECT,
spa_type_monitor_item_ids},
{ 0, NULL, }, { 0, NULL, },
}; };

55
spa/include/spa/node/command-types.h
View file

@ -1,55 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_COMMAND_NODE_TYPES_H__
#define __SPA_COMMAND_NODE_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/utils/type-info.h>
#include <spa/node/command.h>
#define SPA_TYPE_COMMAND__Node SPA_TYPE_COMMAND_BASE "Node"
#define SPA_TYPE_COMMAND_NODE_BASE SPA_TYPE_COMMAND__Node ":"
/** Suspend a node. This will release all resources of the node */
#define SPA_TYPE_COMMAND_NODE__Suspend SPA_TYPE_COMMAND_NODE_BASE "Suspend"
/** Pause processing of a node */
#define SPA_TYPE_COMMAND_NODE__Pause SPA_TYPE_COMMAND_NODE_BASE "Pause"
/** Start processing of a node */
#define SPA_TYPE_COMMAND_NODE__Start SPA_TYPE_COMMAND_NODE_BASE "Start"
/** Enable ports of a node. When sent to a port, enables just that port. Enabled
* ports on a Started node begin streaming immediately */
#define SPA_TYPE_COMMAND_NODE__Enable SPA_TYPE_COMMAND_NODE_BASE "Enable"
/** Disable ports of a node. When sent to a port, disables just that port. */
#define SPA_TYPE_COMMAND_NODE__Disable SPA_TYPE_COMMAND_NODE_BASE "Disable"
/** Flush all data from the node or port */
#define SPA_TYPE_COMMAND_NODE__Flush SPA_TYPE_COMMAND_NODE_BASE "Flush"
/** Drain all data from the node or port */
#define SPA_TYPE_COMMAND_NODE__Drain SPA_TYPE_COMMAND_NODE_BASE "Drain"
/** Set a marker on a node or port */
#define SPA_TYPE_COMMAND_NODE__Marker SPA_TYPE_COMMAND_NODE_BASE "Marker"
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* _SPA_COMMAND_NODE_TYPES_H__ */

17
spa/include/spa/node/command.h
View file

@ -26,6 +26,23 @@ extern "C" {
#include <spa/pod/command.h> #include <spa/pod/command.h>
enum spa_node_command {
SPA_NODE_COMMAND_Suspend,
SPA_NODE_COMMAND_Pause,
SPA_NODE_COMMAND_Start,
SPA_NODE_COMMAND_Enable,
SPA_NODE_COMMAND_Disable,
SPA_NODE_COMMAND_Flush,
SPA_NODE_COMMAND_Drain,
SPA_NODE_COMMAND_Marker,
};
#define SPA_NODE_COMMAND_ID(cmd) SPA_COMMAND_ID(cmd, SPA_ID_COMMAND_Node)
#define SPA_NODE_COMMAND_INIT(id) (struct spa_command) \
{ { sizeof(struct spa_command_body), SPA_ID_Object }, \
{ { id, SPA_ID_COMMAND_Node } } } \
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif

41
spa/include/spa/node/event-types.h
View file

@ -1,41 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_EVENT_NODE_TYPES_H__
#define __SPA_EVENT_NODE_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/utils/type-info.h>
#include <spa/node/event.h>
#define SPA_TYPE_EVENT__Node SPA_TYPE_EVENT_BASE "Node"
#define SPA_TYPE_EVENT_NODE_BASE SPA_TYPE_EVENT__Node ":"
#define SPA_TYPE_EVENT_NODE__Error SPA_TYPE_EVENT_NODE_BASE "Error"
#define SPA_TYPE_EVENT_NODE__Buffering SPA_TYPE_EVENT_NODE_BASE "Buffering"
#define SPA_TYPE_EVENT_NODE__RequestRefresh SPA_TYPE_EVENT_NODE_BASE "RequestRefresh"
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_EVENT_NODE_TYPES_H__ */

8
spa/include/spa/node/event.h
View file

@ -28,6 +28,14 @@ extern "C" {
#include <spa/pod/event.h> #include <spa/pod/event.h>
#include <spa/node/node.h> #include <spa/node/node.h>
enum spa_node_event {
SPA_NODE_EVENT_Error,
SPA_NODE_EVENT_Buffering,
SPA_NODE_EVENT_RequestRefresh,
};
#define SPA_NODE_EVENT_ID(ev) SPA_EVENT_ID(ev, SPA_ID_EVENT_Node)
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif

42
spa/include/spa/node/node-types.h
View file

@ -1,42 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_NODE_TYPES_H__
#define __SPA_NODE_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/utils/type-info.h>
#include <spa/node/node.h>
#define SPA_TYPE__Node SPA_TYPE_INTERFACE_BASE "Node"
#define SPA_TYPE_NODE_BASE SPA_TYPE__Node ":"
static const struct spa_type_info spa_type_node[] = {
{ SPA_ID_INTERFACE_Node, SPA_TYPE__Node, SPA_POD_TYPE_ID, },
{ 0, NULL, },
};
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_NODE_TYPES_H__ */

9
spa/include/spa/node/io-types.h → spa/include/spa/node/type-info.h
View file

@ -17,14 +17,17 @@
* Boston, MA 02110-1301, USA. * Boston, MA 02110-1301, USA.
*/ */
#ifndef __SPA_IO_TYPES_H__ #ifndef __SPA_NODE_TYPES_H__
#define __SPA_IO_TYPES_H__ #define __SPA_NODE_TYPES_H__
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <spa/utils/type-info.h> #include <spa/utils/type-info.h>
#include <spa/node/command.h>
#include <spa/node/event.h>
#include <spa/node/io.h> #include <spa/node/io.h>
/** Base for IO structures to interface with node ports */ /** Base for IO structures to interface with node ports */
@ -48,4 +51,4 @@ extern "C" {
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* __SPA_IO_TYPES_H__ */ #endif /* _SPA_NODE_TYPES_H__ */

12
spa/include/spa/param/audio/format-types.h
View file

@ -31,15 +31,15 @@ extern "C" {
#define SPA_TYPE_FORMAT_AUDIO_BASE SPA_TYPE__FormatAudio ":" #define SPA_TYPE_FORMAT_AUDIO_BASE SPA_TYPE__FormatAudio ":"
static const struct spa_type_info spa_type_format_audio_ids[] = { static const struct spa_type_info spa_type_format_audio_ids[] = {
{ SPA_FORMAT_AUDIO_format, SPA_TYPE_FORMAT_AUDIO_BASE "format", SPA_POD_TYPE_INT, { SPA_FORMAT_AUDIO_format, SPA_TYPE_FORMAT_AUDIO_BASE "format", SPA_ID_Enum,
spa_type_audio_format }, spa_type_audio_format },
{ SPA_FORMAT_AUDIO_flags, SPA_TYPE_FORMAT_AUDIO_BASE "flags", SPA_POD_TYPE_INT, { SPA_FORMAT_AUDIO_flags, SPA_TYPE_FORMAT_AUDIO_BASE "flags", SPA_ID_Enum,
spa_type_audio_flags }, spa_type_audio_flags },
{ SPA_FORMAT_AUDIO_layout, SPA_TYPE_FORMAT_AUDIO_BASE "layout", SPA_POD_TYPE_INT, { SPA_FORMAT_AUDIO_layout, SPA_TYPE_FORMAT_AUDIO_BASE "layout", SPA_ID_Enum,
spa_type_audio_layout }, spa_type_audio_layout },
{ SPA_FORMAT_AUDIO_rate, SPA_TYPE_FORMAT_AUDIO_BASE "rate", SPA_POD_TYPE_INT, }, { SPA_FORMAT_AUDIO_rate, SPA_TYPE_FORMAT_AUDIO_BASE "rate", SPA_ID_Int, },
{ SPA_FORMAT_AUDIO_channels, SPA_TYPE_FORMAT_AUDIO_BASE "channels", SPA_POD_TYPE_INT, }, { SPA_FORMAT_AUDIO_channels, SPA_TYPE_FORMAT_AUDIO_BASE "channels", SPA_ID_Int, },
{ SPA_FORMAT_AUDIO_channelMask, SPA_TYPE_FORMAT_AUDIO_BASE "channelMask", SPA_POD_TYPE_INT, }, { SPA_FORMAT_AUDIO_channelMask, SPA_TYPE_FORMAT_AUDIO_BASE "channelMask", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };

72
spa/include/spa/param/audio/raw-types.h
View file

@ -30,38 +30,38 @@ extern "C" {
#define SPA_TYPE_AUDIO_FORMAT_BASE SPA_TYPE__AudioFormat ":" #define SPA_TYPE_AUDIO_FORMAT_BASE SPA_TYPE__AudioFormat ":"
static const struct spa_type_info spa_type_audio_format[] = { static const struct spa_type_info spa_type_audio_format[] = {
{ SPA_AUDIO_FORMAT_UNKNOWN, SPA_TYPE_AUDIO_FORMAT_BASE "UNKNOWN", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_UNKNOWN, SPA_TYPE_AUDIO_FORMAT_BASE "UNKNOWN", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_ENCODED, SPA_TYPE_AUDIO_FORMAT_BASE "ENCODED", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_ENCODED, SPA_TYPE_AUDIO_FORMAT_BASE "ENCODED", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S8, SPA_TYPE_AUDIO_FORMAT_BASE "S8", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S8, SPA_TYPE_AUDIO_FORMAT_BASE "S8", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U8, SPA_TYPE_AUDIO_FORMAT_BASE "U8", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U8, SPA_TYPE_AUDIO_FORMAT_BASE "U8", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S16_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S16LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S16_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S16LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S16_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S16BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S16_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S16BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U16_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U16LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U16_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U16LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U16_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U16BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U16_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U16BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S24_32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S24_32LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S24_32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S24_32LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S24_32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S24_32BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S24_32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S24_32BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U24_32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U24_32LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U24_32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U24_32LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U24_32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U24_32BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U24_32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U24_32BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S32LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S32LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S32BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S32BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U32LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U32LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U32BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U32BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S24_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S24LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S24_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S24LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S24_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S24BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S24_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S24BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U24_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U24LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U24_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U24LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U24_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U24BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U24_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U24BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S20_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S20LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S20_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S20LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S20_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S20BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S20_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S20BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U20_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U20LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U20_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U20LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U20_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U20BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U20_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U20BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S18_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S18LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S18_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S18LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_S18_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S18BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_S18_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S18BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U18_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U18LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U18_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U18LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_U18_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U18BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_U18_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U18BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_F32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "F32LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_F32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "F32LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_F32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "F32BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_F32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "F32BE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_F64_LE, SPA_TYPE_AUDIO_FORMAT_BASE "F64LE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_F64_LE, SPA_TYPE_AUDIO_FORMAT_BASE "F64LE", SPA_ID_Int, },
{ SPA_AUDIO_FORMAT_F64_BE, SPA_TYPE_AUDIO_FORMAT_BASE "F64BE", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FORMAT_F64_BE, SPA_TYPE_AUDIO_FORMAT_BASE "F64BE", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };
@ -69,8 +69,8 @@ static const struct spa_type_info spa_type_audio_format[] = {
#define SPA_TYPE_AUDIO_FLAGS_BASE SPA_TYPE__AudioFlags ":" #define SPA_TYPE_AUDIO_FLAGS_BASE SPA_TYPE__AudioFlags ":"
static const struct spa_type_info spa_type_audio_flags[] = { static const struct spa_type_info spa_type_audio_flags[] = {
{ SPA_AUDIO_FLAG_NONE, SPA_TYPE_AUDIO_FLAGS_BASE "none", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FLAG_NONE, SPA_TYPE_AUDIO_FLAGS_BASE "none", SPA_ID_Int, },
{ SPA_AUDIO_FLAG_UNPOSITIONED, SPA_TYPE_AUDIO_FLAGS_BASE "unpositioned", SPA_POD_TYPE_INT, }, { SPA_AUDIO_FLAG_UNPOSITIONED, SPA_TYPE_AUDIO_FLAGS_BASE "unpositioned", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };
@ -78,8 +78,8 @@ static const struct spa_type_info spa_type_audio_flags[] = {
#define SPA_TYPE_AUDIO_ENUM_BASE SPA_TYPE__AudioLayout ":" #define SPA_TYPE_AUDIO_ENUM_BASE SPA_TYPE__AudioLayout ":"
static const struct spa_type_info spa_type_audio_layout[] = { static const struct spa_type_info spa_type_audio_layout[] = {
{ SPA_AUDIO_LAYOUT_INTERLEAVED, SPA_TYPE_AUDIO_ENUM_BASE "interleaved", SPA_POD_TYPE_INT, }, { SPA_AUDIO_LAYOUT_INTERLEAVED, SPA_TYPE_AUDIO_ENUM_BASE "interleaved", SPA_ID_Int, },
{ SPA_AUDIO_LAYOUT_NON_INTERLEAVED, SPA_TYPE_AUDIO_ENUM_BASE "non-interleaved", SPA_POD_TYPE_INT, }, { SPA_AUDIO_LAYOUT_NON_INTERLEAVED, SPA_TYPE_AUDIO_ENUM_BASE "non-interleaved", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };

12
spa/include/spa/param/buffers-types.h
View file

@ -37,16 +37,16 @@ extern "C" {
#define SPA_TYPE_PARAM_BLOCK_INFO_BASE SPA_TYPE_PARAM__BlockInfo ":" #define SPA_TYPE_PARAM_BLOCK_INFO_BASE SPA_TYPE_PARAM__BlockInfo ":"
static const struct spa_type_info spa_type_param_buffers_items[] = { static const struct spa_type_info spa_type_param_buffers_items[] = {
{ SPA_PARAM_BUFFERS_buffers, SPA_TYPE_PARAM_BUFFERS_BASE "buffers", SPA_POD_TYPE_INT, }, { SPA_PARAM_BUFFERS_buffers, SPA_TYPE_PARAM_BUFFERS_BASE "buffers", SPA_ID_Int, },
{ SPA_PARAM_BUFFERS_blocks, SPA_TYPE_PARAM_BUFFERS_BASE "blocks", SPA_POD_TYPE_INT, }, { SPA_PARAM_BUFFERS_blocks, SPA_TYPE_PARAM_BUFFERS_BASE "blocks", SPA_ID_Int, },
{ SPA_PARAM_BUFFERS_size, SPA_TYPE_PARAM_BLOCK_INFO_BASE "size", SPA_POD_TYPE_INT, }, { SPA_PARAM_BUFFERS_size, SPA_TYPE_PARAM_BLOCK_INFO_BASE "size", SPA_ID_Int, },
{ SPA_PARAM_BUFFERS_stride, SPA_TYPE_PARAM_BLOCK_INFO_BASE "stride", SPA_POD_TYPE_INT, }, { SPA_PARAM_BUFFERS_stride, SPA_TYPE_PARAM_BLOCK_INFO_BASE "stride", SPA_ID_Int, },
{ SPA_PARAM_BUFFERS_align, SPA_TYPE_PARAM_BLOCK_INFO_BASE "align", SPA_POD_TYPE_INT, }, { SPA_PARAM_BUFFERS_align, SPA_TYPE_PARAM_BLOCK_INFO_BASE "align", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };
static const struct spa_type_info spa_type_param_buffers[] = { static const struct spa_type_info spa_type_param_buffers[] = {
{ SPA_ID_OBJECT_ParamBuffers, SPA_TYPE_PARAM__Buffers, SPA_POD_TYPE_OBJECT, { SPA_ID_OBJECT_ParamBuffers, SPA_TYPE_PARAM__Buffers, SPA_ID_Object,
spa_type_param_buffers_items }, spa_type_param_buffers_items },
{ 0, NULL, }, { 0, NULL, },
}; };

68
spa/include/spa/param/format-types.h
View file

@ -37,11 +37,11 @@ extern "C" {
#include <spa/param/video/format-types.h> #include <spa/param/video/format-types.h>
static const struct spa_type_info spa_type_media_type[] = { static const struct spa_type_info spa_type_media_type[] = {
{ SPA_MEDIA_TYPE_audio, SPA_TYPE_MEDIA_TYPE_BASE "audio", SPA_POD_TYPE_INT, }, { SPA_MEDIA_TYPE_audio, SPA_TYPE_MEDIA_TYPE_BASE "audio", SPA_ID_Int, },
{ SPA_MEDIA_TYPE_video, SPA_TYPE_MEDIA_TYPE_BASE "video", SPA_POD_TYPE_INT, }, { SPA_MEDIA_TYPE_video, SPA_TYPE_MEDIA_TYPE_BASE "video", SPA_ID_Int, },
{ SPA_MEDIA_TYPE_image, SPA_TYPE_MEDIA_TYPE_BASE "image", SPA_POD_TYPE_INT, }, { SPA_MEDIA_TYPE_image, SPA_TYPE_MEDIA_TYPE_BASE "image", SPA_ID_Int, },
{ SPA_MEDIA_TYPE_binary, SPA_TYPE_MEDIA_TYPE_BASE "binary", SPA_POD_TYPE_INT, }, { SPA_MEDIA_TYPE_binary, SPA_TYPE_MEDIA_TYPE_BASE "binary", SPA_ID_Int, },
{ SPA_MEDIA_TYPE_stream, SPA_TYPE_MEDIA_TYPE_BASE "stream", SPA_POD_TYPE_INT, }, { SPA_MEDIA_TYPE_stream, SPA_TYPE_MEDIA_TYPE_BASE "stream", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };
@ -50,42 +50,42 @@ static const struct spa_type_info spa_type_media_type[] = {
static const struct spa_type_info spa_type_media_subtype[] = { static const struct spa_type_info spa_type_media_subtype[] = {
/* generic subtypes */ /* generic subtypes */
{ SPA_MEDIA_SUBTYPE_raw, SPA_TYPE_MEDIA_SUBTYPE_BASE "raw", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_raw, SPA_TYPE_MEDIA_SUBTYPE_BASE "raw", SPA_ID_Int, },
/* audio subtypes */ /* audio subtypes */
{ SPA_MEDIA_SUBTYPE_mp3, SPA_TYPE_MEDIA_SUBTYPE_BASE "mp3", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_mp3, SPA_TYPE_MEDIA_SUBTYPE_BASE "mp3", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_aac, SPA_TYPE_MEDIA_SUBTYPE_BASE "aac", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_aac, SPA_TYPE_MEDIA_SUBTYPE_BASE "aac", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_vorbis, SPA_TYPE_MEDIA_SUBTYPE_BASE "vorbis", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_vorbis, SPA_TYPE_MEDIA_SUBTYPE_BASE "vorbis", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_wma, SPA_TYPE_MEDIA_SUBTYPE_BASE "wma", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_wma, SPA_TYPE_MEDIA_SUBTYPE_BASE "wma", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_ra, SPA_TYPE_MEDIA_SUBTYPE_BASE "ra", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_ra, SPA_TYPE_MEDIA_SUBTYPE_BASE "ra", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_sbc, SPA_TYPE_MEDIA_SUBTYPE_BASE "sbc", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_sbc, SPA_TYPE_MEDIA_SUBTYPE_BASE "sbc", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_adpcm, SPA_TYPE_MEDIA_SUBTYPE_BASE "adpcm", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_adpcm, SPA_TYPE_MEDIA_SUBTYPE_BASE "adpcm", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_g723, SPA_TYPE_MEDIA_SUBTYPE_BASE "g723", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_g723, SPA_TYPE_MEDIA_SUBTYPE_BASE "g723", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_g726, SPA_TYPE_MEDIA_SUBTYPE_BASE "g726", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_g726, SPA_TYPE_MEDIA_SUBTYPE_BASE "g726", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_g729, SPA_TYPE_MEDIA_SUBTYPE_BASE "g729", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_g729, SPA_TYPE_MEDIA_SUBTYPE_BASE "g729", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_amr, SPA_TYPE_MEDIA_SUBTYPE_BASE "amr", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_amr, SPA_TYPE_MEDIA_SUBTYPE_BASE "amr", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_gsm, SPA_TYPE_MEDIA_SUBTYPE_BASE "gsm", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_gsm, SPA_TYPE_MEDIA_SUBTYPE_BASE "gsm", SPA_ID_Int, },
/* video subtypes */ /* video subtypes */
{ SPA_MEDIA_SUBTYPE_h264, SPA_TYPE_MEDIA_SUBTYPE_BASE "h264", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_h264, SPA_TYPE_MEDIA_SUBTYPE_BASE "h264", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_mjpg, SPA_TYPE_MEDIA_SUBTYPE_BASE "mjpg", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_mjpg, SPA_TYPE_MEDIA_SUBTYPE_BASE "mjpg", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_dv, SPA_TYPE_MEDIA_SUBTYPE_BASE "dv", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_dv, SPA_TYPE_MEDIA_SUBTYPE_BASE "dv", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_mpegts, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpegts", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_mpegts, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpegts", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_h263, SPA_TYPE_MEDIA_SUBTYPE_BASE "h263", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_h263, SPA_TYPE_MEDIA_SUBTYPE_BASE "h263", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_mpeg1, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg1", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_mpeg1, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg1", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_mpeg2, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg2", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_mpeg2, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg2", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_mpeg4, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg4", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_mpeg4, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg4", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_xvid, SPA_TYPE_MEDIA_SUBTYPE_BASE "xvid", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_xvid, SPA_TYPE_MEDIA_SUBTYPE_BASE "xvid", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_vc1, SPA_TYPE_MEDIA_SUBTYPE_BASE "vc1", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_vc1, SPA_TYPE_MEDIA_SUBTYPE_BASE "vc1", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_vp8, SPA_TYPE_MEDIA_SUBTYPE_BASE "vp8", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_vp8, SPA_TYPE_MEDIA_SUBTYPE_BASE "vp8", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_vp9, SPA_TYPE_MEDIA_SUBTYPE_BASE "vp9", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_vp9, SPA_TYPE_MEDIA_SUBTYPE_BASE "vp9", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_jpeg, SPA_TYPE_MEDIA_SUBTYPE_BASE "jpeg", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_jpeg, SPA_TYPE_MEDIA_SUBTYPE_BASE "jpeg", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_bayer, SPA_TYPE_MEDIA_SUBTYPE_BASE "bayer", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_bayer, SPA_TYPE_MEDIA_SUBTYPE_BASE "bayer", SPA_ID_Int, },
{ SPA_MEDIA_SUBTYPE_midi, SPA_TYPE_MEDIA_SUBTYPE_BASE "midi", SPA_POD_TYPE_INT, }, { SPA_MEDIA_SUBTYPE_midi, SPA_TYPE_MEDIA_SUBTYPE_BASE "midi", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };
static const struct spa_type_info spa_type_format[] = { static const struct spa_type_info spa_type_format[] = {
{ SPA_ID_OBJECT_Format, SPA_TYPE__Format, SPA_POD_TYPE_OBJECT, }, { SPA_ID_OBJECT_Format, SPA_TYPE__Format, SPA_ID_Object, },
{ 0, NULL, }, { 0, NULL, },
}; };

2
spa/include/spa/param/param-types.h
View file

@ -28,7 +28,7 @@ extern "C" {
#include <spa/pod/pod.h> #include <spa/pod/pod.h>
/* base for parameter objects */ /* base for parameter objects */
#define SPA_TYPE__Param SPA_TYPE_POD_OBJECT_BASE "Param" #define SPA_TYPE__Param SPA_TYPE_OBJECT_BASE "Param"
#define SPA_TYPE_PARAM_BASE SPA_TYPE__Param ":" #define SPA_TYPE_PARAM_BASE SPA_TYPE__Param ":"
/* base for parameter object enumerations */ /* base for parameter object enumerations */

36
spa/include/spa/param/video/format-types.h
View file

@ -31,25 +31,25 @@ extern "C" {
#define SPA_TYPE_FORMAT_VIDEO_BASE SPA_TYPE__FormatVideo ":" #define SPA_TYPE_FORMAT_VIDEO_BASE SPA_TYPE__FormatVideo ":"
static const struct spa_type_info spa_type_format_video_ids[] = { static const struct spa_type_info spa_type_format_video_ids[] = {
{ SPA_FORMAT_VIDEO_format, SPA_TYPE_FORMAT_VIDEO_BASE "format", SPA_POD_TYPE_ID, { SPA_FORMAT_VIDEO_format, SPA_TYPE_FORMAT_VIDEO_BASE "format", SPA_ID_Enum,
spa_type_video_format, }, spa_type_video_format, },
{ SPA_FORMAT_VIDEO_size, SPA_TYPE_FORMAT_VIDEO_BASE "size", SPA_POD_TYPE_RECTANGLE, }, { SPA_FORMAT_VIDEO_size, SPA_TYPE_FORMAT_VIDEO_BASE "size", SPA_ID_Rectangle, },
{ SPA_FORMAT_VIDEO_framerate, SPA_TYPE_FORMAT_VIDEO_BASE "framerate", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_framerate, SPA_TYPE_FORMAT_VIDEO_BASE "framerate", SPA_ID_Fraction, },
{ SPA_FORMAT_VIDEO_maxFramerate, SPA_TYPE_FORMAT_VIDEO_BASE "maxFramerate", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_maxFramerate, SPA_TYPE_FORMAT_VIDEO_BASE "maxFramerate", SPA_ID_Fraction, },
{ SPA_FORMAT_VIDEO_views, SPA_TYPE_FORMAT_VIDEO_BASE "views", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_views, SPA_TYPE_FORMAT_VIDEO_BASE "views", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_interlaceMode, SPA_TYPE_FORMAT_VIDEO_BASE "interlaceMode", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_interlaceMode, SPA_TYPE_FORMAT_VIDEO_BASE "interlaceMode", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_pixelAspectRatio, SPA_TYPE_FORMAT_VIDEO_BASE "pixelAspectRatio", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_pixelAspectRatio, SPA_TYPE_FORMAT_VIDEO_BASE "pixelAspectRatio", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_multiviewMode, SPA_TYPE_FORMAT_VIDEO_BASE "multiviewMode", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_multiviewMode, SPA_TYPE_FORMAT_VIDEO_BASE "multiviewMode", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_multiviewFlags, SPA_TYPE_FORMAT_VIDEO_BASE "multiviewFlags", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_multiviewFlags, SPA_TYPE_FORMAT_VIDEO_BASE "multiviewFlags", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_chromaSite, SPA_TYPE_FORMAT_VIDEO_BASE "chromaSite", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_chromaSite, SPA_TYPE_FORMAT_VIDEO_BASE "chromaSite", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_colorRange, SPA_TYPE_FORMAT_VIDEO_BASE "colorRange", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_colorRange, SPA_TYPE_FORMAT_VIDEO_BASE "colorRange", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_colorMatrix, SPA_TYPE_FORMAT_VIDEO_BASE "colorMatrix", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_colorMatrix, SPA_TYPE_FORMAT_VIDEO_BASE "colorMatrix", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_transferFunction, SPA_TYPE_FORMAT_VIDEO_BASE "transferFunction", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_transferFunction, SPA_TYPE_FORMAT_VIDEO_BASE "transferFunction", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_colorPrimaries, SPA_TYPE_FORMAT_VIDEO_BASE "colorPrimaries", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_colorPrimaries, SPA_TYPE_FORMAT_VIDEO_BASE "colorPrimaries", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_profile, SPA_TYPE_FORMAT_VIDEO_BASE "profile", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_profile, SPA_TYPE_FORMAT_VIDEO_BASE "profile", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_level, SPA_TYPE_FORMAT_VIDEO_BASE "level", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_level, SPA_TYPE_FORMAT_VIDEO_BASE "level", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_streamFormat, SPA_TYPE_FORMAT_VIDEO_BASE "streamFormat", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_streamFormat, SPA_TYPE_FORMAT_VIDEO_BASE "streamFormat", SPA_ID_Int, },
{ SPA_FORMAT_VIDEO_alignment, SPA_TYPE_FORMAT_VIDEO_BASE "alignment", SPA_POD_TYPE_INT, }, { SPA_FORMAT_VIDEO_alignment, SPA_TYPE_FORMAT_VIDEO_BASE "alignment", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };

154
spa/include/spa/param/video/raw-types.h
View file

@ -30,83 +30,83 @@ extern "C" {
#define SPA_TYPE_VIDEO_FORMAT_BASE SPA_TYPE__VideoFormat ":" #define SPA_TYPE_VIDEO_FORMAT_BASE SPA_TYPE__VideoFormat ":"
static const struct spa_type_info spa_type_video_format[] = { static const struct spa_type_info spa_type_video_format[] = {
{ SPA_VIDEO_FORMAT_ENCODED, SPA_TYPE_VIDEO_FORMAT_BASE "encoded", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_ENCODED, SPA_TYPE_VIDEO_FORMAT_BASE "encoded", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I420, SPA_TYPE_VIDEO_FORMAT_BASE "I420", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I420, SPA_TYPE_VIDEO_FORMAT_BASE "I420", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_YV12, SPA_TYPE_VIDEO_FORMAT_BASE "YV12", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_YV12, SPA_TYPE_VIDEO_FORMAT_BASE "YV12", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_YUY2, SPA_TYPE_VIDEO_FORMAT_BASE "YUY2", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_YUY2, SPA_TYPE_VIDEO_FORMAT_BASE "YUY2", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_UYVY, SPA_TYPE_VIDEO_FORMAT_BASE "UYVY", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_UYVY, SPA_TYPE_VIDEO_FORMAT_BASE "UYVY", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_AYUV, SPA_TYPE_VIDEO_FORMAT_BASE "AYUV", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_AYUV, SPA_TYPE_VIDEO_FORMAT_BASE "AYUV", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_RGBx, SPA_TYPE_VIDEO_FORMAT_BASE "RGBx", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_RGBx, SPA_TYPE_VIDEO_FORMAT_BASE "RGBx", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_BGRx, SPA_TYPE_VIDEO_FORMAT_BASE "BGRx", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_BGRx, SPA_TYPE_VIDEO_FORMAT_BASE "BGRx", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_xRGB, SPA_TYPE_VIDEO_FORMAT_BASE "xRGB", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_xRGB, SPA_TYPE_VIDEO_FORMAT_BASE "xRGB", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_xBGR, SPA_TYPE_VIDEO_FORMAT_BASE "xBGR", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_xBGR, SPA_TYPE_VIDEO_FORMAT_BASE "xBGR", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_RGBA, SPA_TYPE_VIDEO_FORMAT_BASE "RGBA", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_RGBA, SPA_TYPE_VIDEO_FORMAT_BASE "RGBA", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_BGRA, SPA_TYPE_VIDEO_FORMAT_BASE "BGRA", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_BGRA, SPA_TYPE_VIDEO_FORMAT_BASE "BGRA", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_ARGB, SPA_TYPE_VIDEO_FORMAT_BASE "ARGB", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_ARGB, SPA_TYPE_VIDEO_FORMAT_BASE "ARGB", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_ABGR, SPA_TYPE_VIDEO_FORMAT_BASE "ABGR", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_ABGR, SPA_TYPE_VIDEO_FORMAT_BASE "ABGR", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_RGB, SPA_TYPE_VIDEO_FORMAT_BASE "RGB", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_RGB, SPA_TYPE_VIDEO_FORMAT_BASE "RGB", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_BGR, SPA_TYPE_VIDEO_FORMAT_BASE "BGR", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_BGR, SPA_TYPE_VIDEO_FORMAT_BASE "BGR", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_Y41B, SPA_TYPE_VIDEO_FORMAT_BASE "Y41B", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_Y41B, SPA_TYPE_VIDEO_FORMAT_BASE "Y41B", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_Y42B, SPA_TYPE_VIDEO_FORMAT_BASE "Y42B", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_Y42B, SPA_TYPE_VIDEO_FORMAT_BASE "Y42B", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_YVYU, SPA_TYPE_VIDEO_FORMAT_BASE "YVYU", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_YVYU, SPA_TYPE_VIDEO_FORMAT_BASE "YVYU", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_Y444, SPA_TYPE_VIDEO_FORMAT_BASE "Y444", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_Y444, SPA_TYPE_VIDEO_FORMAT_BASE "Y444", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_v210, SPA_TYPE_VIDEO_FORMAT_BASE "v210", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_v210, SPA_TYPE_VIDEO_FORMAT_BASE "v210", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_v216, SPA_TYPE_VIDEO_FORMAT_BASE "v216", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_v216, SPA_TYPE_VIDEO_FORMAT_BASE "v216", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_NV12, SPA_TYPE_VIDEO_FORMAT_BASE "NV12", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_NV12, SPA_TYPE_VIDEO_FORMAT_BASE "NV12", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_NV21, SPA_TYPE_VIDEO_FORMAT_BASE "NV21", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_NV21, SPA_TYPE_VIDEO_FORMAT_BASE "NV21", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GRAY8, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY8", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GRAY8, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY8", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GRAY16_BE, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GRAY16_BE, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GRAY16_LE, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GRAY16_LE, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_v308, SPA_TYPE_VIDEO_FORMAT_BASE "v308", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_v308, SPA_TYPE_VIDEO_FORMAT_BASE "v308", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_RGB16, SPA_TYPE_VIDEO_FORMAT_BASE "RGB16", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_RGB16, SPA_TYPE_VIDEO_FORMAT_BASE "RGB16", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_BGR16, SPA_TYPE_VIDEO_FORMAT_BASE "BGR16", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_BGR16, SPA_TYPE_VIDEO_FORMAT_BASE "BGR16", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_RGB15, SPA_TYPE_VIDEO_FORMAT_BASE "RGB15", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_RGB15, SPA_TYPE_VIDEO_FORMAT_BASE "RGB15", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_BGR15, SPA_TYPE_VIDEO_FORMAT_BASE "BGR15", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_BGR15, SPA_TYPE_VIDEO_FORMAT_BASE "BGR15", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_UYVP, SPA_TYPE_VIDEO_FORMAT_BASE "UYVP", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_UYVP, SPA_TYPE_VIDEO_FORMAT_BASE "UYVP", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_A420, SPA_TYPE_VIDEO_FORMAT_BASE "A420", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_A420, SPA_TYPE_VIDEO_FORMAT_BASE "A420", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_RGB8P, SPA_TYPE_VIDEO_FORMAT_BASE "RGB8P", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_RGB8P, SPA_TYPE_VIDEO_FORMAT_BASE "RGB8P", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_YUV9, SPA_TYPE_VIDEO_FORMAT_BASE "YUV9", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_YUV9, SPA_TYPE_VIDEO_FORMAT_BASE "YUV9", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_YVU9, SPA_TYPE_VIDEO_FORMAT_BASE "YVU9", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_YVU9, SPA_TYPE_VIDEO_FORMAT_BASE "YVU9", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_IYU1, SPA_TYPE_VIDEO_FORMAT_BASE "IYU1", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_IYU1, SPA_TYPE_VIDEO_FORMAT_BASE "IYU1", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_ARGB64, SPA_TYPE_VIDEO_FORMAT_BASE "ARGB64", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_ARGB64, SPA_TYPE_VIDEO_FORMAT_BASE "ARGB64", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_AYUV64, SPA_TYPE_VIDEO_FORMAT_BASE "AYUV64", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_AYUV64, SPA_TYPE_VIDEO_FORMAT_BASE "AYUV64", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_r210, SPA_TYPE_VIDEO_FORMAT_BASE "r210", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_r210, SPA_TYPE_VIDEO_FORMAT_BASE "r210", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I420_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I420_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I420_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I420_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I422_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I422_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I422_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I422_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_Y444_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_Y444_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_Y444_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_Y444_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBR, SPA_TYPE_VIDEO_FORMAT_BASE "GBR", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBR, SPA_TYPE_VIDEO_FORMAT_BASE "GBR", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBR_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBR_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBR_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBR_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_NV16, SPA_TYPE_VIDEO_FORMAT_BASE "NV16", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_NV16, SPA_TYPE_VIDEO_FORMAT_BASE "NV16", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_NV24, SPA_TYPE_VIDEO_FORMAT_BASE "NV24", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_NV24, SPA_TYPE_VIDEO_FORMAT_BASE "NV24", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_NV12_64Z32, SPA_TYPE_VIDEO_FORMAT_BASE "NV12_64Z32", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_NV12_64Z32, SPA_TYPE_VIDEO_FORMAT_BASE "NV12_64Z32", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_A420_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A420_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_A420_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A420_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_A420_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A420_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_A420_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A420_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_A422_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A422_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_A422_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A422_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_A422_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A422_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_A422_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A422_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_A444_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A444_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_A444_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A444_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_A444_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A444_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_A444_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A444_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_NV61, SPA_TYPE_VIDEO_FORMAT_BASE "NV61", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_NV61, SPA_TYPE_VIDEO_FORMAT_BASE "NV61", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_P010_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "P010_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_P010_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "P010_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_P010_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "P010_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_P010_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "P010_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_IYU2, SPA_TYPE_VIDEO_FORMAT_BASE "IYU2", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_IYU2, SPA_TYPE_VIDEO_FORMAT_BASE "IYU2", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_VYUY, SPA_TYPE_VIDEO_FORMAT_BASE "VYUY", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_VYUY, SPA_TYPE_VIDEO_FORMAT_BASE "VYUY", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBRA, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBRA, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBRA_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_10BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBRA_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_10BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBRA_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_10LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBRA_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_10LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBR_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_12BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBR_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_12BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBR_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_12LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBR_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_12LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBRA_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_12BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBRA_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_12BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_GBRA_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_12LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_GBRA_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_12LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I420_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_12BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I420_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_12BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I420_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_12LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I420_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_12LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I422_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_12BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I422_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_12BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_I422_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_12LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_I422_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_12LE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_Y444_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_12BE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_Y444_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_12BE", SPA_ID_Int, },
{ SPA_VIDEO_FORMAT_Y444_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_12LE", SPA_POD_TYPE_INT, }, { SPA_VIDEO_FORMAT_Y444_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_12LE", SPA_ID_Int, },
{ 0, NULL, }, { 0, NULL, },
}; };

42
spa/include/spa/pod/builder.h
View file

@ -98,7 +98,7 @@ spa_pod_builder_push(struct spa_pod_builder *builder,
frame->pod = *pod; frame->pod = *pod;
frame->ref = ref; frame->ref = ref;
builder->state.in_array = builder->state.first = builder->state.in_array = builder->state.first =
(pod->type == SPA_POD_TYPE_ARRAY || pod->type == SPA_POD_TYPE_PROP); (pod->type == SPA_ID_Array || pod->type == SPA_ID_Prop);
return ref; return ref;
} }
@ -153,7 +153,7 @@ static inline void *spa_pod_builder_pop(struct spa_pod_builder *builder)
top = builder->state.depth > 0 ? &builder->frame[builder->state.depth-1] : NULL; top = builder->state.depth > 0 ? &builder->frame[builder->state.depth-1] : NULL;
builder->state.in_array = (top && builder->state.in_array = (top &&
(top->pod.type == SPA_POD_TYPE_ARRAY || top->pod.type == SPA_POD_TYPE_PROP)); (top->pod.type == SPA_ID_Array || top->pod.type == SPA_ID_Prop));
spa_pod_builder_pad(builder, builder->state.offset); spa_pod_builder_pad(builder, builder->state.offset);
return pod; return pod;
@ -179,7 +179,7 @@ spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod
return ref; return ref;
} }
#define SPA_POD_NONE_INIT() (struct spa_pod) { 0, SPA_POD_TYPE_NONE } #define SPA_POD_NONE_INIT() (struct spa_pod) { 0, SPA_ID_None }
static inline uint32_t spa_pod_builder_none(struct spa_pod_builder *builder) static inline uint32_t spa_pod_builder_none(struct spa_pod_builder *builder)
{ {
@ -187,7 +187,7 @@ static inline uint32_t spa_pod_builder_none(struct spa_pod_builder *builder)
return spa_pod_builder_primitive(builder, &p); return spa_pod_builder_primitive(builder, &p);
} }
#define SPA_POD_BOOL_INIT(val) (struct spa_pod_bool){ { sizeof(uint32_t), SPA_POD_TYPE_BOOL }, val ? 1 : 0, 0 } #define SPA_POD_BOOL_INIT(val) (struct spa_pod_bool){ { sizeof(uint32_t), SPA_ID_Bool }, val ? 1 : 0, 0 }
static inline uint32_t spa_pod_builder_bool(struct spa_pod_builder *builder, bool val) static inline uint32_t spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
{ {
@ -195,7 +195,7 @@ static inline uint32_t spa_pod_builder_bool(struct spa_pod_builder *builder, boo
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_ID_INIT(val) (struct spa_pod_id){ { sizeof(uint32_t), SPA_POD_TYPE_ID }, val, 0 } #define SPA_POD_ID_INIT(val) (struct spa_pod_id){ { sizeof(uint32_t), SPA_ID_Enum }, val, 0 }
static inline uint32_t spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val) static inline uint32_t spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
{ {
@ -203,7 +203,7 @@ static inline uint32_t spa_pod_builder_id(struct spa_pod_builder *builder, uint3
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_INT_INIT(val) (struct spa_pod_int){ { sizeof(uint32_t), SPA_POD_TYPE_INT }, val, 0 } #define SPA_POD_INT_INIT(val) (struct spa_pod_int){ { sizeof(uint32_t), SPA_ID_Int }, val, 0 }
static inline uint32_t spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val) static inline uint32_t spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
{ {
@ -211,7 +211,7 @@ static inline uint32_t spa_pod_builder_int(struct spa_pod_builder *builder, int3
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_LONG_INIT(val) (struct spa_pod_long){ { sizeof(uint64_t), SPA_POD_TYPE_LONG }, val } #define SPA_POD_LONG_INIT(val) (struct spa_pod_long){ { sizeof(uint64_t), SPA_ID_Long }, val }
static inline uint32_t spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val) static inline uint32_t spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val)
{ {
@ -219,7 +219,7 @@ static inline uint32_t spa_pod_builder_long(struct spa_pod_builder *builder, int
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_FLOAT_INIT(val) (struct spa_pod_float){ { sizeof(float), SPA_POD_TYPE_FLOAT }, val } #define SPA_POD_FLOAT_INIT(val) (struct spa_pod_float){ { sizeof(float), SPA_ID_Float }, val }
static inline uint32_t spa_pod_builder_float(struct spa_pod_builder *builder, float val) static inline uint32_t spa_pod_builder_float(struct spa_pod_builder *builder, float val)
{ {
@ -227,7 +227,7 @@ static inline uint32_t spa_pod_builder_float(struct spa_pod_builder *builder, fl
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_DOUBLE_INIT(val) (struct spa_pod_double){ { sizeof(double), SPA_POD_TYPE_DOUBLE }, val } #define SPA_POD_DOUBLE_INIT(val) (struct spa_pod_double){ { sizeof(double), SPA_ID_Double }, val }
static inline uint32_t spa_pod_builder_double(struct spa_pod_builder *builder, double val) static inline uint32_t spa_pod_builder_double(struct spa_pod_builder *builder, double val)
{ {
@ -235,7 +235,7 @@ static inline uint32_t spa_pod_builder_double(struct spa_pod_builder *builder, d
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_STRING_INIT(len) (struct spa_pod_string){ { len, SPA_POD_TYPE_STRING } } #define SPA_POD_STRING_INIT(len) (struct spa_pod_string){ { len, SPA_ID_String } }
static inline uint32_t static inline uint32_t
spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len) spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
@ -265,7 +265,7 @@ static inline uint32_t spa_pod_builder_string(struct spa_pod_builder *builder, c
return spa_pod_builder_string_len(builder, str ? str : "", len); return spa_pod_builder_string_len(builder, str ? str : "", len);
} }
#define SPA_POD_BYTES_INIT(len) (struct spa_pod_bytes){ { len, SPA_POD_TYPE_BYTES } } #define SPA_POD_BYTES_INIT(len) (struct spa_pod_bytes){ { len, SPA_ID_Bytes } }
static inline uint32_t static inline uint32_t
spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len) spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
@ -277,7 +277,7 @@ spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32
return ref; return ref;
} }
#define SPA_POD_POINTER_INIT(type,value) (struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_POD_TYPE_POINTER }, { type, value } } #define SPA_POD_POINTER_INIT(type,value) (struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_ID_Pointer }, { type, value } }
static inline uint32_t static inline uint32_t
spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, void *val) spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, void *val)
@ -286,7 +286,7 @@ spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, void *va
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_FD_INIT(fd) (struct spa_pod_fd){ { sizeof(int), SPA_POD_TYPE_FD }, fd } #define SPA_POD_FD_INIT(fd) (struct spa_pod_fd){ { sizeof(int), SPA_ID_Fd }, fd }
static inline uint32_t spa_pod_builder_fd(struct spa_pod_builder *builder, int fd) static inline uint32_t spa_pod_builder_fd(struct spa_pod_builder *builder, int fd)
{ {
@ -294,7 +294,7 @@ static inline uint32_t spa_pod_builder_fd(struct spa_pod_builder *builder, int f
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_RECTANGLE_INIT(width,height) (struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_POD_TYPE_RECTANGLE }, { width, height } } #define SPA_POD_RECTANGLE_INIT(width,height) (struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_ID_Rectangle }, { width, height } }
static inline uint32_t static inline uint32_t
spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height) spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
@ -303,7 +303,7 @@ spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint3
return spa_pod_builder_primitive(builder, &p.pod); return spa_pod_builder_primitive(builder, &p.pod);
} }
#define SPA_POD_FRACTION_INIT(num,denom) (struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_POD_TYPE_FRACTION }, { num, denom } } #define SPA_POD_FRACTION_INIT(num,denom) (struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_ID_Fraction }, { num, denom } }
static inline uint32_t static inline uint32_t
spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom) spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
@ -316,7 +316,7 @@ static inline uint32_t
spa_pod_builder_push_array(struct spa_pod_builder *builder) spa_pod_builder_push_array(struct spa_pod_builder *builder)
{ {
const struct spa_pod_array p = const struct spa_pod_array p =
{ {sizeof(struct spa_pod_array_body) - sizeof(struct spa_pod), SPA_POD_TYPE_ARRAY}, { {sizeof(struct spa_pod_array_body) - sizeof(struct spa_pod), SPA_ID_Array},
{{0, 0}} }; {{0, 0}} };
return spa_pod_builder_push(builder, &p.pod, return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p, spa_pod_builder_raw(builder, &p,
@ -328,7 +328,7 @@ spa_pod_builder_array(struct spa_pod_builder *builder,
uint32_t child_size, uint32_t child_type, uint32_t n_elems, const void *elems) uint32_t child_size, uint32_t child_type, uint32_t n_elems, const void *elems)
{ {
const struct spa_pod_array p = { const struct spa_pod_array p = {
{(uint32_t)(sizeof(struct spa_pod_array_body) + n_elems * child_size), SPA_POD_TYPE_ARRAY}, {(uint32_t)(sizeof(struct spa_pod_array_body) + n_elems * child_size), SPA_ID_Array},
{{child_size, child_type}} {{child_size, child_type}}
}; };
uint32_t ref = spa_pod_builder_raw(builder, &p, sizeof(p)); uint32_t ref = spa_pod_builder_raw(builder, &p, sizeof(p));
@ -337,7 +337,7 @@ spa_pod_builder_array(struct spa_pod_builder *builder,
return ref; return ref;
} }
#define SPA_POD_STRUCT_INIT(size) (struct spa_pod_struct){ { size, SPA_POD_TYPE_STRUCT } } #define SPA_POD_STRUCT_INIT(size) (struct spa_pod_struct){ { size, SPA_ID_Struct } }
static inline uint32_t static inline uint32_t
spa_pod_builder_push_struct(struct spa_pod_builder *builder) spa_pod_builder_push_struct(struct spa_pod_builder *builder)
@ -347,7 +347,7 @@ spa_pod_builder_push_struct(struct spa_pod_builder *builder)
spa_pod_builder_raw(builder, &p, sizeof(p))); spa_pod_builder_raw(builder, &p, sizeof(p)));
} }
#define SPA_POD_OBJECT_INIT(size,id,type,...) (struct spa_pod_object){ { size, SPA_POD_TYPE_OBJECT }, { id, type }, ##__VA_ARGS__ } #define SPA_POD_OBJECT_INIT(size,id,type,...) (struct spa_pod_object){ { size, SPA_ID_Object }, { id, type }, ##__VA_ARGS__ }
static inline uint32_t static inline uint32_t
spa_pod_builder_push_object(struct spa_pod_builder *builder, uint32_t id, uint32_t type) spa_pod_builder_push_object(struct spa_pod_builder *builder, uint32_t id, uint32_t type)
@ -359,7 +359,7 @@ spa_pod_builder_push_object(struct spa_pod_builder *builder, uint32_t id, uint32
} }
#define SPA_POD_PROP_INIT(size,key,flags,val_size,val_type) \ #define SPA_POD_PROP_INIT(size,key,flags,val_size,val_type) \
(struct spa_pod_prop){ { size, SPA_POD_TYPE_PROP}, {key, flags, { val_size, val_type } } } (struct spa_pod_prop){ { size, SPA_ID_Prop}, {key, flags, { val_size, val_type } } }
static inline uint32_t static inline uint32_t
spa_pod_builder_push_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags) spa_pod_builder_push_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
@ -556,7 +556,7 @@ spa_pod_builder_addv(struct spa_pod_builder *builder,
case ']': case ')': case '>': case ']': case ')': case '>':
spa_pod_builder_pop(builder); spa_pod_builder_pop(builder);
if (builder->state.depth > 0 && if (builder->state.depth > 0 &&
builder->frame[builder->state.depth-1].pod.type == SPA_POD_TYPE_PROP) builder->frame[builder->state.depth-1].pod.type == SPA_ID_Prop)
spa_pod_builder_pop(builder); spa_pod_builder_pop(builder);
break; break;
case ' ': case '\n': case '\t': case '\r': case ' ': case '\n': case '\t': case '\r':

16
spa/include/spa/pod/command.h
View file

@ -36,15 +36,17 @@ struct spa_command {
struct spa_command_body body; struct spa_command_body body;
}; };
#define SPA_COMMAND_TYPE(cmd) ((cmd)->body.body.type) #define SPA_COMMAND_TYPE(cmd) ((cmd)->body.body.type)
#define SPA_COMMAND_ID(cmd,type) (SPA_COMMAND_TYPE(cmd) == type ? \
(cmd)->body.body.id : SPA_ID_INVALID)
#define SPA_COMMAND_INIT(type) (struct spa_command) \ #define SPA_COMMAND_INIT(type,id) (struct spa_command) \
{ { sizeof(struct spa_command_body), SPA_POD_TYPE_OBJECT }, \ { { sizeof(struct spa_command_body), SPA_ID_Object }, \
{ { 0, type } } } \ { { id, type } } } \
#define SPA_COMMAND_INIT_FULL(t,size,type,...) (t) \ #define SPA_COMMAND_INIT_FULL(t,size,type,id,...) (t) \
{ { size, SPA_POD_TYPE_OBJECT }, \ { { size, SPA_ID_OBJECT }, \
{ { 0, type }, ##__VA_ARGS__ } } \ { { id, type }, ##__VA_ARGS__ } } \
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */

30
spa/include/spa/pod/compare.h
View file

@ -27,25 +27,25 @@
#include <spa/pod/iter.h> #include <spa/pod/iter.h>
#include <spa/pod/builder.h> #include <spa/pod/builder.h>
static inline int spa_pod_compare_value(enum spa_pod_type type, const void *r1, const void *r2) static inline int spa_pod_compare_value(uint32_t type, const void *r1, const void *r2)
{ {
switch (type) { switch (type) {
case SPA_POD_TYPE_INVALID: case SPA_ID_INVALID:
return 0; return 0;
case SPA_POD_TYPE_BOOL: case SPA_ID_Bool:
case SPA_POD_TYPE_ID: case SPA_ID_Enum:
return *(int32_t *) r1 == *(uint32_t *) r2 ? 0 : 1; return *(int32_t *) r1 == *(uint32_t *) r2 ? 0 : 1;
case SPA_POD_TYPE_INT: case SPA_ID_Int:
return *(int32_t *) r1 - *(int32_t *) r2; return *(int32_t *) r1 - *(int32_t *) r2;
case SPA_POD_TYPE_LONG: case SPA_ID_Long:
return *(int64_t *) r1 - *(int64_t *) r2; return *(int64_t *) r1 - *(int64_t *) r2;
case SPA_POD_TYPE_FLOAT: case SPA_ID_Float:
return *(float *) r1 - *(float *) r2; return *(float *) r1 - *(float *) r2;
case SPA_POD_TYPE_DOUBLE: case SPA_ID_Double:
return *(double *) r1 - *(double *) r2; return *(double *) r1 - *(double *) r2;
case SPA_POD_TYPE_STRING: case SPA_ID_String:
return strcmp(r1, r2); return strcmp(r1, r2);
case SPA_POD_TYPE_RECTANGLE: case SPA_ID_Rectangle:
{ {
const struct spa_rectangle *rec1 = (struct spa_rectangle *) r1, const struct spa_rectangle *rec1 = (struct spa_rectangle *) r1,
*rec2 = (struct spa_rectangle *) r2; *rec2 = (struct spa_rectangle *) r2;
@ -56,7 +56,7 @@ static inline int spa_pod_compare_value(enum spa_pod_type type, const void *r1,
else else
return 1; return 1;
} }
case SPA_POD_TYPE_FRACTION: case SPA_ID_Fraction:
{ {
const struct spa_fraction *f1 = (struct spa_fraction *) r1, const struct spa_fraction *f1 = (struct spa_fraction *) r1,
*f2 = (struct spa_fraction *) r2; *f2 = (struct spa_fraction *) r2;
@ -92,19 +92,19 @@ static inline int spa_pod_compare_part(const struct spa_pod *pod1, uint32_t pod1
return -EINVAL; return -EINVAL;
switch (SPA_POD_TYPE(p1)) { switch (SPA_POD_TYPE(p1)) {
case SPA_POD_TYPE_STRUCT: case SPA_ID_Struct:
case SPA_POD_TYPE_OBJECT: case SPA_ID_Object:
if (SPA_POD_TYPE(p2) != SPA_POD_TYPE(p1)) if (SPA_POD_TYPE(p2) != SPA_POD_TYPE(p1))
return -EINVAL; return -EINVAL;
if (SPA_POD_TYPE(p1) == SPA_POD_TYPE_STRUCT) if (SPA_POD_TYPE(p1) == SPA_ID_Struct)
recurse_offset = sizeof(struct spa_pod_struct); recurse_offset = sizeof(struct spa_pod_struct);
else else
recurse_offset = sizeof(struct spa_pod_object); recurse_offset = sizeof(struct spa_pod_object);
do_advance = true; do_advance = true;
break; break;
case SPA_POD_TYPE_PROP: case SPA_ID_Prop:
{ {
struct spa_pod_prop *pr1, *pr2; struct spa_pod_prop *pr1, *pr2;
void *a1, *a2; void *a1, *a2;

36
spa/include/spa/pod/event-types.h
View file

@ -1,36 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_EVENT_TYPES_H__
#define __SPA_EVENT_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/pod/pod-types.h>
#define SPA_TYPE__Event SPA_TYPE_POD_OBJECT_BASE "Event"
#define SPA_TYPE_EVENT_BASE SPA_TYPE__Event ":"
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_EVENT_TYPES_H__ */

16
spa/include/spa/pod/event.h
View file

@ -35,15 +35,17 @@ struct spa_event {
struct spa_event_body body; struct spa_event_body body;
}; };
#define SPA_EVENT_TYPE(ev) ((ev)->body.body.type) #define SPA_EVENT_TYPE(ev) ((ev)->body.body.type)
#define SPA_EVENT_ID(ev,type) (SPA_EVENT_TYPE(ev) == type ? \
(ev)->body.body.id : SPA_ID_INVALID)
#define SPA_EVENT_INIT(type) (struct spa_event) \ #define SPA_EVENT_INIT(type,id) (struct spa_event) \
{ { sizeof(struct spa_event_body), SPA_POD_TYPE_OBJECT }, \ { { sizeof(struct spa_event_body), SPA_ID_Object }, \
{ { 0, type } } } \ { { id, type } } } \
#define SPA_EVENT_INIT_FULL(t,size,type,...) (t) \ #define SPA_EVENT_INIT_FULL(t,size,type,id,...) (t) \
{ { size, SPA_POD_TYPE_OBJECT }, \ { { size, SPA_ID_OBJECT }, \
{ { 0, type }, ##__VA_ARGS__ } } \ { { id, type }, ##__VA_ARGS__ } } \
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */

8
spa/include/spa/pod/filter.h
View file

@ -249,13 +249,13 @@ static inline int spa_pod_filter_part(struct spa_pod_builder *b,
uint32_t filter_offset = 0; uint32_t filter_offset = 0;
switch (SPA_POD_TYPE(pp)) { switch (SPA_POD_TYPE(pp)) {
case SPA_POD_TYPE_STRUCT: case SPA_ID_Struct:
case SPA_POD_TYPE_OBJECT: case SPA_ID_Object:
if (pf != NULL) { if (pf != NULL) {
if (SPA_POD_TYPE(pf) != SPA_POD_TYPE(pp)) if (SPA_POD_TYPE(pf) != SPA_POD_TYPE(pp))
return -EINVAL; return -EINVAL;
if (SPA_POD_TYPE(pp) == SPA_POD_TYPE_STRUCT) { if (SPA_POD_TYPE(pp) == SPA_ID_Struct) {
filter_offset = sizeof(struct spa_pod_struct); filter_offset = sizeof(struct spa_pod_struct);
spa_pod_builder_push_struct(b); spa_pod_builder_push_struct(b);
} else { } else {
@ -269,7 +269,7 @@ static inline int spa_pod_filter_part(struct spa_pod_builder *b,
do_copy = true; do_copy = true;
break; break;
case SPA_POD_TYPE_PROP: case SPA_ID_Prop:
{ {
struct spa_pod_prop *p1, *p2; struct spa_pod_prop *p1, *p2;

12
spa/include/spa/pod/iter.h
View file

@ -101,7 +101,7 @@ static inline struct spa_pod_prop *spa_pod_contents_find_prop(const struct spa_p
{ {
const struct spa_pod *res; const struct spa_pod *res;
SPA_POD_FOREACH(pod, size, res) { SPA_POD_FOREACH(pod, size, res) {
if (res->type == SPA_POD_TYPE_PROP if (res->type == SPA_ID_Prop
&& ((struct spa_pod_prop *) res)->body.key == key) && ((struct spa_pod_prop *) res)->body.key == key)
return (struct spa_pod_prop *) res; return (struct spa_pod_prop *) res;
} }
@ -112,9 +112,9 @@ static inline struct spa_pod_prop *spa_pod_find_prop(const struct spa_pod *pod,
{ {
uint32_t offset; uint32_t offset;
if (pod->type == SPA_POD_TYPE_OBJECT) if (pod->type == SPA_ID_Object)
offset = sizeof(struct spa_pod_object); offset = sizeof(struct spa_pod_object);
else if (pod->type == SPA_POD_TYPE_STRUCT) else if (pod->type == SPA_ID_Struct)
offset = sizeof(struct spa_pod_struct); offset = sizeof(struct spa_pod_struct);
else else
return NULL; return NULL;
@ -128,15 +128,15 @@ static inline int spa_pod_fixate(struct spa_pod *pod)
struct spa_pod *res; struct spa_pod *res;
uint32_t offset; uint32_t offset;
if (pod->type == SPA_POD_TYPE_OBJECT) if (pod->type == SPA_ID_Object)
offset = sizeof(struct spa_pod_object); offset = sizeof(struct spa_pod_object);
else if (pod->type == SPA_POD_TYPE_STRUCT) else if (pod->type == SPA_ID_Struct)
offset = sizeof(struct spa_pod_struct); offset = sizeof(struct spa_pod_struct);
else else
return -EINVAL; return -EINVAL;
SPA_POD_CONTENTS_FOREACH(pod, offset, res) { SPA_POD_CONTENTS_FOREACH(pod, offset, res) {
if (res->type == SPA_POD_TYPE_PROP) if (res->type == SPA_ID_Prop)
SPA_FLAG_UNSET (((struct spa_pod_prop *) res)->body.flags, SPA_FLAG_UNSET (((struct spa_pod_prop *) res)->body.flags,
SPA_POD_PROP_FLAG_UNSET); SPA_POD_PROP_FLAG_UNSET);
} }

44
spa/include/spa/pod/parser.h
View file

@ -53,41 +53,41 @@ static inline bool spa_pod_parser_can_collect(struct spa_pod *pod, char type)
return true; return true;
switch (SPA_POD_TYPE(pod)) { switch (SPA_POD_TYPE(pod)) {
case SPA_POD_TYPE_NONE: case SPA_ID_None:
return type == 'T' || type == 'O' || type == 'V' || type == 's'; return type == 'T' || type == 'O' || type == 'V' || type == 's';
case SPA_POD_TYPE_BOOL: case SPA_ID_Bool:
return type == 'b'; return type == 'b';
case SPA_POD_TYPE_ID: case SPA_ID_Enum:
return type == 'I'; return type == 'I';
case SPA_POD_TYPE_INT: case SPA_ID_Int:
return type == 'i'; return type == 'i';
case SPA_POD_TYPE_LONG: case SPA_ID_Long:
return type == 'l'; return type == 'l';
case SPA_POD_TYPE_FLOAT: case SPA_ID_Float:
return type == 'f'; return type == 'f';
case SPA_POD_TYPE_DOUBLE: case SPA_ID_Double:
return type == 'd'; return type == 'd';
case SPA_POD_TYPE_STRING: case SPA_ID_String:
return type == 's' || type == 'S'; return type == 's' || type == 'S';
case SPA_POD_TYPE_BYTES: case SPA_ID_Bytes:
return type == 'z'; return type == 'z';
case SPA_POD_TYPE_RECTANGLE: case SPA_ID_Rectangle:
return type == 'R'; return type == 'R';
case SPA_POD_TYPE_FRACTION: case SPA_ID_Fraction:
return type == 'F'; return type == 'F';
case SPA_POD_TYPE_BITMAP: case SPA_ID_Bitmap:
return type == 'B'; return type == 'B';
case SPA_POD_TYPE_ARRAY: case SPA_ID_Array:
return type == 'a'; return type == 'a';
case SPA_POD_TYPE_STRUCT: case SPA_ID_Struct:
return type == 'T'; return type == 'T';
case SPA_POD_TYPE_OBJECT: case SPA_ID_Object:
return type == 'O'; return type == 'O';
case SPA_POD_TYPE_POINTER: case SPA_ID_Pointer:
return type == 'p'; return type == 'p';
case SPA_POD_TYPE_FD: case SPA_ID_Fd:
return type == 'h'; return type == 'h';
case SPA_POD_TYPE_PROP: case SPA_ID_Prop:
return type == 'V'; return type == 'V';
default: default:
return false; return false;
@ -115,7 +115,7 @@ do { \
break; \ break; \
case 's': \ case 's': \
*va_arg(args, char**) = \ *va_arg(args, char**) = \
(pod == NULL || (SPA_POD_TYPE(pod) == SPA_POD_TYPE_NONE) \ (pod == NULL || (SPA_POD_TYPE(pod) == SPA_ID_None) \
? NULL \ ? NULL \
: (char *)SPA_POD_CONTENTS(struct spa_pod_string, pod)); \ : (char *)SPA_POD_CONTENTS(struct spa_pod_string, pod)); \
break; \ break; \
@ -157,7 +157,7 @@ do { \
case 'O': \ case 'O': \
case 'T': \ case 'T': \
*va_arg(args, struct spa_pod**) = \ *va_arg(args, struct spa_pod**) = \
(pod == NULL || (SPA_POD_TYPE(pod) == SPA_POD_TYPE_NONE) \ (pod == NULL || (SPA_POD_TYPE(pod) == SPA_ID_None) \
? NULL : pod); \ ? NULL : pod); \
break; \ break; \
default: \ default: \
@ -209,7 +209,7 @@ static inline int spa_pod_parser_getv(struct spa_pod_parser *parser,
while (format) { while (format) {
switch (*format) { switch (*format) {
case '<': case '<':
if (pod == NULL || SPA_POD_TYPE(pod) != SPA_POD_TYPE_OBJECT) if (pod == NULL || SPA_POD_TYPE(pod) != SPA_ID_Object)
return -EINVAL; return -EINVAL;
if (++parser->depth >= SPA_POD_MAX_DEPTH) if (++parser->depth >= SPA_POD_MAX_DEPTH)
return -EINVAL; return -EINVAL;
@ -218,7 +218,7 @@ static inline int spa_pod_parser_getv(struct spa_pod_parser *parser,
spa_pod_iter_init(it, pod, SPA_POD_SIZE(pod), sizeof(struct spa_pod_object)); spa_pod_iter_init(it, pod, SPA_POD_SIZE(pod), sizeof(struct spa_pod_object));
goto read_pod; goto read_pod;
case '[': case '[':
if (pod == NULL || SPA_POD_TYPE(pod) != SPA_POD_TYPE_STRUCT) if (pod == NULL || SPA_POD_TYPE(pod) != SPA_ID_Struct)
return -EINVAL; return -EINVAL;
if (++parser->depth >= SPA_POD_MAX_DEPTH) if (++parser->depth >= SPA_POD_MAX_DEPTH)
return -EINVAL; return -EINVAL;

43
spa/include/spa/pod/pod-types.h
View file

@ -1,43 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_POD_TYPES_H__
#define __SPA_POD_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/utils/type-info.h>
#include <spa/pod/pod.h>
#define SPA_TYPE__POD SPA_TYPE_BASE "POD"
#define SPA_TYPE_POD_BASE SPA_TYPE__POD ":"
#define SPA_TYPE_POD__Object SPA_TYPE_POD_BASE "Object"
#define SPA_TYPE_POD_OBJECT_BASE SPA_TYPE_POD__Object ":"
#define SPA_TYPE_POD__Struct SPA_TYPE_POD_BASE "Struct"
#define SPA_TYPE_POD_STRUCT_BASE SPA_TYPE_POD__Struct ":"
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_POD_TYPES_H__ */

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

@ -27,47 +27,12 @@ extern "C" {
#include <stdarg.h> #include <stdarg.h>
#include <spa/utils/defs.h> #include <spa/utils/defs.h>
#include <spa/utils/type.h>
#ifndef SPA_POD_MAX_DEPTH #ifndef SPA_POD_MAX_DEPTH
#define SPA_POD_MAX_DEPTH 16 #define SPA_POD_MAX_DEPTH 16
#endif #endif
/**
* spa_pod_type:
*/
enum spa_pod_type {
SPA_POD_TYPE_INVALID = 0,
SPA_POD_TYPE_NONE = 1,
SPA_POD_TYPE_BOOL,
SPA_POD_TYPE_ID,
SPA_POD_TYPE_INT,
SPA_POD_TYPE_LONG,
SPA_POD_TYPE_FLOAT,
SPA_POD_TYPE_DOUBLE,
SPA_POD_TYPE_STRING,
SPA_POD_TYPE_BYTES,
SPA_POD_TYPE_RECTANGLE,
SPA_POD_TYPE_FRACTION,
SPA_POD_TYPE_BITMAP,
SPA_POD_TYPE_ARRAY,
SPA_POD_TYPE_STRUCT,
SPA_POD_TYPE_OBJECT,
SPA_POD_TYPE_SEQUENCE,
SPA_POD_TYPE_POINTER,
SPA_POD_TYPE_FD,
SPA_POD_TYPE_PROP,
SPA_POD_TYPE_POD,
SPA_POD_TYPE_CUSTOM_START = 64,
};
#define SPA_POD_BODY_SIZE(pod) (((struct spa_pod*)(pod))->size) #define SPA_POD_BODY_SIZE(pod) (((struct spa_pod*)(pod))->size)
#define SPA_POD_TYPE(pod) (((struct spa_pod*)(pod))->type) #define SPA_POD_TYPE(pod) (((struct spa_pod*)(pod))->type)
#define SPA_POD_SIZE(pod) (sizeof(struct spa_pod) + SPA_POD_BODY_SIZE(pod)) #define SPA_POD_SIZE(pod) (sizeof(struct spa_pod) + SPA_POD_BODY_SIZE(pod))
@ -172,13 +137,13 @@ struct spa_pod_object {
static inline bool spa_pod_is_object_type(const struct spa_pod *pod, uint32_t type) static inline bool spa_pod_is_object_type(const struct spa_pod *pod, uint32_t type)
{ {
return (pod && pod->type == SPA_POD_TYPE_OBJECT return (pod && pod->type == SPA_ID_Object
&& ((struct spa_pod_object *) pod)->body.type == type); && ((struct spa_pod_object *) pod)->body.type == type);
} }
static inline bool spa_pod_is_object_id(const struct spa_pod *pod, uint32_t id) static inline bool spa_pod_is_object_id(const struct spa_pod *pod, uint32_t id)
{ {
return (pod && pod->type == SPA_POD_TYPE_OBJECT return (pod && pod->type == SPA_ID_Object
&& ((struct spa_pod_object *) pod)->body.id == id); && ((struct spa_pod_object *) pod)->body.id == id);
} }

3
spa/include/spa/support/log.h
View file

@ -24,9 +24,6 @@
extern "C" { extern "C" {
#endif #endif
#define SPA_TYPE__Log SPA_TYPE_INTERFACE_BASE "Log"
#define SPA_TYPE_LOG_BASE SPA_TYPE__Log ":"
#include <stdarg.h> #include <stdarg.h>
#include <spa/utils/defs.h> #include <spa/utils/defs.h>

3
spa/include/spa/support/plugin.h
View file

@ -27,9 +27,6 @@ extern "C" {
#include <spa/utils/defs.h> #include <spa/utils/defs.h>
#include <spa/utils/dict.h> #include <spa/utils/dict.h>
#define SPA_TYPE__Handle SPA_TYPE_INTERFACE_BASE "Handle"
#define SPA_TYPE__HandleFactory SPA_TYPE_INTERFACE_BASE "HandleFactory"
struct spa_handle { struct spa_handle {
/** Version of this struct */ /** Version of this struct */
#define SPA_VERSION_HANDLE 0 #define SPA_VERSION_HANDLE 0

2
spa/include/spa/utils/defs.h
View file

@ -114,7 +114,7 @@ struct spa_fraction {
#define SPA_TIME_INVALID ((int64_t)INT64_MIN) #define SPA_TIME_INVALID ((int64_t)INT64_MIN)
#define SPA_IDX_INVALID ((unsigned int)-1) #define SPA_IDX_INVALID ((unsigned int)-1)
#define SPA_ID_INVALID ((uint32_t)0xffffffff) //#define SPA_ID_INVALID ((uint32_t)0xffffffff)
#define SPA_NSEC_PER_SEC (1000000000ll) #define SPA_NSEC_PER_SEC (1000000000ll)
#define SPA_NSEC_PER_MSEC (1000000ll) #define SPA_NSEC_PER_MSEC (1000000ll)

92
spa/include/spa/utils/type-info.h
View file

@ -26,22 +26,6 @@ extern "C" {
#include <spa/utils/defs.h> #include <spa/utils/defs.h>
#define SPA_TYPE_BASE "Spa:"
#define SPA_TYPE__Enum SPA_TYPE_BASE "Enum"
#define SPA_TYPE_ENUM_BASE SPA_TYPE__Enum ":"
#define SPA_TYPE__Flags SPA_TYPE_BASE "Flags"
#define SPA_TYPE_FLAGS_BASE SPA_TYPE__Flags ":"
#define SPA_TYPE__Pointer SPA_TYPE_BASE "Pointer"
#define SPA_TYPE_POINTER_BASE SPA_TYPE__Pointer ":"
#define SPA_TYPE__Interface SPA_TYPE_BASE "Interface"
#define SPA_TYPE_INTERFACE_BASE SPA_TYPE__Interface ":"
#define SPA_TYPE__Object SPA_TYPE_BASE "Object"
#define SPA_TYPE_OBJECT_BASE SPA_TYPE__Object ":"
static inline bool spa_type_is_a(const char *type, const char *parent) static inline bool spa_type_is_a(const char *type, const char *parent)
{ {
@ -55,6 +39,82 @@ struct spa_type_info {
const struct spa_type_info *values; const struct spa_type_info *values;
}; };
#define SPA_TYPE_BASE "Spa:"
#define SPA_TYPE__Flags SPA_TYPE_BASE "Flags"
#define SPA_TYPE_FLAGS_BASE SPA_TYPE__Flags ":"
#define SPA_TYPE__Enum SPA_TYPE_BASE "Enum"
#define SPA_TYPE_ENUM_BASE SPA_TYPE__Enum ":"
#define SPA_TYPE__Pod SPA_TYPE_BASE "Pod"
#define SPA_TYPE_POD_BASE SPA_TYPE__Pod ":"
#define SPA_TYPE__Struct SPA_TYPE_POD_BASE "Struct"
#define SPA_TYPE_STRUCT_BASE SPA_TYPE__Struct ":"
#define SPA_TYPE__Object SPA_TYPE_POD_BASE "Object"
#define SPA_TYPE_OBJECT_BASE SPA_TYPE__Object ":"
#define SPA_TYPE__Pointer SPA_TYPE_BASE "Pointer"
#define SPA_TYPE_POINTER_BASE SPA_TYPE__Pointer ":"
#define SPA_TYPE__Interface SPA_TYPE_POINTER_BASE "Interface"
#define SPA_TYPE_INTERFACE_BASE SPA_TYPE__Interface ":"
#define SPA_TYPE__Event SPA_TYPE_OBJECT_BASE "Event"
#define SPA_TYPE_EVENT_BASE SPA_TYPE__Event ":"
#include <spa/monitor/type-info.h>
#include <spa/node/type-info.h>
static const struct spa_type_info spa_types[] = {
{ SPA_ID_INVALID, "*invalid*", SPA_ID_INVALID, },
/* Basic types */
{ SPA_ID_BASE, SPA_TYPE_BASE, SPA_ID_BASE, },
{ SPA_ID_None, SPA_TYPE_BASE "None", SPA_ID_None, },
{ SPA_ID_Bool, SPA_TYPE_BASE "Bool", SPA_ID_Bool, },
{ SPA_ID_Enum, SPA_TYPE__Enum, SPA_ID_Int, },
{ SPA_ID_Int, SPA_TYPE_BASE "Int", SPA_ID_Int, },
{ SPA_ID_Long, SPA_TYPE_BASE "Long", SPA_ID_Long, },
{ SPA_ID_Float, SPA_TYPE_BASE "Float", SPA_ID_Float, },
{ SPA_ID_Double, SPA_TYPE_BASE "Double", SPA_ID_Double, },
{ SPA_ID_String, SPA_TYPE_BASE "String", SPA_ID_String, },
{ SPA_ID_Bytes, SPA_TYPE_BASE "Bytes", SPA_ID_Bytes, },
{ SPA_ID_Rectangle, SPA_TYPE_BASE "Rectangle", SPA_ID_Rectangle, },
{ SPA_ID_Fraction, SPA_TYPE_BASE "Fraction", SPA_ID_Fraction, },
{ SPA_ID_Bitmap, SPA_TYPE_BASE "Bitmap", SPA_ID_Bitmap, },
{ SPA_ID_Array, SPA_TYPE_BASE "Array", SPA_ID_Array, },
{ SPA_ID_Pod, SPA_TYPE__Pod, SPA_ID_Pod, },
{ SPA_ID_Struct, SPA_TYPE__Struct, SPA_ID_Pod, },
{ SPA_ID_Object, SPA_TYPE__Object, SPA_ID_Pod, },
{ SPA_ID_Sequence, SPA_TYPE_POD_BASE "Sequence", SPA_ID_Pod, },
{ SPA_ID_Pointer, SPA_TYPE__Pointer, SPA_ID_Pointer, },
{ SPA_ID_Fd, SPA_TYPE_BASE "Fd", SPA_ID_Fd, },
{ SPA_ID_Prop, SPA_TYPE_POD_BASE "Prop", SPA_ID_Pod, },
{ SPA_ID_INTERFACE_BASE, SPA_TYPE__Interface, SPA_ID_Pointer, },
{ SPA_ID_INTERFACE_Handle, SPA_TYPE_INTERFACE_BASE "Handle", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_HandleFactory, SPA_TYPE_INTERFACE_BASE "HandleFactory", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_Log, SPA_TYPE_INTERFACE_BASE "Log", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_Loop, SPA_TYPE_INTERFACE_BASE "Loop", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_LoopControl, SPA_TYPE_INTERFACE_BASE "LoopControl", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_LoopUtils, SPA_TYPE_INTERFACE_BASE "LoopUtils", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_DataLoop, SPA_TYPE_INTERFACE_BASE "DataLoop", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_MainLoop, SPA_TYPE_INTERFACE_BASE "MainLoop", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_DBus, SPA_TYPE_INTERFACE_BASE "DBus", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_Monitor, SPA_TYPE_INTERFACE_BASE "Monitor", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_INTERFACE_Node, SPA_TYPE_INTERFACE_BASE "Node", SPA_ID_INTERFACE_BASE, },
{ SPA_ID_EVENT_BASE, SPA_TYPE__Event, SPA_ID_Object, },
{ SPA_ID_EVENT_Monitor, SPA_TYPE_EVENT_BASE "Monitor", SPA_ID_EVENT_BASE, },
{ SPA_ID_EVENT_Node, SPA_TYPE_EVENT_BASE "Node", SPA_ID_EVENT_BASE, },
{ 0, NULL, }
};
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif

56
spa/include/spa/utils/type.h
View file

@ -27,8 +27,33 @@ extern "C" {
#include <spa/utils/defs.h> #include <spa/utils/defs.h>
enum { enum {
SPA_ID_UNASSIGNED = 0, SPA_ID_INVALID = 0xffffffff,
/* Basic types */
SPA_ID_BASE = 0x00000,
SPA_ID_None,
SPA_ID_Bool,
SPA_ID_Enum,
SPA_ID_Int,
SPA_ID_Long,
SPA_ID_Float,
SPA_ID_Double,
SPA_ID_String,
SPA_ID_Bytes,
SPA_ID_Rectangle,
SPA_ID_Fraction,
SPA_ID_Bitmap,
SPA_ID_Array,
SPA_ID_Struct,
SPA_ID_Object,
SPA_ID_Sequence,
SPA_ID_Pointer,
SPA_ID_Fd,
SPA_ID_Prop,
SPA_ID_Pod,
/* Interfaces */ /* Interfaces */
SPA_ID_INTERFACE_BASE = 0x10000,
SPA_ID_INTERFACE_Handle, SPA_ID_INTERFACE_Handle,
SPA_ID_INTERFACE_HandleFactory, SPA_ID_INTERFACE_HandleFactory,
SPA_ID_INTERFACE_Log, SPA_ID_INTERFACE_Log,
@ -42,27 +67,16 @@ enum {
SPA_ID_INTERFACE_Node, SPA_ID_INTERFACE_Node,
/* Events */ /* Events */
SPA_ID_EVENT_BASE = 0x10000, SPA_ID_EVENT_BASE = 0x20000,
SPA_ID_EVENT_MONITOR_Added, SPA_ID_EVENT_Monitor,
SPA_ID_EVENT_MONITOR_Removed, SPA_ID_EVENT_Node,
SPA_ID_EVENT_MONITOR_Changed,
SPA_ID_EVENT_NODE_Error,
SPA_ID_EVENT_NODE_Buffering,
SPA_ID_EVENT_NODE_RequestRefresh,
/* Commands */ /* Commands */
SPA_ID_COMMAND_BASE = 0x20000, SPA_ID_COMMAND_BASE = 0x30000,
SPA_ID_COMMAND_NODE_Suspend, SPA_ID_COMMAND_Node,
SPA_ID_COMMAND_NODE_Pause,
SPA_ID_COMMAND_NODE_Start,
SPA_ID_COMMAND_NODE_Enable,
SPA_ID_COMMAND_NODE_Disable,
SPA_ID_COMMAND_NODE_Flush,
SPA_ID_COMMAND_NODE_Drain,
SPA_ID_COMMAND_NODE_Marker,
/* Objects */ /* Objects */
SPA_ID_OBJECT_BASE = 0x30000, SPA_ID_OBJECT_BASE = 0x40000,
SPA_ID_OBJECT_MonitorItem, SPA_ID_OBJECT_MonitorItem,
SPA_ID_OBJECT_ParamList, SPA_ID_OBJECT_ParamList,
@ -92,6 +106,12 @@ enum {
SPA_ID_PARAM_Meta, /**< allowed metadata for buffers */ SPA_ID_PARAM_Meta, /**< allowed metadata for buffers */
SPA_ID_PARAM_IO, /**< configurable IO areas */ SPA_ID_PARAM_IO, /**< configurable IO areas */
/* Pointers */
SPA_ID_POINTER_BASE = 0x60000,
SPA_ID_POINTER_Buffer,
SPA_ID_POINTER_Meta,
SPA_ID_POINTER_Dict,
/* vendor extensions */ /* vendor extensions */
SPA_ID_VENDOR_PipeWire = 0x01000000, SPA_ID_VENDOR_PipeWire = 0x01000000,

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

@ -347,7 +347,7 @@ static void impl_on_fd_events(struct spa_source *source)
struct impl *this = source->data; struct impl *this = source->data;
struct udev_device *dev; struct udev_device *dev;
const char *action; const char *action;
uint32_t type; uint32_t id;
struct card *card; struct card *card;
struct spa_event *event; struct spa_event *event;
@ -357,18 +357,18 @@ static void impl_on_fd_events(struct spa_source *source)
action = "change"; action = "change";
if (strcmp(action, "add") == 0) { if (strcmp(action, "add") == 0) {
type = SPA_ID_EVENT_MONITOR_Added; id = SPA_MONITOR_EVENT_Added;
} else if (strcmp(action, "change") == 0) { } else if (strcmp(action, "change") == 0) {
type = SPA_ID_EVENT_MONITOR_Changed; id = SPA_MONITOR_EVENT_Changed;
} else if (strcmp(action, "remove") == 0) { } else if (strcmp(action, "remove") == 0) {
type = SPA_ID_EVENT_MONITOR_Removed; id = SPA_MONITOR_EVENT_Removed;
} else } else
return; return;
if ((card = find_card(this, dev)) == NULL) if ((card = find_card(this, dev)) == NULL)
return; return;
if (type == SPA_ID_EVENT_MONITOR_Removed) { if (id == SPA_MONITOR_EVENT_Removed) {
int i; int i;
for (i = 0; i < MAX_DEVICES; i++) { for (i = 0; i < MAX_DEVICES; i++) {
@ -380,7 +380,7 @@ static void impl_on_fd_events(struct spa_source *source)
if (SPA_FLAG_CHECK(device->flags, DEVICE_FLAG_PLAYBACK)) { if (SPA_FLAG_CHECK(device->flags, DEVICE_FLAG_PLAYBACK)) {
snprintf(id, 64, "%s,%d/P", card->name, device->id); snprintf(id, 64, "%s,%d/P", card->name, device->id);
event = spa_pod_builder_object(&b, 0, type); event = spa_pod_builder_object(&b, id, SPA_ID_EVENT_Monitor);
spa_pod_builder_object(&b, spa_pod_builder_object(&b,
0, SPA_ID_OBJECT_MonitorItem, 0, SPA_ID_OBJECT_MonitorItem,
":", SPA_MONITOR_ITEM_id, "s", id, ":", SPA_MONITOR_ITEM_id, "s", id,
@ -389,7 +389,7 @@ static void impl_on_fd_events(struct spa_source *source)
} }
if (SPA_FLAG_CHECK(device->flags, DEVICE_FLAG_RECORD)) { if (SPA_FLAG_CHECK(device->flags, DEVICE_FLAG_RECORD)) {
snprintf(id, 64, "%s,%d/C", card->name, device->id); snprintf(id, 64, "%s,%d/C", card->name, device->id);
event = spa_pod_builder_object(&b, 0, type); event = spa_pod_builder_object(&b, id, SPA_ID_EVENT_Monitor);
spa_pod_builder_object(&b, spa_pod_builder_object(&b,
0, SPA_ID_OBJECT_MonitorItem, 0, SPA_ID_OBJECT_MonitorItem,
":", SPA_MONITOR_ITEM_id, "s", id, ":", SPA_MONITOR_ITEM_id, "s", id,
@ -408,7 +408,7 @@ static void impl_on_fd_events(struct spa_source *source)
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer)); struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
struct spa_pod *item; struct spa_pod *item;
event = spa_pod_builder_object(&b, 0, type); event = spa_pod_builder_object(&b, id, SPA_ID_EVENT_Monitor);
if (get_next_device(this, card, &item, &b) < 0) if (get_next_device(this, card, &item, &b) < 0)
break; break;

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

@ -190,8 +190,8 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct state, node); this = SPA_CONTAINER_OF(node, struct state, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
if (!this->have_format) if (!this->have_format)
return -EIO; return -EIO;
if (this->n_buffers == 0) if (this->n_buffers == 0)
@ -200,7 +200,7 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
if ((res = spa_alsa_start(this, false)) < 0) if ((res = spa_alsa_start(this, false)) < 0)
return res; return res;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if ((res = spa_alsa_pause(this, false)) < 0) if ((res = spa_alsa_pause(this, false)) < 0)
return res; return res;
break; break;

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

@ -192,8 +192,8 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct state, node); this = SPA_CONTAINER_OF(node, struct state, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
if (!this->have_format) if (!this->have_format)
return -EIO; return -EIO;
if (this->n_buffers == 0) if (this->n_buffers == 0)
@ -202,7 +202,7 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
if ((res = spa_alsa_start(this, false)) < 0) if ((res = spa_alsa_start(this, false)) < 0)
return res; return res;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if ((res = spa_alsa_pause(this, false)) < 0) if ((res = spa_alsa_pause(this, false)) < 0)
return res; return res;
break; break;

6
spa/plugins/audioconvert/audioconvert.c
View file

@ -431,14 +431,14 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
if ((res = setup_convert(this)) < 0) if ((res = setup_convert(this)) < 0)
goto error; goto error;
setup_buffers(this, SPA_DIRECTION_INPUT); setup_buffers(this, SPA_DIRECTION_INPUT);
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

6
spa/plugins/audioconvert/channelmix.c
View file

@ -198,11 +198,11 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

6
spa/plugins/audioconvert/fmtconvert.c
View file

@ -224,11 +224,11 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

6
spa/plugins/audioconvert/merger.c
View file

@ -127,11 +127,11 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

6
spa/plugins/audioconvert/resample.c
View file

@ -168,11 +168,11 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

6
spa/plugins/audioconvert/splitter.c
View file

@ -127,11 +127,11 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

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

@ -145,11 +145,11 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

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

@ -388,8 +388,8 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
{ {
struct timespec now; struct timespec now;
@ -413,7 +413,7 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
set_timer(this, true); set_timer(this, true);
break; break;
} }
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if (!this->have_format) if (!this->have_format)
return -EIO; return -EIO;
if (this->n_buffers == 0) if (this->n_buffers == 0)

6
spa/plugins/bluez5/a2dp-sink.c
View file

@ -811,8 +811,8 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
if (!this->have_format) if (!this->have_format)
return -EIO; return -EIO;
if (this->n_buffers == 0) if (this->n_buffers == 0)
@ -821,7 +821,7 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
if ((res = do_start(this)) < 0) if ((res = do_start(this)) < 0)
return res; return res;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if ((res = do_stop(this)) < 0) if ((res = do_stop(this)) < 0)
return res; return res;
break; break;

4
spa/plugins/bluez5/bluez5-monitor.c
View file

@ -640,7 +640,7 @@ static struct spa_bt_node *node_create(struct spa_bt_monitor *monitor, struct sp
struct spa_pod *item; struct spa_pod *item;
spa_pod_builder_init(&b, buffer, sizeof(buffer)); spa_pod_builder_init(&b, buffer, sizeof(buffer));
event = spa_pod_builder_object(&b, 0, SPA_ID_EVENT_MONITOR_Added); event = spa_pod_builder_object(&b, SPA_MONITOR_EVENT_Added, SPA_ID_EVENT_Monitor);
fill_item(monitor, transport, &item, &b); fill_item(monitor, transport, &item, &b);
monitor->callbacks->event(monitor->callbacks_data, event); monitor->callbacks->event(monitor->callbacks_data, event);
@ -656,7 +656,7 @@ static struct spa_bt_node *node_destroy(struct spa_bt_monitor *monitor, struct s
struct spa_pod *item; struct spa_pod *item;
spa_pod_builder_init(&b, buffer, sizeof(buffer)); spa_pod_builder_init(&b, buffer, sizeof(buffer));
event = spa_pod_builder_object(&b, 0, SPA_ID_EVENT_MONITOR_Removed); event = spa_pod_builder_object(&b, SPA_MONITOR_EVENT_Removed, SPA_ID_EVENT_Monitor);
fill_item(monitor, transport, &item, &b); fill_item(monitor, transport, &item, &b);
monitor->callbacks->event(monitor->callbacks_data, event); monitor->callbacks->event(monitor->callbacks_data, event);

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

@ -92,11 +92,11 @@ static int spa_ffmpeg_dec_node_send_command(struct spa_node *node, const struct
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

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

@ -94,11 +94,11 @@ static int spa_ffmpeg_enc_node_send_command(struct spa_node *node, const struct
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

6
spa/plugins/test/fakesink.c
View file

@ -268,8 +268,8 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
{ {
struct timespec now; struct timespec now;
@ -293,7 +293,7 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
set_timer(this, true); set_timer(this, true);
break; break;
} }
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if (!this->have_format) if (!this->have_format)
return -EIO; return -EIO;
if (this->n_buffers == 0) if (this->n_buffers == 0)

6
spa/plugins/test/fakesrc.c
View file

@ -285,8 +285,8 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
{ {
struct timespec now; struct timespec now;
@ -311,7 +311,7 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
set_timer(this, true); set_timer(this, true);
break; break;
} }
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if (!this->have_format) if (!this->have_format)
return -EIO; return -EIO;
if (this->n_buffers == 0) if (this->n_buffers == 0)

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

@ -178,16 +178,16 @@ static void impl_on_fd_events(struct spa_source *source)
action = "change"; action = "change";
if (strcmp(action, "add") == 0) { if (strcmp(action, "add") == 0) {
type = SPA_ID_EVENT_MONITOR_Added; type = SPA_MONITOR_EVENT_Added;
} else if (strcmp(action, "change") == 0) { } else if (strcmp(action, "change") == 0) {
type = SPA_ID_EVENT_MONITOR_Changed; type = SPA_MONITOR_EVENT_Changed;
} else if (strcmp(action, "remove") == 0) { } else if (strcmp(action, "remove") == 0) {
type = SPA_ID_EVENT_MONITOR_Removed; type = SPA_MONITOR_EVENT_Removed;
} else } else
return; return;
spa_pod_builder_init(&b, buffer, sizeof(buffer)); spa_pod_builder_init(&b, buffer, sizeof(buffer));
event = spa_pod_builder_object(&b, 0, type); event = spa_pod_builder_object(&b, type, SPA_ID_EVENT_Monitor);
fill_item(this, &this->uitem, dev, &item, &b); fill_item(this, &this->uitem, dev, &item, &b);
this->callbacks->event(this->callbacks_data, event); this->callbacks->event(this->callbacks_data, event);

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

@ -269,8 +269,8 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
{ {
struct port *port = GET_OUT_PORT(this, 0); struct port *port = GET_OUT_PORT(this, 0);
@ -283,7 +283,7 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
return res; return res;
break; break;
} }
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if ((res = spa_v4l2_stream_off(this)) < 0) if ((res = spa_v4l2_stream_off(this)) < 0)
return res; return res;
break; break;

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

@ -409,7 +409,7 @@ enum_filter_format(uint32_t media_type, int32_t media_subtype,
if (!(p = spa_pod_find_prop(filter, SPA_FORMAT_VIDEO_format))) if (!(p = spa_pod_find_prop(filter, SPA_FORMAT_VIDEO_format)))
return SPA_VIDEO_FORMAT_UNKNOWN; return SPA_VIDEO_FORMAT_UNKNOWN;
if (p->body.value.type != SPA_POD_TYPE_ID) if (p->body.value.type != SPA_ID_Enum)
return SPA_VIDEO_FORMAT_UNKNOWN; return SPA_VIDEO_FORMAT_UNKNOWN;
values = SPA_POD_BODY_CONST(&p->body.value); values = SPA_POD_BODY_CONST(&p->body.value);
@ -596,7 +596,7 @@ spa_v4l2_enum_format(struct impl *this,
if (!(p = spa_pod_find_prop(filter, SPA_FORMAT_VIDEO_size))) if (!(p = spa_pod_find_prop(filter, SPA_FORMAT_VIDEO_size)))
goto do_frmsize; goto do_frmsize;
if (p->body.value.type != SPA_POD_TYPE_RECTANGLE) { if (p->body.value.type != SPA_ID_Rectangle) {
goto enum_end; goto enum_end;
} }
@ -717,7 +717,7 @@ spa_v4l2_enum_format(struct impl *this,
if (!(p = spa_pod_find_prop(filter, SPA_FORMAT_VIDEO_framerate))) if (!(p = spa_pod_find_prop(filter, SPA_FORMAT_VIDEO_framerate)))
goto have_framerate; goto have_framerate;
if (p->body.value.type != SPA_POD_TYPE_FRACTION) if (p->body.value.type != SPA_ID_Fraction)
goto enum_end; goto enum_end;
range = p->body.flags & SPA_POD_PROP_RANGE_MASK; range = p->body.flags & SPA_POD_PROP_RANGE_MASK;

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

@ -327,8 +327,8 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
{ {
struct timespec now; struct timespec now;
@ -352,7 +352,7 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
set_timer(this, true); set_timer(this, true);
break; break;
} }
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if (!this->have_format) if (!this->have_format)
return -EIO; return -EIO;
if (this->n_buffers == 0) if (this->n_buffers == 0)

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

@ -217,11 +217,11 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

8
spa/tests/test-bluez5.c
View file

@ -99,16 +99,16 @@ static void monitor_event(void *_data, struct spa_event *event)
{ {
struct data *data = _data; struct data *data = _data;
switch (SPA_EVENT_TYPE(event)) { switch (SPA_MONITOR_EVENT_ID(event)) {
case SPA_ID_EVENT_MONITOR_Added: case SPA_MONITOR_EVENT_Added:
fprintf(stderr, "added:\n"); fprintf(stderr, "added:\n");
inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event)); inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event));
break; break;
case SPA_ID_EVENT_MONITOR_Removed: case SPA_MONITOR_EVENT_Removed:
fprintf(stderr, "removed:\n"); fprintf(stderr, "removed:\n");
inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event)); inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event));
break; break;
case SPA_ID_EVENT_MONITOR_Changed: case SPA_MONITOR_EVENT_Changed:
fprintf(stderr, "changed:\n"); fprintf(stderr, "changed:\n");
inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event)); inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event));
break; break;

4
spa/tests/test-control.c
View file

@ -481,7 +481,7 @@ static void run_async_sink(struct data *data)
int err; int err;
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)
printf("got source error %d\n", res); printf("got source error %d\n", res);
if ((res = spa_node_send_command(data->sink, &cmd)) < 0) if ((res = spa_node_send_command(data->sink, &cmd)) < 0)
@ -503,7 +503,7 @@ static void run_async_sink(struct data *data)
} }
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
if ((res = spa_node_send_command(data->sink, &cmd)) < 0) if ((res = spa_node_send_command(data->sink, &cmd)) < 0)
printf("got error %d\n", res); printf("got error %d\n", res);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)

4
spa/tests/test-convert.c
View file

@ -314,7 +314,7 @@ static void run_convert(struct data *data)
int res; int res;
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
if ((res = spa_node_send_command(data->conv, &cmd)) < 0) if ((res = spa_node_send_command(data->conv, &cmd)) < 0)
printf("got convert error %d\n", res); printf("got convert error %d\n", res);
} }
@ -336,7 +336,7 @@ static void run_convert(struct data *data)
spa_debug_mem(0, data->out_buffers[0]->datas[1].data, BUFFER_SIZE); spa_debug_mem(0, data->out_buffers[0]->datas[1].data, BUFFER_SIZE);
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
if ((res = spa_node_send_command(data->conv, &cmd)) < 0) if ((res = spa_node_send_command(data->conv, &cmd)) < 0)
printf("got convert error %d\n", res); printf("got convert error %d\n", res);
} }

4
spa/tests/test-convert2.c
View file

@ -435,7 +435,7 @@ static void run_convert(struct data *data)
int res, i, j; int res, i, j;
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if ((res = spa_node_send_command(data->nodes[i].node, &cmd)) < 0) if ((res = spa_node_send_command(data->nodes[i].node, &cmd)) < 0)
printf("got command error %d\n", res); printf("got command error %d\n", res);
@ -468,7 +468,7 @@ static void run_convert(struct data *data)
spa_debug_mem(0, b->datas[i].data, b->datas[i].maxsize); spa_debug_mem(0, b->datas[i].data, b->datas[i].maxsize);
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if ((res = spa_node_send_command(data->nodes[i].node, &cmd)) < 0) if ((res = spa_node_send_command(data->nodes[i].node, &cmd)) < 0)
printf("got command error %d\n", res); printf("got command error %d\n", res);

4
spa/tests/test-graph.c
View file

@ -470,7 +470,7 @@ static void run_async_sink(struct data *data)
int err; int err;
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)
printf("got source error %d\n", res); printf("got source error %d\n", res);
if ((res = spa_node_send_command(data->volume, &cmd)) < 0) if ((res = spa_node_send_command(data->volume, &cmd)) < 0)
@ -494,7 +494,7 @@ static void run_async_sink(struct data *data)
} }
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
if ((res = spa_node_send_command(data->sink, &cmd)) < 0) if ((res = spa_node_send_command(data->sink, &cmd)) < 0)
printf("got error %d\n", res); printf("got error %d\n", res);
if ((res = spa_node_send_command(data->volume, &cmd)) < 0) if ((res = spa_node_send_command(data->volume, &cmd)) < 0)

4
spa/tests/test-mixer.c
View file

@ -617,7 +617,7 @@ static void run_async_sink(struct data *data)
int err; int err;
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
if ((res = spa_node_send_command(data->source1, &cmd)) < 0) if ((res = spa_node_send_command(data->source1, &cmd)) < 0)
printf("got source1 error %d\n", res); printf("got source1 error %d\n", res);
if ((res = spa_node_send_command(data->source2, &cmd)) < 0) if ((res = spa_node_send_command(data->source2, &cmd)) < 0)
@ -643,7 +643,7 @@ static void run_async_sink(struct data *data)
} }
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
if ((res = spa_node_send_command(data->sink, &cmd)) < 0) if ((res = spa_node_send_command(data->sink, &cmd)) < 0)
printf("got error %d\n", res); printf("got error %d\n", res);
if ((res = spa_node_send_command(data->mix, &cmd)) < 0) if ((res = spa_node_send_command(data->mix, &cmd)) < 0)

4
spa/tests/test-perf.c
View file

@ -451,7 +451,7 @@ static void run_graph(struct data *data)
int64_t start, stop; int64_t start, stop;
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)
printf("got source error %d\n", res); printf("got source error %d\n", res);
if ((res = spa_node_send_command(data->sink, &cmd)) < 0) if ((res = spa_node_send_command(data->sink, &cmd)) < 0)
@ -486,7 +486,7 @@ static void run_graph(struct data *data)
printf("stopping, elapsed %" PRIi64 "\n", stop - start); printf("stopping, elapsed %" PRIi64 "\n", stop - start);
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
if ((res = spa_node_send_command(data->sink, &cmd)) < 0) if ((res = spa_node_send_command(data->sink, &cmd)) < 0)
printf("got error %d\n", res); printf("got error %d\n", res);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)

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

@ -204,7 +204,7 @@ static void do_static_struct(void)
sizeof(struct spa_pod_prop_body), sizeof(struct spa_pod_prop_body),
SPA_FORMAT_VIDEO_format, SPA_FORMAT_VIDEO_format,
SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET, SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET,
sizeof(uint32_t), SPA_POD_TYPE_ID), sizeof(uint32_t), SPA_ID_Enum),
{ {
SPA_VIDEO_FORMAT_I420, SPA_VIDEO_FORMAT_I420,
{ SPA_VIDEO_FORMAT_I420, SPA_VIDEO_FORMAT_YUY2 } { SPA_VIDEO_FORMAT_I420, SPA_VIDEO_FORMAT_YUY2 }
@ -213,7 +213,7 @@ static void do_static_struct(void)
sizeof(struct spa_pod_prop_body), sizeof(struct spa_pod_prop_body),
SPA_FORMAT_VIDEO_size, SPA_FORMAT_VIDEO_size,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
sizeof(struct spa_rectangle), SPA_POD_TYPE_RECTANGLE), sizeof(struct spa_rectangle), SPA_ID_Rectangle),
{ {
SPA_RECTANGLE(320,243), SPA_RECTANGLE(320,243),
@ -223,7 +223,7 @@ static void do_static_struct(void)
sizeof(struct spa_pod_prop_body), sizeof(struct spa_pod_prop_body),
SPA_FORMAT_VIDEO_framerate, SPA_FORMAT_VIDEO_framerate,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
sizeof(struct spa_fraction), SPA_POD_TYPE_FRACTION), sizeof(struct spa_fraction), SPA_ID_Fraction),
{ {
SPA_FRACTION(25,1), SPA_FRACTION(25,1),
SPA_FRACTION(0,1), SPA_FRACTION(INT32_MAX,1) SPA_FRACTION(0,1), SPA_FRACTION(INT32_MAX,1)

72
spa/tests/test-props4.c
View file

@ -258,49 +258,49 @@ static inline int spa_pod_id_to_type(char id)
{ {
switch (id) { switch (id) {
case 'n': case 'n':
return SPA_POD_TYPE_NONE; return SPA_ID_None;
case 'b': case 'b':
return SPA_POD_TYPE_BOOL; return SPA_ID_Bool;
case 'I': case 'I':
return SPA_POD_TYPE_ID; return SPA_ID_Enum;
case 'i': case 'i':
return SPA_POD_TYPE_INT; return SPA_ID_INT;
case 'l': case 'l':
return SPA_POD_TYPE_LONG; return SPA_ID_LONG;
case 'f': case 'f':
return SPA_POD_TYPE_FLOAT; return SPA_ID_FLOAT;
case 'd': case 'd':
return SPA_POD_TYPE_DOUBLE; return SPA_ID_DOUBLE;
case 's': case 's':
return SPA_POD_TYPE_STRING; return SPA_ID_STRING;
case 'k': case 'k':
return SPA_POD_TYPE_KEY; return SPA_ID_KEY;
case 'z': case 'z':
return SPA_POD_TYPE_BYTES; return SPA_ID_BYTES;
case 'R': case 'R':
return SPA_POD_TYPE_RECTANGLE; return SPA_ID_RECTANGLE;
case 'F': case 'F':
return SPA_POD_TYPE_FRACTION; return SPA_ID_FRACTION;
case 'B': case 'B':
return SPA_POD_TYPE_BITMASK; return SPA_ID_BITMASK;
case 'A': case 'A':
return SPA_POD_TYPE_ARRAY; return SPA_ID_ARRAY;
case 'S': case 'S':
return SPA_POD_TYPE_STRUCT; return SPA_ID_STRUCT;
case 'O': case 'O':
return SPA_POD_TYPE_OBJECT; return SPA_ID_OBJECT;
case 'M': case 'M':
return SPA_POD_TYPE_MAP; return SPA_ID_MAP;
case 'p': case 'p':
return SPA_POD_TYPE_POINTER; return SPA_ID_POINTER;
case 'h': case 'h':
return SPA_POD_TYPE_FD; return SPA_ID_FD;
case 'V': case 'v': case 'V': case 'v':
return SPA_POD_TYPE_PROP; return SPA_ID_PROP;
case 'P': case 'P':
return SPA_POD_TYPE_POD; return SPA_ID_POD;
default: default:
return SPA_POD_TYPE_INVALID; return SPA_ID_INVALID;
} }
} }
@ -335,7 +335,7 @@ spa_pod_parse_prop(struct spa_pod *pod, enum spa_pod_type type, struct spa_pod_p
{ {
int res; int res;
if (SPA_POD_TYPE(pod) == SPA_POD_TYPE_STRUCT) { if (SPA_POD_TYPE(pod) == SPA_ID_STRUCT) {
const char *flags; const char *flags;
char ch; char ch;
@ -348,7 +348,7 @@ spa_pod_parse_prop(struct spa_pod *pod, enum spa_pod_type type, struct spa_pod_p
return res; return res;
} }
prop->type = spa_pod_id_to_type(*flags++); prop->type = spa_pod_id_to_type(*flags++);
if (type != SPA_POD_TYPE_POD && type != SPA_POD_TYPE(prop->value)) { if (type != SPA_ID_POD && type != SPA_POD_TYPE(prop->value)) {
printf("prop chunk of wrong type %d != %d\n", SPA_POD_TYPE(prop->value), type); printf("prop chunk of wrong type %d != %d\n", SPA_POD_TYPE(prop->value), type);
return -1; return -1;
} }
@ -374,7 +374,7 @@ spa_pod_parse_prop(struct spa_pod *pod, enum spa_pod_type type, struct spa_pod_p
} }
else { else {
/* a single value */ /* a single value */
if (type != SPA_POD_TYPE_POD && type != SPA_POD_TYPE(pod)) { if (type != SPA_ID_POD && type != SPA_POD_TYPE(pod)) {
printf("prop chunk of wrong type %d != %d\n", SPA_POD_TYPE(prop->value), type); printf("prop chunk of wrong type %d != %d\n", SPA_POD_TYPE(prop->value), type);
return -1; return -1;
} }
@ -434,13 +434,13 @@ spa_pod_match(struct spa_pod *pod,
return -1; return -1;
templ += strspn(templ, " \t\r\n"); templ += strspn(templ, " \t\r\n");
if (*templ == ':') { if (*templ == ':') {
if (SPA_POD_TYPE(it[depth].data) != SPA_POD_TYPE_MAP) if (SPA_POD_TYPE(it[depth].data) != SPA_ID_MAP)
return -1; return -1;
it[depth].offset = sizeof(struct spa_pod_map); it[depth].offset = sizeof(struct spa_pod_map);
/* move to key */ /* move to key */
while (spa_pod_iter_has_next(&it[depth])) { while (spa_pod_iter_has_next(&it[depth])) {
current = spa_pod_iter_next(&it[depth]); current = spa_pod_iter_next(&it[depth]);
if (SPA_POD_TYPE(current) == SPA_POD_TYPE_KEY && if (SPA_POD_TYPE(current) == SPA_ID_KEY &&
strncmp(SPA_POD_CONTENTS_CONST(struct spa_pod_key, current), strncmp(SPA_POD_CONTENTS_CONST(struct spa_pod_key, current),
start, len) == 0) start, len) == 0)
break; break;
@ -448,7 +448,7 @@ spa_pod_match(struct spa_pod *pod,
} }
} }
else { else {
if (current == NULL || SPA_POD_TYPE(current) != SPA_POD_TYPE_STRING || if (current == NULL || SPA_POD_TYPE(current) != SPA_ID_STRING ||
strncmp(SPA_POD_CONTENTS_CONST(struct spa_pod_string, current), strncmp(SPA_POD_CONTENTS_CONST(struct spa_pod_string, current),
start, len) != 0) start, len) != 0)
goto done; goto done;
@ -499,7 +499,7 @@ spa_pod_match(struct spa_pod *pod,
no_current: no_current:
type = spa_pod_id_to_type(*templ); type = spa_pod_id_to_type(*templ);
if (current == NULL || (type != SPA_POD_TYPE_POD && type != SPA_POD_TYPE(current))) { if (current == NULL || (type != SPA_ID_POD && type != SPA_POD_TYPE(current))) {
if (!maybe) if (!maybe)
return -1; return -1;
if (store) if (store)
@ -572,13 +572,13 @@ spa_pod_match(struct spa_pod *pod,
doubleval = strtod(start, (char **) &templ); doubleval = strtod(start, (char **) &templ);
if (*templ == 'f') { if (*templ == 'f') {
if (current == NULL || if (current == NULL ||
SPA_POD_TYPE(current) != SPA_POD_TYPE_FLOAT || SPA_POD_TYPE(current) != SPA_ID_FLOAT ||
doubleval != SPA_POD_VALUE(struct spa_pod_float, current)) doubleval != SPA_POD_VALUE(struct spa_pod_float, current))
goto done; goto done;
break; break;
} }
else if (current == NULL || else if (current == NULL ||
SPA_POD_TYPE(current) != SPA_POD_TYPE_DOUBLE || SPA_POD_TYPE(current) != SPA_ID_DOUBLE ||
doubleval != SPA_POD_VALUE(struct spa_pod_double, current)) doubleval != SPA_POD_VALUE(struct spa_pod_double, current))
goto done; goto done;
goto next; goto next;
@ -586,7 +586,7 @@ spa_pod_match(struct spa_pod *pod,
switch (*templ) { switch (*templ) {
case 'x': case 'x':
if (current == NULL || if (current == NULL ||
SPA_POD_TYPE(current) != SPA_POD_TYPE_RECTANGLE) SPA_POD_TYPE(current) != SPA_ID_RECTANGLE)
goto done; goto done;
rectval = &SPA_POD_VALUE(struct spa_pod_rectangle, current); rectval = &SPA_POD_VALUE(struct spa_pod_rectangle, current);
@ -596,7 +596,7 @@ spa_pod_match(struct spa_pod *pod,
goto next; goto next;
case '/': case '/':
if (current == NULL || if (current == NULL ||
SPA_POD_TYPE(current) != SPA_POD_TYPE_FRACTION) SPA_POD_TYPE(current) != SPA_ID_FRACTION)
goto done; goto done;
fracval = &SPA_POD_VALUE(struct spa_pod_fraction, current); fracval = &SPA_POD_VALUE(struct spa_pod_fraction, current);
@ -606,13 +606,13 @@ spa_pod_match(struct spa_pod *pod,
goto next; goto next;
case 'l': case 'l':
if (current == NULL || if (current == NULL ||
SPA_POD_TYPE(current) != SPA_POD_TYPE_LONG || SPA_POD_TYPE(current) != SPA_ID_LONG ||
SPA_POD_VALUE(struct spa_pod_long, current) != intval) SPA_POD_VALUE(struct spa_pod_long, current) != intval)
goto done; goto done;
break; break;
default: default:
if (current == NULL || if (current == NULL ||
SPA_POD_TYPE(current) != SPA_POD_TYPE_INT || SPA_POD_TYPE(current) != SPA_ID_INT ||
SPA_POD_VALUE(struct spa_pod_int, current) != intval) SPA_POD_VALUE(struct spa_pod_int, current) != intval)
goto done; goto done;
break; break;
@ -752,7 +752,7 @@ int main(int argc, char *argv[])
" \"foz\": %h, " " \"foz\": %h, "
" } " " } "
"] ", format, rate, channels, "] ", format, rate, channels,
sizeof(struct spa_rectangle), SPA_POD_TYPE_RECTANGLE, 3, rects, sizeof(struct spa_rectangle), SPA_ID_RECTANGLE, 3, rects,
&pod, &pod,
bytes, sizeof(bytes), bytes, sizeof(bytes),
fmt, fmt,

4
spa/tests/test-ringbuffer.c
View file

@ -382,7 +382,7 @@ static void run_async_sink(struct data *data)
int err; int err;
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)
printf("got source error %d\n", res); printf("got source error %d\n", res);
if ((res = spa_node_send_command(data->sink, &cmd)) < 0) if ((res = spa_node_send_command(data->sink, &cmd)) < 0)
@ -404,7 +404,7 @@ static void run_async_sink(struct data *data)
} }
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
if ((res = spa_node_send_command(data->sink, &cmd)) < 0) if ((res = spa_node_send_command(data->sink, &cmd)) < 0)
printf("got sink error %d\n", res); printf("got sink error %d\n", res);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)

4
spa/tests/test-v4l2.c
View file

@ -497,7 +497,7 @@ static void run_async_source(struct data *data)
int err; int err;
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)
printf("got error %d\n", res); printf("got error %d\n", res);
} }
@ -516,7 +516,7 @@ static void run_async_source(struct data *data)
} }
{ {
struct spa_command cmd = SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause); struct spa_command cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause);
if ((res = spa_node_send_command(data->source, &cmd)) < 0) if ((res = spa_node_send_command(data->source, &cmd)) < 0)
printf("got error %d\n", res); printf("got error %d\n", res);
} }

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

@ -53,23 +53,23 @@ struct data {
static void inspect_item(struct data *data, struct spa_pod *item) static void inspect_item(struct data *data, struct spa_pod *item)
{ {
spa_debug_pod(0, spa_type_monitor, item); spa_debug_pod(0, spa_type_monitor_item, item);
} }
static void on_monitor_event(void *_data, struct spa_event *event) static void on_monitor_event(void *_data, struct spa_event *event)
{ {
struct data *data = _data; struct data *data = _data;
switch (SPA_EVENT_TYPE(event)) { switch (SPA_MONITOR_EVENT_ID(event)) {
case SPA_ID_EVENT_MONITOR_Added: case SPA_MONITOR_EVENT_Added:
fprintf(stderr, "added:\n"); fprintf(stderr, "added:\n");
inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event)); inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event));
break; break;
case SPA_ID_EVENT_MONITOR_Removed: case SPA_MONITOR_EVENT_Removed:
fprintf(stderr, "removed:\n"); fprintf(stderr, "removed:\n");
inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event)); inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event));
break; break;
case SPA_ID_EVENT_MONITOR_Changed: case SPA_MONITOR_EVENT_Changed:
fprintf(stderr, "changed:\n"); fprintf(stderr, "changed:\n");
inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event)); inspect_item(data, SPA_POD_CONTENTS(struct spa_event, event));
break; break;

131
src/examples/sdl.h Normal file
View file

@ -0,0 +1,131 @@
/* PipeWire
* Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <SDL2/SDL.h>
#include <spa/utils/type.h>
#include <spa/pod/builder.h>
#include <spa/param/video/raw.h>
#include <spa/param/video/format.h>
static struct {
Uint32 format;
uint32_t id;
} sdl_video_formats[] = {
{ SDL_PIXELFORMAT_UNKNOWN, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_INDEX1LSB, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_UNKNOWN, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_INDEX1LSB, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_INDEX1MSB, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_INDEX4LSB, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_INDEX4MSB, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_INDEX8, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_RGB332, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_RGB444, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_RGB555, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_BGR555, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_ARGB4444, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_RGBA4444, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_ABGR4444, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_BGRA4444, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_ARGB1555, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_RGBA5551, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_ABGR1555, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_BGRA5551, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_RGB565, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_BGR565, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_RGB24, SPA_VIDEO_FORMAT_RGB,},
{ SDL_PIXELFORMAT_RGB888, SPA_VIDEO_FORMAT_RGB,},
{ SDL_PIXELFORMAT_RGBX8888, SPA_VIDEO_FORMAT_RGBx,},
{ SDL_PIXELFORMAT_BGR24, SPA_VIDEO_FORMAT_BGR,},
{ SDL_PIXELFORMAT_BGR888, SPA_VIDEO_FORMAT_BGR,},
{ SDL_PIXELFORMAT_BGRX8888, SPA_VIDEO_FORMAT_BGRx,},
{ SDL_PIXELFORMAT_ARGB2101010, SPA_VIDEO_FORMAT_UNKNOWN,},
{ SDL_PIXELFORMAT_RGBA8888, SPA_VIDEO_FORMAT_RGBA,},
{ SDL_PIXELFORMAT_ARGB8888, SPA_VIDEO_FORMAT_ARGB,},
{ SDL_PIXELFORMAT_BGRA8888, SPA_VIDEO_FORMAT_BGRA,},
{ SDL_PIXELFORMAT_ABGR8888, SPA_VIDEO_FORMAT_ABGR,},
{ SDL_PIXELFORMAT_YV12, SPA_VIDEO_FORMAT_YV12,},
{ SDL_PIXELFORMAT_IYUV, SPA_VIDEO_FORMAT_I420,},
{ SDL_PIXELFORMAT_YUY2, SPA_VIDEO_FORMAT_YUY2,},
{ SDL_PIXELFORMAT_UYVY, SPA_VIDEO_FORMAT_UYVY,},
{ SDL_PIXELFORMAT_YVYU, SPA_VIDEO_FORMAT_YVYU,},
#if SDL_VERSION_ATLEAST(2,0,4)
{ SDL_PIXELFORMAT_NV12, SPA_VIDEO_FORMAT_NV12,},
{ SDL_PIXELFORMAT_NV21, SPA_VIDEO_FORMAT_NV21,},
#endif
};
static uint32_t sdl_format_to_id(Uint32 format)
{
size_t i;
for (i = 0; i < SPA_N_ELEMENTS(sdl_video_formats); i++) {
if (sdl_video_formats[i].format == format)
return sdl_video_formats[i].id;
}
return SPA_VIDEO_FORMAT_UNKNOWN;
}
static Uint32 id_to_sdl_format(uint32_t id)
{
size_t i;
for (i = 0; i < SPA_N_ELEMENTS(sdl_video_formats); i++) {
if (sdl_video_formats[i].id == id)
return sdl_video_formats[i].format;
}
return SDL_PIXELFORMAT_UNKNOWN;
}
static struct spa_pod *sdl_build_formats(SDL_RendererInfo *info, struct spa_pod_builder *b)
{
int i, c;
spa_pod_builder_push_object(b, SPA_ID_PARAM_EnumFormat, SPA_ID_OBJECT_Format);
spa_pod_builder_id(b, SPA_MEDIA_TYPE_video);
spa_pod_builder_id(b, SPA_MEDIA_SUBTYPE_raw);
spa_pod_builder_push_prop(b, SPA_FORMAT_VIDEO_format,
SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM);
for (i = 0, c = 0; i < info->num_texture_formats; i++) {
uint32_t id = sdl_format_to_id(info->texture_formats[i]);
if (id == 0)
continue;
if (c++ == 0)
spa_pod_builder_id(b, id);
spa_pod_builder_id(b, id);
}
for (i = 0; i < SPA_N_ELEMENTS(sdl_video_formats); i++) {
uint32_t id = sdl_video_formats[i].id;
if (id != SPA_VIDEO_FORMAT_UNKNOWN)
spa_pod_builder_id(b, id);
}
spa_pod_builder_pop(b);
spa_pod_builder_add(b,
":", SPA_FORMAT_VIDEO_size, "Rru", &SPA_RECTANGLE(WIDTH, HEIGHT),
SPA_POD_PROP_MIN_MAX(&SPA_RECTANGLE(1,1),
&SPA_RECTANGLE(info->max_texture_width,
info->max_texture_height)),
":", SPA_FORMAT_VIDEO_framerate, "Fru", &SPA_FRACTION(25,1),
SPA_POD_PROP_MIN_MAX(&SPA_FRACTION(0,1),
&SPA_FRACTION(30,1)),
NULL);
return spa_pod_builder_pop(b);
}

3
src/extensions/protocol-native.h
View file

@ -34,8 +34,7 @@ extern "C" {
struct pw_protocol_native_demarshal { struct pw_protocol_native_demarshal {
int (*func) (void *object, void *data, size_t size); int (*func) (void *object, void *data, size_t size);
#define PW_PROTOCOL_NATIVE_REMAP (1<<0) #define PW_PROTOCOL_NATIVE_PERM_W (1<<0)
#define PW_PROTOCOL_NATIVE_PERM_W (1<<1)
uint32_t flags; uint32_t flags;
}; };

2
src/modules/module-client-node/client-node.c
View file

@ -944,7 +944,7 @@ impl_node_port_send_command(struct spa_node *node,
return 0; return 0;
spa_log_trace(this->log, "send command %s", spa_log_trace(this->log, "send command %s",
spa_debug_type_find_name(spa_debug_types, SPA_COMMAND_TYPE(command))); spa_debug_type_find_name(spa_debug_types, SPA_NODE_COMMAND_ID(command)));
pw_client_node_resource_port_command(this->resource, pw_client_node_resource_port_command(this->resource,
direction, port_id, direction, port_id,

24
src/modules/module-client-node/protocol-native.c
View file

@ -899,10 +899,10 @@ static const struct pw_client_node_proxy_methods pw_protocol_native_client_node_
static const struct pw_protocol_native_demarshal pw_protocol_native_client_node_method_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_client_node_method_demarshal[] = {
{ &client_node_demarshal_done, 0 }, { &client_node_demarshal_done, 0 },
{ &client_node_demarshal_update, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_update, 0 },
{ &client_node_demarshal_port_update, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_port_update, 0 },
{ &client_node_demarshal_set_active, 0 }, { &client_node_demarshal_set_active, 0 },
{ &client_node_demarshal_event_method, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_event_method, 0 },
{ &client_node_demarshal_destroy, 0 }, { &client_node_demarshal_destroy, 0 },
}; };
@ -923,18 +923,18 @@ static const struct pw_client_node_proxy_events pw_protocol_native_client_node_e
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_client_node_event_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_client_node_event_demarshal[] = {
{ &client_node_demarshal_add_mem, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_add_mem, 0 },
{ &client_node_demarshal_transport, 0 }, { &client_node_demarshal_transport, 0 },
{ &client_node_demarshal_set_param, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_set_param, 0 },
{ &client_node_demarshal_set_io, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_set_io, 0 },
{ &client_node_demarshal_event_event, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_event_event, 0 },
{ &client_node_demarshal_command, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_command, 0 },
{ &client_node_demarshal_add_port, 0 }, { &client_node_demarshal_add_port, 0 },
{ &client_node_demarshal_remove_port, 0 }, { &client_node_demarshal_remove_port, 0 },
{ &client_node_demarshal_port_set_param, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_port_set_param, 0 },
{ &client_node_demarshal_port_use_buffers, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_port_use_buffers, 0 },
{ &client_node_demarshal_port_command, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_port_command, 0 },
{ &client_node_demarshal_port_set_io, PW_PROTOCOL_NATIVE_REMAP }, { &client_node_demarshal_port_set_io, 0 },
}; };
static const struct pw_protocol_marshal pw_protocol_native_client_node_marshal = { static const struct pw_protocol_marshal pw_protocol_native_client_node_marshal = {

6
src/modules/module-media-session/floatmix.c
View file

@ -142,11 +142,11 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node); this = SPA_CONTAINER_OF(node, struct impl, node);
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
this->started = true; this->started = true;
break; break;
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
this->started = false; this->started = false;
break; break;
default: default:

83
src/modules/module-protocol-native.c
View file

@ -109,73 +109,6 @@ struct client_data {
bool busy; bool busy;
}; };
#if 0
static bool pod_remap_data(uint32_t type, void *body, uint32_t size, struct pw_map *types)
{
void *t;
switch (type) {
case SPA_POD_TYPE_ID:
if ((t = pw_map_lookup(types, *(int32_t *) body)) == NULL)
return false;
*(int32_t *) body = PW_MAP_PTR_TO_ID(t);
break;
case SPA_POD_TYPE_PROP:
{
struct spa_pod_prop_body *b = body;
if ((t = pw_map_lookup(types, b->key)) == NULL)
return false;
b->key = PW_MAP_PTR_TO_ID(t);
if (b->value.type == SPA_POD_TYPE_ID) {
void *alt;
if (!pod_remap_data
(b->value.type, SPA_POD_BODY(&b->value), b->value.size, types))
return false;
SPA_POD_PROP_ALTERNATIVE_FOREACH(b, size, alt)
if (!pod_remap_data(b->value.type, alt, b->value.size, types))
return false;
}
break;
}
case SPA_POD_TYPE_OBJECT:
{
struct spa_pod_object_body *b = body;
struct spa_pod *p;
if ((t = pw_map_lookup(types, b->id)) != NULL)
b->id = PW_MAP_PTR_TO_ID(t);
else
b->id = SPA_ID_INVALID;
if ((t = pw_map_lookup(types, b->type)) == NULL)
return false;
b->type = PW_MAP_PTR_TO_ID(t);
SPA_POD_OBJECT_BODY_FOREACH(b, size, p)
if (!pod_remap_data(p->type, SPA_POD_BODY(p), p->size, types))
return false;
break;
}
case SPA_POD_TYPE_STRUCT:
{
struct spa_pod *b = body, *p;
SPA_POD_FOREACH(b, size, p)
if (!pod_remap_data(p->type, SPA_POD_BODY(p), p->size, types))
return false;
break;
}
default:
break;
}
return true;
}
#endif
static void static void
process_messages(struct client_data *data) process_messages(struct client_data *data)
{ {
@ -230,12 +163,6 @@ process_messages(struct client_data *data)
continue; continue;
} }
#if 0
if (demarshal[opcode].flags & PW_PROTOCOL_NATIVE_REMAP)
if (!pod_remap_data(SPA_POD_TYPE_STRUCT, message, size, &client->types))
goto invalid_message;
#endif
if (debug_messages) { if (debug_messages) {
fprintf(stderr, "<<<<<<<<< in: %d %d %d\n", id, opcode, size); fprintf(stderr, "<<<<<<<<< in: %d %d %d\n", id, opcode, size);
spa_debug_pod(0, spa_debug_types, (struct spa_pod *)message); spa_debug_pod(0, spa_debug_types, (struct spa_pod *)message);
@ -562,16 +489,6 @@ on_remote_data(void *data, int fd, enum spa_io mask)
continue; continue;
} }
#if 0
if (demarshal[opcode].flags & PW_PROTOCOL_NATIVE_REMAP) {
if (!pod_remap_data(SPA_POD_TYPE_STRUCT, message, size, &this->types)) {
pw_log_error
("protocol-native %p: invalid message received %u for %u", this,
opcode, id);
continue;
}
}
#endif
if (debug_messages) { if (debug_messages) {
fprintf(stderr, "<<<<<<<<< in: %d %d %d\n", id, opcode, size); fprintf(stderr, "<<<<<<<<< in: %d %d %d\n", id, opcode, size);
spa_debug_pod(0, spa_debug_types, (struct spa_pod *)message); spa_debug_pod(0, spa_debug_types, (struct spa_pod *)message);

22
src/modules/module-protocol-native/protocol-native.c
View file

@ -1086,7 +1086,7 @@ static const struct pw_protocol_native_demarshal pw_protocol_native_core_method_
{ &core_demarshal_get_registry, 0, }, { &core_demarshal_get_registry, 0, },
{ &core_demarshal_client_update, 0, }, { &core_demarshal_client_update, 0, },
{ &core_demarshal_permissions, 0, }, { &core_demarshal_permissions, 0, },
{ &core_demarshal_create_object, PW_PROTOCOL_NATIVE_REMAP, }, { &core_demarshal_create_object, 0, },
{ &core_demarshal_destroy, 0, } { &core_demarshal_destroy, 0, }
}; };
@ -1122,7 +1122,7 @@ static const struct pw_registry_proxy_methods pw_protocol_native_registry_method
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_registry_method_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_registry_method_demarshal[] = {
{ &registry_demarshal_bind, PW_PROTOCOL_NATIVE_REMAP, }, { &registry_demarshal_bind, 0, },
}; };
static const struct pw_registry_proxy_events pw_protocol_native_registry_event_marshal = { static const struct pw_registry_proxy_events pw_protocol_native_registry_event_marshal = {
@ -1132,7 +1132,7 @@ static const struct pw_registry_proxy_events pw_protocol_native_registry_event_m
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_registry_event_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_registry_event_demarshal[] = {
{ &registry_demarshal_global, PW_PROTOCOL_NATIVE_REMAP, }, { &registry_demarshal_global, 0, },
{ &registry_demarshal_global_remove, 0, } { &registry_demarshal_global_remove, 0, }
}; };
@ -1171,7 +1171,7 @@ static const struct pw_factory_proxy_events pw_protocol_native_factory_event_mar
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_factory_event_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_factory_event_demarshal[] = {
{ &factory_demarshal_info, PW_PROTOCOL_NATIVE_REMAP, }, { &factory_demarshal_info, 0, },
}; };
const struct pw_protocol_marshal pw_protocol_native_factory_marshal = { const struct pw_protocol_marshal pw_protocol_native_factory_marshal = {
@ -1189,7 +1189,7 @@ static const struct pw_node_proxy_methods pw_protocol_native_node_method_marshal
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_node_method_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_node_method_demarshal[] = {
{ &node_demarshal_enum_params, PW_PROTOCOL_NATIVE_REMAP, }, { &node_demarshal_enum_params, 0, },
}; };
static const struct pw_node_proxy_events pw_protocol_native_node_event_marshal = { static const struct pw_node_proxy_events pw_protocol_native_node_event_marshal = {
@ -1199,8 +1199,8 @@ static const struct pw_node_proxy_events pw_protocol_native_node_event_marshal =
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_node_event_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_node_event_demarshal[] = {
{ &node_demarshal_info, PW_PROTOCOL_NATIVE_REMAP, }, { &node_demarshal_info, 0, },
{ &node_demarshal_param, PW_PROTOCOL_NATIVE_REMAP, } { &node_demarshal_param, 0, }
}; };
static const struct pw_protocol_marshal pw_protocol_native_node_marshal = { static const struct pw_protocol_marshal pw_protocol_native_node_marshal = {
@ -1221,7 +1221,7 @@ static const struct pw_port_proxy_methods pw_protocol_native_port_method_marshal
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_port_method_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_port_method_demarshal[] = {
{ &port_demarshal_enum_params, PW_PROTOCOL_NATIVE_REMAP, }, { &port_demarshal_enum_params, 0, },
}; };
static const struct pw_port_proxy_events pw_protocol_native_port_event_marshal = { static const struct pw_port_proxy_events pw_protocol_native_port_event_marshal = {
@ -1231,8 +1231,8 @@ static const struct pw_port_proxy_events pw_protocol_native_port_event_marshal =
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_port_event_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_port_event_demarshal[] = {
{ &port_demarshal_info, PW_PROTOCOL_NATIVE_REMAP, }, { &port_demarshal_info, 0, },
{ &port_demarshal_param, PW_PROTOCOL_NATIVE_REMAP, } { &port_demarshal_param, 0, }
}; };
static const struct pw_protocol_marshal pw_protocol_native_port_marshal = { static const struct pw_protocol_marshal pw_protocol_native_port_marshal = {
@ -1270,7 +1270,7 @@ static const struct pw_link_proxy_events pw_protocol_native_link_event_marshal =
}; };
static const struct pw_protocol_native_demarshal pw_protocol_native_link_event_demarshal[] = { static const struct pw_protocol_native_demarshal pw_protocol_native_link_event_demarshal[] = {
{ &link_demarshal_info, PW_PROTOCOL_NATIVE_REMAP, } { &link_demarshal_info, 0, }
}; };
static const struct pw_protocol_marshal pw_protocol_native_link_marshal = { static const struct pw_protocol_marshal pw_protocol_native_link_marshal = {

8
src/modules/spa/spa-monitor.c
View file

@ -219,14 +219,14 @@ static void on_monitor_event(void *data, struct spa_event *event)
now_nsec = now.tv_sec * SPA_NSEC_PER_SEC + now.tv_nsec; now_nsec = now.tv_sec * SPA_NSEC_PER_SEC + now.tv_nsec;
item = SPA_POD_CONTENTS(struct spa_event, event); item = SPA_POD_CONTENTS(struct spa_event, event);
switch(SPA_EVENT_TYPE(event)) { switch (SPA_MONITOR_EVENT_ID(event)) {
case SPA_ID_EVENT_MONITOR_Added: case SPA_MONITOR_EVENT_Added:
add_item(this, item, now_nsec); add_item(this, item, now_nsec);
break; break;
case SPA_ID_EVENT_MONITOR_Removed: case SPA_MONITOR_EVENT_Removed:
remove_item(this, item, now_nsec); remove_item(this, item, now_nsec);
break; break;
case SPA_ID_EVENT_MONITOR_Changed: case SPA_MONITOR_EVENT_Changed:
change_item(this, item, now_nsec); change_item(this, item, now_nsec);
break; break;
} }

14
src/modules/spa/spa-node.c
View file

@ -187,31 +187,31 @@ setup_props(struct pw_core *core, struct spa_node *spa_node, struct pw_propertie
pw_log_info("configure prop %s", key); pw_log_info("configure prop %s", key);
switch(prop->body.value.type) { switch(prop->body.value.type) {
case SPA_POD_TYPE_BOOL: case SPA_ID_Bool:
SPA_POD_VALUE(struct spa_pod_bool, &prop->body.value) = SPA_POD_VALUE(struct spa_pod_bool, &prop->body.value) =
pw_properties_parse_bool(value); pw_properties_parse_bool(value);
break; break;
case SPA_POD_TYPE_ID: case SPA_ID_Enum:
SPA_POD_VALUE(struct spa_pod_id, &prop->body.value) = SPA_POD_VALUE(struct spa_pod_id, &prop->body.value) =
spa_debug_type_find_id(spa_debug_types, value); spa_debug_type_find_id(spa_debug_types, value);
break; break;
case SPA_POD_TYPE_INT: case SPA_ID_Int:
SPA_POD_VALUE(struct spa_pod_int, &prop->body.value) = SPA_POD_VALUE(struct spa_pod_int, &prop->body.value) =
pw_properties_parse_int(value); pw_properties_parse_int(value);
break; break;
case SPA_POD_TYPE_LONG: case SPA_ID_Long:
SPA_POD_VALUE(struct spa_pod_long, &prop->body.value) = SPA_POD_VALUE(struct spa_pod_long, &prop->body.value) =
pw_properties_parse_int64(value); pw_properties_parse_int64(value);
break; break;
case SPA_POD_TYPE_FLOAT: case SPA_ID_Float:
SPA_POD_VALUE(struct spa_pod_float, &prop->body.value) = SPA_POD_VALUE(struct spa_pod_float, &prop->body.value) =
pw_properties_parse_float(value); pw_properties_parse_float(value);
break; break;
case SPA_POD_TYPE_DOUBLE: case SPA_ID_Double:
SPA_POD_VALUE(struct spa_pod_double, &prop->body.value) = SPA_POD_VALUE(struct spa_pod_double, &prop->body.value) =
pw_properties_parse_double(value); pw_properties_parse_double(value);
break; break;
case SPA_POD_TYPE_STRING: case SPA_ID_String:
break; break;
default: default:
break; break;

4
src/pipewire/node.c
View file

@ -76,7 +76,7 @@ static int do_pause_node(struct pw_node *this)
pw_log_debug("node %p: pause node", this); pw_log_debug("node %p: pause node", this);
res = spa_node_send_command(this->node, res = spa_node_send_command(this->node,
&SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Pause)); &SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause));
if (res < 0) if (res < 0)
pw_log_debug("node %p: pause node error %s", this, spa_strerror(res)); pw_log_debug("node %p: pause node error %s", this, spa_strerror(res));
@ -97,7 +97,7 @@ static int start_node(struct pw_node *this)
pw_log_debug("node %p: start node", this); pw_log_debug("node %p: start node", this);
res = spa_node_send_command(this->node, res = spa_node_send_command(this->node,
&SPA_COMMAND_INIT(SPA_ID_COMMAND_NODE_Start)); &SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start));
if (res < 0) if (res < 0)
pw_log_debug("node %p: start node error %s", this, spa_strerror(res)); pw_log_debug("node %p: start node error %s", this, spa_strerror(res));

8
src/pipewire/remote.c
View file

@ -885,8 +885,8 @@ static void client_node_command(void *object, uint32_t seq, const struct spa_com
struct pw_remote *remote = proxy->remote; struct pw_remote *remote = proxy->remote;
int res; int res;
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
pw_log_debug("node %p: pause %d", proxy, seq); pw_log_debug("node %p: pause %d", proxy, seq);
pw_loop_update_io(remote->core->data_loop, pw_loop_update_io(remote->core->data_loop,
@ -898,7 +898,7 @@ static void client_node_command(void *object, uint32_t seq, const struct spa_com
pw_client_node_proxy_done(data->node_proxy, seq, res); pw_client_node_proxy_done(data->node_proxy, seq, res);
break; break;
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
pw_log_debug("node %p: start %d", proxy, seq); pw_log_debug("node %p: start %d", proxy, seq);
pw_loop_update_io(remote->core->data_loop, pw_loop_update_io(remote->core->data_loop,
@ -911,7 +911,7 @@ static void client_node_command(void *object, uint32_t seq, const struct spa_com
pw_client_node_proxy_done(data->node_proxy, seq, res); pw_client_node_proxy_done(data->node_proxy, seq, res);
break; break;
default: default:
pw_log_warn("unhandled node command %d", SPA_COMMAND_TYPE(command)); pw_log_warn("unhandled node command %d", SPA_NODE_COMMAND_ID(command));
pw_client_node_proxy_done(data->node_proxy, seq, -ENOTSUP); pw_client_node_proxy_done(data->node_proxy, seq, -ENOTSUP);
} }
} }

8
src/pipewire/stream.c
View file

@ -251,14 +251,14 @@ static int impl_send_command(struct spa_node *node, const struct spa_command *co
struct stream *impl = SPA_CONTAINER_OF(node, struct stream, impl_node); struct stream *impl = SPA_CONTAINER_OF(node, struct stream, impl_node);
struct pw_stream *stream = &impl->this; struct pw_stream *stream = &impl->this;
switch (SPA_COMMAND_TYPE(command)) { switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_ID_COMMAND_NODE_Pause: case SPA_NODE_COMMAND_Pause:
if (stream->state == PW_STREAM_STATE_STREAMING) { if (stream->state == PW_STREAM_STATE_STREAMING) {
pw_log_debug("stream %p: pause", stream); pw_log_debug("stream %p: pause", stream);
stream_set_state(stream, PW_STREAM_STATE_PAUSED, NULL); stream_set_state(stream, PW_STREAM_STATE_PAUSED, NULL);
} }
break; break;
case SPA_ID_COMMAND_NODE_Start: case SPA_NODE_COMMAND_Start:
if (stream->state == PW_STREAM_STATE_PAUSED) { if (stream->state == PW_STREAM_STATE_PAUSED) {
pw_log_debug("stream %p: start %d", stream, impl->direction); pw_log_debug("stream %p: start %d", stream, impl->direction);
@ -273,7 +273,7 @@ static int impl_send_command(struct spa_node *node, const struct spa_command *co
} }
break; break;
default: default:
pw_log_warn("unhandled node command %d", SPA_COMMAND_TYPE(command)); pw_log_warn("unhandled node command %d", SPA_NODE_COMMAND_ID(command));
break; break;
} }
return 0; return 0;

2
src/pipewire/work-queue.c
View file

@ -21,6 +21,8 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <spa/utils/type.h>
#include "pipewire/log.h" #include "pipewire/log.h"
#include "pipewire/work-queue.h" #include "pipewire/work-queue.h"