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

Unify props, params and formats

Browse source 
Make enum_params and set_param to configure properties, format
and other parameters. This allows us to remove some duplicate
code and make the properties and parameters much more extensible.
Use the object id to mark the id of the parameter.
Remove the spa_format and spa_props.
We can now make the client-node easier by merging the various
format methods into the params.
Make the stream API more powerful now that we can pass params
around.
This commit is contained in:
Wim Taymans 2017-11-07 17:39:31 +01:00
parent b6ee67905d
commit f3bca48398
87 changed files with 3773 additions and 3580 deletions
Download patch file Download diff file Expand all files Collapse all files

206
src/examples/export-sink.c
View file

@ -25,7 +25,6 @@
#include <spa/type-map.h>
#include <spa/format-utils.h>
#include <spa/video/format-utils.h>
#include <spa/format-builder.h>
#include <spa/props.h>
#include <spa/lib/debug.h>
@ -90,7 +89,6 @@ struct data {
struct spa_video_info_raw format;
int32_t stride;
uint8_t params_buffer[1024];
struct spa_param *params[2];
struct spa_buffer *buffers[32];
@ -223,27 +221,42 @@ static int impl_port_set_io(struct spa_node *node, enum spa_direction direction,
return SPA_RESULT_OK;
}
static int impl_port_enum_formats(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
struct spa_format **format,
const struct spa_format *filter,
uint32_t index)
static int impl_port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_port_info **info)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->port_info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
d->port_info.rate = 0;
d->port_info.props = NULL;
*info = &d->port_info;
return SPA_RESULT_OK;
}
static int port_enum_formats(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t *index,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(d->buffer, sizeof(d->buffer));
struct spa_pod_frame f[2];
SDL_RendererInfo info;
int i, c;
if (index != 0)
if (*index != 0)
return SPA_RESULT_ENUM_END;
SDL_GetRendererInfo(d->renderer, &info);
spa_pod_builder_push_format(&b, &f[0], d->type.format,
d->type.media_type.video,
d->type.media_subtype.raw);
spa_pod_builder_push_object(builder, &f[0],
d->t->param.idEnumFormat, d->type.format);
spa_pod_builder_id(builder, d->type.media_type.video);
spa_pod_builder_id(builder, d->type.media_subtype.raw);
spa_pod_builder_push_prop(&b, &f[1], d->type.format_video.format,
spa_pod_builder_push_prop(builder, &f[1], d->type.format_video.format,
SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM);
for (i = 0, c = 0; i < info.num_texture_formats; i++) {
@ -251,18 +264,18 @@ static int impl_port_enum_formats(struct spa_node *node, enum spa_direction dire
if (id == 0)
continue;
if (c++ == 0)
spa_pod_builder_id(&b, id);
spa_pod_builder_id(&b, id);
spa_pod_builder_id(builder, id);
spa_pod_builder_id(builder, id);
}
for (i = 0; i < SPA_N_ELEMENTS(video_formats); i++) {
uint32_t id =
*SPA_MEMBER(&d->type.video_format, video_formats[i].id,
uint32_t);
if (id != d->type.video_format.UNKNOWN)
spa_pod_builder_id(&b, id);
spa_pod_builder_id(builder, id);
}
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_add(&b,
spa_pod_builder_pop(builder, &f[1]);
spa_pod_builder_add(builder,
":", d->type.format_video.size, "Rru", &SPA_RECTANGLE(WIDTH, HEIGHT),
2, &SPA_RECTANGLE(1,1),
&SPA_RECTANGLE(info.max_texture_width,
@ -271,27 +284,106 @@ static int impl_port_enum_formats(struct spa_node *node, enum spa_direction dire
2, &SPA_FRACTION(0,1),
&SPA_FRACTION(30,1),
NULL);
spa_pod_builder_pop(&b, &f[0]);
*format = SPA_POD_BUILDER_DEREF(&b, f[0].ref, struct spa_format);
spa_pod_builder_pop(builder, &f[0]);
spa_debug_format(*format);
(*index)++;
return SPA_RESULT_OK;
}
static int impl_port_set_format(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t flags, const struct spa_format *format)
static int port_get_format(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t *index,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (*index != 0 || d->format.format == 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_object(builder,
d->t->param.idFormat, d->type.format,
"I", d->type.media_type.video,
"I", d->type.media_subtype.raw,
":", d->type.format_video.format, "I", d->format.format,
":", d->type.format_video.size, "R", &d->format.size,
":", d->type.format_video.framerate, "F", &d->format.framerate);
(*index)++;
return SPA_RESULT_OK;
}
static int impl_port_enum_params(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t *index,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct pw_type *t = d->t;
struct spa_pod_builder b = { NULL };
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
t->param.idBuffers,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
spa_pod_builder_object(builder,
id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return SPA_RESULT_ENUM_END;
}
else if (id == t->param.idEnumFormat) {
return port_enum_formats(node, direction, port_id, index, filter, builder);
}
else if (id == t->param.idFormat) {
return port_get_format(node, direction, port_id, index, filter, builder);
}
else if (id == t->param.idBuffers) {
if (*index != 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_object(builder,
id, t->param_alloc_buffers.Buffers,
":", t->param_alloc_buffers.size, "i", d->stride * d->format.size.height,
":", t->param_alloc_buffers.stride, "i", d->stride,
":", t->param_alloc_buffers.buffers, "iru", 32,
2, 2, 32,
":", t->param_alloc_buffers.align, "i", 16);
}
else if (id == t->param.idMeta) {
if (*index != 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_object(builder,
id, t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Header,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_header));
}
else
return SPA_RESULT_UNKNOWN_PARAM;
(*index)++;
return SPA_RESULT_OK;
}
static int port_set_format(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t flags, const struct spa_pod_object *format)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
Uint32 sdl_format;
void *dest;
if (format == NULL)
return SPA_RESULT_OK;
spa_debug_format(format);
spa_debug_pod(&format->pod, SPA_DEBUG_FLAG_FORMAT);
spa_format_video_raw_parse(format, &d->format, &d->type.format_video);
@ -307,64 +399,22 @@ static int impl_port_set_format(struct spa_node *node, enum spa_direction direct
SDL_LockTexture(d->texture, NULL, &dest, &d->stride);
SDL_UnlockTexture(d->texture);
spa_pod_builder_init(&b, d->params_buffer, sizeof(d->params_buffer));
d->params[0] = spa_pod_builder_param(&b,
t->param_alloc_buffers.Buffers,
":", t->param_alloc_buffers.size, "i", d->stride * d->format.size.height,
":", t->param_alloc_buffers.stride, "i", d->stride,
":", t->param_alloc_buffers.buffers, "iru", 32,
2, 2, 32,
":", t->param_alloc_buffers.align, "i", 16);
d->params[1] = spa_pod_builder_param(&b,
t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Header,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_header));
return SPA_RESULT_OK;
}
static int impl_port_get_format(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_format **format)
static int impl_port_set_param(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t flags,
const struct spa_pod_object *param)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(d->buffer, sizeof(d->buffer));
struct pw_type *t = d->t;
*format = spa_pod_builder_format(&b, d->type.format,
d->type.media_type.video,
d->type.media_subtype.raw,
":", d->type.format_video.format, "I", d->format.format,
":", d->type.format_video.size, "R", &d->format.size,
":", d->type.format_video.framerate, "F", &d->format.framerate);
return SPA_RESULT_OK;
}
static int impl_port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_port_info **info)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->port_info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
d->port_info.rate = 0;
d->port_info.props = NULL;
*info = &d->port_info;
return SPA_RESULT_OK;
}
static int impl_port_enum_params(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t index, struct spa_param **param)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (index >= 2)
return SPA_RESULT_ENUM_END;
*param = d->params[index];
return SPA_RESULT_OK;
if (id == t->param.idFormat) {
return port_set_format(node, direction, port_id, flags, param);
}
else
return SPA_RESULT_UNKNOWN_PARAM;
}
static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -443,11 +493,9 @@ static const struct spa_node impl_node = {
.get_n_ports = impl_get_n_ports,
.get_port_ids = impl_get_port_ids,
.port_set_io = impl_port_set_io,
.port_enum_formats = impl_port_enum_formats,
.port_set_format = impl_port_set_format,
.port_get_format = impl_port_get_format,
.port_get_info = impl_port_get_info,
.port_enum_params = impl_port_enum_params,
.port_set_param = impl_port_set_param,
.port_use_buffers = impl_port_use_buffers,
.process_input = impl_node_process_input,
};

236
src/examples/export-source.c
View file

@ -24,7 +24,6 @@
#include <spa/type-map.h>
#include <spa/format-utils.h>
#include <spa/audio/format-utils.h>
#include <spa/format-builder.h>
#include <spa/props.h>
#include <spa/lib/debug.h>
@ -88,8 +87,6 @@ struct data {
struct spa_audio_info_raw format;
uint8_t params_buffer[1024];
struct buffer buffers[32];
int n_buffers;
struct spa_list empty;
@ -141,62 +138,6 @@ static int impl_port_set_io(struct spa_node *node, enum spa_direction direction,
return SPA_RESULT_OK;
}
static int impl_port_enum_formats(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
struct spa_format **format,
const struct spa_format *filter,
uint32_t index)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(d->buffer, sizeof(d->buffer));
if (index != 0)
return SPA_RESULT_ENUM_END;
*format = spa_pod_builder_format(&b, d->type.format,
d->type.media_type.audio, d->type.media_subtype.raw,
":", d->type.format_audio.format, "I", d->type.audio_format.S16,
":", d->type.format_audio.channels, "i", 2,
":", d->type.format_audio.rate, "i", 44100);
spa_debug_format(*format);
return SPA_RESULT_OK;
}
static int impl_port_set_format(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t flags, const struct spa_format *format)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (format == NULL)
return SPA_RESULT_OK;
spa_debug_format(format);
if (spa_format_audio_raw_parse(format, &d->format, &d->type.format_audio) < 0)
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (d->format.format != d->type.audio_format.S16)
return SPA_RESULT_ERROR;
return SPA_RESULT_OK;
}
static int impl_port_get_format(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_format **format)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(d->buffer, sizeof(d->buffer));
*format = spa_pod_builder_format(&b, d->type.format,
d->type.media_type.audio, d->type.media_subtype.raw,
":", d->type.format_audio.format, "I", d->format.format,
":", d->type.format_audio.channels, "i", d->format.channels,
":", d->type.format_audio.rate, "i", d->format.rate);
return SPA_RESULT_OK;
}
static int impl_port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_port_info **info)
{
@ -211,49 +152,166 @@ static int impl_port_get_info(struct spa_node *node, enum spa_direction directio
return SPA_RESULT_OK;
}
static int impl_port_enum_params(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t index, struct spa_param **param)
static int port_enum_formats(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t *index,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (*index != 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_object(builder,
d->t->param.idEnumFormat, d->type.format,
"I", d->type.media_type.audio,
"I", d->type.media_subtype.raw,
":", d->type.format_audio.format, "I", d->type.audio_format.S16,
":", d->type.format_audio.channels, "i", 2,
":", d->type.format_audio.rate, "i", 44100);
(*index)++;
return SPA_RESULT_OK;
}
static int port_get_format(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t *index,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (*index != 0)
return SPA_RESULT_ENUM_END;
if (d->format.format == 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_object(builder,
d->t->param.idFormat, d->type.format,
"I", d->type.media_type.audio,
"I", d->type.media_subtype.raw,
":", d->type.format_audio.format, "I", d->format.format,
":", d->type.format_audio.channels, "i", d->format.channels,
":", d->type.format_audio.rate, "i", d->format.rate);
(*index)++;
return SPA_RESULT_OK;
}
static int impl_port_enum_params(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t *index,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct pw_type *t = d->t;
struct spa_pod_builder b = { NULL };
spa_pod_builder_init(&b, d->params_buffer, sizeof(d->params_buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
t->param.idBuffers,
t->param.idMeta };
switch (index) {
case 0:
*param = spa_pod_builder_param(&b,
t->param_alloc_buffers.Buffers,
if (*index < SPA_N_ELEMENTS(list))
spa_pod_builder_object(builder,
id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return SPA_RESULT_ENUM_END;
}
else if (id == t->param.idEnumFormat) {
return port_enum_formats(node, direction, port_id, index, filter, builder);
}
else if (id == t->param.idFormat) {
return port_get_format(node, direction, port_id, index, filter, builder);
}
else if (id == t->param.idBuffers) {
if (*index > 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_object(builder,
id, t->param_alloc_buffers.Buffers,
":", t->param_alloc_buffers.size, "iru", 1024,
2, 32, 4096,
":", t->param_alloc_buffers.stride, "i", 0,
":", t->param_alloc_buffers.buffers, "iru", 2,
2, 2, 32,
":", t->param_alloc_buffers.align, "i", 16);
break;
case 1:
*param = spa_pod_builder_param(&b,
t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Header,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_header));
break;
case 2:
*param = spa_pod_builder_param(&b,
t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Ringbuffer,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_ringbuffer),
":", t->param_alloc_meta_enable.ringbufferSize, "ir", 1024 * 4,
2, 16 * 4, INT32_MAX / 4,
":", t->param_alloc_meta_enable.ringbufferStride, "i", 0,
":", t->param_alloc_meta_enable.ringbufferBlocks, "i", 1,
":", t->param_alloc_meta_enable.ringbufferAlign, "i", 16);
break;
default:
return SPA_RESULT_ENUM_END;
}
else if (id == t->param.idMeta) {
switch (*index) {
case 0:
spa_pod_builder_object(builder,
id, t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Header,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_header));
break;
case 1:
spa_pod_builder_object(builder,
id, t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Ringbuffer,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_ringbuffer),
":", t->param_alloc_meta_enable.ringbufferSize, "ir", 1024 * 4,
2, 16 * 4, INT32_MAX / 4,
":", t->param_alloc_meta_enable.ringbufferStride, "i", 0,
":", t->param_alloc_meta_enable.ringbufferBlocks, "i", 1,
":", t->param_alloc_meta_enable.ringbufferAlign, "i", 16);
break;
default:
return SPA_RESULT_ENUM_END;
}
}
else
return SPA_RESULT_UNKNOWN_PARAM;
(*index)++;
return SPA_RESULT_OK;
}
static int port_set_format(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t flags, const struct spa_pod_object *format)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (format == NULL) {
d->format.format = 0;
return SPA_RESULT_OK;
}
spa_debug_pod(&format->pod, SPA_DEBUG_FLAG_FORMAT);
if (spa_format_audio_raw_parse(format, &d->format, &d->type.format_audio) < 0)
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (d->format.format != d->type.audio_format.S16)
return SPA_RESULT_ERROR;
return SPA_RESULT_OK;
}
static int impl_port_set_param(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t flags,
const struct spa_pod_object *param)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct pw_type *t = d->t;
if (id == t->param.idFormat) {
return port_set_format(node, direction, port_id, flags, param);
}
else
return SPA_RESULT_UNKNOWN_PARAM;
}
static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
struct spa_buffer **buffers, uint32_t n_buffers)
{
@ -378,11 +436,9 @@ static const struct spa_node impl_node = {
.get_n_ports = impl_get_n_ports,
.get_port_ids = impl_get_port_ids,
.port_set_io = impl_port_set_io,
.port_enum_formats = impl_port_enum_formats,
.port_set_format = impl_port_set_format,
.port_get_format = impl_port_get_format,
.port_get_info = impl_port_get_info,
.port_enum_params = impl_port_enum_params,
.port_set_param = impl_port_set_param,
.port_use_buffers = impl_port_use_buffers,
.port_reuse_buffer = impl_port_reuse_buffer,
.process_output = impl_node_process_output,

1
src/examples/export-spa.c
View file

@ -24,7 +24,6 @@
#include <spa/type-map.h>
#include <spa/format-utils.h>
#include <spa/video/format-utils.h>
#include <spa/format-builder.h>
#include <spa/props.h>
#include <spa/lib/debug.h>

154
src/examples/local-v4l2.c
View file

@ -25,7 +25,6 @@
#include <spa/type-map.h>
#include <spa/format-utils.h>
#include <spa/video/format-utils.h>
#include <spa/format-builder.h>
#include <spa/props.h>
#include <spa/lib/debug.h>
@ -85,14 +84,9 @@ struct data {
const struct spa_node_callbacks *callbacks;
void *callbacks_data;
uint8_t buffer[1024];
struct spa_video_info_raw format;
int32_t stride;
uint8_t params_buffer[1024];
struct spa_param *params[2];
struct spa_buffer *buffers[32];
int n_buffers;
};
@ -223,27 +217,42 @@ static int impl_port_set_io(struct spa_node *node, enum spa_direction direction,
return SPA_RESULT_OK;
}
static int impl_port_enum_formats(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
struct spa_format **format,
const struct spa_format *filter,
uint32_t index)
static int impl_port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_port_info **info)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->port_info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
d->port_info.rate = 0;
d->port_info.props = NULL;
*info = &d->port_info;
return SPA_RESULT_OK;
}
static int port_enum_formats(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t *index,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(d->buffer, sizeof(d->buffer));
struct spa_pod_frame f[2];
SDL_RendererInfo info;
int i, c;
if (index != 0)
if (*index != 0)
return SPA_RESULT_ENUM_END;
SDL_GetRendererInfo(d->renderer, &info);
spa_pod_builder_push_format(&b, &f[0], d->type.format,
d->type.media_type.video,
d->type.media_subtype.raw);
spa_pod_builder_push_object(builder, &f[0],
d->t->param.idEnumFormat, d->type.format);
spa_pod_builder_id(builder, d->type.media_type.video);
spa_pod_builder_id(builder, d->type.media_subtype.raw);
spa_pod_builder_push_prop(&b, &f[1], d->type.format_video.format,
spa_pod_builder_push_prop(builder, &f[1], d->type.format_video.format,
SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM);
for (i = 0, c = 0; i < info.num_texture_formats; i++) {
@ -251,19 +260,19 @@ static int impl_port_enum_formats(struct spa_node *node, enum spa_direction dire
if (id == 0)
continue;
if (c++ == 0)
spa_pod_builder_id(&b, id);
spa_pod_builder_id(&b, id);
spa_pod_builder_id(builder, id);
spa_pod_builder_id(builder, id);
}
for (i = 0; i < SPA_N_ELEMENTS(video_formats); i++) {
uint32_t id =
*SPA_MEMBER(&d->type.video_format, video_formats[i].id,
uint32_t);
if (id != d->type.video_format.UNKNOWN)
spa_pod_builder_id(&b, id);
spa_pod_builder_id(builder, id);
}
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(builder, &f[1]);
spa_pod_builder_add(&b,
spa_pod_builder_add(builder,
":", d->type.format_video.size, "Rru", &SPA_RECTANGLE(WIDTH, HEIGHT),
2, &SPA_RECTANGLE(1,1),
&SPA_RECTANGLE(info.max_texture_width,
@ -272,28 +281,64 @@ static int impl_port_enum_formats(struct spa_node *node, enum spa_direction dire
2, &SPA_FRACTION(0,1),
&SPA_FRACTION(30,1),
NULL);
spa_pod_builder_pop(&b, &f[0]);
*format = SPA_POD_BUILDER_DEREF(&b, f[0].ref, struct spa_format);
spa_pod_builder_pop(builder, &f[0]);
spa_debug_format(*format);
(*index)++;
return SPA_RESULT_OK;
}
static int impl_port_set_format(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t flags, const struct spa_format *format)
static int impl_port_enum_params(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t *index,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct pw_type *t = d->t;
struct spa_pod_builder b = { NULL };
if (id == t->param.idEnumFormat) {
return port_enum_formats(node, direction, port_id, index, filter, builder);
}
else if (id == t->param.idBuffers) {
if (*index > 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_object(builder,
id, t->param_alloc_buffers.Buffers,
":", t->param_alloc_buffers.size, "i", d->stride * d->format.size.height,
":", t->param_alloc_buffers.stride, "i", d->stride,
":", t->param_alloc_buffers.buffers, "iru", 2,
2, 1, 32,
":", t->param_alloc_buffers.align, "i", 16);
}
else if (id == t->param.idMeta) {
if (*index > 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_object(builder,
id, t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Header,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_header));
}
else
return SPA_RESULT_UNKNOWN_PARAM;
(*index)++;
return SPA_RESULT_OK;
}
static int port_set_format(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t flags, const struct spa_pod_object *format)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
Uint32 sdl_format;
void *dest;
if (format == NULL) {
if (format == NULL)
return SPA_RESULT_OK;
}
spa_debug_format(format);
spa_debug_pod(&format->pod, SPA_DEBUG_FLAG_FORMAT);
spa_format_video_raw_parse(format, &d->format, &d->type.format_video);
@ -309,48 +354,22 @@ static int impl_port_set_format(struct spa_node *node, enum spa_direction direct
SDL_LockTexture(d->texture, NULL, &dest, &d->stride);
SDL_UnlockTexture(d->texture);
spa_pod_builder_init(&b, d->params_buffer, sizeof(d->params_buffer));
d->params[0] = spa_pod_builder_param(&b,
t->param_alloc_buffers.Buffers,
":", t->param_alloc_buffers.size, "i", d->stride * d->format.size.height,
":", t->param_alloc_buffers.stride, "i", d->stride,
":", t->param_alloc_buffers.buffers, "iru", 2,
2, 1, 32,
":", t->param_alloc_buffers.align, "i", 16);
d->params[1] = spa_pod_builder_param(&b,
t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Header,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_header));
return SPA_RESULT_OK;
}
static int impl_port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_port_info **info)
static int impl_port_set_param(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t flags,
const struct spa_pod_object *param)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct pw_type *t = d->t;
d->port_info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
d->port_info.rate = 0;
d->port_info.props = NULL;
*info = &d->port_info;
return SPA_RESULT_OK;
}
static int impl_port_enum_params(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t index, struct spa_param **param)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (index >= 2)
return SPA_RESULT_ENUM_END;
*param = d->params[index];
return SPA_RESULT_OK;
if (id == t->param.idFormat) {
return port_set_format(node, direction, port_id, flags, param);
}
else
return SPA_RESULT_UNKNOWN_PARAM;
}
static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -425,10 +444,9 @@ static const struct spa_node impl_node = {
.get_n_ports = impl_get_n_ports,
.get_port_ids = impl_get_port_ids,
.port_set_io = impl_port_set_io,
.port_enum_formats = impl_port_enum_formats,
.port_set_format = impl_port_set_format,
.port_get_info = impl_port_get_info,
.port_enum_params = impl_port_enum_params,
.port_set_param = impl_port_set_param,
.port_use_buffers = impl_port_use_buffers,
.process_input = impl_node_process_input,
};

41
src/examples/video-play.c
View file

@ -25,7 +25,6 @@
#include <spa/type-map.h>
#include <spa/format-utils.h>
#include <spa/video/format-utils.h>
#include <spa/format-builder.h>
#include <spa/props.h>
#include <spa/lib/debug.h>
@ -34,6 +33,7 @@
struct type {
uint32_t format;
uint32_t props;
struct spa_type_param param;
struct spa_type_meta meta;
struct spa_type_data data;
struct spa_type_media_type media_type;
@ -46,6 +46,7 @@ static inline void init_type(struct type *type, struct spa_type_map *map)
{
type->format = spa_type_map_get_id(map, SPA_TYPE__Format);
type->props = spa_type_map_get_id(map, SPA_TYPE__Props);
spa_type_param_map(map, &type->param);
spa_type_meta_map(map, &type->meta);
spa_type_data_map(map, &type->data);
spa_type_media_type_map(map, &type->media_type);
@ -234,28 +235,26 @@ static Uint32 id_to_sdl_format(struct data *data, uint32_t id)
}
static void
on_stream_format_changed(void *_data, struct spa_format *format)
on_stream_format_changed(void *_data, struct spa_pod_object *format)
{
struct data *data = _data;
struct pw_stream *stream = data->stream;
struct pw_type *t = data->t;
struct spa_pod_builder b = { NULL };
struct spa_param *params[2];
struct spa_pod_object *params[2];
Uint32 sdl_format;
void *d;
if (format == NULL) {
pw_stream_finish_format(stream, SPA_RESULT_OK, NULL, 0);
pw_stream_finish_format(stream, SPA_RESULT_OK, 0, NULL);
return;
}
spa_debug_format(format);
spa_format_video_raw_parse(format, &data->format, &data->type.format_video);
sdl_format = id_to_sdl_format(data, data->format.format);
if (sdl_format == SDL_PIXELFORMAT_UNKNOWN) {
pw_stream_finish_format(stream, SPA_RESULT_ERROR, NULL, 0);
pw_stream_finish_format(stream, SPA_RESULT_ERROR, 0, NULL);
return;
}
@ -268,20 +267,20 @@ on_stream_format_changed(void *_data, struct spa_format *format)
SDL_UnlockTexture(data->texture);
spa_pod_builder_init(&b, data->params_buffer, sizeof(data->params_buffer));
params[0] = spa_pod_builder_param(&b,
t->param_alloc_buffers.Buffers,
params[0] = spa_pod_builder_object(&b,
t->param.idBuffers, t->param_alloc_buffers.Buffers,
":", t->param_alloc_buffers.size, "i", data->stride * data->format.size.height,
":", t->param_alloc_buffers.stride, "i", data->stride,
":", t->param_alloc_buffers.buffers, "iru", 32,
2, 2, 32,
":", t->param_alloc_buffers.align, "i", 16);
params[1] = spa_pod_builder_param(&b,
t->param_alloc_meta_enable.MetaEnable,
params[1] = spa_pod_builder_object(&b,
t->param.idMeta, t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Header,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_header));
pw_stream_finish_format(stream, SPA_RESULT_OK, params, 2);
pw_stream_finish_format(stream, SPA_RESULT_OK, 2, params);
}
static const struct pw_stream_events stream_events = {
@ -304,7 +303,7 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
case PW_REMOTE_STATE_CONNECTED:
{
const struct spa_format *formats[1];
const struct spa_pod_object *params[1];
uint8_t buffer[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
struct spa_pod_frame f[2];
@ -318,9 +317,10 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
SDL_GetRendererInfo(data->renderer, &info);
spa_pod_builder_push_format(&b, &f[0], data->type.format,
data->type.media_type.video,
data->type.media_subtype.raw);
spa_pod_builder_push_object(&b, &f[0],
data->type.param.idEnumFormat, data->type.format);
spa_pod_builder_id(&b, data->type.media_type.video);
spa_pod_builder_id(&b, data->type.media_subtype.raw);
spa_pod_builder_push_prop(&b, &f[1], data->type.format_video.format,
SPA_POD_PROP_FLAG_UNSET |
@ -351,10 +351,10 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
&SPA_RECTANGLE(30,1),
NULL);
spa_pod_builder_pop(&b, &f[0]);
formats[0] = SPA_POD_BUILDER_DEREF(&b, f[0].ref, struct spa_format);
params[0] = SPA_POD_BUILDER_DEREF(&b, f[0].ref, struct spa_pod_object);
printf("supported formats:\n");
spa_debug_format(formats[0]);
spa_debug_pod(&params[0]->pod, SPA_DEBUG_FLAG_FORMAT);
pw_stream_add_listener(data->stream,
&data->stream_listener,
@ -363,8 +363,9 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
pw_stream_connect(data->stream,
PW_DIRECTION_INPUT,
PW_STREAM_MODE_BUFFER,
data->path, PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_INACTIVE, 1, formats);
data->path,
PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_INACTIVE,
1, params);
break;
}
default:

31
src/examples/video-src.c
View file

@ -25,7 +25,6 @@
#include <spa/type-map.h>
#include <spa/format-utils.h>
#include <spa/video/format-utils.h>
#include <spa/format-builder.h>
#include <spa/props.h>
#include <spa/lib/debug.h>
@ -34,6 +33,7 @@
struct type {
uint32_t format;
uint32_t props;
struct spa_type_param param;
struct spa_type_meta meta;
struct spa_type_data data;
struct spa_type_media_type media_type;
@ -46,6 +46,7 @@ static inline void init_type(struct type *type, struct spa_type_map *map)
{
type->format = spa_type_map_get_id(map, SPA_TYPE__Format);
type->props = spa_type_map_get_id(map, SPA_TYPE__Props);
spa_type_param_map(map, &type->param);
spa_type_meta_map(map, &type->meta);
spa_type_data_map(map, &type->data);
spa_type_media_type_map(map, &type->media_type);
@ -166,16 +167,16 @@ static void on_stream_state_changed(void *_data, enum pw_stream_state old, enum
}
static void
on_stream_format_changed(void *_data, struct spa_format *format)
on_stream_format_changed(void *_data, struct spa_pod_object *format)
{
struct data *data = _data;
struct pw_stream *stream = data->stream;
struct pw_type *t = data->t;
struct spa_pod_builder b = { NULL };
struct spa_param *params[2];
struct spa_pod_object *params[2];
if (format == NULL) {
pw_stream_finish_format(stream, SPA_RESULT_OK, NULL, 0);
pw_stream_finish_format(stream, SPA_RESULT_OK, 0, NULL);
return;
}
spa_format_video_raw_parse(format, &data->format, &data->type.format_video);
@ -183,20 +184,20 @@ on_stream_format_changed(void *_data, struct spa_format *format)
data->stride = SPA_ROUND_UP_N(data->format.size.width * BPP, 4);
spa_pod_builder_init(&b, data->params_buffer, sizeof(data->params_buffer));
params[0] = spa_pod_builder_param(&b,
t->param_alloc_buffers.Buffers,
params[0] = spa_pod_builder_object(&b,
t->param.idBuffers, t->param_alloc_buffers.Buffers,
":", t->param_alloc_buffers.size, "i", data->stride * data->format.size.height,
":", t->param_alloc_buffers.stride, "i", data->stride,
":", t->param_alloc_buffers.buffers, "iru", 2,
2, 1, 32,
":", t->param_alloc_buffers.align, "i", 16);
params[1] = spa_pod_builder_param(&b,
t->param_alloc_meta_enable.MetaEnable,
params[1] = spa_pod_builder_object(&b,
t->param.idMeta, t->param_alloc_meta_enable.MetaEnable,
":", t->param_alloc_meta_enable.type, "I", t->meta.Header,
":", t->param_alloc_meta_enable.size, "i", sizeof(struct spa_meta_header));
pw_stream_finish_format(stream, SPA_RESULT_OK, params, 2);
pw_stream_finish_format(stream, SPA_RESULT_OK, 2, params);
}
static const struct pw_stream_events stream_events = {
@ -218,7 +219,7 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
case PW_REMOTE_STATE_CONNECTED:
{
const struct spa_format *formats[1];
const struct spa_pod_object *params[1];
uint8_t buffer[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
@ -227,8 +228,10 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
data->stream = pw_stream_new(remote, "video-src", NULL);
formats[0] = spa_pod_builder_format(&b, data->type.format,
data->type.media_type.video, data->type.media_subtype.raw,
params[0] = spa_pod_builder_object(&b,
data->type.param.idEnumFormat, data->type.format,
"I", data->type.media_type.video,
"I", data->type.media_subtype.raw,
":", data->type.format_video.format, "I", data->type.video_format.RGB,
":", data->type.format_video.size, "Rru", &SPA_RECTANGLE(320, 240),
2, &SPA_RECTANGLE(1, 1),
@ -242,8 +245,8 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
pw_stream_connect(data->stream,
PW_DIRECTION_OUTPUT,
PW_STREAM_MODE_BUFFER,
NULL, PW_STREAM_FLAG_NONE, 1, formats);
NULL, PW_STREAM_FLAG_NONE,
1, params);
break;
}
default: