mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-01 22:58:50 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

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_subtype)
{
SpaFormat f = { media_type, media_subtype, { { 0, 0 }, { 0, 0 } } };
off_t offset;
offset = spa_pod_builder_raw (builder, &f, sizeof(f) - sizeof(SpaPODObject), false);
if (spa_pod_builder_push_object (builder, frame, 0, 0) == -1)
offset = -1;
return offset;
const SpaFormat p = { { sizeof (SpaFormatBody), SPA_POD_TYPE_FORMAT },
{ media_type, media_subtype } };
return spa_pod_builder_push (builder, frame, &p.pod,
spa_pod_builder_raw (builder, &p, sizeof(p), false));
}
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,
} SpaFormatProps;
typedef struct {
uint32_t media_type;
uint32_t media_subtype;
/* contents follow, series of SpaPODProp */
} SpaFormatBody;
/**
* SpaFormat:
* @media_type: media type
@ -96,12 +102,25 @@ typedef enum {
* @pod: POD object with properties
*/
struct _SpaFormat {
uint32_t media_type;
uint32_t media_subtype;
SpaPODObject obj;
SpaPOD pod;
SpaFormatBody body;
};
#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
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_OBJECT,
SPA_POD_TYPE_PROP,
SPA_POD_TYPE_BYTES
SPA_POD_TYPE_BYTES,
SPA_POD_TYPE_FORMAT
} SpaPODType;
typedef struct {
@ -55,7 +56,7 @@ typedef struct {
uint32_t type;
} 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_CONTENTS(type,pod) SPA_MEMBER((pod),sizeof(type),void)
@ -169,10 +170,15 @@ typedef struct {
(iter) < SPA_MEMBER ((body), (size), 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) \
for ((iter) = SPA_MEMBER ((body), sizeof (SpaPODObjectBody), 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) \
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)))
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;
SPA_POD_OBJECT_BODY_FOREACH (body, size, res) {
if (res->body.key == key)
SPA_POD_FOREACH (obj, res) {
if (res->pod.type == SPA_POD_TYPE_PROP && res->body.key == key)
return res;
}
return NULL;
}
#ifdef __cplusplus
} /* extern "C" */
#endif

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

