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

uri -> type

Browse source 
Clean up some more types.
This commit is contained in:
Wim Taymans 2017-03-24 13:11:57 +01:00
parent 5825c62d6d
commit 25b7ede0bc
46 changed files with 276 additions and 256 deletions
Download patch file Download diff file Expand all files Collapse all files

18
pinos/client/context.c
View file

@ -159,20 +159,20 @@ core_event_remove_id (void *object,
}
static void
core_event_update_uris (void *object,
uint32_t first_id,
uint32_t n_uris,
const char **uris)
core_event_update_types (void *object,
uint32_t first_id,
uint32_t n_types,
const char **types)
{
PinosProxy *proxy = object;
PinosContext *this = proxy->context;
int i;
for (i = 0; i < n_uris; i++, first_id++) {
SpaType this_id = spa_type_map_get_id (this->type.map, uris[i]);
printf ("update %d %s -> %d\n", first_id, uris[i], this_id);
for (i = 0; i < n_types; i++, first_id++) {
SpaType this_id = spa_type_map_get_id (this->type.map, types[i]);
printf ("update %d %s -> %d\n", first_id, types[i], this_id);
if (!pinos_map_insert_at (&this->types, first_id, SPA_UINT32_TO_PTR (this_id)))
pinos_log_error ("can't add uri for client");
pinos_log_error ("can't add type for client");
}
}
@ -181,7 +181,7 @@ static const PinosCoreEvents core_events = {
&core_event_done,
&core_event_error,
&core_event_remove_id,
&core_event_update_uris
&core_event_update_types
};
static void

26
pinos/gst/gstpinosformat.c
View file

@ -43,8 +43,8 @@ static struct {
SpaTypeMediaSubtype media_subtype;
SpaTypeMediaSubtypeVideo media_subtype_video;
SpaTypeMediaSubtypeAudio media_subtype_audio;
SpaTypePropVideo prop_video;
SpaTypePropAudio prop_audio;
SpaTypeFormatVideo format_video;
SpaTypeFormatAudio format_audio;
SpaTypeVideoFormat video_format;
SpaTypeAudioFormat audio_format;
} type = { 0, };
@ -59,8 +59,8 @@ ensure_types (void)
spa_type_media_subtype_map (map, &type.media_subtype);
spa_type_media_subtype_video_map (map, &type.media_subtype_video);
spa_type_media_subtype_audio_map (map, &type.media_subtype_audio);
spa_type_prop_video_map (map, &type.prop_video);
spa_type_prop_audio_map (map, &type.prop_audio);
spa_type_format_video_map (map, &type.format_video);
spa_type_format_audio_map (map, &type.format_audio);
spa_type_video_format_map (map, &type.video_format);
spa_type_audio_format_map (map, &type.audio_format);
}
@ -369,10 +369,10 @@ handle_video_fields (ConvertData *d)
for (i = 0; (v = get_nth_string (value, i)); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
type.prop_video.format,
type.format_video.format,
get_range_type (value) | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_uri (&d->b, *video_format_map[gst_video_format_from_string (v)]);
spa_pod_builder_id (&d->b, *video_format_map[gst_video_format_from_string (v)]);
}
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, SpaPODProp)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
@ -385,7 +385,7 @@ handle_video_fields (ConvertData *d)
for (i = 0; get_nth_rectangle (value, value2, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
type.prop_video.size,
type.format_video.size,
get_range_type2 (value, value2) | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_rectangle (&d->b, v.width, v.height);
@ -401,7 +401,7 @@ handle_video_fields (ConvertData *d)
for (i = 0; get_nth_fraction (value, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
type.prop_video.framerate,
type.format_video.framerate,
get_range_type (value) | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_fraction (&d->b, v.num, v.denom);
@ -426,10 +426,10 @@ handle_audio_fields (ConvertData *d)
for (i = 0; (v = get_nth_string (value, i)); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
type.prop_audio.format,
type.format_audio.format,
get_range_type (value) | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_uri (&d->b, *audio_format_map[gst_audio_format_from_string (v)]);
spa_pod_builder_id (&d->b, *audio_format_map[gst_audio_format_from_string (v)]);
}
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, SpaPODProp)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
@ -451,7 +451,7 @@ handle_audio_fields (ConvertData *d)
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
type.prop_audio.layout,
type.format_audio.layout,
get_range_type (value) | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_int (&d->b, layout);
@ -466,7 +466,7 @@ handle_audio_fields (ConvertData *d)
for (i = 0; get_nth_int (value, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
type.prop_audio.rate,
type.format_audio.rate,
get_range_type (value) | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_int (&d->b, v);
@ -481,7 +481,7 @@ handle_audio_fields (ConvertData *d)
for (i = 0; get_nth_int (value, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
type.prop_audio.channels,
type.format_audio.channels,
get_range_type (value) | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_int (&d->b, v);

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

@ -54,8 +54,8 @@ setup_video_node (PinosCore *core, SpaNode *spa_node, PinosProperties *pinos_pro
}
if ((prop = spa_pod_object_find_prop (props, spa_type_map_get_id (core->type.map, SPA_TYPE_PROPS__patternType)))) {
if (prop->body.value.type == SPA_POD_TYPE_URI)
SPA_POD_VALUE (SpaPODURI, &prop->body.value) = spa_type_map_get_id (core->type.map, pattern_type);
if (prop->body.value.type == SPA_POD_TYPE_ID)
SPA_POD_VALUE (SpaPODId, &prop->body.value) = spa_type_map_get_id (core->type.map, pattern_type);
}
if ((res = spa_node_set_props (spa_node, props)) != SPA_RESULT_OK) {

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

@ -30,7 +30,7 @@ typedef struct _SpaAllocParam SpaAllocParam;
#include <spa/type-map.h>
#include <spa/pod-utils.h>
#define SPA_TYPE__AllocParam "Spa:Object:AllocParam"
#define SPA_TYPE__AllocParam SPA_TYPE_POD_OBJECT_BASE "AllocParam"
#define SPA_TYPE_ALLOC_PARAM_BASE SPA_TYPE__AllocParam ":"
typedef struct {

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

@ -35,18 +35,18 @@ typedef struct {
uint32_t rate;
uint32_t channels;
uint32_t channel_mask;
} SpaTypePropAudio;
} SpaTypeFormatAudio;
static inline void
spa_type_prop_audio_map (SpaTypeMap *map, SpaTypePropAudio *type)
spa_type_format_audio_map (SpaTypeMap *map, SpaTypeFormatAudio *type)
{
if (type->format == 0) {
type->format = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__format);
type->flags = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__flags);
type->layout = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__layout);
type->rate = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__rate);
type->channels = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__channels);
type->channel_mask = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__channelMask);
type->format = spa_type_map_get_id (map, SPA_TYPE_FORMAT_AUDIO__format);
type->flags = spa_type_map_get_id (map, SPA_TYPE_FORMAT_AUDIO__flags);
type->layout = spa_type_map_get_id (map, SPA_TYPE_FORMAT_AUDIO__layout);
type->rate = spa_type_map_get_id (map, SPA_TYPE_FORMAT_AUDIO__rate);
type->channels = spa_type_map_get_id (map, SPA_TYPE_FORMAT_AUDIO__channels);
type->channel_mask = spa_type_map_get_id (map, SPA_TYPE_FORMAT_AUDIO__channelMask);
}
}

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

@ -29,15 +29,15 @@ extern "C" {
typedef struct _SpaAudioInfo SpaAudioInfo;
#define SPA_TYPE_PROP__Audio "Spa:Prop:Audio"
#define SPA_TYPE_PROP_AUDIO_BASE SPA_TYPE_PROP__Audio ":"
#define SPA_TYPE_FORMAT__Audio SPA_TYPE_FORMAT_BASE "Audio"
#define SPA_TYPE_FORMAT_AUDIO_BASE SPA_TYPE_FORMAT__Audio ":"
#define SPA_TYPE_PROP_AUDIO__format SPA_TYPE_PROP_AUDIO_BASE "format"
#define SPA_TYPE_PROP_AUDIO__flags SPA_TYPE_PROP_AUDIO_BASE "flags"
#define SPA_TYPE_PROP_AUDIO__layout SPA_TYPE_PROP_AUDIO_BASE "layout"
#define SPA_TYPE_PROP_AUDIO__rate SPA_TYPE_PROP_AUDIO_BASE "rate"
#define SPA_TYPE_PROP_AUDIO__channels SPA_TYPE_PROP_AUDIO_BASE "channels"
#define SPA_TYPE_PROP_AUDIO__channelMask SPA_TYPE_PROP_AUDIO_BASE "channel-mask"
#define SPA_TYPE_FORMAT_AUDIO__format SPA_TYPE_FORMAT_AUDIO_BASE "format"
#define SPA_TYPE_FORMAT_AUDIO__flags SPA_TYPE_FORMAT_AUDIO_BASE "flags"
#define SPA_TYPE_FORMAT_AUDIO__layout SPA_TYPE_FORMAT_AUDIO_BASE "layout"
#define SPA_TYPE_FORMAT_AUDIO__rate SPA_TYPE_FORMAT_AUDIO_BASE "rate"
#define SPA_TYPE_FORMAT_AUDIO__channels SPA_TYPE_FORMAT_AUDIO_BASE "channels"
#define SPA_TYPE_FORMAT_AUDIO__channelMask SPA_TYPE_FORMAT_AUDIO_BASE "channel-mask"
struct _SpaAudioInfo {
uint32_t media_type;

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

@ -28,8 +28,8 @@ typedef struct _SpaAudioInfoRaw SpaAudioInfoRaw;
#include <endian.h>
#define SPA_TYPE_AudioFormat "Spa:Enum:AudioFormat"
#define SPA_TYPE_AUDIO_FORMAT_BASE SPA_TYPE_AudioFormat ":"
#define SPA_TYPE__AudioFormat SPA_TYPE_ENUM_BASE "AudioFormat"
#define SPA_TYPE_AUDIO_FORMAT_BASE SPA_TYPE__AudioFormat ":"
#define SPA_TYPE_AUDIO_FORMAT__UNKNOWN SPA_TYPE_AUDIO_FORMAT_BASE "UNKNOWN"
#define SPA_TYPE_AUDIO_FORMAT__ENCODED SPA_TYPE_AUDIO_FORMAT_BASE "ENCODED"

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

@ -26,7 +26,7 @@ extern "C" {
typedef struct _SpaBuffer SpaBuffer;
#define SPA_TYPE__Buffer "Spa:Pointer:Buffer"
#define SPA_TYPE__Buffer SPA_TYPE_POINTER_BASE "Buffer"
#define SPA_TYPE_BUFFER_BASE SPA_TYPE__Buffer ":"
/**

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

@ -26,7 +26,7 @@ extern "C" {
typedef struct _SpaClock SpaClock;
#define SPA_TYPE__Clock "Spa:Interface:Clock"
#define SPA_TYPE__Clock SPA_TYPE_INTERFACE_BASE "Clock"
#define SPA_TYPE_CLOCK_BASE SPA_TYPE__Clock ":"
/**

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

@ -29,7 +29,7 @@ typedef struct _SpaCommand SpaCommand;
#include <spa/defs.h>
#include <spa/pod.h>
#define SPA_TYPE__Command "Spa:Object:Command"
#define SPA_TYPE__Command SPA_TYPE_POD_OBJECT_BASE "Command"
#define SPA_TYPE_COMMAND_BASE SPA_TYPE__Command ":"
typedef struct {

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

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

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

@ -29,7 +29,7 @@ typedef struct _SpaEvent SpaEvent;
#include <spa/defs.h>
#include <spa/pod.h>
#define SPA_TYPE__Event "Spa:Object:Event"
#define SPA_TYPE__Event SPA_TYPE_POD_OBJECT_BASE "Event"
#define SPA_TYPE_EVENT_BASE SPA_TYPE__Event ":"
typedef struct {

8
spa/include/spa/format-builder.h
View file

@ -38,16 +38,16 @@ spa_pod_builder_push_format (SpaPODBuilder *builder,
{
const SpaFormat p = { { sizeof (SpaFormatBody), SPA_POD_TYPE_OBJECT },
{ { 0, format_type },
{ { sizeof (uint32_t), SPA_POD_TYPE_URI }, media_type },
{ { sizeof (uint32_t), SPA_POD_TYPE_URI }, media_subtype } } };
{ { sizeof (uint32_t), SPA_POD_TYPE_ID }, media_type },
{ { sizeof (uint32_t), SPA_POD_TYPE_ID }, media_subtype } } };
return spa_pod_builder_push (builder, frame, &p.pod,
spa_pod_builder_raw (builder, &p, sizeof(p)));
}
#define spa_pod_builder_format(b,f,format_type,media_type,media_subtype,...) \
spa_pod_builder_object(b, f, 0, format_type, \
SPA_POD_TYPE_URI,media_type, \
SPA_POD_TYPE_URI,media_subtype, \
SPA_POD_TYPE_ID,media_type, \
SPA_POD_TYPE_ID,media_subtype, \
__VA_ARGS__)
SpaResult

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

@ -133,8 +133,8 @@ spa_type_media_subtype_audio_map (SpaTypeMap *map, SpaTypeMediaSubtypeAudio *typ
#define SPA_FORMAT_INIT(size,type,media_type,media_subtype,...) \
{ { size, SPA_POD_TYPE_OBJECT }, \
{ { 0, type }, \
SPA_POD_URI_INIT (media_type), \
SPA_POD_URI_INIT (media_subtype) } }
SPA_POD_ID_INIT (media_type), \
SPA_POD_ID_INIT (media_subtype) } }
#define SPA_FORMAT_BODY_FOREACH(body, size, iter) \
for ((iter) = SPA_MEMBER ((body), sizeof (SpaFormatBody), SpaPODProp); \

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

@ -24,7 +24,7 @@
extern "C" {
#endif
#define SPA_TYPE__Format "Spa:Object:Format"
#define SPA_TYPE__Format SPA_TYPE_POD_OBJECT_BASE "Format"
#define SPA_TYPE_FORMAT_BASE SPA_TYPE__Format ":"
typedef struct _SpaFormat SpaFormat;
@ -32,14 +32,14 @@ typedef struct _SpaFormat SpaFormat;
#include <spa/defs.h>
#include <spa/pod.h>
#define SPA_TYPE__MediaType "Spa:Enum:MediaType"
#define SPA_TYPE__MediaType SPA_TYPE_ENUM_BASE "MediaType"
#define SPA_TYPE_MEDIA_TYPE_BASE SPA_TYPE__MediaType ":"
#define SPA_TYPE_MEDIA_TYPE__audio SPA_TYPE_MEDIA_TYPE_BASE "audio"
#define SPA_TYPE_MEDIA_TYPE__video SPA_TYPE_MEDIA_TYPE_BASE "video"
#define SPA_TYPE_MEDIA_TYPE__image SPA_TYPE_MEDIA_TYPE_BASE "image"
#define SPA_TYPE__MediaSubtype "Spa:Enum:MediaSubtype"
#define SPA_TYPE__MediaSubtype SPA_TYPE_ENUM_BASE "MediaSubtype"
#define SPA_TYPE_MEDIA_SUBTYPE_BASE SPA_TYPE__MediaSubtype ":"
/* generic subtypes */
@ -77,8 +77,8 @@ typedef struct _SpaFormat SpaFormat;
typedef struct {
SpaPODObjectBody obj_body;
SpaPODURI media_type SPA_ALIGNED (8);
SpaPODURI media_subtype SPA_ALIGNED (8);
SpaPODId media_type SPA_ALIGNED (8);
SpaPODId media_subtype SPA_ALIGNED (8);
/* contents follow, series of SpaPODProp */
} SpaFormatBody;

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

@ -26,7 +26,7 @@ extern "C" {
typedef struct _SpaLog SpaLog;
#define SPA_TYPE__Log "Spa:Interface:Log"
#define SPA_TYPE__Log SPA_TYPE_INTERFACE_BASE "Log"
#define SPA_TYPE_LOG_BASE SPA_TYPE__Log ":"
#include <stdarg.h>

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

@ -29,11 +29,12 @@ typedef struct _SpaSource SpaSource;
typedef struct _SpaLoopControl SpaLoopControl;
typedef struct _SpaLoopUtils SpaLoopUtils;
#define SPA_TYPE__Loop "Spa:Interface:Loop"
#define SPA_TYPE__LoopControl "Spa:Interface:LoopControl"
#define SPA_TYPE__LoopUtils "Spa:Interface:LoopUtils"
#define SPA_TYPE__Loop SPA_TYPE_INTERFACE_BASE "Loop"
#define SPA_TYPE_LOOP_BASE SPA_TYPE__Loop ":"
#define SPA_TYPE__LoopControl SPA_TYPE_INTERFACE_BASE "LoopControl"
#define SPA_TYPE__LoopUtils SPA_TYPE_INTERFACE_BASE "LoopUtils"
#define SPA_TYPE_LOOP_BASE SPA_TYPE__Loop ":"
#define SPA_TYPE_LOOP__MainLoop SPA_TYPE_LOOP_BASE "MainLoop"
#define SPA_TYPE_LOOP__DataLoop SPA_TYPE_LOOP_BASE "DataLoop"

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

@ -26,7 +26,7 @@ extern "C" {
typedef struct _SpaMonitor SpaMonitor;
#define SPA_TYPE__Monitor "Spa:Interface:Monitor"
#define SPA_TYPE__Monitor SPA_TYPE_INTERFACE_BASE "Monitor"
#define SPA_TYPE_MONITOR_BASE SPA_TYPE__Monitor ":"
#include <spa/defs.h>
@ -42,8 +42,9 @@ typedef SpaEvent SpaEventMonitor;
#define SPA_TYPE_EVENT_MONITOR__Changed SPA_TYPE_EVENT_MONITOR_BASE "Changed"
typedef SpaPODObject SpaMonitorItem;
#define SPA_TYPE__MonitorItem "Spa:Object:MonitorItem"
#define SPA_TYPE__MonitorItem SPA_TYPE_POD_OBJECT_BASE "MonitorItem"
#define SPA_TYPE_MONITOR_ITEM_BASE SPA_TYPE__MonitorItem ":"
#define SPA_TYPE_MONITOR_ITEM__id SPA_TYPE_MONITOR_ITEM_BASE "id"
#define SPA_TYPE_MONITOR_ITEM__flags SPA_TYPE_MONITOR_ITEM_BASE "flags"
#define SPA_TYPE_MONITOR_ITEM__state SPA_TYPE_MONITOR_ITEM_BASE "state"

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

@ -26,7 +26,7 @@ extern "C" {
typedef struct _SpaNode SpaNode;
#define SPA_TYPE__Node "Spa:Interface:Node"
#define SPA_TYPE__Node SPA_TYPE_INTERFACE_BASE "Node"
#define SPA_TYPE_NODE_BASE SPA_TYPE__Node ":"
/**

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

@ -27,8 +27,8 @@ extern "C" {
#include <spa/defs.h>
#include <spa/dict.h>
#define SPA_TYPE__Handle "Spa:Interface:Handle"
#define SPA_TYPE__HandleFactory "Spa:Interface:HandleFactory"
#define SPA_TYPE__Handle SPA_TYPE_INTERFACE_BASE "Handle"
#define SPA_TYPE__HandleFactory SPA_TYPE_INTERFACE_BASE "HandleFactory"
typedef struct _SpaHandle SpaHandle;
typedef struct _SpaHandleFactory SpaHandleFactory;

10
spa/include/spa/pod-builder.h
View file

@ -157,12 +157,12 @@ spa_pod_builder_bool (SpaPODBuilder *builder, bool val)
return spa_pod_builder_primitive (builder, &p.pod);
}
#define SPA_POD_URI_INIT(val) { { sizeof (uint32_t), SPA_POD_TYPE_URI }, val }
#define SPA_POD_ID_INIT(val) { { sizeof (uint32_t), SPA_POD_TYPE_ID }, val }
static inline uint32_t
spa_pod_builder_uri (SpaPODBuilder *builder, uint32_t val)
spa_pod_builder_id (SpaPODBuilder *builder, uint32_t val)
{
const SpaPODURI p = SPA_POD_URI_INIT (val);
const SpaPODId p = SPA_POD_ID_INIT (val);
return spa_pod_builder_primitive (builder, &p.pod);
}
@ -332,7 +332,7 @@ spa_pod_builder_addv (SpaPODBuilder *builder,
union {
SpaPOD pod;
SpaPODBool bool_pod;
SpaPODURI uri_pod;
SpaPODId id_pod;
SpaPODInt int_pod;
SpaPODLong long_pod;
SpaPODFloat float_pod;
@ -361,7 +361,7 @@ spa_pod_builder_addv (SpaPODBuilder *builder,
case SPA_POD_TYPE_NONE:
break;
case SPA_POD_TYPE_BOOL:
case SPA_POD_TYPE_URI:
case SPA_POD_TYPE_ID:
case SPA_POD_TYPE_INT:
head.int_pod.pod.type = type;
head.int_pod.pod.size = body_size = sizeof (uint32_t);

4
spa/include/spa/pod-utils.h
View file

@ -109,7 +109,7 @@ spa_pod_object_find_prop (const SpaPODObject *obj, uint32_t key)
} else if ((pod)->type == type || (pod)->type == -type) { \
switch (type) { \
case SPA_POD_TYPE_BOOL: \
case SPA_POD_TYPE_URI: \
case SPA_POD_TYPE_ID: \
case SPA_POD_TYPE_INT: \
*(va_arg (args, int32_t*)) = SPA_POD_VALUE(SpaPODInt, pod); \
break; \
@ -175,7 +175,7 @@ spa_pod_object_find_prop (const SpaPODObject *obj, uint32_t key)
va_arg (args, void*); \
/* fallthrough */ \
case SPA_POD_TYPE_BOOL: \
case SPA_POD_TYPE_URI: \
case SPA_POD_TYPE_ID: \
case SPA_POD_TYPE_INT: \
case SPA_POD_TYPE_LONG: \
case SPA_POD_TYPE_FLOAT: \

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

@ -28,6 +28,15 @@ extern "C" {
#include <spa/defs.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 ":"
/**
* SpaPODType:
*/
@ -35,7 +44,7 @@ typedef enum {
SPA_POD_TYPE_INVALID = 0,
SPA_POD_TYPE_NONE = 1,
SPA_POD_TYPE_BOOL,
SPA_POD_TYPE_URI,
SPA_POD_TYPE_ID,
SPA_POD_TYPE_INT,
SPA_POD_TYPE_LONG,
SPA_POD_TYPE_FLOAT,
@ -55,7 +64,7 @@ typedef enum {
typedef struct {
uint32_t size;
uint32_t type;
uint32_t type; /* one of SpaPODType */
} SpaPOD;
typedef struct {
@ -65,7 +74,7 @@ typedef struct {
} SpaPODInt;
typedef SpaPODInt SpaPODBool;
typedef SpaPODInt SpaPODURI;
typedef SpaPODInt SpaPODId;
typedef struct {
SpaPOD pod;

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

@ -29,7 +29,7 @@ extern "C" {
typedef SpaPODObject SpaProps;
#define SPA_TYPE__Props "Spa:Object:Props"
#define SPA_TYPE__Props SPA_TYPE_POD_OBJECT_BASE "Props"
#define SPA_TYPE_PROPS_BASE SPA_TYPE__Props ":"
#define SPA_TYPE_PROPS__device SPA_TYPE_PROPS_BASE "device"

2
spa/include/spa/ringbuffer.h
View file

@ -26,7 +26,7 @@ extern "C" {
typedef struct _SpaRingbuffer SpaRingbuffer;
#define SPA_TYPE__RingBuffer "Spa:Object:RingBuffer"
#define SPA_TYPE__RingBuffer SPA_TYPE_INTERFACE_BASE "RingBuffer"
#define SPA_TYPE_RINGBUFFER_BASE SPA_TYPE__RingBuffer ":"
#include <string.h>

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

@ -30,8 +30,7 @@ typedef struct _SpaTypeMap SpaTypeMap;
#include <spa/plugin.h>
#include <spa/type.h>
#define SPA_TYPE__TypeMap "Spa:Interface:TypeMap"
#define SPA_TYPE_TYPE_MAP_BASE SPA_TYPE__TypeMap ":"
#define SPA_TYPE__TypeMap SPA_TYPE_INTERFACE_BASE "TypeMap"
/**
* SpaTypeMap:

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

@ -28,6 +28,16 @@ extern "C" {
typedef uint32_t SpaType;
#define SPA_TYPE_BASE "Spa:"
#define SPA_TYPE__Enum SPA_TYPE_BASE "Enum"
#define SPA_TYPE_ENUM_BASE SPA_TYPE__Enum ":"
#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 ":"
#ifdef __cplusplus
} /* extern "C" */

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

@ -47,30 +47,30 @@ typedef struct {
uint32_t level;
uint32_t stream_format;
uint32_t alignment;
} SpaTypePropVideo;
} SpaTypeFormatVideo;
static inline void
spa_type_prop_video_map (SpaTypeMap *map, SpaTypePropVideo *type)
spa_type_format_video_map (SpaTypeMap *map, SpaTypeFormatVideo *type)
{
if (type->format == 0) {
type->format = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__format);
type->size = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__size);
type->framerate = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__framerate);
type->max_framerate = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__maxFramerate);
type->views = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__views);
type->interlace_mode = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__interlaceMode);
type->pixel_aspect_ratio = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__pixelAspectRatio);
type->multiview_mode = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__multiviewMode);
type->multiview_flags = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__multiviewFlags);
type->chroma_site = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__chromaSite);
type->color_range = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorRange);
type->color_matrix = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorMatrix);
type->transfer_function = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__transferFunction);
type->color_primaries = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorPrimaries);
type->profile = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__profile);
type->level = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__level);
type->stream_format = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__streamFormat);
type->alignment = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__alignment);
type->format = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__format);
type->size = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__size);
type->framerate = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__framerate);
type->max_framerate = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__maxFramerate);
type->views = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__views);
type->interlace_mode = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__interlaceMode);
type->pixel_aspect_ratio = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__pixelAspectRatio);
type->multiview_mode = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__multiviewMode);
type->multiview_flags = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__multiviewFlags);
type->chroma_site = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__chromaSite);
type->color_range = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__colorRange);
type->color_matrix = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__colorMatrix);
type->transfer_function = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__transferFunction);
type->color_primaries = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__colorPrimaries);
type->profile = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__profile);
type->level = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__level);
type->stream_format = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__streamFormat);
type->alignment = spa_type_map_get_id (map, SPA_TYPE_FORMAT_VIDEO__alignment);
}
}

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

@ -30,27 +30,27 @@ extern "C" {
typedef struct _SpaVideoInfo SpaVideoInfo;
#define SPA_TYPE_PROP__Video "Spa:Prop:Video"
#define SPA_TYPE_PROP_VIDEO_BASE SPA_TYPE_PROP__Video ":"
#define SPA_TYPE_FORMAT__Video SPA_TYPE_FORMAT_BASE "Video"
#define SPA_TYPE_FORMAT_VIDEO_BASE SPA_TYPE_FORMAT__Video ":"
#define SPA_TYPE_PROP_VIDEO__format SPA_TYPE_PROP_VIDEO_BASE "format"
#define SPA_TYPE_PROP_VIDEO__size SPA_TYPE_PROP_VIDEO_BASE "size"
#define SPA_TYPE_PROP_VIDEO__framerate SPA_TYPE_PROP_VIDEO_BASE "framerate"
#define SPA_TYPE_PROP_VIDEO__maxFramerate SPA_TYPE_PROP_VIDEO_BASE "max-framerate"
#define SPA_TYPE_PROP_VIDEO__views SPA_TYPE_PROP_VIDEO_BASE "views"
#define SPA_TYPE_PROP_VIDEO__interlaceMode SPA_TYPE_PROP_VIDEO_BASE "interlace-mode"
#define SPA_TYPE_PROP_VIDEO__pixelAspectRatio SPA_TYPE_PROP_VIDEO_BASE "pixel-aspect-ratio"
#define SPA_TYPE_PROP_VIDEO__multiviewMode SPA_TYPE_PROP_VIDEO_BASE "multiview-mode"
#define SPA_TYPE_PROP_VIDEO__multiviewFlags SPA_TYPE_PROP_VIDEO_BASE "multiview-flags"
#define SPA_TYPE_PROP_VIDEO__chromaSite SPA_TYPE_PROP_VIDEO_BASE "chroma-site"
#define SPA_TYPE_PROP_VIDEO__colorRange SPA_TYPE_PROP_VIDEO_BASE "color-range"
#define SPA_TYPE_PROP_VIDEO__colorMatrix SPA_TYPE_PROP_VIDEO_BASE "color-matrix"
#define SPA_TYPE_PROP_VIDEO__transferFunction SPA_TYPE_PROP_VIDEO_BASE "transfer-function"
#define SPA_TYPE_PROP_VIDEO__colorPrimaries SPA_TYPE_PROP_VIDEO_BASE "color-primaries"
#define SPA_TYPE_PROP_VIDEO__profile SPA_TYPE_PROP_VIDEO_BASE "profile"
#define SPA_TYPE_PROP_VIDEO__level SPA_TYPE_PROP_VIDEO_BASE "level"
#define SPA_TYPE_PROP_VIDEO__streamFormat SPA_TYPE_PROP_VIDEO_BASE "stream-format"
#define SPA_TYPE_PROP_VIDEO__alignment SPA_TYPE_PROP_VIDEO_BASE "alignment"
#define SPA_TYPE_FORMAT_VIDEO__format SPA_TYPE_FORMAT_VIDEO_BASE "format"
#define SPA_TYPE_FORMAT_VIDEO__size SPA_TYPE_FORMAT_VIDEO_BASE "size"
#define SPA_TYPE_FORMAT_VIDEO__framerate SPA_TYPE_FORMAT_VIDEO_BASE "framerate"
#define SPA_TYPE_FORMAT_VIDEO__maxFramerate SPA_TYPE_FORMAT_VIDEO_BASE "max-framerate"
#define SPA_TYPE_FORMAT_VIDEO__views SPA_TYPE_FORMAT_VIDEO_BASE "views"
#define SPA_TYPE_FORMAT_VIDEO__interlaceMode SPA_TYPE_FORMAT_VIDEO_BASE "interlace-mode"
#define SPA_TYPE_FORMAT_VIDEO__pixelAspectRatio SPA_TYPE_FORMAT_VIDEO_BASE "pixel-aspect-ratio"
#define SPA_TYPE_FORMAT_VIDEO__multiviewMode SPA_TYPE_FORMAT_VIDEO_BASE "multiview-mode"
#define SPA_TYPE_FORMAT_VIDEO__multiviewFlags SPA_TYPE_FORMAT_VIDEO_BASE "multiview-flags"
#define SPA_TYPE_FORMAT_VIDEO__chromaSite SPA_TYPE_FORMAT_VIDEO_BASE "chroma-site"
#define SPA_TYPE_FORMAT_VIDEO__colorRange SPA_TYPE_FORMAT_VIDEO_BASE "color-range"
#define SPA_TYPE_FORMAT_VIDEO__colorMatrix SPA_TYPE_FORMAT_VIDEO_BASE "color-matrix"
#define SPA_TYPE_FORMAT_VIDEO__transferFunction SPA_TYPE_FORMAT_VIDEO_BASE "transfer-function"
#define SPA_TYPE_FORMAT_VIDEO__colorPrimaries SPA_TYPE_FORMAT_VIDEO_BASE "color-primaries"
#define SPA_TYPE_FORMAT_VIDEO__profile SPA_TYPE_FORMAT_VIDEO_BASE "profile"
#define SPA_TYPE_FORMAT_VIDEO__level SPA_TYPE_FORMAT_VIDEO_BASE "level"
#define SPA_TYPE_FORMAT_VIDEO__streamFormat SPA_TYPE_FORMAT_VIDEO_BASE "stream-format"
#define SPA_TYPE_FORMAT_VIDEO__alignment SPA_TYPE_FORMAT_VIDEO_BASE "alignment"
struct _SpaVideoInfo {
uint32_t media_type;

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

@ -34,7 +34,7 @@ typedef struct _SpaVideoInfoRaw SpaVideoInfoRaw;
#define SPA_VIDEO_MAX_PLANES 4
#define SPA_VIDEO_MAX_COMPONENTS 4
#define SPA_TYPE__VideoFormat "Spa:Enum:VideoFormat"
#define SPA_TYPE__VideoFormat SPA_TYPE_ENUM_BASE "VideoFormat"
#define SPA_TYPE_VIDEO_FORMAT_BASE SPA_TYPE__VideoFormat ":"
#define SPA_TYPE_VIDEO_FORMAT__ENCODED SPA_TYPE_VIDEO_FORMAT_BASE "encoded"

16
spa/lib/audio-raw.c
View file

@ -33,13 +33,13 @@ spa_format_audio_parse (const SpaFormat *format,
static SpaTypeMediaType media_type = { 0, };
static SpaTypeMediaSubtype media_subtype = { 0, };
static SpaTypeMediaSubtypeAudio media_subtype_audio = { 0, };
static SpaTypePropAudio prop_audio = { 0, };
static SpaTypeFormatAudio format_audio = { 0, };
SpaTypeMap *map = spa_type_map_get_default();
spa_type_media_type_map (map, &media_type);
spa_type_media_subtype_map (map, &media_subtype);
spa_type_media_subtype_audio_map (map, &media_subtype_audio);
spa_type_prop_audio_map (map, &prop_audio);
spa_type_format_audio_map (map, &format_audio);
if (format->body.media_type.value != media_type.audio)
return SPA_RESULT_INVALID_MEDIA_TYPE;
@ -49,12 +49,12 @@ spa_format_audio_parse (const SpaFormat *format,
if (info->media_subtype == media_subtype.raw) {
spa_format_query (format,
prop_audio.format, SPA_POD_TYPE_URI, &info->info.raw.format,
prop_audio.flags, SPA_POD_TYPE_INT, &info->info.raw.flags,
prop_audio.layout, SPA_POD_TYPE_INT, &info->info.raw.layout,
prop_audio.rate, SPA_POD_TYPE_INT, &info->info.raw.rate,
prop_audio.channels, SPA_POD_TYPE_INT, &info->info.raw.channels,
prop_audio.channel_mask, SPA_POD_TYPE_INT, &info->info.raw.channel_mask,
format_audio.format, SPA_POD_TYPE_ID, &info->info.raw.format,
format_audio.flags, SPA_POD_TYPE_INT, &info->info.raw.flags,
format_audio.layout, SPA_POD_TYPE_INT, &info->info.raw.layout,
format_audio.rate, SPA_POD_TYPE_INT, &info->info.raw.rate,
format_audio.channels, SPA_POD_TYPE_INT, &info->info.raw.channels,
format_audio.channel_mask, SPA_POD_TYPE_INT, &info->info.raw.channel_mask,
0);
}
else

8
spa/lib/debug.c
View file

@ -189,7 +189,7 @@ struct pod_type_name {
{ "invalid", "*Invalid*" },
{ "none", "None" },
{ "bool", "Bool" },
{ "uri", "URI" },
{ "id", "Id" },
{ "int", "Int" },
{ "long", "Long" },
{ "float", "Float" },
@ -213,8 +213,8 @@ print_pod_value (uint32_t size, uint32_t type, void *body, int prefix)
case SPA_POD_TYPE_BOOL:
printf ("%-*sBool %d\n", prefix, "", *(int32_t *) body);
break;
case SPA_POD_TYPE_URI:
printf ("%-*sURI %d %s\n", prefix, "", *(int32_t *) body,
case SPA_POD_TYPE_ID:
printf ("%-*sId %d %s\n", prefix, "", *(int32_t *) body,
spa_type_map_get_type (spa_type_map_get_default(), *(int32_t*)body));
break;
case SPA_POD_TYPE_INT:
@ -334,7 +334,7 @@ print_format_value (uint32_t size, uint32_t type, void *body)
case SPA_POD_TYPE_BOOL:
fprintf (stderr, "%s", *(int32_t *) body ? "true" : "false");
break;
case SPA_POD_TYPE_URI:
case SPA_POD_TYPE_ID:
{
const char *str = spa_type_map_get_type (spa_type_map_get_default(), *(int32_t*)body);
if (str) {

4
spa/lib/mapper.c
View file

@ -26,11 +26,11 @@
#include <lib/debug.h>
#define MAX_URIS 4096
#define MAX_TYPES 4096
typedef struct {
SpaTypeMap map;
char *types[MAX_URIS];
char *types[MAX_TYPES];
unsigned int n_types;
} TypeMap;

2
spa/lib/props.c
View file

@ -31,7 +31,7 @@ compare_value (SpaPODType type, const void *r1, const void *r2)
case SPA_POD_TYPE_INVALID:
return 0;
case SPA_POD_TYPE_BOOL:
case SPA_POD_TYPE_URI:
case SPA_POD_TYPE_ID:
return *(int32_t*)r1 == *(uint32_t*)r2 ? 0 : 1;
case SPA_POD_TYPE_INT:
return *(int32_t*)r1 - *(int32_t*)r2;

44
spa/lib/video-raw.c
View file

@ -34,13 +34,13 @@ spa_format_video_parse (const SpaFormat *format,
static SpaTypeMediaType media_type = { 0, };
static SpaTypeMediaSubtype media_subtype = { 0, };
static SpaTypeMediaSubtypeVideo media_subtype_video = { 0, };
static SpaTypePropVideo prop_video = { 0, };
static SpaTypeFormatVideo format_video = { 0, };
SpaTypeMap *map = spa_type_map_get_default ();
spa_type_media_type_map (map, &media_type);
spa_type_media_subtype_map (map, &media_subtype);
spa_type_media_subtype_video_map (map, &media_subtype_video);
spa_type_prop_video_map (map, &prop_video);
spa_type_format_video_map (map, &format_video);
if (format->body.media_type.value != media_type.video)
return SPA_RESULT_INVALID_MEDIA_TYPE;
@ -50,32 +50,32 @@ spa_format_video_parse (const SpaFormat *format,
if (info->media_subtype == media_subtype.raw)
spa_format_query (format,
prop_video.format, SPA_POD_TYPE_URI, &info->info.raw.format,
prop_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.raw.size,
prop_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.raw.framerate,
prop_video.max_framerate, SPA_POD_TYPE_FRACTION, &info->info.raw.max_framerate,
prop_video.views, SPA_POD_TYPE_INT, &info->info.raw.views,
prop_video.interlace_mode, SPA_POD_TYPE_INT, &info->info.raw.interlace_mode,
prop_video.pixel_aspect_ratio, SPA_POD_TYPE_FRACTION, &info->info.raw.pixel_aspect_ratio,
prop_video.multiview_mode, SPA_POD_TYPE_INT, &info->info.raw.multiview_mode,
prop_video.multiview_flags, SPA_POD_TYPE_INT, &info->info.raw.multiview_flags,
prop_video.chroma_site, SPA_POD_TYPE_INT, &info->info.raw.chroma_site,
prop_video.color_range, SPA_POD_TYPE_INT, &info->info.raw.color_range,
prop_video.color_matrix, SPA_POD_TYPE_INT, &info->info.raw.color_matrix,
prop_video.transfer_function, SPA_POD_TYPE_INT, &info->info.raw.transfer_function,
prop_video.color_primaries, SPA_POD_TYPE_INT, &info->info.raw.color_primaries,
format_video.format, SPA_POD_TYPE_ID, &info->info.raw.format,
format_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.raw.size,
format_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.raw.framerate,
format_video.max_framerate, SPA_POD_TYPE_FRACTION, &info->info.raw.max_framerate,
format_video.views, SPA_POD_TYPE_INT, &info->info.raw.views,
format_video.interlace_mode, SPA_POD_TYPE_INT, &info->info.raw.interlace_mode,
format_video.pixel_aspect_ratio, SPA_POD_TYPE_FRACTION, &info->info.raw.pixel_aspect_ratio,
format_video.multiview_mode, SPA_POD_TYPE_INT, &info->info.raw.multiview_mode,
format_video.multiview_flags, SPA_POD_TYPE_INT, &info->info.raw.multiview_flags,
format_video.chroma_site, SPA_POD_TYPE_INT, &info->info.raw.chroma_site,
format_video.color_range, SPA_POD_TYPE_INT, &info->info.raw.color_range,
format_video.color_matrix, SPA_POD_TYPE_INT, &info->info.raw.color_matrix,
format_video.transfer_function, SPA_POD_TYPE_INT, &info->info.raw.transfer_function,
format_video.color_primaries, SPA_POD_TYPE_INT, &info->info.raw.color_primaries,
0);
else if (info->media_subtype == media_subtype_video.h264)
spa_format_query (format,
prop_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.h264.size,
prop_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.h264.framerate,
prop_video.max_framerate, SPA_POD_TYPE_FRACTION, &info->info.h264.max_framerate,
format_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.h264.size,
format_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.h264.framerate,
format_video.max_framerate, SPA_POD_TYPE_FRACTION, &info->info.h264.max_framerate,
0);
else if (info->media_subtype == media_subtype_video.mjpg)
spa_format_query (format,
prop_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.mjpg.size,
prop_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.mjpg.framerate,
prop_video.max_framerate, SPA_POD_TYPE_FRACTION, &info->info.mjpg.max_framerate,
format_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.mjpg.size,
format_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.mjpg.framerate,
format_video.max_framerate, SPA_POD_TYPE_FRACTION, &info->info.mjpg.max_framerate,
0);
else
return SPA_RESULT_NOT_IMPLEMENTED;

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

@ -304,11 +304,11 @@ next:
case 0:
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, 3, this->type.audio_format.S16,
PROP_U_EN (&f[1], this->type.format_audio.format, SPA_POD_TYPE_ID, 3, this->type.audio_format.S16,
this->type.audio_format.S16,
this->type.audio_format.S32),
PROP_U_MM (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
PROP_U_MM (&f[1], this->type.format_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.format_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
case 1:
spa_pod_builder_format (&b, &f[0], this->type.format,

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

@ -342,11 +342,11 @@ next:
case 0:
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, 3, this->type.audio_format.S16,
PROP_U_EN (&f[1], this->type.format_audio.format, SPA_POD_TYPE_ID, 3, this->type.audio_format.S16,
this->type.audio_format.S16,
this->type.audio_format.S32),
PROP_U_MM (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
PROP_U_MM (&f[1], this->type.format_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.format_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
case 1:
spa_pod_builder_format (&b, &f[0], this->type.format,

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

@ -74,7 +74,7 @@ typedef struct {
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeMediaSubtypeAudio media_subtype_audio;
SpaTypePropAudio prop_audio;
SpaTypeFormatAudio format_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
@ -99,7 +99,7 @@ init_type (Type *type, SpaTypeMap *map)
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_media_subtype_audio_map (map, &type->media_subtype_audio);
spa_type_prop_audio_map (map, &type->prop_audio);
spa_type_format_audio_map (map, &type->format_audio);
spa_type_audio_format_map (map, &type->audio_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);

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

@ -50,7 +50,7 @@ typedef struct {
uint32_t wave_square;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypePropAudio prop_audio;
SpaTypeFormatAudio format_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
@ -73,7 +73,7 @@ init_type (Type *type, SpaTypeMap *map)
type->wave_square = spa_type_map_get_id (map, SPA_TYPE_PROPS__waveType ":square");
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_prop_audio_map (map, &type->prop_audio);
spa_type_format_audio_map (map, &type->format_audio);
spa_type_audio_format_map (map, &type->audio_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
@ -192,7 +192,7 @@ spa_audiotestsrc_node_get_props (SpaNode *node,
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_live, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], this->type.prop_wave, SPA_POD_TYPE_URI, 3, this->props.wave,
PROP_EN (&f[1], this->type.prop_wave, SPA_POD_TYPE_ID, 3, this->props.wave,
this->type.wave_sine,
this->type.wave_square),
PROP_MM (&f[1], this->type.prop_freq, SPA_POD_TYPE_DOUBLE, this->props.freq,
@ -221,7 +221,7 @@ spa_audiotestsrc_node_set_props (SpaNode *node,
} else {
spa_props_query (props,
this->type.prop_live, SPA_POD_TYPE_BOOL, &this->props.live,
this->type.prop_wave, SPA_POD_TYPE_URI, &this->props.wave,
this->type.prop_wave, SPA_POD_TYPE_ID, &this->props.wave,
this->type.prop_freq, SPA_POD_TYPE_DOUBLE, &this->props.freq,
this->type.prop_volume, SPA_POD_TYPE_DOUBLE, &this->props.volume,
0);
@ -486,11 +486,11 @@ next:
case 0:
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, 3, this->type.audio_format.S16,
PROP_U_EN (&f[1], this->type.format_audio.format, SPA_POD_TYPE_ID, 3, this->type.audio_format.S16,
this->type.audio_format.S16,
this->type.audio_format.S32),
PROP_U_MM (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
PROP_U_MM (&f[1], this->type.format_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.format_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
default:
return SPA_RESULT_ENUM_END;
@ -604,9 +604,9 @@ spa_audiotestsrc_node_port_get_format (SpaNode *node,
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, this->current_format.info.raw.format),
PROP (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, this->current_format.info.raw.rate),
PROP (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, this->current_format.info.raw.channels));
PROP (&f[1], this->type.format_audio.format, SPA_POD_TYPE_ID, this->current_format.info.raw.format),
PROP (&f[1], this->type.format_audio.rate, SPA_POD_TYPE_INT, this->current_format.info.raw.rate),
PROP (&f[1], this->type.format_audio.channels, SPA_POD_TYPE_INT, this->current_format.info.raw.channels));
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);

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

@ -74,7 +74,7 @@ typedef struct {
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeMediaSubtypeVideo media_subtype_video;
SpaTypePropVideo prop_video;
SpaTypeFormatVideo format_video;
SpaTypeVideoFormat video_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
@ -95,7 +95,7 @@ init_type (Type *type, SpaTypeMap *map)
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_media_subtype_video_map (map, &type->media_subtype_video);
spa_type_prop_video_map (map, &type->prop_video);
spa_type_format_video_map (map, &type->format_video);
spa_type_video_format_map (map, &type->video_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
@ -593,22 +593,22 @@ spa_v4l2_source_node_port_get_format (SpaNode *node,
if (state->current_format.media_subtype == this->type.media_subtype.raw) {
spa_pod_builder_add (&b,
PROP (&f[1], this->type.prop_video.format, SPA_POD_TYPE_URI, state->current_format.info.raw.format),
PROP (&f[1], this->type.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.raw.size),
PROP (&f[1], this->type.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.raw.framerate),
PROP (&f[1], this->type.format_video.format, SPA_POD_TYPE_ID, state->current_format.info.raw.format),
PROP (&f[1], this->type.format_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.raw.size),
PROP (&f[1], this->type.format_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.raw.framerate),
0);
}
else if (state->current_format.media_subtype == this->type.media_subtype_video.mjpg ||
state->current_format.media_subtype == this->type.media_subtype_video.jpeg) {
spa_pod_builder_add (&b,
PROP (&f[1], this->type.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.mjpg.size),
PROP (&f[1], this->type.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.mjpg.framerate),
PROP (&f[1], this->type.format_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.mjpg.size),
PROP (&f[1], this->type.format_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.mjpg.framerate),
0);
}
else if (state->current_format.media_subtype == this->type.media_subtype_video.h264) {
spa_pod_builder_add (&b,
PROP (&f[1], this->type.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.h264.size),
PROP (&f[1], this->type.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.h264.framerate),
PROP (&f[1], this->type.format_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.h264.size),
PROP (&f[1], this->type.format_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.h264.framerate),
0);
} else
return SPA_RESULT_NO_FORMAT;

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

@ -389,10 +389,10 @@ enum_filter_format (Type *type, const SpaFormat *filter, uint32_t index)
uint32_t n_values;
const uint32_t *values;
if (!(p = spa_format_find_prop (filter, type->prop_video.format)))
if (!(p = spa_format_find_prop (filter, type->format_video.format)))
return type->video_format.UNKNOWN;
if (p->body.value.type != SPA_POD_TYPE_URI)
if (p->body.value.type != SPA_POD_TYPE_ID)
return type->video_format.UNKNOWN;
values = SPA_POD_BODY_CONST (&p->body.value);
@ -572,7 +572,7 @@ next_frmsize:
SpaPODProp *p;
/* check if we have a fixed frame size */
if (!(p = spa_format_find_prop (filter, this->type.prop_video.size)))
if (!(p = spa_format_find_prop (filter, this->type.format_video.size)))
goto do_frmsize;
if (p->body.value.type != SPA_POD_TYPE_RECTANGLE)
@ -605,7 +605,7 @@ do_frmsize:
uint32_t i, n_values;
/* check if we have a fixed frame size */
if (!(p = spa_format_find_prop (filter, this->type.prop_video.size)))
if (!(p = spa_format_find_prop (filter, this->type.format_video.size)))
goto have_size;
range = p->body.flags & SPA_POD_PROP_RANGE_MASK;
@ -668,16 +668,16 @@ have_size:
if (media_subtype == this->type.media_subtype.raw) {
spa_pod_builder_add (&b,
PROP (&f[1], this->type.prop_video.format, SPA_POD_TYPE_URI, video_format),
PROP (&f[1], this->type.format_video.format, SPA_POD_TYPE_ID, video_format),
0);
}
spa_pod_builder_add (&b,
PROP (&f[1], this->type.prop_video.size, SPA_POD_TYPE_RECTANGLE, state->frmsize.discrete.width,
PROP (&f[1], this->type.format_video.size, SPA_POD_TYPE_RECTANGLE, state->frmsize.discrete.width,
state->frmsize.discrete.height),
0);
spa_pod_builder_push_prop (&b, &f[1],
this->type.prop_video.framerate,
this->type.format_video.framerate,
SPA_POD_PROP_RANGE_NONE |
SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_FLAG_READWRITE);
@ -705,7 +705,7 @@ have_size:
uint32_t i, n_values;
const SpaFraction step = { 1, 1 }, *values;
if (!(p = spa_format_find_prop (filter, this->type.prop_video.framerate)))
if (!(p = spa_format_find_prop (filter, this->type.format_video.framerate)))
goto have_framerate;
if (p->body.value.type != SPA_POD_TYPE_FRACTION)

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

@ -48,7 +48,7 @@ typedef struct {
uint32_t pattern_snow;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypePropVideo prop_video;
SpaTypeFormatVideo format_video;
SpaTypeVideoFormat video_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
@ -69,7 +69,7 @@ init_type (Type *type, SpaTypeMap *map)
type->pattern_snow = spa_type_map_get_id (map, SPA_TYPE_PROPS__patternType ":snow");
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_prop_video_map (map, &type->prop_video);
spa_type_format_video_map (map, &type->format_video);
spa_type_video_format_map (map, &type->video_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
@ -184,7 +184,7 @@ spa_videotestsrc_node_get_props (SpaNode *node,
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_live, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], this->type.prop_pattern, SPA_POD_TYPE_URI, 3,
PROP_EN (&f[1], this->type.prop_pattern, SPA_POD_TYPE_ID, 3,
this->props.pattern,
this->type.pattern_smpte_snow,
this->type.pattern_snow));
@ -210,7 +210,7 @@ spa_videotestsrc_node_set_props (SpaNode *node,
} else {
spa_props_query (props,
this->type.prop_live, SPA_POD_TYPE_BOOL, &this->props.live,
this->type.prop_pattern, SPA_POD_TYPE_URI, &this->props.pattern,
this->type.prop_pattern, SPA_POD_TYPE_ID, &this->props.pattern,
0);
}
@ -467,15 +467,15 @@ next:
case 0:
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.video, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_video.format, SPA_POD_TYPE_URI, 3,
PROP_U_EN (&f[1], this->type.format_video.format, SPA_POD_TYPE_ID, 3,
this->type.video_format.RGB,
this->type.video_format.RGB,
this->type.video_format.UYVY),
PROP_U_MM (&f[1], this->type.prop_video.size, SPA_POD_TYPE_RECTANGLE,
PROP_U_MM (&f[1], this->type.format_video.size, SPA_POD_TYPE_RECTANGLE,
320, 240,
1, 1,
INT32_MAX, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_video.framerate, SPA_POD_TYPE_FRACTION,
PROP_U_MM (&f[1], this->type.format_video.framerate, SPA_POD_TYPE_FRACTION,
25, 1,
0, 1,
INT32_MAX, 1));
@ -605,9 +605,9 @@ spa_videotestsrc_node_port_get_format (SpaNode *node,
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.video, this->type.media_subtype.raw,
PROP (&f[1], this->type.prop_video.format, SPA_POD_TYPE_URI, this->current_format.info.raw.format),
PROP (&f[1], this->type.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &this->current_format.info.raw.size),
PROP (&f[1], this->type.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &this->current_format.info.raw.framerate));
PROP (&f[1], this->type.format_video.format, SPA_POD_TYPE_ID, this->current_format.info.raw.format),
PROP (&f[1], this->type.format_video.size, -SPA_POD_TYPE_RECTANGLE, &this->current_format.info.raw.size),
PROP (&f[1], this->type.format_video.framerate, -SPA_POD_TYPE_FRACTION, &this->current_format.info.raw.framerate));
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
return SPA_RESULT_OK;

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

@ -69,7 +69,7 @@ typedef struct {
uint32_t prop_mute;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypePropAudio prop_audio;
SpaTypeFormatAudio format_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
@ -87,7 +87,7 @@ init_type (Type *type, SpaTypeMap *map)
type->prop_mute = spa_type_map_get_id (map, SPA_TYPE_PROPS__mute);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_prop_audio_map (map, &type->prop_audio);
spa_type_format_audio_map (map, &type->format_audio);
spa_type_audio_format_map (map, &type->audio_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
@ -324,12 +324,12 @@ next:
case 0:
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, 3,
PROP_U_EN (&f[1], this->type.format_audio.format, SPA_POD_TYPE_ID, 3,
this->type.audio_format.S16,
this->type.audio_format.S16,
this->type.audio_format.S32),
PROP_U_MM (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
PROP_U_MM (&f[1], this->type.format_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.format_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
default:

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

@ -35,7 +35,7 @@
typedef struct {
uint32_t node;
} URI;
} Type;
typedef struct {
SpaNode *sink;
@ -51,10 +51,10 @@ typedef struct {
SpaSupport support[2];
uint32_t n_support;
SpaIDMap *map;
SpaTypeMap *map;
SpaLog *log;
SpaPoll data_loop;
URI uri;
Type type;
} AppData;
static SpaResult
@ -93,7 +93,7 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
printf ("can't make factory instance: %d\n", res);
return res;
}
if ((res = spa_handle_get_interface (handle, data->uri.node, &iface)) < 0) {
if ((res = spa_handle_get_interface (handle, data->type.node, &iface)) < 0) {
printf ("can't get interface %d\n", res);
return res;
}
@ -358,20 +358,20 @@ main (int argc, char *argv[])
AppData data;
SpaResult res;
data.map = spa_id_map_get_default();
data.map = spa_type_map_get_default();
data.data_loop.size = sizeof (SpaPoll);
data.data_loop.info = NULL;
data.data_loop.add_item = do_add_item;
data.data_loop.update_item = NULL;
data.data_loop.remove_item = NULL;
data.support[0].uri = SPA_TYPE__IDMap;
data.support[0].type = SPA_TYPE__TypeMap;
data.support[0].data = data.map;
data.support[1].uri = SPA_TYPE_LOOP__DataLoop;
data.support[1].type = SPA_TYPE_LOOP__DataLoop;
data.support[1].data = &data.data_loop;
data.n_support = 2;
data.uri.node = spa_id_map_get_id (data.map, SPA_TYPE__Node);
data.type.node = spa_type_map_get_id (data.map, SPA_TYPE__Node);
if ((res = make_nodes (&data)) < 0) {
printf ("can't make nodes: %d\n", res);

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

@ -40,19 +40,19 @@
*/
spa_build (SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
type.prop_video.format, SPA_PROP_TYPE_URI,
type.format_video.format, SPA_PROP_TYPE_ID,
video_format.I420
SPA_POD_PROP_FLAG_UNSET |
SPA_PROP_RANGE_ENUM, 2,
video_format.I420,
video_format.YUY2,
type.prop_video.size , SPA_PROP_TYPE_RECTANGLE,
type.format_video.size , SPA_PROP_TYPE_RECTANGLE,
320, 240,
SPA_POD_PROP_FLAG_UNSET |
SPA_PROP_RANGE_MIN_MAX,
1, 1,
INT32_MAX, INT32_MAX,
type.prop_video.framerate, SPA_PROP_TYPE_FRACTION, 25, 1,
type.format_video.framerate, SPA_PROP_TYPE_FRACTION, 25, 1,
SPA_POD_PROP_FLAG_UNSET |
SPA_PROP_RANGE_MIN_MAX,
0, 1,
@ -64,7 +64,7 @@ static struct {
uint32_t format;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypePropVideo prop_video;
SpaTypeFormatVideo format_video;
SpaTypeVideoFormat video_format;
} type = { 0, };
@ -74,7 +74,7 @@ type_init (SpaTypeMap *map)
type.format = spa_type_map_get_id (map, SPA_TYPE__Format);
spa_type_media_type_map (map, &type.media_type);
spa_type_media_subtype_map (map, &type.media_subtype);
spa_type_prop_video_map (map, &type.prop_video);
spa_type_format_video_map (map, &type.format_video);
spa_type_video_format_map (map, &type.video_format);
}
@ -109,19 +109,19 @@ do_static_struct (void)
} test_format = {
{ { sizeof (test_format.props) + sizeof (SpaFormatBody), SPA_POD_TYPE_OBJECT },
{ { 0, type.format },
{ { sizeof (uint32_t), SPA_POD_TYPE_URI }, type.media_type.video },
{ { sizeof (uint32_t), SPA_POD_TYPE_URI }, type.media_subtype.raw } },
{ { sizeof (uint32_t), SPA_POD_TYPE_ID }, type.media_type.video },
{ { sizeof (uint32_t), SPA_POD_TYPE_ID }, type.media_subtype.raw } },
}, {
{ { sizeof (test_format.props.format_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } ,
{ type.prop_video.format, SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (uint32_t), SPA_POD_TYPE_URI } }, },
{ type.format_video.format, SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (uint32_t), SPA_POD_TYPE_ID } }, },
{ type.video_format.I420,
{ type.video_format.I420, type.video_format.YUY2 } }, 0,
{ { sizeof (test_format.props.size_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } ,
{ type.prop_video.size, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ type.format_video.size, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (SpaRectangle), SPA_POD_TYPE_RECTANGLE } }, },
{ { 320, 243 },
{ 1, 1 },
@ -129,7 +129,7 @@ do_static_struct (void)
{ { sizeof (test_format.props.framerate_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } ,
{ type.prop_video.framerate, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ type.format_video.framerate, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (SpaFraction), SPA_POD_TYPE_FRACTION } }, },
{ { 25, 1 },
{ 0, 1 },
@ -145,8 +145,8 @@ do_static_struct (void)
SpaFraction frac = { 0, 0 };
match = spa_pod_contents_query (&test_format.fmt.pod, sizeof (SpaFormat),
type.prop_video.format, SPA_POD_TYPE_INT, &format,
type.prop_video.framerate, SPA_POD_TYPE_FRACTION, &frac,
type.format_video.format, SPA_POD_TYPE_INT, &format,
type.format_video.framerate, SPA_POD_TYPE_FRACTION, &frac,
0);
printf ("%d %d %d %d\n", match, format, frac.num, frac.denom);
@ -170,16 +170,16 @@ main (int argc, char *argv[])
type.media_type.video,
type.media_subtype.raw), SpaFormat);
spa_pod_builder_push_prop (&b, &frame[1],
type.prop_video.format,
type.format_video.format,
SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_uri (&b, type.video_format.I420);
spa_pod_builder_uri (&b, type.video_format.I420);
spa_pod_builder_uri (&b, type.video_format.YUY2);
spa_pod_builder_id (&b, type.video_format.I420);
spa_pod_builder_id (&b, type.video_format.I420);
spa_pod_builder_id (&b, type.video_format.YUY2);
spa_pod_builder_pop (&b, &frame[1]);
SpaRectangle size_min_max[] = { { 1, 1 }, { INT32_MAX, INT32_MAX } };
spa_pod_builder_push_prop (&b, &frame[1],
type.prop_video.size,
type.format_video.size,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_rectangle (&b, 320, 240);
spa_pod_builder_raw (&b, size_min_max, sizeof(size_min_max));
@ -187,7 +187,7 @@ main (int argc, char *argv[])
SpaFraction rate_min_max[] = { { 0, 1 }, { INT32_MAX, 1 } };
spa_pod_builder_push_prop (&b, &frame[1],
type.prop_video.framerate,
type.format_video.framerate,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_fraction (&b, 25, 1);
spa_pod_builder_raw (&b, rate_min_max, sizeof(rate_min_max));
@ -202,15 +202,15 @@ main (int argc, char *argv[])
spa_pod_builder_format (&b, &frame[0], type.format,
type.media_type.video, type.media_subtype.raw,
SPA_POD_TYPE_PROP, &frame[1],
type.prop_video.format, SPA_POD_PROP_FLAG_UNSET |
type.format_video.format, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_URI, 3,
SPA_POD_TYPE_ID, 3,
type.video_format.I420,
type.video_format.I420,
type.video_format.YUY2,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
type.prop_video.size, SPA_POD_PROP_FLAG_UNSET |
type.format_video.size, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_RECTANGLE, 3,
320, 241,
@ -218,7 +218,7 @@ main (int argc, char *argv[])
INT32_MAX, INT32_MAX,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
type.prop_video.framerate, SPA_POD_PROP_FLAG_UNSET |
type.format_video.framerate, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_FRACTION, 3,
25, 1,
@ -234,18 +234,18 @@ main (int argc, char *argv[])
spa_pod_builder_add (&b,
SPA_POD_TYPE_OBJECT, &frame[0], 0, type.format,
SPA_POD_TYPE_URI, type.media_type.video,
SPA_POD_TYPE_URI, type.media_subtype.raw,
SPA_POD_TYPE_ID, type.media_type.video,
SPA_POD_TYPE_ID, type.media_subtype.raw,
SPA_POD_TYPE_PROP, &frame[1],
type.prop_video.format, SPA_POD_PROP_FLAG_UNSET |
type.format_video.format, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_URI, 3,
SPA_POD_TYPE_ID, 3,
type.video_format.I420,
type.video_format.I420,
type.video_format.YUY2,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
type.prop_video.size, SPA_POD_PROP_FLAG_UNSET |
type.format_video.size, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_RECTANGLE, 3,
320, 242,
@ -253,7 +253,7 @@ main (int argc, char *argv[])
INT32_MAX, INT32_MAX,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
type.prop_video.framerate, SPA_POD_PROP_FLAG_UNSET |
type.format_video.framerate, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_FRACTION, 3,
25, 1,

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

@ -49,7 +49,7 @@ typedef struct {
typedef struct {
uint32_t node;
} URI;
} Type;
typedef struct {
SpaNode *source;
@ -72,10 +72,10 @@ typedef struct {
SpaSupport support[2];
uint32_t n_support;
SpaIDMap *map;
SpaTypeMap *map;
SpaLog *log;
SpaPoll data_loop;
URI uri;
Type type;
} AppData;
static SpaResult
@ -114,7 +114,7 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
printf ("can't make factory instance: %d\n", res);
return res;
}
if ((res = spa_handle_get_interface (handle, data->uri.node, &iface)) < 0) {
if ((res = spa_handle_get_interface (handle, data->type.node, &iface)) < 0) {
printf ("can't get interface %d\n", res);
return res;
}
@ -457,7 +457,7 @@ main (int argc, char *argv[])
data.use_buffer = true;
data.map = spa_id_map_get_default ();
data.map = spa_type_map_get_default ();
data.data_loop.size = sizeof (SpaPoll);
data.data_loop.info = NULL;
@ -465,13 +465,13 @@ main (int argc, char *argv[])
data.data_loop.update_item = do_update_item;
data.data_loop.remove_item = do_remove_item;
data.support[0].uri = SPA_TYPE__IDMap;
data.support[0].type = SPA_TYPE__TypeMap;
data.support[0].data = data.map;
data.support[1].uri = SPA_TYPE_LOOP__DataLoop;
data.support[1].type = SPA_TYPE_LOOP__DataLoop;
data.support[1].data = &data.data_loop;
data.n_support = 2;
data.uri.node = spa_id_map_get_id (data.map, SPA_TYPE__Node);
data.type.node = spa_type_map_get_id (data.map, SPA_TYPE__Node);
if (SDL_Init (SDL_INIT_VIDEO) < 0) {
printf ("can't initialize SDL: %s\n", SDL_GetError ());