mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-02 09:01:50 -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

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

@ -62,13 +62,28 @@ enum {
PROP_ID_PERIOD_EVENT,
};
#define PROP(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE,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_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__)
static SpaResult
spa_alsa_sink_node_get_props (SpaNode *node,
SpaProps **props)
{
SpaALSASink *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -77,46 +92,15 @@ spa_alsa_sink_node_get_props (SpaNode *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_CARD_NAME, SPA_POD_PROP_FLAG_READABLE |
SPA_POD_PROP_RANGE_NONE,
-SPA_POD_TYPE_STRING, 1,
this->props.card_name, sizeof (this->props.card_name),
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_PERIOD_SIZE, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
this->props.period_size,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_PERIODS, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
this->props.periods,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_PERIOD_EVENT, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_NONE,
SPA_POD_TYPE_BOOL, 1,
this->props.period_event,
-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 (&f[1], PROP_ID_DEVICE_NAME, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP (&f[1], PROP_ID_CARD_NAME, -SPA_POD_TYPE_STRING, this->props.card_name, sizeof (this->props.card_name)),
PROP_MM (&f[1], PROP_ID_PERIOD_SIZE, SPA_POD_TYPE_INT, this->props.period_size, 1, INT32_MAX),
PROP_MM (&f[1], PROP_ID_PERIODS, SPA_POD_TYPE_INT, this->props.periods, 1, INT32_MAX),
PROP (&f[1], PROP_ID_PERIOD_EVENT, SPA_POD_TYPE_BOOL, this->props.period_event));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
}
@ -136,30 +120,12 @@ spa_alsa_sink_node_set_props (SpaNode *node,
reset_alsa_sink_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;
case PROP_ID_PERIOD_SIZE:
this->props.period_size = ((SpaPODInt*)&pr->body.value)->value;
break;
case PROP_ID_PERIODS:
this->props.periods = ((SpaPODInt*)&pr->body.value)->value;
break;
case PROP_ID_PERIOD_EVENT:
this->props.period_event = ((SpaPODBool*)&pr->body.value)->value;
break;
}
}
spa_props_query (props,
PROP_ID_DEVICE, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
PROP_ID_PERIOD_SIZE, SPA_POD_TYPE_INT, &this->props.period_size,
PROP_ID_PERIODS, SPA_POD_TYPE_INT, &this->props.periods,
PROP_ID_PERIOD_EVENT, SPA_POD_TYPE_BOOL, &this->props.period_event,
0);
}
return SPA_RESULT_OK;
}
@ -358,46 +324,30 @@ next:
switch (index++) {
case 0:
fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32,
-SPA_POD_TYPE_PROP, &f[0],
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_RATE, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
44100,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f[0],
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
2,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f[0], 0), SpaFormat);
spa_pod_builder_format (&b, &f[0],
SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
PROP_U_EN (&f[1], SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_TYPE_INT, 3, SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32),
PROP_U_MM (&f[1], SPA_PROP_ID_AUDIO_RATE, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
case 1:
fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
spa_pod_builder_format (&b, &f[0],
SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_AAC,
0), SpaFormat);
0);
break;
default:
return SPA_RESULT_ENUM_END;
}
fmt = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
if ((res = spa_format_filter (fmt, filter, &b)) != SPA_RESULT_OK)
goto next;
*format = SPA_MEMBER (b.data, 0, SpaFormat);
*format = SPA_POD_BUILDER_DEREF (&b, 0, SpaFormat);
return SPA_RESULT_OK;
}
@ -422,6 +372,8 @@ spa_alsa_sink_node_port_set_format (SpaNode *node,
{
SpaALSASink *this;
SpaResult res;
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -453,26 +405,26 @@ spa_alsa_sink_node_port_set_format (SpaNode *node,
this->info.latency = (this->period_frames * SPA_NSEC_PER_SEC) / this->rate;
this->info.n_params = 3;
this->info.params = this->params;
this->params[0] = &this->param_buffers.param;
this->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
this->param_buffers.param.size = sizeof (this->param_buffers);
this->param_buffers.minsize = this->period_frames * this->frame_size;
this->param_buffers.stride = 0;
this->param_buffers.min_buffers = 1;
this->param_buffers.max_buffers = 32;
this->param_buffers.align = 16;
this->params[1] = &this->param_meta.param;
this->param_meta.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
this->param_meta.param.size = sizeof (this->param_meta);
this->param_meta.type = SPA_META_TYPE_HEADER;
this->params[2] = &this->param_meta_rb.param;
this->param_meta_rb.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
this->param_meta_rb.param.size = sizeof (this->param_meta_rb);
this->param_meta_rb.type = SPA_META_TYPE_RINGBUFFER;
this->param_meta_rb.minsize = this->period_frames * this->frame_size * 32;
this->param_meta_rb.stride = 0;
this->param_meta_rb.blocks = 1;
this->param_meta_rb.align = 16;
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->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, this->period_frames * this->frame_size),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_STRIDE, SPA_POD_TYPE_INT, 0),
PROP_MM (&f[1], SPA_ALLOC_PARAM_BUFFERS_BUFFERS, SPA_POD_TYPE_INT, 32, 1, 32),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_ALIGN, SPA_POD_TYPE_INT, 16));
this->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));
this->params[1] = 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_RINGBUFFER),
PROP (&f[1], SPA_ALLOC_PARAM_META_ENABLE_RB_SIZE, SPA_POD_TYPE_INT, this->period_frames * this->frame_size * 32),
PROP (&f[1], SPA_ALLOC_PARAM_META_ENABLE_RB_STRIDE, SPA_POD_TYPE_INT, 0),
PROP (&f[1], SPA_ALLOC_PARAM_META_ENABLE_RB_BLOCKS, SPA_POD_TYPE_INT, 1),
PROP (&f[1], SPA_ALLOC_PARAM_META_ENABLE_RB_ALIGN, SPA_POD_TYPE_INT, 16));
this->params[2] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
this->have_format = true;

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

