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

pod: make format like other PODs

Browse source
This commit is contained in:
Wim Taymans 2017-02-27 17:07:48 +01:00
parent e2d930e394
commit f02f93cda9
13 changed files with 125 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

4
pinos/client/serialize.c
View file

@ -95,7 +95,7 @@ pinos_serialize_format_get_size (const SpaFormat *format)
if (format == NULL) if (format == NULL)
return 0; return 0;
return SPA_FORMAT_SIZE (format); return SPA_POD_SIZE (format);
} }
size_t size_t
@ -106,7 +106,7 @@ pinos_serialize_format_serialize (void *dest, const SpaFormat *format)
if (format == NULL) if (format == NULL)
return 0; return 0;
size = SPA_FORMAT_SIZE (format); size = SPA_POD_SIZE (format);
memcpy (dest, format, size); memcpy (dest, format, size);
return size; return size;

12
pinos/gst/gstpinosformat.c
View file

@ -444,13 +444,13 @@ gst_caps_from_format (const SpaFormat *format)
{ {
GstCaps *res = NULL; GstCaps *res = NULL;
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) { if (format->body.media_type == SPA_MEDIA_TYPE_VIDEO) {
SpaVideoInfo f; SpaVideoInfo f;
if (spa_format_video_parse (format, &f) < 0) if (spa_format_video_parse (format, &f) < 0)
return NULL; return NULL;
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) { if (format->body.media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
res = gst_caps_new_simple ("video/x-raw", res = gst_caps_new_simple ("video/x-raw",
"format", G_TYPE_STRING, gst_video_format_to_string (f.info.raw.format), "format", G_TYPE_STRING, gst_video_format_to_string (f.info.raw.format),
"width", G_TYPE_INT, f.info.raw.size.width, "width", G_TYPE_INT, f.info.raw.size.width,
@ -458,14 +458,14 @@ gst_caps_from_format (const SpaFormat *format)
"framerate", GST_TYPE_FRACTION, f.info.raw.framerate.num, f.info.raw.framerate.denom, "framerate", GST_TYPE_FRACTION, f.info.raw.framerate.num, f.info.raw.framerate.denom,
NULL); NULL);
} }
else if (format->media_subtype == SPA_MEDIA_SUBTYPE_MJPG) { else if (format->body.media_subtype == SPA_MEDIA_SUBTYPE_MJPG) {
res = gst_caps_new_simple ("image/jpeg", res = gst_caps_new_simple ("image/jpeg",
"width", G_TYPE_INT, f.info.mjpg.size.width, "width", G_TYPE_INT, f.info.mjpg.size.width,
"height", G_TYPE_INT, f.info.mjpg.size.height, "height", G_TYPE_INT, f.info.mjpg.size.height,
"framerate", GST_TYPE_FRACTION, f.info.mjpg.framerate.num, f.info.mjpg.framerate.denom, "framerate", GST_TYPE_FRACTION, f.info.mjpg.framerate.num, f.info.mjpg.framerate.denom,
NULL); NULL);
} }
else if (format->media_subtype == SPA_MEDIA_SUBTYPE_H264) { else if (format->body.media_subtype == SPA_MEDIA_SUBTYPE_H264) {
res = gst_caps_new_simple ("video/x-h264", res = gst_caps_new_simple ("video/x-h264",
"width", G_TYPE_INT, f.info.h264.size.width, "width", G_TYPE_INT, f.info.h264.size.width,
"height", G_TYPE_INT, f.info.h264.size.height, "height", G_TYPE_INT, f.info.h264.size.height,
@ -474,13 +474,13 @@ gst_caps_from_format (const SpaFormat *format)
"alignment", G_TYPE_STRING, "au", "alignment", G_TYPE_STRING, "au",
NULL); NULL);
} }
} else if (format->media_type == SPA_MEDIA_TYPE_AUDIO) { } else if (format->body.media_type == SPA_MEDIA_TYPE_AUDIO) {
SpaAudioInfo f; SpaAudioInfo f;
if (spa_format_audio_parse (format, &f) < 0) if (spa_format_audio_parse (format, &f) < 0)
return NULL; return NULL;
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) { if (format->body.media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
res = gst_caps_new_simple ("audio/x-raw", res = gst_caps_new_simple ("audio/x-raw",
"format", G_TYPE_STRING, gst_audio_format_to_string (f.info.raw.format), "format", G_TYPE_STRING, gst_audio_format_to_string (f.info.raw.format),
"layout", G_TYPE_STRING, "interleaved", "layout", G_TYPE_STRING, "interleaved",

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

@ -35,13 +35,10 @@ spa_pod_builder_push_format (SpaPODBuilder *builder,
uint32_t media_type, uint32_t media_type,
uint32_t media_subtype) uint32_t media_subtype)
{ {
SpaFormat f = { media_type, media_subtype, { { 0, 0 }, { 0, 0 } } }; const SpaFormat p = { { sizeof (SpaFormatBody), SPA_POD_TYPE_FORMAT },
off_t offset; { media_type, media_subtype } };
return spa_pod_builder_push (builder, frame, &p.pod,
offset = spa_pod_builder_raw (builder, &f, sizeof(f) - sizeof(SpaPODObject), false); spa_pod_builder_raw (builder, &p, sizeof(p), false));
if (spa_pod_builder_push_object (builder, frame, 0, 0) == -1)
offset = -1;
return offset;
} }
static inline off_t static inline off_t

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

@ -89,6 +89,12 @@ typedef enum {
SPA_PROP_ID_MEDIA_CUSTOM_START = 200, SPA_PROP_ID_MEDIA_CUSTOM_START = 200,
} SpaFormatProps; } SpaFormatProps;
typedef struct {
uint32_t media_type;
uint32_t media_subtype;
/* contents follow, series of SpaPODProp */
} SpaFormatBody;
/** /**
* SpaFormat: * SpaFormat:
* @media_type: media type * @media_type: media type
@ -96,12 +102,25 @@ typedef enum {
* @pod: POD object with properties * @pod: POD object with properties
*/ */
struct _SpaFormat { struct _SpaFormat {
uint32_t media_type; SpaPOD pod;
uint32_t media_subtype; SpaFormatBody body;
SpaPODObject obj;
}; };
#define SPA_FORMAT_SIZE(f) (sizeof(SpaFormat) + (f)->obj.pod.size) #define SPA_FORMAT_BODY_FOREACH(body, size, iter) \
for ((iter) = SPA_MEMBER ((body), sizeof (SpaFormatBody), SpaPODProp); \
(iter) < SPA_MEMBER ((body), (size), SpaPODProp); \
(iter) = SPA_MEMBER ((iter), SPA_ROUND_UP_N (SPA_POD_SIZE (iter), 8), SpaPODProp))
static inline SpaPODProp *
spa_format_find_prop (const SpaFormat *format, uint32_t key)
{
SpaPODProp *res;
SPA_POD_FOREACH (format, res) {
if (res->pod.type == SPA_POD_TYPE_PROP && res->body.key == key)
return res;
}
return NULL;
}
static inline SpaResult static inline SpaResult
spa_format_fixate (SpaFormat *format) spa_format_fixate (SpaFormat *format)

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

@ -47,7 +47,8 @@ typedef enum {
SPA_POD_TYPE_STRUCT, SPA_POD_TYPE_STRUCT,
SPA_POD_TYPE_OBJECT, SPA_POD_TYPE_OBJECT,
SPA_POD_TYPE_PROP, SPA_POD_TYPE_PROP,
SPA_POD_TYPE_BYTES SPA_POD_TYPE_BYTES,
SPA_POD_TYPE_FORMAT
} SpaPODType; } SpaPODType;
typedef struct { typedef struct {
@ -55,7 +56,7 @@ typedef struct {
uint32_t type; uint32_t type;
} SpaPOD; } SpaPOD;
#define SPA_POD_BODY_SIZE(pod) ((pod)->size) #define SPA_POD_BODY_SIZE(pod) (((SpaPOD*)(pod))->size)
#define SPA_POD_SIZE(pod) (sizeof(SpaPOD) + SPA_POD_BODY_SIZE(pod)) #define SPA_POD_SIZE(pod) (sizeof(SpaPOD) + SPA_POD_BODY_SIZE(pod))
#define SPA_POD_CONTENTS(type,pod) SPA_MEMBER((pod),sizeof(type),void) #define SPA_POD_CONTENTS(type,pod) SPA_MEMBER((pod),sizeof(type),void)
@ -169,10 +170,15 @@ typedef struct {
(iter) < SPA_MEMBER ((body), (size), SpaPOD); \ (iter) < SPA_MEMBER ((body), (size), SpaPOD); \
(iter) = SPA_MEMBER ((iter), SPA_ROUND_UP_N (SPA_POD_SIZE (iter), 8), SpaPOD)) (iter) = SPA_MEMBER ((iter), SPA_ROUND_UP_N (SPA_POD_SIZE (iter), 8), SpaPOD))
#define SPA_POD_FOREACH(pod, iter) \
for ((iter) = SPA_POD_CONTENTS(__typeof__(*pod), pod); \
(iter) < SPA_MEMBER ((pod), SPA_POD_SIZE (pod), __typeof__(*iter)); \
(iter) = SPA_MEMBER ((iter), SPA_ROUND_UP_N (SPA_POD_SIZE (iter), 8), __typeof__(*iter)))
#define SPA_POD_OBJECT_BODY_FOREACH(body, size, iter) \ #define SPA_POD_OBJECT_BODY_FOREACH(body, size, iter) \
for ((iter) = SPA_MEMBER ((body), sizeof (SpaPODObjectBody), SpaPODProp); \ for ((iter) = SPA_MEMBER ((body), sizeof (SpaPODObjectBody), SpaPODProp); \
(iter) < SPA_MEMBER ((body), (size), SpaPODProp); \ (iter) < SPA_MEMBER ((body), (size), SpaPODProp); \
(iter) = SPA_MEMBER ((iter), SPA_ROUND_UP_N (SPA_POD_SIZE (&(iter)->pod), 8), SpaPODProp)) (iter) = SPA_MEMBER ((iter), SPA_ROUND_UP_N (SPA_POD_SIZE (iter), 8), SpaPODProp))
#define SPA_POD_PROP_ALTERNATIVE_FOREACH(body, _size, iter) \ #define SPA_POD_PROP_ALTERNATIVE_FOREACH(body, _size, iter) \
for ((iter) = SPA_MEMBER ((body), (body)->value.size + sizeof (SpaPODPropBody), __typeof__(*iter)); \ for ((iter) = SPA_MEMBER ((body), (body)->value.size + sizeof (SpaPODPropBody), __typeof__(*iter)); \
@ -180,17 +186,16 @@ typedef struct {
(iter) = SPA_MEMBER ((iter), (body)->value.size, __typeof__(*iter))) (iter) = SPA_MEMBER ((iter), (body)->value.size, __typeof__(*iter)))
static inline SpaPODProp * static inline SpaPODProp *
spa_pod_object_body_find_prop (const SpaPODObjectBody *body, uint32_t size, uint32_t key) spa_pod_object_find_prop (const SpaPODObject *obj, uint32_t key)
{ {
SpaPODProp *res; SpaPODProp *res;
SPA_POD_OBJECT_BODY_FOREACH (body, size, res) { SPA_POD_FOREACH (obj, res) {
if (res->body.key == key) if (res->pod.type == SPA_POD_TYPE_PROP && res->body.key == key)
return res; return res;
} }
return NULL; return NULL;
} }
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif

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

@ -60,10 +60,10 @@ spa_format_audio_parse (const SpaFormat *format,
SpaPODProp *prop; SpaPODProp *prop;
const ParseInfo *pinfo, *find; const ParseInfo *pinfo, *find;
if (format->media_type != SPA_MEDIA_TYPE_AUDIO) if (format->body.media_type != SPA_MEDIA_TYPE_AUDIO)
return SPA_RESULT_INVALID_MEDIA_TYPE; return SPA_RESULT_INVALID_MEDIA_TYPE;
switch (format->media_subtype) { switch (format->body.media_subtype) {
case SPA_MEDIA_SUBTYPE_RAW: case SPA_MEDIA_SUBTYPE_RAW:
pinfo = raw_parse_info; pinfo = raw_parse_info;
break; break;
@ -85,10 +85,10 @@ spa_format_audio_parse (const SpaFormat *format,
return SPA_RESULT_INVALID_ARGUMENTS; return SPA_RESULT_INVALID_ARGUMENTS;
} }
info->media_type = format->media_type; info->media_type = format->body.media_type;
info->media_subtype = format->media_subtype; info->media_subtype = format->body.media_subtype;
SPA_POD_OBJECT_BODY_FOREACH (&format->obj.body, format->obj.pod.size, prop) { SPA_POD_FOREACH (format, prop) {
if ((find = parse_info_find (pinfo, prop->body.key, prop->body.value.type))) { if ((find = parse_info_find (pinfo, prop->body.key, prop->body.value.type))) {
memcpy (SPA_MEMBER (info, find->offset, void), memcpy (SPA_MEMBER (info, find->offset, void),
SPA_POD_BODY (&prop->body.value), SPA_POD_BODY (&prop->body.value),

71
spa/lib/debug.c
View file

@ -391,28 +391,45 @@ print_pod_value (uint32_t size, uint32_t type, void *body, int prefix)
{ {
SpaPODObjectBody *b = body; SpaPODObjectBody *b = body;
SpaPODProp *p; SpaPODProp *p;
printf ("%-*sObject: size %d\n", prefix, "", size);
SPA_POD_OBJECT_BODY_FOREACH (b, size, p)
print_pod_value (p->pod.size, p->pod.type, SPA_POD_BODY (p), prefix + 6);
break;
}
case SPA_POD_TYPE_PROP:
{
SpaPODPropBody *b = body;
void *alt; void *alt;
int i; int i;
printf ("%-*sObject: size %d\n", prefix, "", size); printf ("%-*sProp: key %d, flags %d\n", prefix + 2, "", b->key, b->flags);
SPA_POD_OBJECT_BODY_FOREACH (b, size, p) { if (b->flags & SPA_POD_PROP_FLAG_UNSET)
printf ("%-*sProp: key %d, flags %d\n", prefix + 2, "", p->body.key, p->body.flags); printf ("%-*sUnset (Default):\n", prefix + 4, "");
if (p->body.flags & SPA_POD_PROP_FLAG_UNSET) else
printf ("%-*sUnset (Default):\n", prefix + 4, ""); printf ("%-*sValue:\n", prefix + 4, "");
else print_pod_value (b->value.size, b->value.type, SPA_POD_BODY (&b->value), prefix + 6);
printf ("%-*sValue:\n", prefix + 4, "");
print_pod_value (p->body.value.size, p->body.value.type, SPA_POD_BODY (&p->body.value), prefix + 6);
i = 0; i = 0;
SPA_POD_PROP_ALTERNATIVE_FOREACH (&p->body, p->pod.size, alt) { SPA_POD_PROP_ALTERNATIVE_FOREACH (b, size, alt) {
if (i == 0) if (i == 0)
printf ("%-*sAlternatives:\n", prefix + 4, ""); printf ("%-*sAlternatives:\n", prefix + 4, "");
print_pod_value (p->body.value.size, p->body.value.type, alt, prefix + 6); print_pod_value (b->value.size, b->value.type, alt, prefix + 6);
i++; i++;
}
} }
break; break;
} }
case SPA_POD_TYPE_FORMAT:
{
SpaFormatBody *b = body;
SpaPODProp *p;
printf ("%-*sFormat: size %d\n", prefix, "", size);
printf ("%-*s Media Type: %d / %d\n", prefix, "", b->media_type, b->media_subtype);
SPA_FORMAT_BODY_FOREACH (b, size, p)
print_pod_value (p->pod.size, p->pod.type, SPA_POD_BODY (p), prefix + 6);
break;
}
} }
} }
@ -478,12 +495,12 @@ spa_debug_format (const SpaFormat *format)
if (format == NULL) if (format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS; return SPA_RESULT_INVALID_ARGUMENTS;
if (format->media_type > 0 && format->media_type < SPA_N_ELEMENTS (media_type_names)) { if (format->body.media_type > 0 && format->body.media_type < SPA_N_ELEMENTS (media_type_names)) {
media_type = media_type_names[format->media_type].name; media_type = media_type_names[format->body.media_type].name;
first = media_type_names[format->media_type].first; first = media_type_names[format->body.media_type].first;
last = media_type_names[format->media_type].last; last = media_type_names[format->body.media_type].last;
idx = media_type_names[format->media_type].idx; idx = media_type_names[format->body.media_type].idx;
prop_names = media_type_names[format->media_type].prop_names; prop_names = media_type_names[format->body.media_type].prop_names;
} }
else { else {
media_type = "unknown"; media_type = "unknown";
@ -491,17 +508,17 @@ spa_debug_format (const SpaFormat *format)
prop_names = NULL; prop_names = NULL;
} }
if (format->media_subtype >= SPA_MEDIA_SUBTYPE_ANY_FIRST && if (format->body.media_subtype >= SPA_MEDIA_SUBTYPE_ANY_FIRST &&
format->media_subtype <= SPA_MEDIA_SUBTYPE_ANY_LAST) { format->body.media_subtype <= SPA_MEDIA_SUBTYPE_ANY_LAST) {
media_subtype = media_subtype_names[format->media_subtype].name; media_subtype = media_subtype_names[format->body.media_subtype].name;
} else if (format->media_subtype >= first && format->media_subtype <= last) } else if (format->body.media_subtype >= first && format->body.media_subtype <= last)
media_subtype = media_subtype_names[format->media_subtype - first + idx].name; media_subtype = media_subtype_names[format->body.media_subtype - first + idx].name;
else else
media_subtype = "unknown"; media_subtype = "unknown";
fprintf (stderr, "%-6s %s/%s\n", "", media_type, media_subtype); fprintf (stderr, "%-6s %s/%s\n", "", media_type, media_subtype);
SPA_POD_OBJECT_BODY_FOREACH (&format->obj.body, format->obj.pod.size, prop) { SPA_POD_FOREACH (format, prop) {
if ((prop->body.flags & SPA_POD_PROP_FLAG_UNSET) && if ((prop->body.flags & SPA_POD_PROP_FLAG_UNSET) &&
(prop->body.flags & SPA_POD_PROP_FLAG_OPTIONAL)) (prop->body.flags & SPA_POD_PROP_FLAG_OPTIONAL))
continue; continue;

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

@ -85,10 +85,10 @@ spa_format_video_parse (const SpaFormat *format,
SpaPODProp *prop; SpaPODProp *prop;
const ParseInfo *pinfo, *find; const ParseInfo *pinfo, *find;
if (format->media_type != SPA_MEDIA_TYPE_VIDEO) if (format->body.media_type != SPA_MEDIA_TYPE_VIDEO)
return SPA_RESULT_INVALID_MEDIA_TYPE; return SPA_RESULT_INVALID_MEDIA_TYPE;
switch (format->media_subtype) { switch (format->body.media_subtype) {
case SPA_MEDIA_SUBTYPE_RAW: case SPA_MEDIA_SUBTYPE_RAW:
pinfo = raw_parse_info; pinfo = raw_parse_info;
break; break;
@ -116,10 +116,10 @@ spa_format_video_parse (const SpaFormat *format,
return SPA_RESULT_INVALID_ARGUMENTS; return SPA_RESULT_INVALID_ARGUMENTS;
} }
info->media_type = format->media_type; info->media_type = format->body.media_type;
info->media_subtype = format->media_subtype; info->media_subtype = format->body.media_subtype;
SPA_POD_OBJECT_BODY_FOREACH (&format->obj.body, format->obj.pod.size, prop) { SPA_POD_FOREACH (format, prop) {
if ((find = parse_info_find (pinfo, prop->body.key, prop->body.value.type))) { if ((find = parse_info_find (pinfo, prop->body.key, prop->body.value.type))) {
memcpy (SPA_MEMBER (info, find->offset, void), memcpy (SPA_MEMBER (info, find->offset, void),
SPA_POD_BODY (&prop->body.value), SPA_POD_BODY (&prop->body.value),
@ -138,15 +138,15 @@ spa_format_filter (const SpaFormat *format,
return SPA_RESULT_INVALID_ARGUMENTS; return SPA_RESULT_INVALID_ARGUMENTS;
if (filter == NULL) { if (filter == NULL) {
spa_pod_builder_raw (result, format, SPA_FORMAT_SIZE (format), true); spa_pod_builder_raw (result, format, SPA_POD_SIZE (format), true);
return SPA_RESULT_OK; return SPA_RESULT_OK;
} }
if (filter->media_type != format->media_type || if (filter->body.media_type != format->body.media_type ||
filter->media_subtype != format->media_subtype) filter->body.media_subtype != format->body.media_subtype)
return SPA_RESULT_INVALID_MEDIA_TYPE; return SPA_RESULT_INVALID_MEDIA_TYPE;
spa_pod_builder_raw (result, format, SPA_FORMAT_SIZE (format), true); spa_pod_builder_raw (result, format, SPA_POD_SIZE (format), true);
return SPA_RESULT_OK; return SPA_RESULT_OK;
} }

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

@ -308,8 +308,8 @@ spa_ffmpeg_enc_node_port_set_format (SpaNode *node,
return SPA_RESULT_OK; return SPA_RESULT_OK;
} }
if (format->media_type != SPA_MEDIA_TYPE_VIDEO || if (format->body.media_type != SPA_MEDIA_TYPE_VIDEO ||
format->media_subtype != SPA_MEDIA_SUBTYPE_RAW) format->body.media_subtype != SPA_MEDIA_SUBTYPE_RAW)
return SPA_RESULT_INVALID_MEDIA_TYPE; return SPA_RESULT_INVALID_MEDIA_TYPE;
if ((res = spa_format_video_parse (format, &port->format[0]) < 0)) if ((res = spa_format_video_parse (format, &port->format[0]) < 0))

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

@ -326,13 +326,14 @@ enum_filter_format (const SpaFormat *filter, unsigned int index)
{ {
SpaVideoFormat video_format = SPA_VIDEO_FORMAT_UNKNOWN; SpaVideoFormat video_format = SPA_VIDEO_FORMAT_UNKNOWN;
if ((filter->media_type == SPA_MEDIA_TYPE_VIDEO || filter->media_type == SPA_MEDIA_TYPE_IMAGE)) { if ((filter->body.media_type == SPA_MEDIA_TYPE_VIDEO ||
if (filter->media_subtype == SPA_MEDIA_SUBTYPE_RAW) { filter->body.media_type == SPA_MEDIA_TYPE_IMAGE)) {
if (filter->body.media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
SpaPODProp *p; SpaPODProp *p;
unsigned int n_values; unsigned int n_values;
const uint32_t *values; const uint32_t *values;
if (!(p = spa_pod_object_body_find_prop (&filter->obj.body, filter->obj.pod.size, SPA_PROP_ID_VIDEO_FORMAT))) if (!(p = spa_format_find_prop (filter, SPA_PROP_ID_VIDEO_FORMAT)))
return SPA_VIDEO_FORMAT_UNKNOWN; return SPA_VIDEO_FORMAT_UNKNOWN;
if (p->body.value.type != SPA_POD_TYPE_INT) if (p->body.value.type != SPA_POD_TYPE_INT)
@ -487,8 +488,8 @@ next_fmtdesc:
if (video_format == SPA_VIDEO_FORMAT_UNKNOWN) if (video_format == SPA_VIDEO_FORMAT_UNKNOWN)
return SPA_RESULT_ENUM_END; return SPA_RESULT_ENUM_END;
info = find_format_info_by_media_type (filter->media_type, info = find_format_info_by_media_type (filter->body.media_type,
filter->media_subtype, filter->body.media_subtype,
video_format, video_format,
0); 0);
if (info == NULL) if (info == NULL)
@ -516,7 +517,7 @@ next_frmsize:
SpaPODProp *p; SpaPODProp *p;
/* check if we have a fixed frame size */ /* check if we have a fixed frame size */
if (!(p = spa_pod_object_body_find_prop (&filter->obj.body, filter->obj.pod.size, SPA_PROP_ID_VIDEO_SIZE))) if (!(p = spa_format_find_prop (filter, SPA_PROP_ID_VIDEO_SIZE)))
goto do_frmsize; goto do_frmsize;
if (p->body.value.type != SPA_POD_TYPE_RECTANGLE) if (p->body.value.type != SPA_POD_TYPE_RECTANGLE)
@ -549,7 +550,7 @@ do_frmsize:
unsigned int i, n_values; unsigned int i, n_values;
/* check if we have a fixed frame size */ /* check if we have a fixed frame size */
if (!(p = spa_pod_object_body_find_prop (&filter->obj.body, filter->obj.pod.size, SPA_PROP_ID_VIDEO_SIZE))) if (!(p = spa_format_find_prop (filter, SPA_PROP_ID_VIDEO_SIZE)))
goto have_size; goto have_size;
range = p->body.flags & SPA_POD_PROP_RANGE_MASK; range = p->body.flags & SPA_POD_PROP_RANGE_MASK;
@ -652,7 +653,7 @@ have_size:
unsigned int i, n_values; unsigned int i, n_values;
const SpaFraction step = { 1, 1 }, *values; const SpaFraction step = { 1, 1 }, *values;
if (!(p = spa_pod_object_body_find_prop (&filter->obj.body, filter->obj.pod.size, SPA_PROP_ID_VIDEO_FRAMERATE))) if (!(p = spa_format_find_prop (filter, SPA_PROP_ID_VIDEO_FRAMERATE)))
goto have_framerate; goto have_framerate;
if (p->body.value.type != SPA_POD_TYPE_FRACTION) if (p->body.value.type != SPA_POD_TYPE_FRACTION)

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

@ -337,8 +337,8 @@ spa_xv_sink_node_port_set_format (SpaNode *node,
return SPA_RESULT_OK; return SPA_RESULT_OK;
} }
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) { if (format->body.media_type == SPA_MEDIA_TYPE_VIDEO) {
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) { if (format->body.media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
if ((res = spa_format_video_parse (format, &info) < 0)) if ((res = spa_format_video_parse (format, &info) < 0))
return res; return res;
} else } else

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

@ -86,10 +86,9 @@ static const struct _test_format {
} framerate_vals; } framerate_vals;
} props; } props;
} test_format = { } test_format = {
{ SPA_MEDIA_TYPE_VIDEO, { { sizeof (test_format.props) + sizeof (SpaFormatBody), SPA_POD_TYPE_FORMAT },
SPA_MEDIA_SUBTYPE_RAW, { SPA_MEDIA_TYPE_VIDEO,
{ { sizeof (test_format.props) + sizeof (SpaPODObjectBody), SPA_POD_TYPE_OBJECT }, SPA_MEDIA_SUBTYPE_RAW },
{ 0, 0 } },
}, { }, {
{ { sizeof (test_format.props.format_vals) + sizeof (SpaPODPropBody), { { sizeof (test_format.props.format_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } , SPA_POD_TYPE_PROP } ,
@ -157,7 +156,7 @@ main (int argc, char *argv[])
spa_pod_builder_pop (&b, &frame[0]); spa_pod_builder_pop (&b, &frame[0]);
spa_debug_pod (&fmt->obj.pod); spa_debug_pod (&fmt->pod);
memset (&b, 0, sizeof(b)); memset (&b, 0, sizeof(b));
b.data = buffer; b.data = buffer;
@ -184,10 +183,10 @@ main (int argc, char *argv[])
0); 0);
fmt = SPA_MEMBER (buffer, o, SpaFormat); fmt = SPA_MEMBER (buffer, o, SpaFormat);
spa_debug_pod (&fmt->obj.pod); spa_debug_pod (&fmt->pod);
spa_debug_format (fmt); spa_debug_format (fmt);
spa_debug_pod (&test_format.fmt.obj.pod); spa_debug_pod (&test_format.fmt.pod);
spa_debug_format (&test_format.fmt); spa_debug_format (&test_format.fmt);
return 0; return 0;

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

@ -86,7 +86,7 @@ main (int argc, char *argv[])
spa_debug_pod (obj); spa_debug_pod (obj);
SpaPODProp *p = spa_pod_object_body_find_prop (SPA_POD_BODY (obj), obj->size, 4); SpaPODProp *p = spa_pod_object_find_prop ((SpaPODObject *)obj, 4);
printf ("%d %d\n", p->body.key, p->body.flags); printf ("%d %d\n", p->body.key, p->body.flags);
spa_debug_pod (&p->body.value); spa_debug_pod (&p->body.value);