From b51d3e486218e8f74d4fefed3f0bf7cea459e081 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Wed, 26 Apr 2017 18:42:50 +0200 Subject: [PATCH] buffer: make data and meta types dynamic Use dynamic types for the data and meta types. Move the meta into a separate header. Remove port state, we can keep track of that ourselves. Add size to MetaDataEnable params --- pinos/client/interfaces.h | 2 +- pinos/client/protocol-native.c | 9 +- pinos/client/stream.c | 39 +++--- pinos/client/stream.h | 5 +- pinos/client/type.c | 2 + pinos/client/type.h | 2 + pinos/examples/video-play.c | 11 +- pinos/examples/video-src.c | 17 ++- pinos/gst/gstpinossink.c | 47 +++---- pinos/gst/gstpinossrc.c | 43 +++---- pinos/server/client-node.c | 60 ++++----- pinos/server/core.c | 14 +-- pinos/server/link.c | 92 +++++++------- pinos/server/node.c | 4 +- pinos/server/port.c | 14 +-- pinos/server/port.h | 11 +- pinos/server/protocol-native.c | 9 +- spa/include/spa/alloc-param.h | 3 + spa/include/spa/buffer.h | 161 +++++------------------- spa/include/spa/meta.h | 135 ++++++++++++++++++++ spa/include/spa/node.h | 10 +- spa/include/spa/type.h | 3 + spa/lib/debug.c | 131 ++++++++----------- spa/lib/debug.h | 2 +- spa/plugins/alsa/alsa-sink.c | 29 +++-- spa/plugins/alsa/alsa-source.c | 24 ++-- spa/plugins/alsa/alsa-utils.h | 4 + spa/plugins/audiomixer/audiomixer.c | 23 ++-- spa/plugins/audiotestsrc/audiotestsrc.c | 27 ++-- spa/plugins/v4l2/v4l2-source.c | 4 + spa/plugins/v4l2/v4l2-utils.c | 64 +++++----- spa/plugins/videotestsrc/videotestsrc.c | 25 ++-- spa/plugins/volume/volume.c | 32 ++--- spa/tests/test-mixer.c | 8 +- spa/tests/test-ringbuffer.c | 10 +- spa/tests/test-v4l2.c | 20 +-- 36 files changed, 543 insertions(+), 553 deletions(-) create mode 100644 spa/include/spa/meta.h diff --git a/pinos/client/interfaces.h b/pinos/client/interfaces.h index aa298e37e..9c96bae5f 100644 --- a/pinos/client/interfaces.h +++ b/pinos/client/interfaces.h @@ -244,7 +244,7 @@ typedef struct { SpaDirection direction, uint32_t port_id, uint32_t mem_id, - SpaDataType type, + uint32_t type, int memfd, uint32_t flags, uint32_t offset, diff --git a/pinos/client/protocol-native.c b/pinos/client/protocol-native.c index e29dec015..8106797fd 100644 --- a/pinos/client/protocol-native.c +++ b/pinos/client/protocol-native.c @@ -510,6 +510,7 @@ client_node_marshal_port_update (void *object, spa_pod_builder_add (&b.b, SPA_POD_TYPE_STRUCT, &f[1], SPA_POD_TYPE_INT, info->flags, + SPA_POD_TYPE_INT, info->rate, SPA_POD_TYPE_LONG, info->maxbuffering, SPA_POD_TYPE_LONG, info->latency, SPA_POD_TYPE_INT, info->n_params, @@ -718,11 +719,12 @@ client_node_demarshal_add_mem (void *object, int memfd; if (!spa_pod_iter_struct (&it, data, size) || + !pinos_pod_remap_data (SPA_POD_TYPE_STRUCT, data, size, &proxy->context->types) || !spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &direction, SPA_POD_TYPE_INT, &port_id, SPA_POD_TYPE_INT, &mem_id, - SPA_POD_TYPE_INT, &type, + SPA_POD_TYPE_ID, &type, SPA_POD_TYPE_INT, &memfd_idx, SPA_POD_TYPE_INT, &flags, SPA_POD_TYPE_INT, &offset, @@ -756,6 +758,7 @@ client_node_demarshal_use_buffers (void *object, int i, j; if (!spa_pod_iter_struct (&it, data, size) || + !pinos_pod_remap_data (SPA_POD_TYPE_STRUCT, data, size, &proxy->context->types) || !spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &seq, SPA_POD_TYPE_INT, &direction, @@ -781,7 +784,7 @@ client_node_demarshal_use_buffers (void *object, SpaMeta *m = &buf->metas[j]; if (!spa_pod_iter_get (&it, - SPA_POD_TYPE_INT, &m->type, + SPA_POD_TYPE_ID, &m->type, SPA_POD_TYPE_INT, &m->size, 0)) return false; } @@ -793,7 +796,7 @@ client_node_demarshal_use_buffers (void *object, SpaData *d = &buf->datas[j]; if (!spa_pod_iter_get (&it, - SPA_POD_TYPE_INT, &d->type, + SPA_POD_TYPE_ID, &d->type, SPA_POD_TYPE_INT, &data_id, SPA_POD_TYPE_INT, &d->flags, SPA_POD_TYPE_INT, &d->mapoffset, diff --git a/pinos/client/stream.c b/pinos/client/stream.c index 273efd8a5..78c36c89f 100644 --- a/pinos/client/stream.c +++ b/pinos/client/stream.c @@ -62,8 +62,6 @@ typedef struct { PinosStream this; - uint32_t port_state; - uint32_t n_possible_formats; SpaFormat **possible_formats; @@ -230,7 +228,6 @@ pinos_stream_new (PinosContext *context, this->state = PINOS_STREAM_STATE_UNCONNECTED; - impl->port_state = SPA_PORT_STATE_INIT; pinos_array_init (&impl->mem_ids, 64); pinos_array_ensure_size (&impl->mem_ids, sizeof (MemId) * 64); pinos_array_init (&impl->buffer_ids, 32); @@ -741,7 +738,7 @@ client_node_add_mem (void *object, SpaDirection direction, uint32_t port_id, uint32_t mem_id, - SpaDataType type, + uint32_t type, int memfd, uint32_t flags, uint32_t offset, @@ -856,26 +853,20 @@ client_node_use_buffers (void *object, memcpy (d, &buffers[i].buffer->datas[j], sizeof (SpaData)); d->chunk = SPA_MEMBER (bid->buf_ptr, offset + sizeof (SpaChunk) * j, SpaChunk); - switch (d->type) { - case SPA_DATA_TYPE_ID: - { - MemId *bmid = find_mem (stream, SPA_PTR_TO_UINT32 (d->data)); - d->type = SPA_DATA_TYPE_MEMFD; - d->data = NULL; - d->fd = bmid->fd; - pinos_log_debug (" data %d %u -> fd %d", j, bmid->id, bmid->fd); - break; - } - case SPA_DATA_TYPE_MEMPTR: - { - d->data = SPA_MEMBER (bid->buf_ptr, SPA_PTR_TO_INT (d->data), void); - d->fd = -1; - pinos_log_debug (" data %d %u -> mem %p", j, bid->id, d->data); - break; - } - default: - pinos_log_warn ("unknown buffer data type %d", d->type); - break; + if (d->type == stream->context->type.data.Id) { + MemId *bmid = find_mem (stream, SPA_PTR_TO_UINT32 (d->data)); + d->type = stream->context->type.data.MemFd; + d->data = NULL; + d->fd = bmid->fd; + pinos_log_debug (" data %d %u -> fd %d", j, bmid->id, bmid->fd); + } + else if (d->type == stream->context->type.data.MemPtr) { + d->data = SPA_MEMBER (bid->buf_ptr, SPA_PTR_TO_INT (d->data), void); + d->fd = -1; + pinos_log_debug (" data %d %u -> mem %p", j, bid->id, d->data); + } + else { + pinos_log_warn ("unknown buffer data type %d", d->type); } } pinos_signal_emit (&stream->add_buffer, stream, bid->id); diff --git a/pinos/client/stream.h b/pinos/client/stream.h index 61df94f06..2a9805af0 100644 --- a/pinos/client/stream.h +++ b/pinos/client/stream.h @@ -44,8 +44,9 @@ typedef enum { const char * pinos_stream_state_as_string (PinosStreamState state); typedef enum { - PINOS_STREAM_FLAG_NONE = 0, - PINOS_STREAM_FLAG_AUTOCONNECT = (1 << 0), + PINOS_STREAM_FLAG_NONE = 0, + PINOS_STREAM_FLAG_AUTOCONNECT = (1 << 0), + PINOS_STREAM_FLAG_CLOCK_UPDATE = (1 << 1), } PinosStreamFlags; typedef enum { diff --git a/pinos/client/type.c b/pinos/client/type.c index 1d7fe4e3f..6bb3da74a 100644 --- a/pinos/client/type.c +++ b/pinos/client/type.c @@ -51,6 +51,8 @@ pinos_type_init (PinosType *type) type->spa_format = spa_type_map_get_id (type->map, SPA_TYPE__Format); type->spa_props = spa_type_map_get_id (type->map, SPA_TYPE__Props); + spa_type_meta_map (type->map, &type->meta); + spa_type_data_map (type->map, &type->data); spa_type_event_node_map (type->map, &type->event_node); spa_type_command_node_map (type->map, &type->command_node); spa_type_monitor_map (type->map, &type->monitor); diff --git a/pinos/client/type.h b/pinos/client/type.h index bbfb4b62c..874e6ab46 100644 --- a/pinos/client/type.h +++ b/pinos/client/type.h @@ -56,6 +56,8 @@ struct _PinosType { SpaType spa_format; SpaType spa_props; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeEventNode event_node; SpaTypeCommandNode command_node; SpaTypeMonitor monitor; diff --git a/pinos/examples/video-play.c b/pinos/examples/video-play.c index 0eba81910..5c6f8c098 100644 --- a/pinos/examples/video-play.c +++ b/pinos/examples/video-play.c @@ -35,6 +35,8 @@ typedef struct { uint32_t format; uint32_t props; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeFormatVideo format_video; @@ -46,6 +48,8 @@ init_type (Type *type, SpaTypeMap *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_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_format_video_map (map, &type->format_video); @@ -112,12 +116,12 @@ on_stream_new_buffer (PinosListener *listener, buf = pinos_stream_peek_buffer (data->stream, id); - if (buf->datas[0].type == SPA_DATA_TYPE_MEMFD) { + if (buf->datas[0].type == data->type.data.MemFd) { map = mmap (NULL, buf->datas[0].maxsize + buf->datas[0].mapoffset, PROT_READ, MAP_PRIVATE, buf->datas[0].fd, 0); sdata = SPA_MEMBER (map, buf->datas[0].mapoffset, uint8_t); } - else if (buf->datas[0].type == SPA_DATA_TYPE_MEMPTR) { + else if (buf->datas[0].type == data->type.data.MemPtr) { map = NULL; sdata = buf->datas[0].data; } else @@ -275,7 +279,8 @@ on_stream_format_changed (PinosListener *listener, params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, ctx->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, ctx->type.meta.Header), + PROP (&f[1], ctx->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); pinos_stream_finish_format (stream, SPA_RESULT_OK, params, 2); diff --git a/pinos/examples/video-src.c b/pinos/examples/video-src.c index 6a9bfe38e..4230fa087 100644 --- a/pinos/examples/video-src.c +++ b/pinos/examples/video-src.c @@ -18,6 +18,7 @@ */ #include +#include #include #include @@ -33,6 +34,8 @@ typedef struct { uint32_t format; uint32_t props; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeFormatVideo format_video; @@ -44,6 +47,8 @@ init_type (Type *type, SpaTypeMap *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_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_format_video_map (map, &type->format_video); @@ -90,12 +95,16 @@ on_timeout (SpaLoopUtils *utils, buf = pinos_stream_peek_buffer (data->stream, id); - if (buf->datas[0].type == SPA_DATA_TYPE_MEMFD) { + if (buf->datas[0].type == data->type.data.MemFd) { map = mmap (NULL, buf->datas[0].maxsize + buf->datas[0].mapoffset, PROT_READ | PROT_WRITE, MAP_SHARED, buf->datas[0].fd, 0); + if (map == MAP_FAILED) { + printf ("failed to mmap: %s\n", strerror (errno)); + return; + } p = SPA_MEMBER (map, buf->datas[0].mapoffset, uint8_t); } - else if (buf->datas[0].type == SPA_DATA_TYPE_MEMPTR) { + else if (buf->datas[0].type == data->type.data.MemPtr) { map = NULL; p = buf->datas[0].data; } else @@ -185,7 +194,8 @@ on_stream_format_changed (PinosListener *listener, params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, ctx->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, ctx->type.meta.Header), + PROP (&f[1], ctx->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); pinos_stream_finish_format (stream, SPA_RESULT_OK, params, 2); @@ -225,7 +235,6 @@ on_state_changed (PinosListener *listener, 1, 1, 4096, 4096), PROP (&f[1], data->type.format_video.framerate, SPA_POD_TYPE_FRACTION, 25, 1)); - formats[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat); pinos_signal_add (&data->stream->state_changed, diff --git a/pinos/gst/gstpinossink.c b/pinos/gst/gstpinossink.c index 4da3e9c58..1dd54200e 100644 --- a/pinos/gst/gstpinossink.c +++ b/pinos/gst/gstpinossink.c @@ -384,40 +384,23 @@ on_add_buffer (PinosListener *listener, data.sink = gst_object_ref (pinossink); data.id = id; data.buf = b; - data.header = NULL; + data.header = spa_buffer_find_meta (b, stream->context->type.meta.Header); - for (i = 0; i < b->n_metas; i++) { - SpaMeta *m = &b->metas[i]; - - switch (m->type) { - case SPA_META_TYPE_HEADER: - data.header = m->data; - break; - default: - break; - } - } for (i = 0; i < b->n_datas; i++) { SpaData *d = &b->datas[i]; GstMemory *gmem = NULL; - switch (d->type) { - case SPA_DATA_TYPE_MEMFD: - case SPA_DATA_TYPE_DMABUF: - { - gmem = gst_fd_allocator_alloc (pinossink->allocator, dup (d->fd), - d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE); - gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size); - data.offset = d->mapoffset; - break; - } - case SPA_DATA_TYPE_MEMPTR: - gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, d->chunk->offset, - d->chunk->size, NULL, NULL); - data.offset = 0; - break; - default: - break; + if (d->type == stream->context->type.data.MemFd || + d->type == stream->context->type.data.DmaBuf) { + gmem = gst_fd_allocator_alloc (pinossink->allocator, dup (d->fd), + d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE); + gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size); + data.offset = d->mapoffset; + } + else if (d->type == stream->context->type.data.MemPtr) { + gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, d->chunk->offset, + d->chunk->size, NULL, NULL); + data.offset = 0; } if (gmem) gst_buffer_append_memory (buf, gmem); @@ -590,11 +573,13 @@ on_format_changed (PinosListener *listener, port_params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, ctx->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, ctx->type.meta.Header), + PROP (&f[1], ctx->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); port_params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, ctx->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_RINGBUFFER), + PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, ctx->type.meta.Ringbuffer), + PROP (&f[1], ctx->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaRingbuffer)), PROP (&f[1], ctx->type.alloc_param_meta_enable.ringbufferSize, SPA_POD_TYPE_INT, size * SPA_MAX (4, SPA_MAX (min_buffers, max_buffers))), diff --git a/pinos/gst/gstpinossrc.c b/pinos/gst/gstpinossrc.c index 00139bab2..064ed3e56 100644 --- a/pinos/gst/gstpinossrc.c +++ b/pinos/gst/gstpinossrc.c @@ -388,6 +388,7 @@ on_add_buffer (PinosListener *listener, GstBuffer *buf; uint32_t i; ProcessMemData data; + PinosContext *ctx = pinossrc->stream->context; GST_LOG_OBJECT (pinossrc, "add buffer"); @@ -402,39 +403,22 @@ on_add_buffer (PinosListener *listener, data.src = gst_object_ref (pinossrc); data.id = id; data.buf = b; - data.header = NULL; + data.header = spa_buffer_find_meta (b, ctx->type.meta.Header); - for (i = 0; i < b->n_metas; i++) { - SpaMeta *m = &b->metas[i]; - - switch (m->type) { - case SPA_META_TYPE_HEADER: - data.header = m->data; - break; - default: - break; - } - } for (i = 0; i < b->n_datas; i++) { SpaData *d = &b->datas[i]; GstMemory *gmem = NULL; - switch (d->type) { - case SPA_DATA_TYPE_MEMFD: - case SPA_DATA_TYPE_DMABUF: - { - gmem = gst_fd_allocator_alloc (pinossrc->fd_allocator, dup (d->fd), - d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE); - gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size); - data.offset = d->mapoffset; - break; - } - case SPA_DATA_TYPE_MEMPTR: - gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, d->chunk->offset + d->mapoffset, - d->chunk->size, NULL, NULL); - data.offset = 0; - default: - break; + if (d->type == ctx->type.data.MemFd || d->type == ctx->type.data.DmaBuf) { + gmem = gst_fd_allocator_alloc (pinossrc->fd_allocator, dup (d->fd), + d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE); + gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size); + data.offset = d->mapoffset; + } + else if (d->type == ctx->type.data.MemPtr) { + gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, d->chunk->offset + d->mapoffset, + d->chunk->size, NULL, NULL); + data.offset = 0; } if (gmem) gst_buffer_append_memory (buf, gmem); @@ -787,7 +771,8 @@ on_format_changed (PinosListener *listener, spa_pod_builder_init (&b, buffer, sizeof (buffer)); spa_pod_builder_object (&b, &f[0], 0, ctx->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], ctx->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, ctx->type.meta.Header), + PROP (&f[1], ctx->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); GST_DEBUG_OBJECT (pinossrc, "doing finish format"); diff --git a/pinos/server/client-node.c b/pinos/server/client-node.c index 6498d429a..6f8f301d7 100644 --- a/pinos/server/client-node.c +++ b/pinos/server/client-node.c @@ -613,16 +613,15 @@ spa_proxy_node_port_use_buffers (SpaNode *node, uint32_t n_buffers) { SpaProxy *this; + PinosClientNodeImpl *impl; SpaProxyPort *port; uint32_t i, j; size_t n_mem; PinosClientNodeBuffer *mb; SpaMetaShared *msh; - if (node == NULL) - return SPA_RESULT_INVALID_ARGUMENTS; - this = SPA_CONTAINER_OF (node, SpaProxy, node); + impl = this->impl; spa_log_info (this->log, "proxy %p: use buffers %p %u", this, buffers, n_buffers); if (!CHECK_PORT (this, direction, port_id)) @@ -650,7 +649,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node, for (i = 0; i < n_buffers; i++) { ProxyBuffer *b = &port->buffers[i]; - msh = spa_buffer_find_meta (buffers[i], SPA_META_TYPE_SHARED); + msh = spa_buffer_find_meta (buffers[i], impl->core->type.meta.Shared); if (msh == NULL) { spa_log_error (this->log, "missing shared metadata on buffer %d", i); return SPA_RESULT_ERROR; @@ -670,7 +669,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node, direction, port_id, mb[i].mem_id, - SPA_DATA_TYPE_MEMFD, + impl->core->type.data.MemFd, msh->fd, msh->flags, msh->offset, @@ -685,31 +684,29 @@ spa_proxy_node_port_use_buffers (SpaNode *node, memcpy (&b->buffer.datas[j], d, sizeof (SpaData)); - switch (d->type) { - case SPA_DATA_TYPE_DMABUF: - case SPA_DATA_TYPE_MEMFD: - pinos_client_node_notify_add_mem (this->resource, - direction, - port_id, - n_mem, - d->type, - d->fd, - d->flags, - d->mapoffset, - d->maxsize); - b->buffer.datas[j].type = SPA_DATA_TYPE_ID; - b->buffer.datas[j].data = SPA_UINT32_TO_PTR (n_mem); - n_mem++; - break; - case SPA_DATA_TYPE_MEMPTR: - b->buffer.datas[j].data = SPA_INT_TO_PTR (b->size); - b->size += d->maxsize; - break; - default: - b->buffer.datas[j].type = SPA_DATA_TYPE_INVALID; - b->buffer.datas[j].data = 0; - spa_log_error (this->log, "invalid memory type %d", d->type); - break; + if (d->type == impl->core->type.data.DmaBuf || + d->type == impl->core->type.data.MemFd) { + pinos_client_node_notify_add_mem (this->resource, + direction, + port_id, + n_mem, + d->type, + d->fd, + d->flags, + d->mapoffset, + d->maxsize); + b->buffer.datas[j].type = impl->core->type.data.Id; + b->buffer.datas[j].data = SPA_UINT32_TO_PTR (n_mem); + n_mem++; + } + else if (d->type == impl->core->type.data.MemPtr) { + b->buffer.datas[j].data = SPA_INT_TO_PTR (b->size); + b->size += d->maxsize; + } + else { + b->buffer.datas[j].type = SPA_ID_INVALID; + b->buffer.datas[j].data = 0; + spa_log_error (this->log, "invalid memory type %d", d->type); } } } @@ -833,9 +830,6 @@ spa_proxy_node_process_output (SpaNode *node) int i; bool send_need = false, flush = false; - if (node == NULL) - return SPA_RESULT_INVALID_ARGUMENTS; - this = SPA_CONTAINER_OF (node, SpaProxy, node); impl = this->impl; diff --git a/pinos/server/core.c b/pinos/server/core.c index 99d3efbe9..8fe4c64c7 100644 --- a/pinos/server/core.c +++ b/pinos/server/core.c @@ -654,12 +654,12 @@ pinos_core_find_format (PinosCore *core, pinos_log_debug ("core %p: finding best format %d %d", core, out_state, in_state); - if (out_state > SPA_PORT_STATE_CONFIGURE && output->node->state == PINOS_NODE_STATE_IDLE) - out_state = SPA_PORT_STATE_CONFIGURE; - if (in_state > SPA_PORT_STATE_CONFIGURE && input->node->state == PINOS_NODE_STATE_IDLE) - in_state = SPA_PORT_STATE_CONFIGURE; + if (out_state > PINOS_PORT_STATE_CONFIGURE && output->node->state == PINOS_NODE_STATE_IDLE) + out_state = PINOS_PORT_STATE_CONFIGURE; + if (in_state > PINOS_PORT_STATE_CONFIGURE && input->node->state == PINOS_NODE_STATE_IDLE) + in_state = PINOS_PORT_STATE_CONFIGURE; - if (in_state == SPA_PORT_STATE_CONFIGURE && out_state > SPA_PORT_STATE_CONFIGURE) { + if (in_state == PINOS_PORT_STATE_CONFIGURE && out_state > PINOS_PORT_STATE_CONFIGURE) { /* only input needs format */ if ((res = spa_node_port_get_format (output->node->node, SPA_DIRECTION_OUTPUT, @@ -668,7 +668,7 @@ pinos_core_find_format (PinosCore *core, asprintf (error, "error get output format: %d", res); goto error; } - } else if (out_state == SPA_PORT_STATE_CONFIGURE && in_state > SPA_PORT_STATE_CONFIGURE) { + } else if (out_state == PINOS_PORT_STATE_CONFIGURE && in_state > PINOS_PORT_STATE_CONFIGURE) { /* only output needs format */ if ((res = spa_node_port_get_format (input->node->node, SPA_DIRECTION_INPUT, @@ -677,7 +677,7 @@ pinos_core_find_format (PinosCore *core, asprintf (error, "error get input format: %d", res); goto error; } - } else if (in_state == SPA_PORT_STATE_CONFIGURE && out_state == SPA_PORT_STATE_CONFIGURE) { + } else if (in_state == PINOS_PORT_STATE_CONFIGURE && out_state == PINOS_PORT_STATE_CONFIGURE) { again: /* both ports need a format */ pinos_log_debug ("core %p: finding best format", core); diff --git a/pinos/server/link.c b/pinos/server/link.c index d78d9f33d..29f43f5e7 100644 --- a/pinos/server/link.c +++ b/pinos/server/link.c @@ -83,7 +83,7 @@ complete_ready (void *obj, { PinosPort *port = data; if (SPA_RESULT_IS_OK (res)) { - port->state = SPA_PORT_STATE_READY; + port->state = PINOS_PORT_STATE_READY; pinos_log_debug ("port %p: state READY", port); } else @@ -98,7 +98,7 @@ complete_paused (void *obj, { PinosPort *port = data; if (SPA_RESULT_IS_OK (res)) { - port->state = SPA_PORT_STATE_PAUSED; + port->state = PINOS_PORT_STATE_PAUSED; pinos_log_debug ("port %p: state PAUSED", port); } else @@ -113,7 +113,7 @@ complete_streaming (void *obj, { PinosPort *port = data; if (SPA_RESULT_IS_OK (res)) { - port->state = SPA_PORT_STATE_STREAMING; + port->state = PINOS_PORT_STATE_STREAMING; pinos_log_debug ("port %p: state STREAMING", port); } else @@ -128,7 +128,7 @@ do_negotiate (PinosLink *this, uint32_t in_state, uint32_t out_state) SpaFormat *format; char *error = NULL; - if (in_state != SPA_PORT_STATE_CONFIGURE && out_state != SPA_PORT_STATE_CONFIGURE) + if (in_state != PINOS_PORT_STATE_CONFIGURE && out_state != PINOS_PORT_STATE_CONFIGURE) return SPA_RESULT_OK; pinos_link_update_state (this, PINOS_LINK_STATE_NEGOTIATING, NULL); @@ -143,20 +143,20 @@ do_negotiate (PinosLink *this, uint32_t in_state, uint32_t out_state) if (format == NULL) goto error; - if (out_state > SPA_PORT_STATE_CONFIGURE && this->output->node->state == PINOS_NODE_STATE_IDLE) { + if (out_state > PINOS_PORT_STATE_CONFIGURE && this->output->node->state == PINOS_NODE_STATE_IDLE) { pinos_node_set_state (this->output->node, PINOS_NODE_STATE_SUSPENDED); - out_state = SPA_PORT_STATE_CONFIGURE; + out_state = PINOS_PORT_STATE_CONFIGURE; } - if (in_state > SPA_PORT_STATE_CONFIGURE && this->input->node->state == PINOS_NODE_STATE_IDLE) { + if (in_state > PINOS_PORT_STATE_CONFIGURE && this->input->node->state == PINOS_NODE_STATE_IDLE) { pinos_node_set_state (this->input->node, PINOS_NODE_STATE_SUSPENDED); - in_state = SPA_PORT_STATE_CONFIGURE; + in_state = PINOS_PORT_STATE_CONFIGURE; } pinos_log_debug ("link %p: doing set format", this); if (pinos_log_level_enabled (SPA_LOG_LEVEL_DEBUG)) spa_debug_format (format, this->core->type.map); - if (out_state == SPA_PORT_STATE_CONFIGURE) { + if (out_state == PINOS_PORT_STATE_CONFIGURE) { pinos_log_debug ("link %p: doing set format on output", this); if ((res = spa_node_port_set_format (this->output->node->node, SPA_DIRECTION_OUTPUT, @@ -168,7 +168,7 @@ do_negotiate (PinosLink *this, uint32_t in_state, uint32_t out_state) } pinos_work_queue_add (impl->work, this->output->node, res, complete_ready, this->output); } - if (in_state == SPA_PORT_STATE_CONFIGURE) { + if (in_state == PINOS_PORT_STATE_CONFIGURE) { pinos_log_debug ("link %p: doing set format on input", this); if ((res2 = spa_node_port_set_format (this->input->node->node, SPA_DIRECTION_INPUT, @@ -203,7 +203,7 @@ find_param (const SpaPortInfo *info, uint32_t type) } static void * -find_meta_enable (PinosCore *core, const SpaPortInfo *info, SpaMetaType type) +find_meta_enable (PinosCore *core, const SpaPortInfo *info, uint32_t type) { uint32_t i; @@ -212,7 +212,7 @@ find_meta_enable (PinosCore *core, const SpaPortInfo *info, SpaMetaType type) uint32_t qtype; if (spa_alloc_param_query (info->params[i], - core->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, &qtype, 0) != 1) + core->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, &qtype, 0) != 1) continue; if (qtype == type) @@ -248,8 +248,8 @@ alloc_buffers (PinosLink *this, metas = alloca (sizeof (SpaMeta) * n_params + 1); /* add shared metadata */ - metas[n_metas].type = SPA_META_TYPE_SHARED; - metas[n_metas].size = spa_meta_type_get_size (SPA_META_TYPE_SHARED); + metas[n_metas].type = this->core->type.meta.Shared; + metas[n_metas].size = sizeof (SpaMetaShared); meta_size += metas[n_metas].size; n_metas++; skel_size += sizeof (SpaMeta); @@ -259,15 +259,16 @@ alloc_buffers (PinosLink *this, SpaAllocParam *ap = params[i]; if (ap->pod.type == this->core->type.alloc_param_meta_enable.MetaEnable) { - uint32_t type; + uint32_t type, size; if (spa_alloc_param_query (ap, - this->core->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, &type, + this->core->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, &type, + this->core->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, &size, 0) != 1) continue; metas[n_metas].type = type; - metas[n_metas].size = spa_meta_type_get_size (type); + metas[n_metas].size = size; meta_size += metas[n_metas].size; n_metas++; skel_size += sizeof (SpaMeta); @@ -312,26 +313,17 @@ alloc_buffers (PinosLink *this, m->data = p; m->size = metas[j].size; - switch (m->type) { - case SPA_META_TYPE_SHARED: - { - SpaMetaShared *msh = p; + if (m->type == this->core->type.meta.Shared) { + SpaMetaShared *msh = p; - msh->type = SPA_DATA_TYPE_MEMFD; - msh->flags = 0; - msh->fd = mem->fd; - msh->offset = data_size * i; - msh->size = data_size; - break; - } - case SPA_META_TYPE_RINGBUFFER: - { - SpaMetaRingbuffer *rb = p; - spa_ringbuffer_init (&rb->ringbuffer, data_sizes[0]); - break; - } - default: - break; + msh->flags = 0; + msh->fd = mem->fd; + msh->offset = data_size * i; + msh->size = data_size; + } + else if (m->type == this->core->type.meta.Ringbuffer) { + SpaMetaRingbuffer *rb = p; + spa_ringbuffer_init (&rb->ringbuffer, data_sizes[0]); } p += m->size; } @@ -347,7 +339,7 @@ alloc_buffers (PinosLink *this, d->chunk = &cdp[j]; if (data_sizes[j] > 0) { - d->type = SPA_DATA_TYPE_MEMFD; + d->type = this->core->type.data.MemFd; d->flags = 0; d->fd = mem->fd; d->mapoffset = SPA_PTRDIFF (ddp, mem->ptr); @@ -358,7 +350,7 @@ alloc_buffers (PinosLink *this, d->chunk->stride = data_strides[j]; ddp += data_sizes[j]; } else { - d->type = SPA_DATA_TYPE_INVALID; + d->type = SPA_ID_INVALID; d->data = NULL; } } @@ -375,7 +367,7 @@ do_allocation (PinosLink *this, uint32_t in_state, uint32_t out_state) SpaPortInfoFlags in_flags, out_flags; char *error = NULL; - if (in_state != SPA_PORT_STATE_READY && out_state != SPA_PORT_STATE_READY) + if (in_state != PINOS_PORT_STATE_READY && out_state != PINOS_PORT_STATE_READY) return SPA_RESULT_OK; pinos_link_update_state (this, PINOS_LINK_STATE_ALLOCATING, NULL); @@ -406,7 +398,7 @@ do_allocation (PinosLink *this, uint32_t in_state, uint32_t out_state) this->input->node->live = true; } - if (in_state == SPA_PORT_STATE_READY && out_state == SPA_PORT_STATE_READY) { + if (in_state == PINOS_PORT_STATE_READY && out_state == PINOS_PORT_STATE_READY) { if ((out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) && (in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS)) { out_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS; @@ -428,10 +420,10 @@ do_allocation (PinosLink *this, uint32_t in_state, uint32_t out_state) res = SPA_RESULT_ERROR; goto error; } - } else if (in_state == SPA_PORT_STATE_READY && out_state > SPA_PORT_STATE_READY) { + } else if (in_state == PINOS_PORT_STATE_READY && out_state > PINOS_PORT_STATE_READY) { out_flags &= ~SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS; in_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS; - } else if (out_state == SPA_PORT_STATE_READY && in_state > SPA_PORT_STATE_READY) { + } else if (out_state == PINOS_PORT_STATE_READY && in_state > PINOS_PORT_STATE_READY) { in_flags &= ~SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS; out_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS; } else { @@ -450,8 +442,8 @@ do_allocation (PinosLink *this, uint32_t in_state, uint32_t out_state) uint32_t max_buffers; size_t minsize = 1024, stride = 0; - in_me = find_meta_enable (this->core, iinfo, SPA_META_TYPE_RINGBUFFER); - out_me = find_meta_enable (this->core, oinfo, SPA_META_TYPE_RINGBUFFER); + in_me = find_meta_enable (this->core, iinfo, this->core->type.meta.Ringbuffer); + out_me = find_meta_enable (this->core, oinfo, this->core->type.meta.Ringbuffer); if (in_me && out_me) { uint32_t ms1, ms2, s1, s2; max_buffers = 1; @@ -631,18 +623,18 @@ do_start (PinosLink *this, uint32_t in_state, uint32_t out_state) SpaResult res = SPA_RESULT_OK; PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this); - if (in_state < SPA_PORT_STATE_PAUSED || out_state < SPA_PORT_STATE_PAUSED) + if (in_state < PINOS_PORT_STATE_PAUSED || out_state < PINOS_PORT_STATE_PAUSED) return SPA_RESULT_OK; - else if (in_state == SPA_PORT_STATE_STREAMING && out_state == SPA_PORT_STATE_STREAMING) { + else if (in_state == PINOS_PORT_STATE_STREAMING && out_state == PINOS_PORT_STATE_STREAMING) { pinos_link_update_state (this, PINOS_LINK_STATE_RUNNING, NULL); } else { pinos_link_update_state (this, PINOS_LINK_STATE_PAUSED, NULL); - if (in_state == SPA_PORT_STATE_PAUSED) { + if (in_state == PINOS_PORT_STATE_PAUSED) { res = pinos_node_set_state (this->input->node, PINOS_NODE_STATE_RUNNING); pinos_work_queue_add (impl->work, this->input->node, res, complete_streaming, this->input); } - if (out_state == SPA_PORT_STATE_PAUSED) { + if (out_state == PINOS_PORT_STATE_PAUSED) { res = pinos_node_set_state (this->output->node, PINOS_NODE_STATE_RUNNING); pinos_work_queue_add (impl->work, this->output->node, res, complete_streaming, this->output); } @@ -940,7 +932,7 @@ clear_port_buffers (PinosLink *link, PinosPort *port) { PinosLinkImpl *impl = SPA_CONTAINER_OF (link, PinosLinkImpl, this); - if (impl->buffer_owner != port && port->state > SPA_PORT_STATE_READY) { + if (impl->buffer_owner != port && port->state > PINOS_PORT_STATE_READY) { pinos_log_debug ("link %p: clear buffers on port %p", link, port); spa_node_port_use_buffers (port->node->node, port->direction, @@ -948,7 +940,7 @@ clear_port_buffers (PinosLink *link, PinosPort *port) NULL, 0); port->buffers = NULL; port->n_buffers = 0; - port->state = SPA_PORT_STATE_READY; + port->state = PINOS_PORT_STATE_READY; pinos_log_debug ("port %p: state READY", port); } } diff --git a/pinos/server/node.c b/pinos/server/node.c index e0ee43768..f75d7a419 100644 --- a/pinos/server/node.c +++ b/pinos/server/node.c @@ -208,7 +208,7 @@ suspend_node (PinosNode *this) if (p->allocated) pinos_memblock_free (&p->buffer_mem); p->allocated = false; - p->state = SPA_PORT_STATE_CONFIGURE; + p->state = PINOS_PORT_STATE_CONFIGURE; } spa_list_for_each (p, &this->output_ports, link) { @@ -219,7 +219,7 @@ suspend_node (PinosNode *this) if (p->allocated) pinos_memblock_free (&p->buffer_mem); p->allocated = false; - p->state = SPA_PORT_STATE_CONFIGURE; + p->state = PINOS_PORT_STATE_CONFIGURE; } return res; } diff --git a/pinos/server/port.c b/pinos/server/port.c index 733639829..4749bb313 100644 --- a/pinos/server/port.c +++ b/pinos/server/port.c @@ -48,7 +48,7 @@ pinos_port_new (PinosNode *node, this->node = node; this->direction = direction; this->port_id = port_id; - this->state = SPA_PORT_STATE_CONFIGURE; + this->state = PINOS_PORT_STATE_CONFIGURE; this->io.status = SPA_RESULT_OK; this->io.buffer_id = SPA_ID_INVALID; @@ -205,14 +205,14 @@ pinos_port_pause_rt (PinosPort *port) SpaCommand cmd = SPA_COMMAND_INIT (port->node->core->type.command_node.Pause); SpaResult res; - if (port->state <= SPA_PORT_STATE_PAUSED) + if (port->state <= PINOS_PORT_STATE_PAUSED) return SPA_RESULT_OK; res = spa_node_port_send_command (port->node->node, port->direction, port->port_id, &cmd); - port->state = SPA_PORT_STATE_PAUSED; + port->state = PINOS_PORT_STATE_PAUSED; pinos_log_debug ("port %p: state PAUSED", port); return res; } @@ -244,7 +244,7 @@ do_remove_link_done (SpaLoop *loop, } } - if (!port->allocated && port->state > SPA_PORT_STATE_READY) { + if (!port->allocated && port->state > PINOS_PORT_STATE_READY) { pinos_log_debug ("port %p: clear buffers on port", port); spa_node_port_use_buffers (port->node->node, port->direction, @@ -252,7 +252,7 @@ do_remove_link_done (SpaLoop *loop, NULL, 0); port->buffers = NULL; port->n_buffers = 0; - port->state = SPA_PORT_STATE_READY; + port->state = PINOS_PORT_STATE_READY; pinos_log_debug ("port %p: state READY", port); } @@ -324,7 +324,7 @@ do_clear_buffers_done (SpaLoop *loop, PinosPort *port = user_data; SpaResult res; - if (port->state <= SPA_PORT_STATE_READY) + if (port->state <= PINOS_PORT_STATE_READY) return SPA_RESULT_OK; pinos_log_debug ("port %p: clear buffers finish", port); @@ -334,7 +334,7 @@ do_clear_buffers_done (SpaLoop *loop, NULL, 0); port->buffers = NULL; port->n_buffers = 0; - port->state = SPA_PORT_STATE_READY; + port->state = PINOS_PORT_STATE_READY; pinos_log_debug ("port %p: state READY", port); return res; diff --git a/pinos/server/port.h b/pinos/server/port.h index cff91a926..5d5cd904d 100644 --- a/pinos/server/port.h +++ b/pinos/server/port.h @@ -37,6 +37,15 @@ typedef struct _PinosPort PinosPort; #include #include +typedef enum { + PINOS_PORT_STATE_ERROR = -1, + PINOS_PORT_STATE_INIT = 0, + PINOS_PORT_STATE_CONFIGURE = 1, + PINOS_PORT_STATE_READY = 2, + PINOS_PORT_STATE_PAUSED = 3, + PINOS_PORT_STATE_STREAMING = 4, +} PinosPortState; + struct _PinosPort { SpaList link; @@ -45,7 +54,7 @@ struct _PinosPort { PinosNode *node; PinosDirection direction; uint32_t port_id; - uint32_t state; + PinosPortState state; SpaPortIO io; bool allocated; diff --git a/pinos/server/protocol-native.c b/pinos/server/protocol-native.c index 9d451ca35..f7e79939b 100644 --- a/pinos/server/protocol-native.c +++ b/pinos/server/protocol-native.c @@ -658,7 +658,7 @@ client_node_marshal_add_mem (void *object, SpaDirection direction, uint32_t port_id, uint32_t mem_id, - SpaDataType type, + uint32_t type, int memfd, uint32_t flags, uint32_t offset, @@ -675,7 +675,7 @@ client_node_marshal_add_mem (void *object, SPA_POD_TYPE_INT, direction, SPA_POD_TYPE_INT, port_id, SPA_POD_TYPE_INT, mem_id, - SPA_POD_TYPE_INT, type, + SPA_POD_TYPE_ID, type, SPA_POD_TYPE_INT, pinos_connection_add_fd (connection, memfd), SPA_POD_TYPE_INT, flags, SPA_POD_TYPE_INT, offset, @@ -720,14 +720,14 @@ client_node_marshal_use_buffers (void *object, for (j = 0; j < buf->n_metas; j++) { SpaMeta *m = &buf->metas[j]; spa_pod_builder_add (&b.b, - SPA_POD_TYPE_INT, m->type, + SPA_POD_TYPE_ID, m->type, SPA_POD_TYPE_INT, m->size, 0); } spa_pod_builder_add (&b.b, SPA_POD_TYPE_INT, buf->n_datas, 0); for (j = 0; j < buf->n_datas; j++) { SpaData *d = &buf->datas[j]; spa_pod_builder_add (&b.b, - SPA_POD_TYPE_INT, d->type, + SPA_POD_TYPE_ID, d->type, SPA_POD_TYPE_INT, SPA_PTR_TO_UINT32 (d->data), SPA_POD_TYPE_INT, d->flags, SPA_POD_TYPE_INT, d->mapoffset, @@ -865,6 +865,7 @@ client_node_demarshal_port_update (void *object, if (!spa_pod_iter_pod (&it2, ipod) || !spa_pod_iter_get (&it2, SPA_POD_TYPE_INT, &info.flags, + SPA_POD_TYPE_INT, &info.rate, SPA_POD_TYPE_LONG, &info.maxbuffering, SPA_POD_TYPE_LONG, &info.latency, SPA_POD_TYPE_INT, &info.n_params, diff --git a/spa/include/spa/alloc-param.h b/spa/include/spa/alloc-param.h index 7cd521738..8237ad326 100644 --- a/spa/include/spa/alloc-param.h +++ b/spa/include/spa/alloc-param.h @@ -87,6 +87,7 @@ spa_type_alloc_param_buffers_map (SpaTypeMap *map, SpaTypeAllocParamBuffers *typ #define SPA_TYPE_ALLOC_PARAM__MetaEnable SPA_TYPE_ALLOC_PARAM_BASE "MetaEnable" #define SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE SPA_TYPE_ALLOC_PARAM__MetaEnable ":" #define SPA_TYPE_ALLOC_PARAM_META_ENABLE__type SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "type" +#define SPA_TYPE_ALLOC_PARAM_META_ENABLE__size SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "size" #define SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferSize SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "ringbufferSize" #define SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferStride SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "ringbufferStride" @@ -96,6 +97,7 @@ spa_type_alloc_param_buffers_map (SpaTypeMap *map, SpaTypeAllocParamBuffers *typ typedef struct { uint32_t MetaEnable; uint32_t type; + uint32_t size; uint32_t ringbufferSize; uint32_t ringbufferStride; uint32_t ringbufferBlocks; @@ -108,6 +110,7 @@ spa_type_alloc_param_meta_enable_map (SpaTypeMap *map, SpaTypeAllocParamMetaEnab if (type->MetaEnable == 0) { type->MetaEnable = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM__MetaEnable); type->type = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__type); + type->size = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__size); type->ringbufferSize = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferSize); type->ringbufferStride = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferStride); type->ringbufferBlocks = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferBlocks); diff --git a/spa/include/spa/buffer.h b/spa/include/spa/buffer.h index 9177f43c8..3839779ec 100644 --- a/spa/include/spa/buffer.h +++ b/spa/include/spa/buffer.h @@ -26,126 +26,37 @@ extern "C" { typedef struct _SpaBuffer SpaBuffer; +#include +#include + #define SPA_TYPE__Buffer SPA_TYPE_POINTER_BASE "Buffer" #define SPA_TYPE_BUFFER_BASE SPA_TYPE__Buffer ":" -/** - * SpaMetaType: - * @SPA_META_TYPE_INVALID: invalid metadata, should be ignored - * @SPA_META_TYPE_HEADER: header metadata - * @SPA_META_TYPE_POINTER: a generic pointer - * @SPA_META_TYPE_VIDEO_CROP: video cropping region - * @SPA_META_TYPE_RINGBUFFER: a ringbuffer - * @SPA_META_TYPE_SHARED: buffer data and metadata memory can be shared - */ -typedef enum { - SPA_META_TYPE_INVALID = 0, - SPA_META_TYPE_HEADER, - SPA_META_TYPE_POINTER, - SPA_META_TYPE_VIDEO_CROP, - SPA_META_TYPE_RINGBUFFER, - SPA_META_TYPE_SHARED, -} SpaMetaType; +#define SPA_TYPE__Data SPA_TYPE_ENUM_BASE "DataType" +#define SPA_TYPE_DATA_BASE SPA_TYPE__Data ":" -/** - * SpaDataType: - * @SPA_DATA_TYPE_INVALID: invalid data, should be ignored - * @SPA_DATA_TYPE_MEMPTR: data points to CPU accessible memory - * @SPA_DATA_TYPE_MEMFD: fd is memfd, data can be mmapped - * @SPA_DATA_TYPE_DMABUF: fd is dmabuf, data can be mmapped - * @SPA_DATA_TYPE_ID: data is an id use SPA_PTR_TO_INT32. The definition of - * the ID is conveyed in some other way - */ -typedef enum { - SPA_DATA_TYPE_INVALID = 0, - SPA_DATA_TYPE_MEMPTR, - SPA_DATA_TYPE_MEMFD, - SPA_DATA_TYPE_DMABUF, - SPA_DATA_TYPE_ID, -} SpaDataType; - -#include -#include - -/** - * SpaBufferFlags: - * @SPA_BUFFER_FLAG_NONE: no flag - * @SPA_BUFFER_FLAG_DISCONT: the buffer marks a data discontinuity - * @SPA_BUFFER_FLAG_CORRUPTED: the buffer data might be corrupted - * @SPA_BUFFER_FLAG_MARKER: the buffer contains a media specific marker - * @SPA_BUFFER_FLAG_HEADER: the buffer contains a header - * @SPA_BUFFER_FLAG_GAP: the buffer has been constructed to fill a gap - * and contains media neutral data - * @SPA_BUFFER_FLAG_DELTA_UNIT: the media cannot be decoded independently - */ -typedef enum { - SPA_BUFFER_FLAG_NONE = 0, - SPA_BUFFER_FLAG_DISCONT = (1 << 0), - SPA_BUFFER_FLAG_CORRUPTED = (1 << 1), - SPA_BUFFER_FLAG_MARKER = (1 << 2), - SPA_BUFFER_FLAG_HEADER = (1 << 3), - SPA_BUFFER_FLAG_GAP = (1 << 4), - SPA_BUFFER_FLAG_DELTA_UNIT = (1 << 5), -} SpaBufferFlags; +#define SPA_TYPE_DATA__MemPtr SPA_TYPE_DATA_BASE "MemPtr" +#define SPA_TYPE_DATA__MemFd SPA_TYPE_DATA_BASE "MemFd" +#define SPA_TYPE_DATA__DmaBuf SPA_TYPE_DATA_BASE "DmaBuf" +#define SPA_TYPE_DATA__Id SPA_TYPE_DATA_BASE "Id" typedef struct { - SpaBufferFlags flags; - uint32_t seq; - int64_t pts; - int64_t dts_offset; -} SpaMetaHeader; + uint32_t MemPtr; + uint32_t MemFd; + uint32_t DmaBuf; + uint32_t Id; +} SpaTypeData; -typedef struct { - const char *ptr_type; - void *ptr; -} SpaMetaPointer; - -/** - * SpaMetaVideoCrop: - * @x: - * @y: - * @width: - * @height - */ -typedef struct { - int32_t x, y; - int32_t width, height; -} SpaMetaVideoCrop; - -/** - * SpaMetaRingbuffer: - * @ringbuffer: - */ -typedef struct { - SpaRingbuffer ringbuffer; -} SpaMetaRingbuffer; - -/** - * SpaMetaShared: - * @type: - * @flags: - * @fd: - * @size: - */ -typedef struct { - SpaDataType type; - int32_t flags; - int fd; - int32_t offset; - uint32_t size; -} SpaMetaShared; - -/** - * SpaMeta: - * @type: metadata type - * @data: pointer to metadata - * @size: size of metadata - */ -typedef struct { - SpaMetaType type; - void *data; - uint32_t size; -} SpaMeta; +static inline void +spa_type_data_map (SpaTypeMap *map, SpaTypeData *type) +{ + if (type->MemPtr == 0) { + type->MemPtr = spa_type_map_get_id (map, SPA_TYPE_DATA__MemPtr); + type->MemFd = spa_type_map_get_id (map, SPA_TYPE_DATA__MemFd); + type->DmaBuf = spa_type_map_get_id (map, SPA_TYPE_DATA__DmaBuf); + type->Id = spa_type_map_get_id (map, SPA_TYPE_DATA__Id); + } +} /** * SpaChunk: @@ -164,13 +75,13 @@ typedef struct { * @type: memory type * @flags: memory flags * @fd: file descriptor - * @offset: start offset when mapping @fd + * @mapoffset: start offset when mapping @fd * @maxsize: maximum size of the memory * @data: pointer to memory * @chunk: pointer to chunk with valid offset */ typedef struct { - SpaDataType type; + uint32_t type; uint32_t flags; int fd; uint32_t mapoffset; @@ -195,32 +106,16 @@ struct _SpaBuffer { SpaData *datas; }; - static inline void * -spa_buffer_find_meta (SpaBuffer *b, SpaMetaType type) +spa_buffer_find_meta (SpaBuffer *b, uint32_t type) { uint32_t i; for (i = 0; i < b->n_metas; i++) if (b->metas[i].type == type) return b->metas[i].data; - return NULL; -} -static inline uint32_t -spa_meta_type_get_size (SpaMetaType type) -{ - static const uint32_t header_sizes[] = { - 0, - sizeof (SpaMetaHeader), - sizeof (SpaMetaPointer), - sizeof (SpaMetaVideoCrop), - sizeof (SpaMetaRingbuffer), - sizeof (SpaMetaShared), - }; - if (type <= 0 || type >= SPA_N_ELEMENTS (header_sizes)) - return 0; - return header_sizes[type]; + return NULL; } #ifdef __cplusplus diff --git a/spa/include/spa/meta.h b/spa/include/spa/meta.h new file mode 100644 index 000000000..1e6ef7eb4 --- /dev/null +++ b/spa/include/spa/meta.h @@ -0,0 +1,135 @@ +/* Simple Plugin API + * Copyright (C) 2017 Wim Taymans + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifndef __SPA_META_H__ +#define __SPA_META_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#define SPA_TYPE__Meta SPA_TYPE_POINTER_BASE "Meta" +#define SPA_TYPE_META_BASE SPA_TYPE__Meta ":" + +#define SPA_TYPE_META__Header SPA_TYPE_META_BASE "Header" +#define SPA_TYPE_META__Pointer SPA_TYPE_META_BASE "Pointer" +#define SPA_TYPE_META__VideoCrop SPA_TYPE_META_BASE "VideoCrop" +#define SPA_TYPE_META__Ringbuffer SPA_TYPE_META_BASE "Ringbuffer" +#define SPA_TYPE_META__Shared SPA_TYPE_META_BASE "Shared" + +typedef struct { + uint32_t Header; + uint32_t Pointer; + uint32_t VideoCrop; + uint32_t Ringbuffer; + uint32_t Shared; +} SpaTypeMeta; + +static inline void +spa_type_meta_map (SpaTypeMap *map, SpaTypeMeta *type) +{ + if (type->Header == 0) { + type->Header = spa_type_map_get_id (map, SPA_TYPE_META__Header); + type->Pointer = spa_type_map_get_id (map, SPA_TYPE_META__Pointer); + type->VideoCrop = spa_type_map_get_id (map, SPA_TYPE_META__VideoCrop); + type->Ringbuffer = spa_type_map_get_id (map, SPA_TYPE_META__Ringbuffer); + type->Shared = spa_type_map_get_id (map, SPA_TYPE_META__Shared); + } +} + +/** + * SpaMetaHeader: + * @flags: extra flags + * @seq: sequence number. This monotonically increments and with the rate, + * it can be used to derive a media time. + * @pts: The MONOTONIC time for @seq. + * @dts_offset: offset relative to @pts to start decoding this buffer. + */ +typedef struct { +#define SPA_META_HEADER_FLAG_DISCONT (1 << 0) /* data is not continous with previous buffer */ +#define SPA_META_HEADER_FLAG_CORRUPTED (1 << 1) /* data might be corrupted */ +#define SPA_META_HEADER_FLAG_MARKER (1 << 2) /* media specific marker */ +#define SPA_META_HEADER_FLAG_HEADER (1 << 3) /* data contains a codec specific header */ +#define SPA_META_HEADER_FLAG_GAP (1 << 4) /* data contains media neutral data */ +#define SPA_META_HEADER_FLAG_DELTA_UNIT (1 << 5) /* cannot be decoded independently */ + uint32_t flags; + uint32_t seq; + int64_t pts; + int64_t dts_offset; +} SpaMetaHeader; + +typedef struct { + uint32_t type; + void *ptr; +} SpaMetaPointer; + +/** + * SpaMetaVideoCrop: + * @x: + * @y: + * @width: + * @height + */ +typedef struct { + int32_t x, y; + int32_t width, height; +} SpaMetaVideoCrop; + +/** + * SpaMetaRingbuffer: + * @ringbuffer: + */ +typedef struct { + SpaRingbuffer ringbuffer; +} SpaMetaRingbuffer; + +/** + * SpaMetaShared: + * @flags: flags + * @fd: the fd of the memory + * @offset: start offset of memory + * @size: size of the memory + */ +typedef struct { + int32_t flags; + int fd; + int32_t offset; + uint32_t size; +} SpaMetaShared; + +/** + * SpaMeta: + * @type: metadata type + * @data: pointer to metadata + * @size: size of metadata + */ +typedef struct { + uint32_t type; + void *data; + uint32_t size; +} SpaMeta; + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* __SPA_META_H__ */ diff --git a/spa/include/spa/node.h b/spa/include/spa/node.h index ef32389a4..4d24d41cb 100644 --- a/spa/include/spa/node.h +++ b/spa/include/spa/node.h @@ -102,23 +102,17 @@ typedef enum { /** * SpaPortInfo * @flags: extra port flags + * @rate: rate of sequence number increment per second of media data * @n_params: number of elements in @params; * @params: extra allocation parameters * @maxbuffering: the maximum amount of bytes that the element will keep * around internally * @latency: latency on this port in nanoseconds * @extra: a dictionary of extra port info - * */ typedef struct { -#define SPA_PORT_STATE_ERROR -1 -#define SPA_PORT_STATE_INIT 0 -#define SPA_PORT_STATE_CONFIGURE 1 -#define SPA_PORT_STATE_READY 2 -#define SPA_PORT_STATE_PAUSED 3 -#define SPA_PORT_STATE_STREAMING 4 - uint32_t state; SpaPortInfoFlags flags; + uint32_t rate; uint32_t n_params; SpaAllocParam **params; uint64_t maxbuffering; diff --git a/spa/include/spa/type.h b/spa/include/spa/type.h index 1f1a0adcc..aa43d3450 100644 --- a/spa/include/spa/type.h +++ b/spa/include/spa/type.h @@ -33,6 +33,9 @@ typedef uint32_t SpaType; #define SPA_TYPE__Enum SPA_TYPE_BASE "Enum" #define SPA_TYPE_ENUM_BASE SPA_TYPE__Enum ":" +#define SPA_TYPE__Pointer SPA_TYPE_BASE "Pointer" +#define SPA_TYPE_POINTER_BASE SPA_TYPE__Pointer ":" + #define SPA_TYPE__Interface SPA_TYPE_BASE "Interface" #define SPA_TYPE_INTERFACE_BASE SPA_TYPE__Interface ":" diff --git a/spa/lib/debug.c b/spa/lib/debug.c index 34abd1805..15f118dc5 100644 --- a/spa/lib/debug.c +++ b/spa/lib/debug.c @@ -23,31 +23,6 @@ #include #include "debug.h" -static const struct meta_type_name { - const char *name; -} meta_type_names[] = { - { "invalid" }, - { "SpaMetaHeader" }, - { "SpaMetaPointer" }, - { "SpaMetaVideoCrop" }, - { "SpaMetaRingbuffer" }, - { "SpaMetaShared" }, - { "invalid" }, -}; -#define META_TYPE_NAME(t) meta_type_names[SPA_CLAMP(t,0,SPA_N_ELEMENTS(meta_type_names)-1)].name - -static const struct data_type_name { - const char *name; -} data_type_names[] = { - { "invalid" }, - { "memptr" }, - { "memfd" }, - { "dmabuf" }, - { "ID" }, - { "invalid" }, -}; -#define DATA_TYPE_NAME(t) data_type_names[SPA_CLAMP(t,0,SPA_N_ELEMENTS(data_type_names)-1)].name - SpaResult spa_debug_port_info (const SpaPortInfo *info, const SpaTypeMap *map) { @@ -69,7 +44,7 @@ spa_debug_port_info (const SpaPortInfo *info, const SpaTypeMap *map) } SpaResult -spa_debug_buffer (const SpaBuffer *buffer) +spa_debug_buffer (const SpaBuffer *buffer, const SpaTypeMap *map) { int i; @@ -81,67 +56,59 @@ spa_debug_buffer (const SpaBuffer *buffer) fprintf (stderr, " n_metas: %u (at %p)\n", buffer->n_metas, buffer->metas); for (i = 0; i < buffer->n_metas; i++) { SpaMeta *m = &buffer->metas[i]; - fprintf (stderr, " meta %d: type %d (%s), data %p, size %d:\n", i, m->type, META_TYPE_NAME (m->type), m->data, m->size); - switch (m->type) { - case SPA_META_TYPE_HEADER: - { - SpaMetaHeader *h = m->data; - fprintf (stderr, " SpaMetaHeader:\n"); - fprintf (stderr, " flags: %08x\n", h->flags); - fprintf (stderr, " seq: %u\n", h->seq); - fprintf (stderr, " pts: %"PRIi64"\n", h->pts); - fprintf (stderr, " dts_offset: %"PRIi64"\n", h->dts_offset); - break; - } - case SPA_META_TYPE_POINTER: - { - SpaMetaPointer *h = m->data; - fprintf (stderr, " SpaMetaPointer:\n"); - fprintf (stderr, " ptr_type: %s\n", h->ptr_type); - fprintf (stderr, " ptr: %p\n", h->ptr); - spa_debug_dump_mem (m->data, m->size); - break; - } - case SPA_META_TYPE_VIDEO_CROP: - { - SpaMetaVideoCrop *h = m->data; - fprintf (stderr, " SpaMetaVideoCrop:\n"); - fprintf (stderr, " x: %d\n", h->x); - fprintf (stderr, " y: %d\n", h->y); - fprintf (stderr, " width: %d\n", h->width); - fprintf (stderr, " height: %d\n", h->height); - break; - } - case SPA_META_TYPE_RINGBUFFER: - { - SpaMetaRingbuffer *h = m->data; - fprintf (stderr, " SpaMetaRingbuffer:\n"); - fprintf (stderr, " readindex: %d\n", h->ringbuffer.readindex); - fprintf (stderr, " writeindex: %d\n", h->ringbuffer.writeindex); - fprintf (stderr, " size: %d\n", h->ringbuffer.size); - fprintf (stderr, " mask: %d\n", h->ringbuffer.mask); - break; - } - case SPA_META_TYPE_SHARED: - { - SpaMetaShared *h = m->data; - fprintf (stderr, " SpaMetaShared:\n"); - fprintf (stderr, " type: %d\n", h->type); - fprintf (stderr, " flags: %d\n", h->flags); - fprintf (stderr, " fd: %d\n", h->fd); - fprintf (stderr, " offset: %d\n", h->offset); - fprintf (stderr, " size: %d\n", h->size); - break; - } - default: - spa_debug_dump_mem (m->data, m->size); - break; + const char *type_name; + + type_name = spa_type_map_get_type (map, m->type); + fprintf (stderr, " meta %d: type %d (%s), data %p, size %d:\n", i, m->type, + type_name, m->data, m->size); + + if (!strcmp (type_name, SPA_TYPE_META__Header)) { + SpaMetaHeader *h = m->data; + fprintf (stderr, " SpaMetaHeader:\n"); + fprintf (stderr, " flags: %08x\n", h->flags); + fprintf (stderr, " seq: %u\n", h->seq); + fprintf (stderr, " pts: %"PRIi64"\n", h->pts); + fprintf (stderr, " dts_offset: %"PRIi64"\n", h->dts_offset); + } + else if (!strcmp (type_name, SPA_TYPE_META__Pointer)) { + SpaMetaPointer *h = m->data; + fprintf (stderr, " SpaMetaPointer:\n"); + fprintf (stderr, " type: %s\n", spa_type_map_get_type (map, h->type)); + fprintf (stderr, " ptr: %p\n", h->ptr); + } + else if (!strcmp (type_name, SPA_TYPE_META__VideoCrop)) { + SpaMetaVideoCrop *h = m->data; + fprintf (stderr, " SpaMetaVideoCrop:\n"); + fprintf (stderr, " x: %d\n", h->x); + fprintf (stderr, " y: %d\n", h->y); + fprintf (stderr, " width: %d\n", h->width); + fprintf (stderr, " height: %d\n", h->height); + } + else if (!strcmp (type_name, SPA_TYPE_META__Ringbuffer)) { + SpaMetaRingbuffer *h = m->data; + fprintf (stderr, " SpaMetaRingbuffer:\n"); + fprintf (stderr, " readindex: %d\n", h->ringbuffer.readindex); + fprintf (stderr, " writeindex: %d\n", h->ringbuffer.writeindex); + fprintf (stderr, " size: %d\n", h->ringbuffer.size); + fprintf (stderr, " mask: %d\n", h->ringbuffer.mask); + } + else if (!strcmp (type_name, SPA_TYPE_META__Shared)) { + SpaMetaShared *h = m->data; + fprintf (stderr, " SpaMetaShared:\n"); + fprintf (stderr, " flags: %d\n", h->flags); + fprintf (stderr, " fd: %d\n", h->fd); + fprintf (stderr, " offset: %d\n", h->offset); + fprintf (stderr, " size: %d\n", h->size); + } + else { + fprintf (stderr, " Unknown:\n"); + spa_debug_dump_mem (m->data, m->size); } } fprintf (stderr, " n_datas: \t%u (at %p)\n", buffer->n_datas, buffer->datas); for (i = 0; i < buffer->n_datas; i++) { SpaData *d = &buffer->datas[i]; - fprintf (stderr, " type: %d (%s)\n", d->type, DATA_TYPE_NAME (d->type)); + fprintf (stderr, " type: %d (%s)\n", d->type, spa_type_map_get_type (map, d->type)); fprintf (stderr, " flags: %d\n", d->flags); fprintf (stderr, " data: %p\n", d->data); fprintf (stderr, " fd: %d\n", d->fd); diff --git a/spa/lib/debug.h b/spa/lib/debug.h index 688005956..b42ed2a84 100644 --- a/spa/lib/debug.h +++ b/spa/lib/debug.h @@ -34,7 +34,7 @@ extern "C" { #include SpaResult spa_debug_port_info (const SpaPortInfo *info, const SpaTypeMap *map); -SpaResult spa_debug_buffer (const SpaBuffer *buffer); +SpaResult spa_debug_buffer (const SpaBuffer *buffer, const SpaTypeMap *map); SpaResult spa_debug_props (const SpaProps *props, const SpaTypeMap *map); SpaResult spa_debug_pod (const SpaPOD *pod, const SpaTypeMap *map); SpaResult spa_debug_format (const SpaFormat *format, const SpaTypeMap *map); diff --git a/spa/plugins/alsa/alsa-sink.c b/spa/plugins/alsa/alsa-sink.c index 61218e7e3..a3bbd504f 100644 --- a/spa/plugins/alsa/alsa-sink.c +++ b/spa/plugins/alsa/alsa-sink.c @@ -329,11 +329,13 @@ spa_alsa_sink_node_port_set_format (SpaNode *node, this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Header), + PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_RINGBUFFER), + PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Ringbuffer), + PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaRingbuffer)), PROP (&f[1], this->type.alloc_param_meta_enable.ringbufferSize, SPA_POD_TYPE_INT, this->period_frames * this->frame_size * 32), PROP (&f[1], this->type.alloc_param_meta_enable.ringbufferStride, SPA_POD_TYPE_INT, 0), PROP (&f[1], this->type.alloc_param_meta_enable.ringbufferBlocks, SPA_POD_TYPE_INT, 1), @@ -444,23 +446,20 @@ spa_alsa_sink_node_port_use_buffers (SpaNode *node, for (i = 0; i < n_buffers; i++) { SpaALSABuffer *b = &this->buffers[i]; + uint32_t type = buffers[i]->datas[0].type; + b->outbuf = buffers[i]; b->outstanding = true; - b->h = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_HEADER); - b->rb = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_RINGBUFFER); + b->h = spa_buffer_find_meta (b->outbuf, this->type.meta.Header); + b->rb = spa_buffer_find_meta (b->outbuf, this->type.meta.Ringbuffer); - switch (buffers[i]->datas[0].type) { - case SPA_DATA_TYPE_MEMFD: - case SPA_DATA_TYPE_DMABUF: - case SPA_DATA_TYPE_MEMPTR: - if (buffers[i]->datas[0].data == NULL) { - spa_log_error (this->log, "alsa-source: need mapped memory"); - continue; - } - break; - default: - break; + if ((type == this->type.data.MemFd || + type == this->type.data.DmaBuf || + type == this->type.data.MemPtr) && + buffers[i]->datas[0].data == NULL) { + spa_log_error (this->log, "alsa-source: need mapped memory"); + return SPA_RESULT_ERROR; } } this->n_buffers = n_buffers; diff --git a/spa/plugins/alsa/alsa-source.c b/spa/plugins/alsa/alsa-source.c index 3e4c789cb..6db0531f7 100644 --- a/spa/plugins/alsa/alsa-source.c +++ b/spa/plugins/alsa/alsa-source.c @@ -376,7 +376,8 @@ spa_alsa_source_node_port_set_format (SpaNode *node, this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Header), + PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); this->info.extra = NULL; @@ -482,22 +483,19 @@ spa_alsa_source_node_port_use_buffers (SpaNode *node, } for (i = 0; i < n_buffers; i++) { SpaALSABuffer *b = &this->buffers[i]; + SpaData *d = buffers[i]->datas; + b->outbuf = buffers[i]; b->outstanding = false; - b->h = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_HEADER); + b->h = spa_buffer_find_meta (b->outbuf, this->type.meta.Header); - switch (buffers[i]->datas[0].type) { - case SPA_DATA_TYPE_MEMFD: - case SPA_DATA_TYPE_DMABUF: - case SPA_DATA_TYPE_MEMPTR: - if (buffers[i]->datas[0].data == NULL) { - spa_log_error (this->log, "alsa-source: need mapped memory"); - continue; - } - break; - default: - break; + if (!((d[0].type == this->type.data.MemFd || + d[0].type == this->type.data.DmaBuf || + d[0].type == this->type.data.MemPtr) && + d[0].data != NULL)) { + spa_log_error (this->log, "alsa-source: need mapped memory"); + return SPA_RESULT_ERROR; } spa_list_insert (this->free.prev, &b->link); } diff --git a/spa/plugins/alsa/alsa-utils.h b/spa/plugins/alsa/alsa-utils.h index a6d9216ae..4cb3366ef 100644 --- a/spa/plugins/alsa/alsa-utils.h +++ b/spa/plugins/alsa/alsa-utils.h @@ -67,6 +67,8 @@ typedef struct { uint32_t prop_device_name; uint32_t prop_card_name; uint32_t prop_min_latency; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtypeAudio media_subtype_audio; @@ -90,6 +92,8 @@ init_type (Type *type, SpaTypeMap *map) type->prop_card_name = spa_type_map_get_id (map, SPA_TYPE_PROPS__cardName); type->prop_min_latency = spa_type_map_get_id (map, SPA_TYPE_PROPS__minLatency); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_audio_map (map, &type->media_subtype_audio); diff --git a/spa/plugins/audiomixer/audiomixer.c b/spa/plugins/audiomixer/audiomixer.c index f88fcf492..f9389de5b 100644 --- a/spa/plugins/audiomixer/audiomixer.c +++ b/spa/plugins/audiomixer/audiomixer.c @@ -62,6 +62,8 @@ typedef struct { SpaTypeFormatAudio format_audio; SpaTypeAudioFormat audio_format; SpaTypeCommandNode command_node; + SpaTypeMeta meta; + SpaTypeData data; } Type; static inline void @@ -74,6 +76,8 @@ init_type (Type *type, SpaTypeMap *map) spa_type_format_audio_map (map, &type->format_audio); spa_type_audio_format_map (map, &type->audio_format); spa_type_command_node_map (map, &type->command_node); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); } struct _SpaAudioMixer { @@ -477,19 +481,14 @@ spa_audiomixer_node_port_use_buffers (SpaNode *node, b = &port->buffers[i]; b->outbuf = buffers[i]; b->outstanding = direction == SPA_DIRECTION_INPUT ? true : false; - b->h = spa_buffer_find_meta (buffers[i], SPA_META_TYPE_HEADER); + b->h = spa_buffer_find_meta (buffers[i], this->type.meta.Header); - switch (d[0].type) { - case SPA_DATA_TYPE_MEMPTR: - case SPA_DATA_TYPE_MEMFD: - case SPA_DATA_TYPE_DMABUF: - if (d[0].data == NULL) { - spa_log_error (this->log, "volume %p: invalid memory on buffer %p", this, buffers[i]); - continue; - } - break; - default: - break; + if (!((d[0].type == this->type.data.MemPtr || + d[0].type == this->type.data.MemFd || + d[0].type == this->type.data.DmaBuf) && + d[0].data != NULL)) { + spa_log_error (this->log, "volume %p: invalid memory on buffer %p", this, buffers[i]); + return SPA_RESULT_ERROR; } if (!b->outstanding) spa_list_insert (port->queue.prev, &b->link); diff --git a/spa/plugins/audiotestsrc/audiotestsrc.c b/spa/plugins/audiotestsrc/audiotestsrc.c index 5fc48fb0d..cc9e0d2b3 100644 --- a/spa/plugins/audiotestsrc/audiotestsrc.c +++ b/spa/plugins/audiotestsrc/audiotestsrc.c @@ -48,6 +48,8 @@ typedef struct { uint32_t prop_volume; uint32_t wave_sine; uint32_t wave_square; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeFormatAudio format_audio; @@ -71,6 +73,8 @@ init_type (Type *type, SpaTypeMap *map) type->prop_volume = spa_type_map_get_id (map, SPA_TYPE_PROPS__volume); type->wave_sine = spa_type_map_get_id (map, SPA_TYPE_PROPS__waveType ":sine"); type->wave_square = spa_type_map_get_id (map, SPA_TYPE_PROPS__waveType ":square"); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_format_audio_map (map, &type->format_audio); @@ -618,7 +622,8 @@ spa_audiotestsrc_node_port_set_format (SpaNode *node, this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Header), + PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); this->info.extra = NULL; @@ -725,20 +730,14 @@ spa_audiotestsrc_node_port_use_buffers (SpaNode *node, b = &this->buffers[i]; b->outbuf = buffers[i]; b->outstanding = false; - b->h = spa_buffer_find_meta (buffers[i], SPA_META_TYPE_HEADER); - b->rb = spa_buffer_find_meta (buffers[i], SPA_META_TYPE_RINGBUFFER); + b->h = spa_buffer_find_meta (buffers[i], this->type.meta.Header); + b->rb = spa_buffer_find_meta (buffers[i], this->type.meta.Ringbuffer); - switch (d[0].type) { - case SPA_DATA_TYPE_MEMPTR: - case SPA_DATA_TYPE_MEMFD: - case SPA_DATA_TYPE_DMABUF: - if (d[0].data == NULL) { - spa_log_error (this->log, "audiotestsrc %p: invalid memory on buffer %p", this, buffers[i]); - continue; - } - break; - default: - break; + if ((d[0].type == this->type.data.MemPtr || + d[0].type == this->type.data.MemFd || + d[0].type == this->type.data.DmaBuf) && + d[0].data == NULL) { + spa_log_error (this->log, "audiotestsrc %p: invalid memory on buffer %p", this, buffers[i]); } spa_list_insert (this->empty.prev, &b->link); } diff --git a/spa/plugins/v4l2/v4l2-source.c b/spa/plugins/v4l2/v4l2-source.c index 4c83d42a3..da0a44abf 100644 --- a/spa/plugins/v4l2/v4l2-source.c +++ b/spa/plugins/v4l2/v4l2-source.c @@ -80,6 +80,8 @@ typedef struct { SpaTypeCommandNode command_node; SpaTypeAllocParamBuffers alloc_param_buffers; SpaTypeAllocParamMetaEnable alloc_param_meta_enable; + SpaTypeMeta meta; + SpaTypeData data; } Type; static inline void @@ -101,6 +103,8 @@ init_type (Type *type, SpaTypeMap *map) spa_type_command_node_map (map, &type->command_node); spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers); spa_type_alloc_param_meta_enable_map (map, &type->alloc_param_meta_enable); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); } typedef struct { diff --git a/spa/plugins/v4l2/v4l2-utils.c b/spa/plugins/v4l2/v4l2-utils.c index 8514977b8..69ac5863f 100644 --- a/spa/plugins/v4l2/v4l2-utils.c +++ b/spa/plugins/v4l2/v4l2-utils.c @@ -121,7 +121,7 @@ spa_v4l2_clear_buffers (SpaV4l2Source *this) munmap (b->outbuf->datas[0].data, b->outbuf->datas[0].maxsize); if (b->outbuf->datas[0].fd != -1) close (b->outbuf->datas[0].fd); - b->outbuf->datas[0].type = SPA_DATA_TYPE_INVALID; + b->outbuf->datas[0].type = SPA_ID_INVALID; } } @@ -916,7 +916,8 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *format, bool try_only) state->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Header), + PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); state->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); state->info.extra = NULL; @@ -959,9 +960,9 @@ mmap_read (SpaV4l2Source *this) b = &state->buffers[buf.index]; if (b->h) { - b->h->flags = SPA_BUFFER_FLAG_NONE; + b->h->flags = 0; if (buf.flags & V4L2_BUF_FLAG_ERROR) - b->h->flags |= SPA_BUFFER_FLAG_CORRUPTED; + b->h->flags |= SPA_META_HEADER_FLAG_CORRUPTED; b->h->seq = buf.sequence; b->h->pts = pts; } @@ -1007,17 +1008,19 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe SpaData *d; if (n_buffers > 0) { - switch (buffers[0]->datas[0].type) { - case SPA_DATA_TYPE_MEMPTR: - case SPA_DATA_TYPE_MEMFD: - state->memtype = V4L2_MEMORY_USERPTR; - break; - case SPA_DATA_TYPE_DMABUF: - state->memtype = V4L2_MEMORY_DMABUF; - break; - default: - spa_log_error (state->log, "v4l2: can't use buffers"); - return SPA_RESULT_ERROR; + SpaData *d = buffers[0]->datas; + + if ((d[0].type == this->type.data.MemPtr || + d[0].type == this->type.data.MemFd) && + d[0].data != NULL) { + state->memtype = V4L2_MEMORY_USERPTR; + } + else if (d[0].type == this->type.data.DmaBuf) { + state->memtype = V4L2_MEMORY_DMABUF; + } + else { + spa_log_error (state->log, "v4l2: can't use buffers of type %d", d[0].type); + return SPA_RESULT_ERROR; } } @@ -1043,7 +1046,7 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe b->outbuf = buffers[i]; b->outstanding = true; b->allocated = false; - b->h = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_HEADER); + b->h = spa_buffer_find_meta (b->outbuf, this->type.meta.Header); spa_log_info (state->log, "v4l2: import buffer %p", buffers[i]); @@ -1057,21 +1060,14 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe b->v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; b->v4l2_buffer.memory = state->memtype; b->v4l2_buffer.index = i; - switch (d[0].type) { - case SPA_DATA_TYPE_MEMPTR: - case SPA_DATA_TYPE_MEMFD: - if (d[0].data == NULL) { - spa_log_error (state->log, "v4l2: need mmaped memory"); - continue; - } - b->v4l2_buffer.m.userptr = (unsigned long) d[0].data; - b->v4l2_buffer.length = d[0].maxsize; - break; - case SPA_DATA_TYPE_DMABUF: - b->v4l2_buffer.m.fd = d[0].fd; - break; - default: - break; + + if (d[0].type == this->type.data.MemPtr || + d[0].type == this->type.data.MemFd) { + b->v4l2_buffer.m.userptr = (unsigned long) d[0].data; + b->v4l2_buffer.length = d[0].maxsize; + } + else if (d[0].type == this->type.data.DmaBuf) { + b->v4l2_buffer.m.fd = d[0].fd; } spa_v4l2_buffer_recycle (this, buffers[i]->id); } @@ -1126,7 +1122,7 @@ mmap_init (SpaV4l2Source *this, b->outbuf = buffers[i]; b->outstanding = true; b->allocated = true; - b->h = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_HEADER); + b->h = spa_buffer_find_meta (b->outbuf, this->type.meta.Header); CLEAR (b->v4l2_buffer); b->v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; @@ -1156,11 +1152,11 @@ mmap_init (SpaV4l2Source *this, perror("VIDIOC_EXPBUF"); continue; } - d[0].type = SPA_DATA_TYPE_DMABUF; + d[0].type = this->type.data.DmaBuf; d[0].fd = expbuf.fd; d[0].data = NULL; } else { - d[0].type = SPA_DATA_TYPE_MEMPTR; + d[0].type = this->type.data.MemPtr; d[0].fd = -1; d[0].data = mmap (NULL, b->v4l2_buffer.length, diff --git a/spa/plugins/videotestsrc/videotestsrc.c b/spa/plugins/videotestsrc/videotestsrc.c index 9352eb5f0..4b6b9bb85 100644 --- a/spa/plugins/videotestsrc/videotestsrc.c +++ b/spa/plugins/videotestsrc/videotestsrc.c @@ -46,6 +46,8 @@ typedef struct { uint32_t prop_pattern; uint32_t pattern_smpte_snow; uint32_t pattern_snow; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeFormatVideo format_video; @@ -67,6 +69,8 @@ init_type (Type *type, SpaTypeMap *map) type->prop_pattern = spa_type_map_get_id (map, SPA_TYPE_PROPS__patternType); type->pattern_smpte_snow = spa_type_map_get_id (map, SPA_TYPE_PROPS__patternType ":smpte-snow"); type->pattern_snow = spa_type_map_get_id (map, SPA_TYPE_PROPS__patternType ":snow"); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_format_video_map (map, &type->format_video); @@ -581,7 +585,8 @@ spa_videotestsrc_node_port_set_format (SpaNode *node, this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Header), + PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); this->info.extra = NULL; @@ -687,19 +692,13 @@ spa_videotestsrc_node_port_use_buffers (SpaNode *node, b = &this->buffers[i]; b->outbuf = buffers[i]; b->outstanding = false; - b->h = spa_buffer_find_meta (buffers[i], SPA_META_TYPE_HEADER); + b->h = spa_buffer_find_meta (buffers[i], this->type.meta.Header); - switch (d[0].type) { - case SPA_DATA_TYPE_MEMPTR: - case SPA_DATA_TYPE_MEMFD: - case SPA_DATA_TYPE_DMABUF: - if (d[0].data == NULL) { - spa_log_error (this->log, "videotestsrc %p: invalid memory on buffer %p", this, buffers[i]); - continue; - } - break; - default: - break; + if ((d[0].type == this->type.data.MemPtr || + d[0].type == this->type.data.MemFd || + d[0].type == this->type.data.DmaBuf) && + d[0].data == NULL) { + spa_log_error (this->log, "videotestsrc %p: invalid memory on buffer %p", this, buffers[i]); } spa_list_insert (this->empty.prev, &b->link); } diff --git a/spa/plugins/volume/volume.c b/spa/plugins/volume/volume.c index e45253493..61730541e 100644 --- a/spa/plugins/volume/volume.c +++ b/spa/plugins/volume/volume.c @@ -66,6 +66,8 @@ typedef struct { uint32_t props; uint32_t prop_volume; uint32_t prop_mute; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeFormatAudio format_audio; @@ -84,6 +86,8 @@ init_type (Type *type, SpaTypeMap *map) type->props = spa_type_map_get_id (map, SPA_TYPE__Props); type->prop_volume = spa_type_map_get_id (map, SPA_TYPE_PROPS__volume); type->prop_mute = spa_type_map_get_id (map, SPA_TYPE_PROPS__mute); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_format_audio_map (map, &type->format_audio); @@ -402,7 +406,8 @@ spa_volume_node_port_set_format (SpaNode *node, port->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable, - PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER)); + PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Header), + PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader))); port->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); port->info.extra = NULL; @@ -508,21 +513,18 @@ spa_volume_node_port_use_buffers (SpaNode *node, b = &port->buffers[i]; b->outbuf = buffers[i]; b->outstanding = true; - b->h = spa_buffer_find_meta (buffers[i], SPA_META_TYPE_HEADER); + b->h = spa_buffer_find_meta (buffers[i], this->type.meta.Header); - switch (d[0].type) { - case SPA_DATA_TYPE_MEMPTR: - case SPA_DATA_TYPE_MEMFD: - case SPA_DATA_TYPE_DMABUF: - if (d[0].data == NULL) { - spa_log_error (this->log, "volume %p: invalid memory on buffer %p", this, buffers[i]); - continue; - } - b->ptr = d[0].data; - b->size = d[0].maxsize; - break; - default: - break; + if ((d[0].type == this->type.data.MemPtr || + d[0].type == this->type.data.MemFd || + d[0].type == this->type.data.DmaBuf) && + d[0].data != NULL) { + b->ptr = d[0].data; + b->size = d[0].maxsize; + } + else { + spa_log_error (this->log, "volume %p: invalid memory on buffer %p", this, buffers[i]); + return SPA_RESULT_ERROR; } spa_list_insert (port->empty.prev, &b->link); } diff --git a/spa/tests/test-mixer.c b/spa/tests/test-mixer.c index dae67f4c9..7d7f8639c 100644 --- a/spa/tests/test-mixer.c +++ b/spa/tests/test-mixer.c @@ -46,6 +46,8 @@ typedef struct { uint32_t props_volume; uint32_t props_min_latency; uint32_t props_live; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeFormatAudio format_audio; @@ -65,6 +67,8 @@ init_type (Type *type, SpaTypeMap *map) type->props_volume = spa_type_map_get_id (map, SPA_TYPE_PROPS__volume); type->props_min_latency = spa_type_map_get_id (map, SPA_TYPE_PROPS__minLatency); type->props_live = spa_type_map_get_id (map, SPA_TYPE_PROPS__live); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_format_audio_map (map, &type->format_audio); @@ -141,11 +145,11 @@ init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t b->header.seq = 0; b->header.pts = 0; b->header.dts_offset = 0; - b->metas[0].type = SPA_META_TYPE_HEADER; + b->metas[0].type = data->type.meta.Header; b->metas[0].data = &b->header; b->metas[0].size = sizeof (b->header); - b->datas[0].type = SPA_DATA_TYPE_MEMPTR; + b->datas[0].type = data->type.data.MemPtr; b->datas[0].flags = 0; b->datas[0].fd = -1; b->datas[0].mapoffset = 0; diff --git a/spa/tests/test-ringbuffer.c b/spa/tests/test-ringbuffer.c index 522027318..f6526cd0e 100644 --- a/spa/tests/test-ringbuffer.c +++ b/spa/tests/test-ringbuffer.c @@ -46,6 +46,8 @@ typedef struct { uint32_t props_volume; uint32_t props_min_latency; uint32_t props_live; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeFormatAudio format_audio; @@ -65,6 +67,8 @@ init_type (Type *type, SpaTypeMap *map) type->props_volume = spa_type_map_get_id (map, SPA_TYPE_PROPS__volume); type->props_min_latency = spa_type_map_get_id (map, SPA_TYPE_PROPS__minLatency); type->props_live = spa_type_map_get_id (map, SPA_TYPE_PROPS__live); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_format_audio_map (map, &type->format_audio); @@ -130,16 +134,16 @@ init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t b->header.seq = 0; b->header.pts = 0; b->header.dts_offset = 0; - b->metas[0].type = SPA_META_TYPE_HEADER; + b->metas[0].type = data->type.meta.Header; b->metas[0].data = &b->header; b->metas[0].size = sizeof (b->header); spa_ringbuffer_init (&b->rb.ringbuffer, size); - b->metas[1].type = SPA_META_TYPE_RINGBUFFER; + b->metas[1].type = data->type.meta.Ringbuffer; b->metas[1].data = &b->rb; b->metas[1].size = sizeof (b->rb); - b->datas[0].type = SPA_DATA_TYPE_MEMPTR; + b->datas[0].type = data->type.data.MemPtr; b->datas[0].flags = 0; b->datas[0].fd = -1; b->datas[0].mapoffset = 0; diff --git a/spa/tests/test-v4l2.c b/spa/tests/test-v4l2.c index 1df7f325d..8987b94f7 100644 --- a/spa/tests/test-v4l2.c +++ b/spa/tests/test-v4l2.c @@ -43,6 +43,9 @@ typedef struct { uint32_t props; uint32_t format; uint32_t props_device; + uint32_t SDL_Texture; + SpaTypeMeta meta; + SpaTypeData data; SpaTypeMediaType media_type; SpaTypeMediaSubtype media_subtype; SpaTypeFormatVideo format_video; @@ -58,6 +61,9 @@ init_type (Type *type, SpaTypeMap *map) type->props = spa_type_map_get_id (map, SPA_TYPE__Props); type->format = spa_type_map_get_id (map, SPA_TYPE__Format); type->props_device = spa_type_map_get_id (map, SPA_TYPE_PROPS__device); + type->SDL_Texture = spa_type_map_get_id (map, SPA_TYPE_POINTER_BASE "SDL_Texture"); + spa_type_meta_map (map, &type->meta); + spa_type_data_map (map, &type->data); spa_type_media_type_map (map, &type->media_type); spa_type_media_subtype_map (map, &type->media_subtype); spa_type_format_video_map (map, &type->format_video); @@ -177,8 +183,8 @@ on_source_event (SpaNode *node, SpaEvent *event, void *user_data) metas = b->metas; datas = b->datas; - if (metas[1].type == SPA_META_TYPE_POINTER && - strcmp (((SpaMetaPointer *)metas[1].data)->ptr_type, "SDL_Texture") == 0) { + if (metas[1].type == data->type.meta.Pointer && + ((SpaMetaPointer *)metas[1].data)->type == data->type.SDL_Texture) { SDL_Texture *texture; texture = ((SpaMetaPointer *)metas[1].data)->ptr; @@ -192,7 +198,7 @@ on_source_event (SpaNode *node, SpaEvent *event, void *user_data) fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError()); return; } - datas[0].type = SPA_DATA_TYPE_MEMPTR; + datas[0].type = data->type.data.MemPtr; datas[0].flags = 0; datas[0].fd = -1; datas[0].mapoffset = 0; @@ -328,17 +334,17 @@ alloc_buffers (AppData *data) b->header.seq = 0; b->header.pts = 0; b->header.dts_offset = 0; - b->metas[0].type = SPA_META_TYPE_HEADER; + b->metas[0].type = data->type.meta.Header; b->metas[0].data = &b->header; b->metas[0].size = sizeof (b->header); - b->ptr.ptr_type = "SDL_Texture"; + b->ptr.type = data->type.SDL_Texture; b->ptr.ptr = texture; - b->metas[1].type = SPA_META_TYPE_POINTER; + b->metas[1].type = data->type.meta.Pointer; b->metas[1].data = &b->ptr; b->metas[1].size = sizeof (b->ptr); - b->datas[0].type = SPA_DATA_TYPE_MEMPTR; + b->datas[0].type = data->type.data.MemPtr; b->datas[0].flags = 0; b->datas[0].fd = -1; b->datas[0].mapoffset = 0;