@ -62,13 +62,30 @@ enum {
PROP_ID_PERIOD_EVENT,
};
#define PROP(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE,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__)
static SpaResult
spa_alsa_source_node_get_props (SpaNode *node,
SpaProps **props)
{
SpaALSASource *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -77,45 +94,15 @@ spa_alsa_source_node_get_props (SpaNode *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_CARD_NAME, SPA_POD_PROP_FLAG_READABLE |
SPA_POD_PROP_RANGE_NONE,
-SPA_POD_TYPE_STRING, 1,
this->props.card_name, sizeof (this->props.card_name),
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_PERIOD_SIZE, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
this->props.period_size,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_PERIODS, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
this->props.periods,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_PERIOD_EVENT, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_NONE,
SPA_POD_TYPE_BOOL, 1,
this->props.period_event,
-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 (&f[1], PROP_ID_DEVICE_NAME, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP (&f[1], PROP_ID_CARD_NAME, -SPA_POD_TYPE_STRING, this->props.card_name, sizeof (this->props.card_name)),
PROP_MM (&f[1], PROP_ID_PERIOD_SIZE, SPA_POD_TYPE_INT, this->props.period_size, 1, INT32_MAX),
PROP_MM (&f[1], PROP_ID_PERIODS, SPA_POD_TYPE_INT, this->props.periods, 1, INT32_MAX),
PROP (&f[1], PROP_ID_PERIOD_EVENT, SPA_POD_TYPE_BOOL, this->props.period_event));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
}
@ -135,31 +122,12 @@ spa_alsa_source_node_set_props (SpaNode *node,
reset_alsa_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;
case PROP_ID_PERIOD_SIZE:
this->props.period_size = ((SpaPODInt*)&pr->body.value)->value;
break;
case PROP_ID_PERIODS:
this->props.periods = ((SpaPODInt*)&pr->body.value)->value;
break;
case PROP_ID_PERIOD_EVENT:
this->props.period_event = ((SpaPODBool*)&pr->body.value)->value;
break;
}
}
spa_props_query (props,
PROP_ID_DEVICE, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
PROP_ID_PERIOD_SIZE, SPA_POD_TYPE_INT, &this->props.period_size,
PROP_ID_PERIODS, SPA_POD_TYPE_INT, &this->props.periods,
PROP_ID_PERIOD_EVENT, SPA_POD_TYPE_BOOL, &this->props.period_event,
0);
}
return SPA_RESULT_OK;
@ -390,38 +358,22 @@ next:
switch (index++) {
case 0:
fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
spa_pod_builder_format (&b, &f[0],
SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32,
-SPA_POD_TYPE_PROP, &f[0],
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_RATE, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
44100,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f[0],
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
2,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f[0], 0), SpaFormat);
PROP_U_EN (&f[1], SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_TYPE_INT, 3, SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32),
PROP_U_MM (&f[1], SPA_PROP_ID_AUDIO_RATE, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
case 1:
fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
spa_pod_builder_format (&b, &f[0],
SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_AAC,
0), SpaFormat);
0);
default:
return SPA_RESULT_ENUM_END;
}
fmt = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
@ -466,6 +418,8 @@ spa_alsa_source_node_port_set_format (SpaNode *node,
{
SpaALSASource *this;
SpaResult res;
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -496,18 +450,19 @@ spa_alsa_source_node_port_set_format (SpaNode *node,
this->info.latency = (this->period_frames * SPA_NSEC_PER_SEC) / this->rate;
this->info.n_params = 2;
this->info.params = this->params;
this->params[0] = &this->param_buffers.param;
this->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
this->param_buffers.param.size = sizeof (this->param_buffers);
this->param_buffers.minsize = this->period_frames * this->frame_size;
this->param_buffers.stride = 0;
this->param_buffers.min_buffers = 1;
this->param_buffers.max_buffers = 32;
this->param_buffers.align = 16;
this->params[1] = &this->param_meta.param;
this->param_meta.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
this->param_meta.param.size = sizeof (this->param_meta);
this->param_meta.type = SPA_META_TYPE_HEADER;
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->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, this->period_frames * this->frame_size),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_STRIDE, SPA_POD_TYPE_INT, 0),
PROP_MM (&f[1], SPA_ALLOC_PARAM_BUFFERS_BUFFERS, SPA_POD_TYPE_INT, 32, 1, 32),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_ALIGN, SPA_POD_TYPE_INT, 16));
this->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));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
this->have_format = true;

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