@ -60,10 +60,10 @@ spa_format_audio_parse (const SpaFormat *format,
SpaPODProp *prop;
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;
switch (format->media_subtype) {
switch (format->body.media_subtype) {
case SPA_MEDIA_SUBTYPE_RAW:
pinfo = raw_parse_info;
break;
@ -85,10 +85,10 @@ spa_format_audio_parse (const SpaFormat *format,
return SPA_RESULT_INVALID_ARGUMENTS;
}
info->media_type = format->media_type;
info->media_subtype = format->media_subtype;
info->media_type = format->body.media_type;
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))) {
memcpy (SPA_MEMBER (info, find->offset, void),
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;
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;
int i;
printf ("%-*sObject: size %d\n", prefix, "", size);
SPA_POD_OBJECT_BODY_FOREACH (b, size, p) {
printf ("%-*sProp: key %d, flags %d\n", prefix + 2, "", p->body.key, p->body.flags);
if (p->body.flags & SPA_POD_PROP_FLAG_UNSET)
printf ("%-*sUnset (Default):\n", prefix + 4, "");
else
printf ("%-*sValue:\n", prefix + 4, "");
print_pod_value (p->body.value.size, p->body.value.type, SPA_POD_BODY (&p->body.value), prefix + 6);
printf ("%-*sProp: key %d, flags %d\n", prefix + 2, "", b->key, b->flags);
if (b->flags & SPA_POD_PROP_FLAG_UNSET)
printf ("%-*sUnset (Default):\n", prefix + 4, "");
else
printf ("%-*sValue:\n", prefix + 4, "");
print_pod_value (b->value.size, b->value.type, SPA_POD_BODY (&b->value), prefix + 6);
i = 0;
SPA_POD_PROP_ALTERNATIVE_FOREACH (&p->body, p->pod.size, alt) {
if (i == 0)
printf ("%-*sAlternatives:\n", prefix + 4, "");
print_pod_value (p->body.value.size, p->body.value.type, alt, prefix + 6);
i++;
}
i = 0;
SPA_POD_PROP_ALTERNATIVE_FOREACH (b, size, alt) {
if (i == 0)
printf ("%-*sAlternatives:\n", prefix + 4, "");
print_pod_value (b->value.size, b->value.type, alt, prefix + 6);
i++;
}
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)
return SPA_RESULT_INVALID_ARGUMENTS;
if (format->media_type > 0 && format->media_type < SPA_N_ELEMENTS (media_type_names)) {
media_type = media_type_names[format->media_type].name;
first = media_type_names[format->media_type].first;
last = media_type_names[format->media_type].last;
idx = media_type_names[format->media_type].idx;
prop_names = media_type_names[format->media_type].prop_names;
if (format->body.media_type > 0 && format->body.media_type < SPA_N_ELEMENTS (media_type_names)) {
media_type = media_type_names[format->body.media_type].name;
first = media_type_names[format->body.media_type].first;
last = media_type_names[format->body.media_type].last;
idx = media_type_names[format->body.media_type].idx;
prop_names = media_type_names[format->body.media_type].prop_names;
}
else {
media_type = "unknown";
@ -491,17 +508,17 @@ spa_debug_format (const SpaFormat *format)
prop_names = NULL;
}
if (format->media_subtype >= SPA_MEDIA_SUBTYPE_ANY_FIRST &&
format->media_subtype <= SPA_MEDIA_SUBTYPE_ANY_LAST) {
media_subtype = media_subtype_names[format->media_subtype].name;
} else if (format->media_subtype >= first && format->media_subtype <= last)
media_subtype = media_subtype_names[format->media_subtype - first + idx].name;
if (format->body.media_subtype >= SPA_MEDIA_SUBTYPE_ANY_FIRST &&
format->body.media_subtype <= SPA_MEDIA_SUBTYPE_ANY_LAST) {
media_subtype = media_subtype_names[format->body.media_subtype].name;
} else if (format->body.media_subtype >= first && format->body.media_subtype <= last)
media_subtype = media_subtype_names[format->body.media_subtype - first + idx].name;
else
media_subtype = "unknown";
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) &&
(prop->body.flags & SPA_POD_PROP_FLAG_OPTIONAL))
continue;

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

@ -85,10 +85,10 @@ spa_format_video_parse (const SpaFormat *format,
SpaPODProp *prop;
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;
switch (format->media_subtype) {
switch (format->body.media_subtype) {
case SPA_MEDIA_SUBTYPE_RAW:
pinfo = raw_parse_info;
break;
@ -116,10 +116,10 @@ spa_format_video_parse (const SpaFormat *format,
return SPA_RESULT_INVALID_ARGUMENTS;
}
info->media_type = format->media_type;
info->media_subtype = format->media_subtype;
info->media_type = format->body.media_type;
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))) {
memcpy (SPA_MEMBER (info, find->offset, void),
SPA_POD_BODY (&prop->body.value),
@ -138,15 +138,15 @@ spa_format_filter (const SpaFormat *format,
return SPA_RESULT_INVALID_ARGUMENTS;
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;
}
if (filter->media_type != format->media_type ||
filter->media_subtype != format->media_subtype)
if (filter->body.media_type != format->body.media_type ||
filter->body.media_subtype != format->body.media_subtype)
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;
}

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;
}
if (format->media_type != SPA_MEDIA_TYPE_VIDEO ||
format->media_subtype != SPA_MEDIA_SUBTYPE_RAW)
if (format->body.media_type != SPA_MEDIA_TYPE_VIDEO ||
format->body.media_subtype != SPA_MEDIA_SUBTYPE_RAW)
return SPA_RESULT_INVALID_MEDIA_TYPE;
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;
if ((filter->media_type == SPA_MEDIA_TYPE_VIDEO || filter->media_type == SPA_MEDIA_TYPE_IMAGE)) {
if (filter->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
if ((filter->body.media_type == SPA_MEDIA_TYPE_VIDEO ||
filter->body.media_type == SPA_MEDIA_TYPE_IMAGE)) {
if (filter->body.media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
SpaPODProp *p;
unsigned int n_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;
if (p->body.value.type != SPA_POD_TYPE_INT)
@ -487,8 +488,8 @@ next_fmtdesc:
if (video_format == SPA_VIDEO_FORMAT_UNKNOWN)
return SPA_RESULT_ENUM_END;
info = find_format_info_by_media_type (filter->media_type,
filter->media_subtype,
info = find_format_info_by_media_type (filter->body.media_type,
filter->body.media_subtype,
video_format,
0);
if (info == NULL)
@ -516,7 +517,7 @@ next_frmsize:
SpaPODProp *p;
/* 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;
if (p->body.value.type != SPA_POD_TYPE_RECTANGLE)
@ -549,7 +550,7 @@ do_frmsize:
unsigned int i, n_values;
/* 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;
range = p->body.flags & SPA_POD_PROP_RANGE_MASK;
@ -652,7 +653,7 @@ have_size:
unsigned int i, n_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;
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;
}
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
if (format->body.media_type == SPA_MEDIA_TYPE_VIDEO) {
if (format->body.media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
if ((res = spa_format_video_parse (format, &info) < 0))
return res;
} else

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

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

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

@ -86,7 +86,7 @@ main (int argc, char *argv[])
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);
spa_debug_pod (&p->body.value);