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

Make AllocParams into POD objects

Browse source 
Make allocparams into pod objects. This makes it easy to serialize,
copy, create and intersect them.
Add convenience macros for properties
Add helper function to collect object properties.
This commit is contained in:
Wim Taymans 2017-03-17 11:58:09 +01:00
parent b1f7df52e3
commit 8a6ce3b179
34 changed files with 948 additions and 1054 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -100,8 +100,7 @@ typedef struct {
SpaPortInfo info;
SpaAllocParam *params[2];
SpaAllocParamBuffers param_buffers;
SpaAllocParamMetaEnable param_meta;
uint8_t params_buffer[1024];
void *io;
int64_t last_ticks;
@ -136,6 +135,25 @@ update_state (SpaV4l2Source *this, SpaNodeState state)
spa_log_info (this->log, "state: %d", state);
this->node.state = state;
}
#define PROP(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE,type,1,__VA_ARGS__)
#define PROP_R(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READABLE,type,1,__VA_ARGS__)
#define PROP_MM(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE | \
SPA_POD_PROP_RANGE_MIN_MAX,type,3,__VA_ARGS__)
#define PROP_U_MM(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE | \
SPA_POD_PROP_FLAG_UNSET | \
SPA_POD_PROP_RANGE_MIN_MAX,type,3,__VA_ARGS__)
#define PROP_EN(f,key,type,n,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE | \
SPA_POD_PROP_RANGE_ENUM,type,n,__VA_ARGS__)
#define PROP_U_EN(f,key,type,n,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE | \
SPA_POD_PROP_FLAG_UNSET | \
SPA_POD_PROP_RANGE_ENUM,type,n,__VA_ARGS__)
#include "v4l2-utils.c"
enum {
@ -151,7 +169,7 @@ spa_v4l2_source_node_get_props (SpaNode *node,
{
SpaV4l2Source *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -159,28 +177,11 @@ spa_v4l2_source_node_get_props (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaV4l2Source, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
*props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
SPA_POD_TYPE_PROP, &f,
PROP_ID_DEVICE, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_NONE,
-SPA_POD_TYPE_STRING, 1,
this->props.device, sizeof (this->props.device),
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_DEVICE_NAME, SPA_POD_PROP_FLAG_READABLE |
SPA_POD_PROP_RANGE_NONE,
-SPA_POD_TYPE_STRING, 1,
this->props.device_name, sizeof (this->props.device_name),
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_DEVICE_FD, SPA_POD_PROP_FLAG_READABLE |
SPA_POD_PROP_RANGE_NONE,
SPA_POD_TYPE_INT, 1,
this->props.device_fd,
-SPA_POD_TYPE_PROP, &f, 0), SpaProps);
spa_pod_builder_props (&b, &f[0],
PROP (&f[1], PROP_ID_DEVICE, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP_R (&f[1], PROP_ID_DEVICE_NAME, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP_R (&f[1], PROP_ID_DEVICE_FD, SPA_POD_TYPE_INT, this->props.device_fd));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
}
@ -200,22 +201,9 @@ spa_v4l2_source_node_set_props (SpaNode *node,
reset_v4l2_source_props (&this->props);
return SPA_RESULT_OK;
} else {
SpaPOD *p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, p) {
SpaPODProp *pr;
if (p->type != SPA_POD_TYPE_PROP)
continue;
pr = (SpaPODProp *)p;
switch (pr->body.key) {
case PROP_ID_DEVICE:
strncpy (this->props.device, SPA_POD_CONTENTS (SpaPODProp, pr), 63);
break;
}
}
spa_props_query (props,
PROP_ID_DEVICE, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
0);
}
return SPA_RESULT_OK;
}
@ -588,54 +576,23 @@ spa_v4l2_source_node_port_get_format (SpaNode *node,
switch (state->current_format.media_subtype) {
case SPA_MEDIA_SUBTYPE_RAW:
spa_pod_builder_add (&b,
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_FORMAT, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_INT, 1,
state->current_format.info.raw.format,
-SPA_POD_TYPE_PROP, &f[1],
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_SIZE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_RECTANGLE, 1,
state->current_format.info.raw.size.width,
state->current_format.info.raw.size.height,
-SPA_POD_TYPE_PROP, &f[1],
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_FRACTION, 1,
state->current_format.info.raw.framerate.num,
state->current_format.info.raw.framerate.denom,
-SPA_POD_TYPE_PROP, &f[1], 0);
PROP (&f[1], SPA_PROP_ID_VIDEO_FORMAT, SPA_POD_TYPE_INT, state->current_format.info.raw.format),
PROP (&f[1], SPA_PROP_ID_VIDEO_SIZE, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.raw.size),
PROP (&f[1], SPA_PROP_ID_VIDEO_FRAMERATE, -SPA_POD_TYPE_FRACTION, &state->current_format.info.raw.framerate),
0);
break;
case SPA_MEDIA_SUBTYPE_MJPG:
case SPA_MEDIA_SUBTYPE_JPEG:
spa_pod_builder_add (&b,
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_SIZE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_RECTANGLE, 1,
state->current_format.info.mjpg.size.width,
state->current_format.info.mjpg.size.height,
-SPA_POD_TYPE_PROP, &f[1],
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_FRACTION, 1,
state->current_format.info.mjpg.framerate.num,
state->current_format.info.mjpg.framerate.denom,
-SPA_POD_TYPE_PROP, &f[1], 0);
PROP (&f[1], SPA_PROP_ID_VIDEO_SIZE, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.mjpg.size),
PROP (&f[1], SPA_PROP_ID_VIDEO_FRAMERATE, -SPA_POD_TYPE_FRACTION, &state->current_format.info.mjpg.framerate),
0);
break;
case SPA_MEDIA_SUBTYPE_H264:
spa_pod_builder_add (&b,
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_SIZE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_RECTANGLE, 1,
state->current_format.info.h264.size.width,
state->current_format.info.h264.size.height,
-SPA_POD_TYPE_PROP, &f[1],
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_FRACTION, 1,
state->current_format.info.h264.framerate.num,
state->current_format.info.h264.framerate.denom,
-SPA_POD_TYPE_PROP, &f[1], 0);
PROP (&f[1], SPA_PROP_ID_VIDEO_SIZE, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.h264.size),
PROP (&f[1], SPA_PROP_ID_VIDEO_FRAMERATE, -SPA_POD_TYPE_FRACTION, &state->current_format.info.h264.framerate),
0);
break;
case SPA_MEDIA_SUBTYPE_DV:
case SPA_MEDIA_SUBTYPE_MPEGTS:

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

@ -456,7 +456,6 @@ spa_v4l2_enum_format (SpaV4l2Source *this,
const FormatInfo *info;
SpaPODFrame f[2];
SpaPODProp *prop;
SpaFormat *fmt;
SpaPODBuilder b = { state->format_buffer, sizeof (state->format_buffer), };
if (spa_v4l2_open (this) < 0)
@ -605,25 +604,17 @@ have_size:
spa_pod_builder_push_format (&b, &f[0],
info->media_type,
info->media_subtype),
fmt = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
info->media_subtype);
if (info->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
spa_pod_builder_add (&b,
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_FORMAT, SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_INT, 1,
info->format,
-SPA_POD_TYPE_PROP, &f[1], 0);
PROP (&f[1], SPA_PROP_ID_VIDEO_FORMAT, SPA_POD_TYPE_INT, info->format),
0);
}
spa_pod_builder_add (&b,
SPA_POD_TYPE_PROP, &f[1],
SPA_PROP_ID_VIDEO_SIZE, SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_RECTANGLE, 1,
state->frmsize.discrete.width,
state->frmsize.discrete.height,
-SPA_POD_TYPE_PROP, &f[1], 0);
PROP (&f[1], SPA_PROP_ID_VIDEO_SIZE, SPA_POD_TYPE_RECTANGLE, state->frmsize.discrete.width,
state->frmsize.discrete.height),
0);
spa_pod_builder_push_prop (&b, &f[1],
SPA_PROP_ID_VIDEO_FRAMERATE,
@ -729,13 +720,13 @@ have_framerate:
spa_pod_builder_pop (&b, &f[1]);
spa_pod_builder_pop (&b, &f[0]);
*format = fmt;
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
return SPA_RESULT_OK;
}
static int
spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *f, bool try_only)
spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *format, bool try_only)
{
SpaV4l2State *state = &this->state[0];
int cmd;
@ -745,28 +736,30 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *f, bool try_only)
SpaVideoFormat video_format;
SpaRectangle *size = NULL;
SpaFraction *framerate = NULL;
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
CLEAR (fmt);
CLEAR (streamparm);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
switch (f->media_subtype) {
switch (format->media_subtype) {
case SPA_MEDIA_SUBTYPE_RAW:
video_format = f->info.raw.format;
size = &f->info.raw.size;
framerate = &f->info.raw.framerate;
video_format = format->info.raw.format;
size = &format->info.raw.size;
framerate = &format->info.raw.framerate;
break;
case SPA_MEDIA_SUBTYPE_MJPG:
case SPA_MEDIA_SUBTYPE_JPEG:
video_format = SPA_VIDEO_FORMAT_ENCODED;
size = &f->info.mjpg.size;
framerate = &f->info.mjpg.framerate;
size = &format->info.mjpg.size;
framerate = &format->info.mjpg.framerate;
break;
case SPA_MEDIA_SUBTYPE_H264:
video_format = SPA_VIDEO_FORMAT_ENCODED;
size = &f->info.h264.size;
framerate = &f->info.h264.framerate;
size = &format->info.h264.size;
framerate = &format->info.h264.framerate;
break;
case SPA_MEDIA_SUBTYPE_DV:
case SPA_MEDIA_SUBTYPE_MPEGTS:
@ -781,13 +774,13 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *f, bool try_only)
break;
}
info = find_format_info_by_media_type (f->media_type,
f->media_subtype,
info = find_format_info_by_media_type (format->media_type,
format->media_subtype,
video_format,
0);
if (info == NULL || size == NULL || framerate == NULL) {
spa_log_error (state->log, "v4l2: unknown media type %d %d %d", f->media_type,
f->media_subtype, video_format);
spa_log_error (state->log, "v4l2: unknown media type %d %d %d", format->media_type,
format->media_subtype, video_format);
return -1;
}
@ -847,18 +840,18 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *f, bool try_only)
state->info.n_params = 2;
state->info.params = state->params;
state->params[0] = &state->param_buffers.param;
state->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
state->param_buffers.param.size = sizeof (state->param_buffers);
state->param_buffers.minsize = fmt.fmt.pix.sizeimage;
state->param_buffers.stride = fmt.fmt.pix.bytesperline;
state->param_buffers.min_buffers = 2;
state->param_buffers.max_buffers = MAX_BUFFERS;
state->param_buffers.align = 16;
state->params[1] = &state->param_meta.param;
state->param_meta.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
state->param_meta.param.size = sizeof (state->param_meta);
state->param_meta.type = SPA_META_TYPE_HEADER;
spa_pod_builder_init (&b, state->params_buffer, sizeof (state->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, SPA_ALLOC_PARAM_TYPE_BUFFERS,
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_SIZE, SPA_POD_TYPE_INT, fmt.fmt.pix.sizeimage),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_STRIDE, SPA_POD_TYPE_INT, fmt.fmt.pix.bytesperline),
PROP_U_MM (&f[1], SPA_ALLOC_PARAM_BUFFERS_BUFFERS, SPA_POD_TYPE_INT, MAX_BUFFERS, 2, MAX_BUFFERS),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_ALIGN, SPA_POD_TYPE_INT, 16));
state->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, SPA_ALLOC_PARAM_TYPE_META_ENABLE,
PROP (&f[1], SPA_ALLOC_PARAM_META_ENABLE_TYPE, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
state->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
state->info.extra = NULL;