@ -102,9 +102,7 @@ struct _SpaALSAState {
SpaPortInfo info;
SpaAllocParam *params[3];
SpaAllocParamBuffers param_buffers;
SpaAllocParamMetaEnable param_meta;
SpaAllocParamMetaEnableRingbuffer param_meta_rb;
uint8_t params_buffer[1024];
void *io;
SpaALSABuffer buffers[MAX_BUFFERS];

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

@ -84,8 +84,7 @@ struct _SpaAudioTestSrc {
SpaPortInfo info;
SpaAllocParam *params[2];
SpaAllocParamBuffers param_buffers;
SpaAllocParamMetaEnable param_meta;
uint8_t params_buffer[1024];
SpaPortOutput *output;
bool have_format;
@ -131,13 +130,30 @@ reset_audiotestsrc_props (SpaAudioTestSrcProps *props)
props->volume = DEFAULT_VOLUME;
}
#define PROP(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE,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__)
static SpaResult
spa_audiotestsrc_node_get_props (SpaNode *node,
SpaProps **props)
{
SpaAudioTestSrc *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -145,38 +161,17 @@ spa_audiotestsrc_node_get_props (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaAudioTestSrc, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0],
PROP (&f[1], PROP_ID_LIVE, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], PROP_ID_WAVE, SPA_POD_TYPE_INT, 3, this->props.wave,
wave_val_sine,
wave_val_square),
PROP_MM (&f[1], PROP_ID_FREQ, SPA_POD_TYPE_DOUBLE, this->props.freq,
0.0, 50000000.0),
PROP_MM (&f[1], PROP_ID_VOLUME, SPA_POD_TYPE_DOUBLE, this->props.volume,
0.0, 10.0));
*props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
SPA_POD_TYPE_PROP, &f,
PROP_ID_LIVE, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_NONE,
SPA_POD_TYPE_BOOL, 1,
this->props.live,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_WAVE, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
this->props.wave,
wave_val_sine,
wave_val_square,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_FREQ, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_DOUBLE, 3,
this->props.freq,
0.0,
50000000.0,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_VOLUME, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_DOUBLE, 3,
this->props.volume,
0.0,
10.0,
-SPA_POD_TYPE_PROP, &f, 0), SpaProps);
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
}
@ -195,31 +190,12 @@ spa_audiotestsrc_node_set_props (SpaNode *node,
if (props == NULL) {
reset_audiotestsrc_props (&this->props);
} 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_LIVE:
this->props.live = ((SpaPODBool*)&pr->body.value)->value;
break;
case PROP_ID_WAVE:
this->props.wave = ((SpaPODInt*)&pr->body.value)->value;
break;
case PROP_ID_FREQ:
this->props.freq = ((SpaPODDouble*)&pr->body.value)->value;
break;
case PROP_ID_VOLUME:
this->props.volume = ((SpaPODDouble*)&pr->body.value)->value;
break;
}
}
spa_props_query (props,
PROP_ID_LIVE, SPA_POD_TYPE_BOOL, &this->props.live,
PROP_ID_WAVE, SPA_POD_TYPE_INT, &this->props.wave,
PROP_ID_FREQ, SPA_POD_TYPE_DOUBLE, &this->props.freq,
PROP_ID_VOLUME, SPA_POD_TYPE_DOUBLE, &this->props.volume,
0);
}
if (this->props.live)
@ -490,34 +466,18 @@ next:
switch (index++) {
case 0:
fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
spa_pod_builder_format (&b, &f[0],
SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32,
-SPA_POD_TYPE_PROP, &f[0],
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_RATE, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
44100,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f[0],
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
2,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f[0], 0), SpaFormat);
PROP_U_EN (&f[1], SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_TYPE_INT, 3, SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32),
PROP_U_MM (&f[1], SPA_PROP_ID_AUDIO_RATE, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
default:
return SPA_RESULT_ENUM_END;
}
fmt = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
@ -572,23 +532,27 @@ spa_audiotestsrc_node_port_set_format (SpaNode *node,
}
if (this->have_format) {
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
this->info.maxbuffering = -1;
this->info.latency = BYTES_TO_TIME (this, 1024);
this->info.n_params = 2;
this->info.params = this->params;
this->params[0] = &this->param_buffers.param;
this->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
this->param_buffers.param.size = sizeof (this->param_buffers);
this->param_buffers.minsize = 1024;
this->param_buffers.stride = 1024;
this->param_buffers.min_buffers = 2;
this->param_buffers.max_buffers = 32;
this->param_buffers.align = 16;
this->params[1] = &this->param_meta.param;
this->param_meta.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
this->param_meta.param.size = sizeof (this->param_meta);
this->param_meta.type = SPA_META_TYPE_HEADER;
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->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, 1024),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_STRIDE, SPA_POD_TYPE_INT, 1024),
PROP_MM (&f[1], SPA_ALLOC_PARAM_BUFFERS_BUFFERS, SPA_POD_TYPE_INT, 32, 2, 32),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_ALIGN, SPA_POD_TYPE_INT, 16));
this->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));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
update_state (this, SPA_NODE_STATE_READY);
}
@ -606,7 +570,7 @@ spa_audiotestsrc_node_port_get_format (SpaNode *node,
{
SpaAudioTestSrc *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -620,24 +584,13 @@ spa_audiotestsrc_node_port_get_format (SpaNode *node,
return SPA_RESULT_NO_FORMAT;
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
*format = SPA_MEMBER (b.data, spa_pod_builder_format (&b,
spa_pod_builder_format (&b, &f[0],
SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_INT, 1,
this->current_format.info.raw.format,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_AUDIO_RATE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_INT, 1,
this->current_format.info.raw.rate,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_INT, 1,
this->current_format.info.raw.channels,
-SPA_POD_TYPE_PROP, &f, 0), SpaFormat);
PROP (&f[1], SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_TYPE_INT, this->current_format.info.raw.format),
PROP (&f[1], SPA_PROP_ID_AUDIO_RATE, SPA_POD_TYPE_INT, this->current_format.info.raw.rate),
PROP (&f[1], SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_TYPE_INT, this->current_format.info.raw.channels));
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
return SPA_RESULT_OK;
}

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

@ -47,8 +47,6 @@ typedef struct {
bool have_buffers;
FFMpegBuffer buffers[MAX_BUFFERS];
SpaPortInfo info;
SpaAllocParam *params[1];
SpaAllocParamBuffers param_buffers;
void *io;
} SpaFFMpegPort;
@ -210,12 +208,12 @@ spa_ffmpeg_dec_node_port_enum_formats (SpaNode *node,
const SpaFormat *filter,
uint32_t index)
{
SpaFFMpegDec *this;
//SpaFFMpegDec *this;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, SpaFFMpegDec, node);
//this = SPA_CONTAINER_OF (node, SpaFFMpegDec, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;

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

@ -52,8 +52,6 @@ typedef struct {
bool have_buffers;
FFMpegBuffer buffers[MAX_BUFFERS];
SpaPortInfo info;
SpaAllocParam *params[1];
SpaAllocParamBuffers param_buffers;
void *io;
} SpaFFMpegPort;
@ -215,18 +213,18 @@ spa_ffmpeg_enc_node_port_enum_formats (SpaNode *node,
const SpaFormat *filter,
uint32_t index)
{
SpaFFMpegEnc *this;
SpaFFMpegPort *port;
//SpaFFMpegEnc *this;
//SpaFFMpegPort *port;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, SpaFFMpegEnc, node);
//this = SPA_CONTAINER_OF (node, SpaFFMpegEnc, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
//port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
switch (index) {
case 0:

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;

2
spa/plugins/videotestsrc/draw.c
View file

@ -162,7 +162,7 @@ drawing_data_init (DrawingData *dd,
dd->line = data;
dd->width = size->width;
dd->height = size->height;
dd->stride = this->param_buffers.stride;
dd->stride = this->stride;
return SPA_RESULT_OK;
}

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

@ -82,8 +82,8 @@ struct _SpaVideoTestSrc {
SpaPortInfo info;
SpaAllocParam *params[2];
SpaAllocParamBuffers param_buffers;
SpaAllocParamMetaEnable param_meta;
uint8_t params_buffer[1024];
int stride;
SpaPortOutput *output;
bool have_format;
@ -123,13 +123,30 @@ reset_videotestsrc_props (SpaVideoTestSrcProps *props)
props->pattern = DEFAULT_PATTERN;
}
#define PROP(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_READWRITE,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__)
static SpaResult
spa_videotestsrc_node_get_props (SpaNode *node,
SpaProps **props)
{
SpaVideoTestSrc *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -138,21 +155,14 @@ spa_videotestsrc_node_get_props (SpaNode *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_LIVE, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_NONE,
SPA_POD_TYPE_BOOL, 1,
this->props.live,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_PATTERN, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
this->props.pattern,
pattern_val_smpte_snow,
pattern_val_snow,
-SPA_POD_TYPE_PROP, &f, 0), SpaProps);
spa_pod_builder_props (&b, &f[0],
PROP (&f[1], PROP_ID_LIVE, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], PROP_ID_PATTERN, SPA_POD_TYPE_INT, 3,
this->props.pattern,
pattern_val_smpte_snow,
pattern_val_snow));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
}
@ -171,24 +181,10 @@ spa_videotestsrc_node_set_props (SpaNode *node,
if (props == NULL) {
reset_videotestsrc_props (&this->props);
} 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_LIVE:
this->props.live = ((SpaPODBool*)&pr->body.value)->value;
break;
case PROP_ID_PATTERN:
this->props.pattern = ((SpaPODInt*)&pr->body.value)->value;
break;
}
}
spa_props_query (props,
PROP_ID_LIVE, SPA_POD_TYPE_BOOL, &this->props.live,
PROP_ID_PATTERN, SPA_POD_TYPE_INT, &this->props.pattern,
0);
}
if (this->props.live)
@ -453,37 +449,27 @@ next:
switch (index++) {
case 0:
fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
spa_pod_builder_format (&b, &f[0],
SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_VIDEO_FORMAT, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_UYVY,
-SPA_POD_TYPE_PROP, &f[0],
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_VIDEO_SIZE, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_RECTANGLE, 3,
320, 240,
1, 1,
INT32_MAX, INT32_MAX,
-SPA_POD_TYPE_PROP, &f[0],
SPA_POD_TYPE_PROP, &f[0],
SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_FRACTION, 3,
25, 1,
0, 1,
INT32_MAX, 1,
-SPA_POD_TYPE_PROP, &f[0], 0), SpaFormat);
PROP_U_EN (&f[1], SPA_PROP_ID_VIDEO_FORMAT, SPA_POD_TYPE_INT, 3,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_UYVY),
PROP_U_MM (&f[1], SPA_PROP_ID_VIDEO_SIZE, SPA_POD_TYPE_RECTANGLE,
320, 240,
1, 1,
INT32_MAX, INT32_MAX),
PROP_U_MM (&f[1], SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_TYPE_FRACTION,
25, 1,
0, 1,
INT32_MAX, 1));
break;
default:
return SPA_RESULT_ENUM_END;
}
fmt = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
if ((res = spa_format_filter (fmt, filter, &b)) != SPA_RESULT_OK)
@ -537,6 +523,8 @@ spa_videotestsrc_node_port_set_format (SpaNode *node,
if (this->have_format) {
SpaVideoInfoRaw *raw_info = &this->current_format.info.raw;
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
switch (raw_info->format) {
case SPA_VIDEO_FORMAT_RGB:
@ -554,18 +542,21 @@ spa_videotestsrc_node_port_set_format (SpaNode *node,
this->info.n_params = 2;
this->info.params = this->params;
this->params[0] = &this->param_buffers.param;
this->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
this->param_buffers.param.size = sizeof (this->param_buffers);
this->param_buffers.stride = this->bpp * raw_info->size.width;
this->param_buffers.minsize = this->param_buffers.stride * raw_info->size.height;
this->param_buffers.min_buffers = 2;
this->param_buffers.max_buffers = 32;
this->param_buffers.align = 16;
this->params[1] = &this->param_meta.param;
this->param_meta.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
this->param_meta.param.size = sizeof (this->param_meta);
this->param_meta.type = SPA_META_TYPE_HEADER;
this->stride = SPA_ROUND_UP_N (this->bpp * raw_info->size.width, 4);
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->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, this->stride * raw_info->size.height),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_STRIDE, SPA_POD_TYPE_INT, this->stride),
PROP_U_MM (&f[1], SPA_ALLOC_PARAM_BUFFERS_BUFFERS, SPA_POD_TYPE_INT, 32, 2, 32),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_ALIGN, SPA_POD_TYPE_INT, 16));
this->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));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
update_state (this, SPA_NODE_STATE_READY);
}
@ -583,7 +574,7 @@ spa_videotestsrc_node_port_get_format (SpaNode *node,
{
SpaVideoTestSrc *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -598,25 +589,12 @@ spa_videotestsrc_node_port_get_format (SpaNode *node,
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
*format = SPA_MEMBER (b.data, spa_pod_builder_format (&b,
SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_VIDEO_FORMAT, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_INT, 1,
this->current_format.info.raw.format,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_VIDEO_SIZE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_RECTANGLE, 1,
this->current_format.info.raw.size.width,
this->current_format.info.raw.size.height,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_READWRITE,
SPA_POD_TYPE_FRACTION, 1,
this->current_format.info.raw.framerate.num,
this->current_format.info.raw.framerate.denom,
-SPA_POD_TYPE_PROP, &f, 0), SpaFormat);
spa_pod_builder_format (&b, &f[0],
SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
PROP (&f[1], SPA_PROP_ID_VIDEO_FORMAT, SPA_POD_TYPE_INT, this->current_format.info.raw.format),
PROP (&f[1], SPA_PROP_ID_VIDEO_SIZE, -SPA_POD_TYPE_RECTANGLE, &this->current_format.info.raw.size),
PROP (&f[1], SPA_PROP_ID_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;
}

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

@ -51,8 +51,7 @@ typedef struct {
SpaPortInfo info;
SpaAllocParam *params[2];
SpaAllocParamBuffers param_buffers;
SpaAllocParamMetaEnable param_meta;
uint8_t params_buffer[1024];
SpaVolumeBuffer buffers[MAX_BUFFERS];
uint32_t n_buffers;
@ -113,13 +112,28 @@ update_state (SpaVolume *this, SpaNodeState 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_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_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__)
static SpaResult
spa_volume_node_get_props (SpaNode *node,
SpaProps **props)
{
SpaVolume *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -127,29 +141,18 @@ spa_volume_node_get_props (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaVolume, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0],
PROP_MM (&f[1], PROP_ID_VOLUME, SPA_POD_TYPE_DOUBLE, this->props.volume, 0.0, 10.0),
PROP (&f[1], PROP_ID_MUTE, SPA_POD_TYPE_BOOL, this->props.mute));
*props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
SPA_POD_TYPE_PROP, &f,
PROP_ID_VOLUME, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_DOUBLE, 3,
this->props.volume,
0.0,
10.0,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
PROP_ID_MUTE, SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_NONE,
SPA_POD_TYPE_BOOL, 1,
this->props.mute,
-SPA_POD_TYPE_PROP, &f, 0), SpaProps);
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
}
static SpaResult
spa_volume_node_set_props (SpaNode *node,
const SpaProps *props)
spa_volume_node_set_props (SpaNode *node,
const SpaProps *props)
{
SpaVolume *this;
@ -161,24 +164,10 @@ spa_volume_node_set_props (SpaNode *node,
if (props == NULL) {
reset_volume_props (&this->props);
} 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_VOLUME:
this->props.volume = ((SpaPODDouble*)&pr->body.value)->value;
break;
case PROP_ID_MUTE:
this->props.mute = ((SpaPODBool*)&pr->body.value)->value;
break;
}
}
spa_props_query (props,
PROP_ID_VOLUME, SPA_POD_TYPE_DOUBLE, &this->props.volume,
PROP_ID_MUTE, SPA_POD_TYPE_BOOL, &this->props.mute,
0);
}
return SPA_RESULT_OK;
}
@ -303,7 +292,7 @@ spa_volume_node_port_enum_formats (SpaNode *node,
SpaFormat *fmt;
uint8_t buffer[1024];
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -318,35 +307,19 @@ next:
switch (index++) {
case 0:
fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_AUDIO_RATE, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
44100,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f,
SPA_POD_TYPE_PROP, &f,
SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_INT, 3,
2,
1, INT32_MAX,
-SPA_POD_TYPE_PROP, &f, 0), SpaFormat);
spa_pod_builder_format (&b, &f[0], SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
PROP_U_EN (&f[1], SPA_PROP_ID_AUDIO_FORMAT, SPA_POD_TYPE_INT, 3,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32),
PROP_U_MM (&f[1], SPA_PROP_ID_AUDIO_RATE, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], SPA_PROP_ID_AUDIO_CHANNELS, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
default:
return SPA_RESULT_ENUM_END;
}
fmt = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
if ((res = spa_format_filter (fmt, filter, &b)) != SPA_RESULT_OK)
@ -400,23 +373,27 @@ spa_volume_node_port_set_format (SpaNode *node,
}
if (port->have_format) {
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
port->info.maxbuffering = -1;
port->info.latency = 0;
port->info.n_params = 2;
port->info.params = port->params;
port->params[0] = &port->param_buffers.param;
port->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
port->param_buffers.param.size = sizeof (port->param_buffers);
port->param_buffers.minsize = 16;
port->param_buffers.stride = 16;
port->param_buffers.min_buffers = 2;
port->param_buffers.max_buffers = MAX_BUFFERS;
port->param_buffers.align = 16;
port->params[1] = &port->param_meta.param;
port->param_meta.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
port->param_meta.param.size = sizeof (port->param_meta);
port->param_meta.type = SPA_META_TYPE_HEADER;
spa_pod_builder_init (&b, port->params_buffer, sizeof (port->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, 16),
PROP (&f[1], SPA_ALLOC_PARAM_BUFFERS_STRIDE, SPA_POD_TYPE_INT, 16),
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));
port->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));
port->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
port->info.extra = NULL;
update_state (this, SPA_NODE_STATE_READY);
}

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

@ -114,13 +114,18 @@ update_state (SpaXvSink *this, SpaNodeState 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__)
static SpaResult
spa_xv_sink_node_get_props (SpaNode *node,
SpaProps **props)
{
SpaXvSink *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f;
SpaPODFrame f[2];
if (node == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -128,26 +133,11 @@ spa_xv_sink_node_get_props (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaXvSink, 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;
}
@ -166,21 +156,9 @@ spa_xv_sink_node_set_props (SpaNode *node,
if (props == NULL) {
reset_xv_sink_props (&this->props);
} 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;
}
@ -301,12 +279,12 @@ spa_xv_sink_node_port_enum_formats (SpaNode *node,
const SpaFormat *filter,
uint32_t index)
{
SpaXvSink *this;
//SpaXvSink *this;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, SpaXvSink, node);
//this = SPA_CONTAINER_OF (node, SpaXvSink, node);
if (!CHECK_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;