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

buffer: make data and meta types dynamic

Browse source 
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
This commit is contained in:
Wim Taymans 2017-04-26 18:42:50 +02:00
parent ed273ec465
commit b51d3e4862
36 changed files with 543 additions and 553 deletions
Download patch file Download diff file Expand all files Collapse all files

2
pinos/client/interfaces.h
View file

@ -244,7 +244,7 @@ typedef struct {
SpaDirection direction, SpaDirection direction,
uint32_t port_id, uint32_t port_id,
uint32_t mem_id, uint32_t mem_id,
SpaDataType type, uint32_t type,
int memfd, int memfd,
uint32_t flags, uint32_t flags,
uint32_t offset, uint32_t offset,

9
pinos/client/protocol-native.c
View file

@ -510,6 +510,7 @@ client_node_marshal_port_update (void *object,
spa_pod_builder_add (&b.b, spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f[1], SPA_POD_TYPE_STRUCT, &f[1],
SPA_POD_TYPE_INT, info->flags, SPA_POD_TYPE_INT, info->flags,
SPA_POD_TYPE_INT, info->rate,
SPA_POD_TYPE_LONG, info->maxbuffering, SPA_POD_TYPE_LONG, info->maxbuffering,
SPA_POD_TYPE_LONG, info->latency, SPA_POD_TYPE_LONG, info->latency,
SPA_POD_TYPE_INT, info->n_params, SPA_POD_TYPE_INT, info->n_params,
@ -718,11 +719,12 @@ client_node_demarshal_add_mem (void *object,
int memfd; int memfd;
if (!spa_pod_iter_struct (&it, data, size) || 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_iter_get (&it,
SPA_POD_TYPE_INT, &direction, SPA_POD_TYPE_INT, &direction,
SPA_POD_TYPE_INT, &port_id, SPA_POD_TYPE_INT, &port_id,
SPA_POD_TYPE_INT, &mem_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, &memfd_idx,
SPA_POD_TYPE_INT, &flags, SPA_POD_TYPE_INT, &flags,
SPA_POD_TYPE_INT, &offset, SPA_POD_TYPE_INT, &offset,
@ -756,6 +758,7 @@ client_node_demarshal_use_buffers (void *object,
int i, j; int i, j;
if (!spa_pod_iter_struct (&it, data, size) || 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_iter_get (&it,
SPA_POD_TYPE_INT, &seq, SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_INT, &direction, SPA_POD_TYPE_INT, &direction,
@ -781,7 +784,7 @@ client_node_demarshal_use_buffers (void *object,
SpaMeta *m = &buf->metas[j]; SpaMeta *m = &buf->metas[j];
if (!spa_pod_iter_get (&it, 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)) SPA_POD_TYPE_INT, &m->size, 0))
return false; return false;
} }
@ -793,7 +796,7 @@ client_node_demarshal_use_buffers (void *object,
SpaData *d = &buf->datas[j]; SpaData *d = &buf->datas[j];
if (!spa_pod_iter_get (&it, 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, &data_id,
SPA_POD_TYPE_INT, &d->flags, SPA_POD_TYPE_INT, &d->flags,
SPA_POD_TYPE_INT, &d->mapoffset, SPA_POD_TYPE_INT, &d->mapoffset,

39
pinos/client/stream.c
View file

@ -62,8 +62,6 @@ typedef struct
{ {
PinosStream this; PinosStream this;
uint32_t port_state;
uint32_t n_possible_formats; uint32_t n_possible_formats;
SpaFormat **possible_formats; SpaFormat **possible_formats;
@ -230,7 +228,6 @@ pinos_stream_new (PinosContext *context,
this->state = PINOS_STREAM_STATE_UNCONNECTED; this->state = PINOS_STREAM_STATE_UNCONNECTED;
impl->port_state = SPA_PORT_STATE_INIT;
pinos_array_init (&impl->mem_ids, 64); pinos_array_init (&impl->mem_ids, 64);
pinos_array_ensure_size (&impl->mem_ids, sizeof (MemId) * 64); pinos_array_ensure_size (&impl->mem_ids, sizeof (MemId) * 64);
pinos_array_init (&impl->buffer_ids, 32); pinos_array_init (&impl->buffer_ids, 32);
@ -741,7 +738,7 @@ client_node_add_mem (void *object,
SpaDirection direction, SpaDirection direction,
uint32_t port_id, uint32_t port_id,
uint32_t mem_id, uint32_t mem_id,
SpaDataType type, uint32_t type,
int memfd, int memfd,
uint32_t flags, uint32_t flags,
uint32_t offset, uint32_t offset,
@ -856,26 +853,20 @@ client_node_use_buffers (void *object,
memcpy (d, &buffers[i].buffer->datas[j], sizeof (SpaData)); memcpy (d, &buffers[i].buffer->datas[j], sizeof (SpaData));
d->chunk = SPA_MEMBER (bid->buf_ptr, offset + sizeof (SpaChunk) * j, SpaChunk); d->chunk = SPA_MEMBER (bid->buf_ptr, offset + sizeof (SpaChunk) * j, SpaChunk);
switch (d->type) { if (d->type == stream->context->type.data.Id) {
case SPA_DATA_TYPE_ID: MemId *bmid = find_mem (stream, SPA_PTR_TO_UINT32 (d->data));
{ d->type = stream->context->type.data.MemFd;
MemId *bmid = find_mem (stream, SPA_PTR_TO_UINT32 (d->data)); d->data = NULL;
d->type = SPA_DATA_TYPE_MEMFD; d->fd = bmid->fd;
d->data = NULL; pinos_log_debug (" data %d %u -> fd %d", j, bmid->id, bmid->fd);
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) {
break; d->data = SPA_MEMBER (bid->buf_ptr, SPA_PTR_TO_INT (d->data), void);
} d->fd = -1;
case SPA_DATA_TYPE_MEMPTR: pinos_log_debug (" data %d %u -> mem %p", j, bid->id, d->data);
{ }
d->data = SPA_MEMBER (bid->buf_ptr, SPA_PTR_TO_INT (d->data), void); else {
d->fd = -1; pinos_log_warn ("unknown buffer data type %d", d->type);
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;
} }
} }
pinos_signal_emit (&stream->add_buffer, stream, bid->id); pinos_signal_emit (&stream->add_buffer, stream, bid->id);

5
pinos/client/stream.h
View file

@ -44,8 +44,9 @@ typedef enum {
const char * pinos_stream_state_as_string (PinosStreamState state); const char * pinos_stream_state_as_string (PinosStreamState state);
typedef enum { typedef enum {
PINOS_STREAM_FLAG_NONE = 0, PINOS_STREAM_FLAG_NONE = 0,
PINOS_STREAM_FLAG_AUTOCONNECT = (1 << 0), PINOS_STREAM_FLAG_AUTOCONNECT = (1 << 0),
PINOS_STREAM_FLAG_CLOCK_UPDATE = (1 << 1),
} PinosStreamFlags; } PinosStreamFlags;
typedef enum { typedef enum {

2
pinos/client/type.c
View file

@ -51,6 +51,8 @@ pinos_type_init (PinosType *type)
type->spa_format = spa_type_map_get_id (type->map, SPA_TYPE__Format); 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); 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_event_node_map (type->map, &type->event_node);
spa_type_command_node_map (type->map, &type->command_node); spa_type_command_node_map (type->map, &type->command_node);
spa_type_monitor_map (type->map, &type->monitor); spa_type_monitor_map (type->map, &type->monitor);

2
pinos/client/type.h
View file

@ -56,6 +56,8 @@ struct _PinosType {
SpaType spa_format; SpaType spa_format;
SpaType spa_props; SpaType spa_props;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeEventNode event_node; SpaTypeEventNode event_node;
SpaTypeCommandNode command_node; SpaTypeCommandNode command_node;
SpaTypeMonitor monitor; SpaTypeMonitor monitor;

11
pinos/examples/video-play.c
View file

@ -35,6 +35,8 @@
typedef struct { typedef struct {
uint32_t format; uint32_t format;
uint32_t props; uint32_t props;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeFormatVideo format_video; 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->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props); 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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_video_map (map, &type->format_video); 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); 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 = mmap (NULL, buf->datas[0].maxsize + buf->datas[0].mapoffset, PROT_READ,
MAP_PRIVATE, buf->datas[0].fd, 0); MAP_PRIVATE, buf->datas[0].fd, 0);
sdata = SPA_MEMBER (map, buf->datas[0].mapoffset, uint8_t); 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; map = NULL;
sdata = buf->datas[0].data; sdata = buf->datas[0].data;
} else } else
@ -275,7 +279,8 @@ on_stream_format_changed (PinosListener *listener,
params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); 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, 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); params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
pinos_stream_finish_format (stream, SPA_RESULT_OK, params, 2); pinos_stream_finish_format (stream, SPA_RESULT_OK, params, 2);

17
pinos/examples/video-src.c
View file

@ -18,6 +18,7 @@
*/ */
#include <stdio.h> #include <stdio.h>
#include <errno.h>
#include <sys/mman.h> #include <sys/mman.h>
#include <spa/include/spa/type-map.h> #include <spa/include/spa/type-map.h>
@ -33,6 +34,8 @@
typedef struct { typedef struct {
uint32_t format; uint32_t format;
uint32_t props; uint32_t props;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeFormatVideo format_video; 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->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props); 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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_video_map (map, &type->format_video); 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); 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 = mmap (NULL, buf->datas[0].maxsize + buf->datas[0].mapoffset, PROT_READ | PROT_WRITE,
MAP_SHARED, buf->datas[0].fd, 0); 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); 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; map = NULL;
p = buf->datas[0].data; p = buf->datas[0].data;
} else } else
@ -185,7 +194,8 @@ on_stream_format_changed (PinosListener *listener,
params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam); 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, 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); params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
pinos_stream_finish_format (stream, SPA_RESULT_OK, params, 2); pinos_stream_finish_format (stream, SPA_RESULT_OK, params, 2);
@ -225,7 +235,6 @@ on_state_changed (PinosListener *listener,
1, 1, 1, 1,
4096, 4096), 4096, 4096),
PROP (&f[1], data->type.format_video.framerate, SPA_POD_TYPE_FRACTION, 25, 1)); 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); formats[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
pinos_signal_add (&data->stream->state_changed, pinos_signal_add (&data->stream->state_changed,

47
pinos/gst/gstpinossink.c
View file

@ -384,40 +384,23 @@ on_add_buffer (PinosListener *listener,
data.sink = gst_object_ref (pinossink); data.sink = gst_object_ref (pinossink);
data.id = id; data.id = id;
data.buf = b; 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++) { for (i = 0; i < b->n_datas; i++) {
SpaData *d = &b->datas[i]; SpaData *d = &b->datas[i];
GstMemory *gmem = NULL; GstMemory *gmem = NULL;
switch (d->type) { if (d->type == stream->context->type.data.MemFd ||
case SPA_DATA_TYPE_MEMFD: d->type == stream->context->type.data.DmaBuf) {
case SPA_DATA_TYPE_DMABUF: gmem = gst_fd_allocator_alloc (pinossink->allocator, dup (d->fd),
{ d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE);
gmem = gst_fd_allocator_alloc (pinossink->allocator, dup (d->fd), gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size);
d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE); data.offset = d->mapoffset;
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) {
break; gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, d->chunk->offset,
} d->chunk->size, NULL, NULL);
case SPA_DATA_TYPE_MEMPTR: data.offset = 0;
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 (gmem) if (gmem)
gst_buffer_append_memory (buf, 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); 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, 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); 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, 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, PROP (&f[1], ctx->type.alloc_param_meta_enable.ringbufferSize, SPA_POD_TYPE_INT,
size * SPA_MAX (4, size * SPA_MAX (4,
SPA_MAX (min_buffers, max_buffers))), SPA_MAX (min_buffers, max_buffers))),

43
pinos/gst/gstpinossrc.c
View file

@ -388,6 +388,7 @@ on_add_buffer (PinosListener *listener,
GstBuffer *buf; GstBuffer *buf;
uint32_t i; uint32_t i;
ProcessMemData data; ProcessMemData data;
PinosContext *ctx = pinossrc->stream->context;
GST_LOG_OBJECT (pinossrc, "add buffer"); GST_LOG_OBJECT (pinossrc, "add buffer");
@ -402,39 +403,22 @@ on_add_buffer (PinosListener *listener,
data.src = gst_object_ref (pinossrc); data.src = gst_object_ref (pinossrc);
data.id = id; data.id = id;
data.buf = b; 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++) { for (i = 0; i < b->n_datas; i++) {
SpaData *d = &b->datas[i]; SpaData *d = &b->datas[i];
GstMemory *gmem = NULL; GstMemory *gmem = NULL;
switch (d->type) { if (d->type == ctx->type.data.MemFd || d->type == ctx->type.data.DmaBuf) {
case SPA_DATA_TYPE_MEMFD: gmem = gst_fd_allocator_alloc (pinossrc->fd_allocator, dup (d->fd),
case SPA_DATA_TYPE_DMABUF: d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE);
{ gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size);
gmem = gst_fd_allocator_alloc (pinossrc->fd_allocator, dup (d->fd), data.offset = d->mapoffset;
d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE); }
gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size); else if (d->type == ctx->type.data.MemPtr) {
data.offset = d->mapoffset; gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, d->chunk->offset + d->mapoffset,
break; d->chunk->size, NULL, NULL);
} data.offset = 0;
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 (gmem) if (gmem)
gst_buffer_append_memory (buf, 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_init (&b, buffer, sizeof (buffer));
spa_pod_builder_object (&b, &f[0], 0, ctx->type.alloc_param_meta_enable.MetaEnable, 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); params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
GST_DEBUG_OBJECT (pinossrc, "doing finish format"); GST_DEBUG_OBJECT (pinossrc, "doing finish format");

60
pinos/server/client-node.c
View file

@ -613,16 +613,15 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
uint32_t n_buffers) uint32_t n_buffers)
{ {
SpaProxy *this; SpaProxy *this;
PinosClientNodeImpl *impl;
SpaProxyPort *port; SpaProxyPort *port;
uint32_t i, j; uint32_t i, j;
size_t n_mem; size_t n_mem;
PinosClientNodeBuffer *mb; PinosClientNodeBuffer *mb;
SpaMetaShared *msh; SpaMetaShared *msh;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, SpaProxy, node); 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); spa_log_info (this->log, "proxy %p: use buffers %p %u", this, buffers, n_buffers);
if (!CHECK_PORT (this, direction, port_id)) 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++) { for (i = 0; i < n_buffers; i++) {
ProxyBuffer *b = &port->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) { if (msh == NULL) {
spa_log_error (this->log, "missing shared metadata on buffer %d", i); spa_log_error (this->log, "missing shared metadata on buffer %d", i);
return SPA_RESULT_ERROR; return SPA_RESULT_ERROR;
@ -670,7 +669,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
direction, direction,
port_id, port_id,
mb[i].mem_id, mb[i].mem_id,
SPA_DATA_TYPE_MEMFD, impl->core->type.data.MemFd,
msh->fd, msh->fd,
msh->flags, msh->flags,
msh->offset, msh->offset,
@ -685,31 +684,29 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
memcpy (&b->buffer.datas[j], d, sizeof (SpaData)); memcpy (&b->buffer.datas[j], d, sizeof (SpaData));
switch (d->type) { if (d->type == impl->core->type.data.DmaBuf ||
case SPA_DATA_TYPE_DMABUF: d->type == impl->core->type.data.MemFd) {
case SPA_DATA_TYPE_MEMFD: pinos_client_node_notify_add_mem (this->resource,
pinos_client_node_notify_add_mem (this->resource, direction,
direction, port_id,
port_id, n_mem,
n_mem, d->type,
d->type, d->fd,
d->fd, d->flags,
d->flags, d->mapoffset,
d->mapoffset, d->maxsize);
d->maxsize); b->buffer.datas[j].type = impl->core->type.data.Id;
b->buffer.datas[j].type = SPA_DATA_TYPE_ID; b->buffer.datas[j].data = SPA_UINT32_TO_PTR (n_mem);
b->buffer.datas[j].data = SPA_UINT32_TO_PTR (n_mem); n_mem++;
n_mem++; }
break; else if (d->type == impl->core->type.data.MemPtr) {
case SPA_DATA_TYPE_MEMPTR: b->buffer.datas[j].data = SPA_INT_TO_PTR (b->size);
b->buffer.datas[j].data = SPA_INT_TO_PTR (b->size); b->size += d->maxsize;
b->size += d->maxsize; }
break; else {
default: b->buffer.datas[j].type = SPA_ID_INVALID;
b->buffer.datas[j].type = SPA_DATA_TYPE_INVALID; b->buffer.datas[j].data = 0;
b->buffer.datas[j].data = 0; spa_log_error (this->log, "invalid memory type %d", d->type);
spa_log_error (this->log, "invalid memory type %d", d->type);
break;
} }
} }
} }
@ -833,9 +830,6 @@ spa_proxy_node_process_output (SpaNode *node)
int i; int i;
bool send_need = false, flush = false; bool send_need = false, flush = false;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, SpaProxy, node); this = SPA_CONTAINER_OF (node, SpaProxy, node);
impl = this->impl; impl = this->impl;

14
pinos/server/core.c
View file

@ -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); 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) if (out_state > PINOS_PORT_STATE_CONFIGURE && output->node->state == PINOS_NODE_STATE_IDLE)
out_state = SPA_PORT_STATE_CONFIGURE; out_state = PINOS_PORT_STATE_CONFIGURE;
if (in_state > SPA_PORT_STATE_CONFIGURE && input->node->state == PINOS_NODE_STATE_IDLE) if (in_state > PINOS_PORT_STATE_CONFIGURE && input->node->state == PINOS_NODE_STATE_IDLE)
in_state = SPA_PORT_STATE_CONFIGURE; 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 */ /* only input needs format */
if ((res = spa_node_port_get_format (output->node->node, if ((res = spa_node_port_get_format (output->node->node,
SPA_DIRECTION_OUTPUT, SPA_DIRECTION_OUTPUT,
@ -668,7 +668,7 @@ pinos_core_find_format (PinosCore *core,
asprintf (error, "error get output format: %d", res); asprintf (error, "error get output format: %d", res);
goto error; 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 */ /* only output needs format */
if ((res = spa_node_port_get_format (input->node->node, if ((res = spa_node_port_get_format (input->node->node,
SPA_DIRECTION_INPUT, SPA_DIRECTION_INPUT,
@ -677,7 +677,7 @@ pinos_core_find_format (PinosCore *core,
asprintf (error, "error get input format: %d", res); asprintf (error, "error get input format: %d", res);
goto error; 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: again:
/* both ports need a format */ /* both ports need a format */
pinos_log_debug ("core %p: finding best format", core); pinos_log_debug ("core %p: finding best format", core);

92
pinos/server/link.c
View file

@ -83,7 +83,7 @@ complete_ready (void *obj,
{ {
PinosPort *port = data; PinosPort *port = data;
if (SPA_RESULT_IS_OK (res)) { 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); pinos_log_debug ("port %p: state READY", port);
} }
else else
@ -98,7 +98,7 @@ complete_paused (void *obj,
{ {
PinosPort *port = data; PinosPort *port = data;
if (SPA_RESULT_IS_OK (res)) { 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); pinos_log_debug ("port %p: state PAUSED", port);
} }
else else
@ -113,7 +113,7 @@ complete_streaming (void *obj,
{ {
PinosPort *port = data; PinosPort *port = data;
if (SPA_RESULT_IS_OK (res)) { 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); pinos_log_debug ("port %p: state STREAMING", port);
} }
else else
@ -128,7 +128,7 @@ do_negotiate (PinosLink *this, uint32_t in_state, uint32_t out_state)
SpaFormat *format; SpaFormat *format;
char *error = NULL; 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; return SPA_RESULT_OK;
pinos_link_update_state (this, PINOS_LINK_STATE_NEGOTIATING, NULL); 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) if (format == NULL)
goto error; 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); 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); 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); pinos_log_debug ("link %p: doing set format", this);
if (pinos_log_level_enabled (SPA_LOG_LEVEL_DEBUG)) if (pinos_log_level_enabled (SPA_LOG_LEVEL_DEBUG))
spa_debug_format (format, this->core->type.map); 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); pinos_log_debug ("link %p: doing set format on output", this);
if ((res = spa_node_port_set_format (this->output->node->node, if ((res = spa_node_port_set_format (this->output->node->node,
SPA_DIRECTION_OUTPUT, 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); 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); pinos_log_debug ("link %p: doing set format on input", this);
if ((res2 = spa_node_port_set_format (this->input->node->node, if ((res2 = spa_node_port_set_format (this->input->node->node,
SPA_DIRECTION_INPUT, SPA_DIRECTION_INPUT,
@ -203,7 +203,7 @@ find_param (const SpaPortInfo *info, uint32_t type)
} }
static void * 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; uint32_t i;
@ -212,7 +212,7 @@ find_meta_enable (PinosCore *core, const SpaPortInfo *info, SpaMetaType type)
uint32_t qtype; uint32_t qtype;
if (spa_alloc_param_query (info->params[i], 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; continue;
if (qtype == type) if (qtype == type)
@ -248,8 +248,8 @@ alloc_buffers (PinosLink *this,
metas = alloca (sizeof (SpaMeta) * n_params + 1); metas = alloca (sizeof (SpaMeta) * n_params + 1);
/* add shared metadata */ /* add shared metadata */
metas[n_metas].type = SPA_META_TYPE_SHARED; metas[n_metas].type = this->core->type.meta.Shared;
metas[n_metas].size = spa_meta_type_get_size (SPA_META_TYPE_SHARED); metas[n_metas].size = sizeof (SpaMetaShared);
meta_size += metas[n_metas].size; meta_size += metas[n_metas].size;
n_metas++; n_metas++;
skel_size += sizeof (SpaMeta); skel_size += sizeof (SpaMeta);
@ -259,15 +259,16 @@ alloc_buffers (PinosLink *this,
SpaAllocParam *ap = params[i]; SpaAllocParam *ap = params[i];
if (ap->pod.type == this->core->type.alloc_param_meta_enable.MetaEnable) { 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, 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) 0) != 1)
continue; continue;
metas[n_metas].type = type; 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; meta_size += metas[n_metas].size;
n_metas++; n_metas++;
skel_size += sizeof (SpaMeta); skel_size += sizeof (SpaMeta);
@ -312,26 +313,17 @@ alloc_buffers (PinosLink *this,
m->data = p; m->data = p;
m->size = metas[j].size; m->size = metas[j].size;
switch (m->type) { if (m->type == this->core->type.meta.Shared) {
case SPA_META_TYPE_SHARED: SpaMetaShared *msh = p;
{
SpaMetaShared *msh = p;
msh->type = SPA_DATA_TYPE_MEMFD; msh->flags = 0;
msh->flags = 0; msh->fd = mem->fd;
msh->fd = mem->fd; msh->offset = data_size * i;
msh->offset = data_size * i; msh->size = data_size;
msh->size = data_size; }
break; else if (m->type == this->core->type.meta.Ringbuffer) {
} SpaMetaRingbuffer *rb = p;
case SPA_META_TYPE_RINGBUFFER: spa_ringbuffer_init (&rb->ringbuffer, data_sizes[0]);
{
SpaMetaRingbuffer *rb = p;
spa_ringbuffer_init (&rb->ringbuffer, data_sizes[0]);
break;
}
default:
break;
} }
p += m->size; p += m->size;
} }
@ -347,7 +339,7 @@ alloc_buffers (PinosLink *this,
d->chunk = &cdp[j]; d->chunk = &cdp[j];
if (data_sizes[j] > 0) { if (data_sizes[j] > 0) {
d->type = SPA_DATA_TYPE_MEMFD; d->type = this->core->type.data.MemFd;
d->flags = 0; d->flags = 0;
d->fd = mem->fd; d->fd = mem->fd;
d->mapoffset = SPA_PTRDIFF (ddp, mem->ptr); d->mapoffset = SPA_PTRDIFF (ddp, mem->ptr);
@ -358,7 +350,7 @@ alloc_buffers (PinosLink *this,
d->chunk->stride = data_strides[j]; d->chunk->stride = data_strides[j];
ddp += data_sizes[j]; ddp += data_sizes[j];
} else { } else {
d->type = SPA_DATA_TYPE_INVALID; d->type = SPA_ID_INVALID;
d->data = NULL; d->data = NULL;
} }
} }
@ -375,7 +367,7 @@ do_allocation (PinosLink *this, uint32_t in_state, uint32_t out_state)
SpaPortInfoFlags in_flags, out_flags; SpaPortInfoFlags in_flags, out_flags;
char *error = NULL; 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; return SPA_RESULT_OK;
pinos_link_update_state (this, PINOS_LINK_STATE_ALLOCATING, NULL); 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; 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) && if ((out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) &&
(in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS)) { (in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS)) {
out_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_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; res = SPA_RESULT_ERROR;
goto 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; out_flags &= ~SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
in_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_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; in_flags &= ~SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
out_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS; out_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
} else { } else {
@ -450,8 +442,8 @@ do_allocation (PinosLink *this, uint32_t in_state, uint32_t out_state)
uint32_t max_buffers; uint32_t max_buffers;
size_t minsize = 1024, stride = 0; size_t minsize = 1024, stride = 0;
in_me = find_meta_enable (this->core, iinfo, 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, SPA_META_TYPE_RINGBUFFER); out_me = find_meta_enable (this->core, oinfo, this->core->type.meta.Ringbuffer);
if (in_me && out_me) { if (in_me && out_me) {
uint32_t ms1, ms2, s1, s2; uint32_t ms1, ms2, s1, s2;
max_buffers = 1; max_buffers = 1;
@ -631,18 +623,18 @@ do_start (PinosLink *this, uint32_t in_state, uint32_t out_state)
SpaResult res = SPA_RESULT_OK; SpaResult res = SPA_RESULT_OK;
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this); 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; 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); pinos_link_update_state (this, PINOS_LINK_STATE_RUNNING, NULL);
} else { } else {
pinos_link_update_state (this, PINOS_LINK_STATE_PAUSED, NULL); 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); 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); 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); 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); 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); 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); pinos_log_debug ("link %p: clear buffers on port %p", link, port);
spa_node_port_use_buffers (port->node->node, spa_node_port_use_buffers (port->node->node,
port->direction, port->direction,
@ -948,7 +940,7 @@ clear_port_buffers (PinosLink *link, PinosPort *port)
NULL, 0); NULL, 0);
port->buffers = NULL; port->buffers = NULL;
port->n_buffers = 0; port->n_buffers = 0;
port->state = SPA_PORT_STATE_READY; port->state = PINOS_PORT_STATE_READY;
pinos_log_debug ("port %p: state READY", port); pinos_log_debug ("port %p: state READY", port);
} }
} }

4
pinos/server/node.c
View file

@ -208,7 +208,7 @@ suspend_node (PinosNode *this)
if (p->allocated) if (p->allocated)
pinos_memblock_free (&p->buffer_mem); pinos_memblock_free (&p->buffer_mem);
p->allocated = false; p->allocated = false;
p->state = SPA_PORT_STATE_CONFIGURE; p->state = PINOS_PORT_STATE_CONFIGURE;
} }
spa_list_for_each (p, &this->output_ports, link) { spa_list_for_each (p, &this->output_ports, link) {
@ -219,7 +219,7 @@ suspend_node (PinosNode *this)
if (p->allocated) if (p->allocated)
pinos_memblock_free (&p->buffer_mem); pinos_memblock_free (&p->buffer_mem);
p->allocated = false; p->allocated = false;
p->state = SPA_PORT_STATE_CONFIGURE; p->state = PINOS_PORT_STATE_CONFIGURE;
} }
return res; return res;
} }

14
pinos/server/port.c
View file

@ -48,7 +48,7 @@ pinos_port_new (PinosNode *node,
this->node = node; this->node = node;
this->direction = direction; this->direction = direction;
this->port_id = port_id; 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.status = SPA_RESULT_OK;
this->io.buffer_id = SPA_ID_INVALID; 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); SpaCommand cmd = SPA_COMMAND_INIT (port->node->core->type.command_node.Pause);
SpaResult res; SpaResult res;
if (port->state <= SPA_PORT_STATE_PAUSED) if (port->state <= PINOS_PORT_STATE_PAUSED)
return SPA_RESULT_OK; return SPA_RESULT_OK;
res = spa_node_port_send_command (port->node->node, res = spa_node_port_send_command (port->node->node,
port->direction, port->direction,
port->port_id, port->port_id,
&cmd); &cmd);
port->state = SPA_PORT_STATE_PAUSED; port->state = PINOS_PORT_STATE_PAUSED;
pinos_log_debug ("port %p: state PAUSED", port); pinos_log_debug ("port %p: state PAUSED", port);
return res; 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); pinos_log_debug ("port %p: clear buffers on port", port);
spa_node_port_use_buffers (port->node->node, spa_node_port_use_buffers (port->node->node,
port->direction, port->direction,
@ -252,7 +252,7 @@ do_remove_link_done (SpaLoop *loop,
NULL, 0); NULL, 0);
port->buffers = NULL; port->buffers = NULL;
port->n_buffers = 0; port->n_buffers = 0;
port->state = SPA_PORT_STATE_READY; port->state = PINOS_PORT_STATE_READY;
pinos_log_debug ("port %p: state READY", port); pinos_log_debug ("port %p: state READY", port);
} }
@ -324,7 +324,7 @@ do_clear_buffers_done (SpaLoop *loop,
PinosPort *port = user_data; PinosPort *port = user_data;
SpaResult res; SpaResult res;
if (port->state <= SPA_PORT_STATE_READY) if (port->state <= PINOS_PORT_STATE_READY)
return SPA_RESULT_OK; return SPA_RESULT_OK;
pinos_log_debug ("port %p: clear buffers finish", port); pinos_log_debug ("port %p: clear buffers finish", port);
@ -334,7 +334,7 @@ do_clear_buffers_done (SpaLoop *loop,
NULL, 0); NULL, 0);
port->buffers = NULL; port->buffers = NULL;
port->n_buffers = 0; port->n_buffers = 0;
port->state = SPA_PORT_STATE_READY; port->state = PINOS_PORT_STATE_READY;
pinos_log_debug ("port %p: state READY", port); pinos_log_debug ("port %p: state READY", port);
return res; return res;

11
pinos/server/port.h
View file

@ -37,6 +37,15 @@ typedef struct _PinosPort PinosPort;
#include <pinos/server/core.h> #include <pinos/server/core.h>
#include <pinos/server/link.h> #include <pinos/server/link.h>
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 { struct _PinosPort {
SpaList link; SpaList link;
@ -45,7 +54,7 @@ struct _PinosPort {
PinosNode *node; PinosNode *node;
PinosDirection direction; PinosDirection direction;
uint32_t port_id; uint32_t port_id;
uint32_t state; PinosPortState state;
SpaPortIO io; SpaPortIO io;
bool allocated; bool allocated;

9
pinos/server/protocol-native.c
View file

@ -658,7 +658,7 @@ client_node_marshal_add_mem (void *object,
SpaDirection direction, SpaDirection direction,
uint32_t port_id, uint32_t port_id,
uint32_t mem_id, uint32_t mem_id,
SpaDataType type, uint32_t type,
int memfd, int memfd,
uint32_t flags, uint32_t flags,
uint32_t offset, uint32_t offset,
@ -675,7 +675,7 @@ client_node_marshal_add_mem (void *object,
SPA_POD_TYPE_INT, direction, SPA_POD_TYPE_INT, direction,
SPA_POD_TYPE_INT, port_id, SPA_POD_TYPE_INT, port_id,
SPA_POD_TYPE_INT, mem_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, pinos_connection_add_fd (connection, memfd),
SPA_POD_TYPE_INT, flags, SPA_POD_TYPE_INT, flags,
SPA_POD_TYPE_INT, offset, SPA_POD_TYPE_INT, offset,
@ -720,14 +720,14 @@ client_node_marshal_use_buffers (void *object,
for (j = 0; j < buf->n_metas; j++) { for (j = 0; j < buf->n_metas; j++) {
SpaMeta *m = &buf->metas[j]; SpaMeta *m = &buf->metas[j];
spa_pod_builder_add (&b.b, 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_TYPE_INT, m->size, 0);
} }
spa_pod_builder_add (&b.b, SPA_POD_TYPE_INT, buf->n_datas, 0); spa_pod_builder_add (&b.b, SPA_POD_TYPE_INT, buf->n_datas, 0);
for (j = 0; j < buf->n_datas; j++) { for (j = 0; j < buf->n_datas; j++) {
SpaData *d = &buf->datas[j]; SpaData *d = &buf->datas[j];
spa_pod_builder_add (&b.b, 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, SPA_PTR_TO_UINT32 (d->data),
SPA_POD_TYPE_INT, d->flags, SPA_POD_TYPE_INT, d->flags,
SPA_POD_TYPE_INT, d->mapoffset, SPA_POD_TYPE_INT, d->mapoffset,
@ -865,6 +865,7 @@ client_node_demarshal_port_update (void *object,
if (!spa_pod_iter_pod (&it2, ipod) || if (!spa_pod_iter_pod (&it2, ipod) ||
!spa_pod_iter_get (&it2, !spa_pod_iter_get (&it2,
SPA_POD_TYPE_INT, &info.flags, SPA_POD_TYPE_INT, &info.flags,
SPA_POD_TYPE_INT, &info.rate,
SPA_POD_TYPE_LONG, &info.maxbuffering, SPA_POD_TYPE_LONG, &info.maxbuffering,
SPA_POD_TYPE_LONG, &info.latency, SPA_POD_TYPE_LONG, &info.latency,
SPA_POD_TYPE_INT, &info.n_params, SPA_POD_TYPE_INT, &info.n_params,

3
spa/include/spa/alloc-param.h
View file

@ -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__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_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__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__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" #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 { typedef struct {
uint32_t MetaEnable; uint32_t MetaEnable;
uint32_t type; uint32_t type;
uint32_t size;
uint32_t ringbufferSize; uint32_t ringbufferSize;
uint32_t ringbufferStride; uint32_t ringbufferStride;
uint32_t ringbufferBlocks; uint32_t ringbufferBlocks;
@ -108,6 +110,7 @@ spa_type_alloc_param_meta_enable_map (SpaTypeMap *map, SpaTypeAllocParamMetaEnab
if (type->MetaEnable == 0) { if (type->MetaEnable == 0) {
type->MetaEnable = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM__MetaEnable); 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->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->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->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); type->ringbufferBlocks = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferBlocks);

161
spa/include/spa/buffer.h
View file

@ -26,126 +26,37 @@ extern "C" {
typedef struct _SpaBuffer SpaBuffer; typedef struct _SpaBuffer SpaBuffer;
#include <spa/defs.h>
#include <spa/meta.h>
#define SPA_TYPE__Buffer SPA_TYPE_POINTER_BASE "Buffer" #define SPA_TYPE__Buffer SPA_TYPE_POINTER_BASE "Buffer"
#define SPA_TYPE_BUFFER_BASE SPA_TYPE__Buffer ":" #define SPA_TYPE_BUFFER_BASE SPA_TYPE__Buffer ":"
/** #define SPA_TYPE__Data SPA_TYPE_ENUM_BASE "DataType"
* SpaMetaType: #define SPA_TYPE_DATA_BASE SPA_TYPE__Data ":"
* @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__MemPtr SPA_TYPE_DATA_BASE "MemPtr"
* SpaDataType: #define SPA_TYPE_DATA__MemFd SPA_TYPE_DATA_BASE "MemFd"
* @SPA_DATA_TYPE_INVALID: invalid data, should be ignored #define SPA_TYPE_DATA__DmaBuf SPA_TYPE_DATA_BASE "DmaBuf"
* @SPA_DATA_TYPE_MEMPTR: data points to CPU accessible memory #define SPA_TYPE_DATA__Id SPA_TYPE_DATA_BASE "Id"
* @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 <spa/defs.h>
#include <spa/ringbuffer.h>
/**
* 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;
typedef struct { typedef struct {
SpaBufferFlags flags; uint32_t MemPtr;
uint32_t seq; uint32_t MemFd;
int64_t pts; uint32_t DmaBuf;
int64_t dts_offset; uint32_t Id;
} SpaMetaHeader; } SpaTypeData;
typedef struct { static inline void
const char *ptr_type; spa_type_data_map (SpaTypeMap *map, SpaTypeData *type)
void *ptr; {
} SpaMetaPointer; 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);
* SpaMetaVideoCrop: type->DmaBuf = spa_type_map_get_id (map, SPA_TYPE_DATA__DmaBuf);
* @x: type->Id = spa_type_map_get_id (map, SPA_TYPE_DATA__Id);
* @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;
/** /**
* SpaChunk: * SpaChunk:
@ -164,13 +75,13 @@ typedef struct {
* @type: memory type * @type: memory type
* @flags: memory flags * @flags: memory flags
* @fd: file descriptor * @fd: file descriptor
* @offset: start offset when mapping @fd * @mapoffset: start offset when mapping @fd
* @maxsize: maximum size of the memory * @maxsize: maximum size of the memory
* @data: pointer to memory * @data: pointer to memory
* @chunk: pointer to chunk with valid offset * @chunk: pointer to chunk with valid offset
*/ */
typedef struct { typedef struct {
SpaDataType type; uint32_t type;
uint32_t flags; uint32_t flags;
int fd; int fd;
uint32_t mapoffset; uint32_t mapoffset;
@ -195,32 +106,16 @@ struct _SpaBuffer {
SpaData *datas; SpaData *datas;
}; };
static inline void * static inline void *
spa_buffer_find_meta (SpaBuffer *b, SpaMetaType type) spa_buffer_find_meta (SpaBuffer *b, uint32_t type)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < b->n_metas; i++) for (i = 0; i < b->n_metas; i++)
if (b->metas[i].type == type) if (b->metas[i].type == type)
return b->metas[i].data; return b->metas[i].data;
return NULL;
}
static inline uint32_t return NULL;
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];
} }
#ifdef __cplusplus #ifdef __cplusplus

135
spa/include/spa/meta.h Normal file
View file

@ -0,0 +1,135 @@
/* Simple Plugin API
* Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
*
* 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 <spa/defs.h>
#include <spa/ringbuffer.h>
#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__ */

10
spa/include/spa/node.h
View file

@ -102,23 +102,17 @@ typedef enum {
/** /**
* SpaPortInfo * SpaPortInfo
* @flags: extra port flags * @flags: extra port flags
* @rate: rate of sequence number increment per second of media data
* @n_params: number of elements in @params; * @n_params: number of elements in @params;
* @params: extra allocation parameters * @params: extra allocation parameters
* @maxbuffering: the maximum amount of bytes that the element will keep * @maxbuffering: the maximum amount of bytes that the element will keep
* around internally * around internally
* @latency: latency on this port in nanoseconds * @latency: latency on this port in nanoseconds
* @extra: a dictionary of extra port info * @extra: a dictionary of extra port info
*
*/ */
typedef struct { 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; SpaPortInfoFlags flags;
uint32_t rate;
uint32_t n_params; uint32_t n_params;
SpaAllocParam **params; SpaAllocParam **params;
uint64_t maxbuffering; uint64_t maxbuffering;

3
spa/include/spa/type.h
View file

@ -33,6 +33,9 @@ typedef uint32_t SpaType;
#define SPA_TYPE__Enum SPA_TYPE_BASE "Enum" #define SPA_TYPE__Enum SPA_TYPE_BASE "Enum"
#define SPA_TYPE_ENUM_BASE SPA_TYPE__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 SPA_TYPE_BASE "Interface"
#define SPA_TYPE_INTERFACE_BASE SPA_TYPE__Interface ":" #define SPA_TYPE_INTERFACE_BASE SPA_TYPE__Interface ":"

131
spa/lib/debug.c
View file

@ -23,31 +23,6 @@
#include <spa/format-utils.h> #include <spa/format-utils.h>
#include "debug.h" #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 SpaResult
spa_debug_port_info (const SpaPortInfo *info, const SpaTypeMap *map) 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 SpaResult
spa_debug_buffer (const SpaBuffer *buffer) spa_debug_buffer (const SpaBuffer *buffer, const SpaTypeMap *map)
{ {
int i; 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); fprintf (stderr, " n_metas: %u (at %p)\n", buffer->n_metas, buffer->metas);
for (i = 0; i < buffer->n_metas; i++) { for (i = 0; i < buffer->n_metas; i++) {
SpaMeta *m = &buffer->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); const char *type_name;
switch (m->type) {
case SPA_META_TYPE_HEADER: 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,
SpaMetaHeader *h = m->data; type_name, m->data, m->size);
fprintf (stderr, " SpaMetaHeader:\n");
fprintf (stderr, " flags: %08x\n", h->flags); if (!strcmp (type_name, SPA_TYPE_META__Header)) {
fprintf (stderr, " seq: %u\n", h->seq); SpaMetaHeader *h = m->data;
fprintf (stderr, " pts: %"PRIi64"\n", h->pts); fprintf (stderr, " SpaMetaHeader:\n");
fprintf (stderr, " dts_offset: %"PRIi64"\n", h->dts_offset); fprintf (stderr, " flags: %08x\n", h->flags);
break; fprintf (stderr, " seq: %u\n", h->seq);
} fprintf (stderr, " pts: %"PRIi64"\n", h->pts);
case SPA_META_TYPE_POINTER: fprintf (stderr, " dts_offset: %"PRIi64"\n", h->dts_offset);
{ }
SpaMetaPointer *h = m->data; else if (!strcmp (type_name, SPA_TYPE_META__Pointer)) {
fprintf (stderr, " SpaMetaPointer:\n"); SpaMetaPointer *h = m->data;
fprintf (stderr, " ptr_type: %s\n", h->ptr_type); fprintf (stderr, " SpaMetaPointer:\n");
fprintf (stderr, " ptr: %p\n", h->ptr); fprintf (stderr, " type: %s\n", spa_type_map_get_type (map, h->type));
spa_debug_dump_mem (m->data, m->size); fprintf (stderr, " ptr: %p\n", h->ptr);
break; }
} else if (!strcmp (type_name, SPA_TYPE_META__VideoCrop)) {
case SPA_META_TYPE_VIDEO_CROP: SpaMetaVideoCrop *h = m->data;
{ fprintf (stderr, " SpaMetaVideoCrop:\n");
SpaMetaVideoCrop *h = m->data; fprintf (stderr, " x: %d\n", h->x);
fprintf (stderr, " SpaMetaVideoCrop:\n"); fprintf (stderr, " y: %d\n", h->y);
fprintf (stderr, " x: %d\n", h->x); fprintf (stderr, " width: %d\n", h->width);
fprintf (stderr, " y: %d\n", h->y); fprintf (stderr, " height: %d\n", h->height);
fprintf (stderr, " width: %d\n", h->width); }
fprintf (stderr, " height: %d\n", h->height); else if (!strcmp (type_name, SPA_TYPE_META__Ringbuffer)) {
break; SpaMetaRingbuffer *h = m->data;
} fprintf (stderr, " SpaMetaRingbuffer:\n");
case SPA_META_TYPE_RINGBUFFER: fprintf (stderr, " readindex: %d\n", h->ringbuffer.readindex);
{ fprintf (stderr, " writeindex: %d\n", h->ringbuffer.writeindex);
SpaMetaRingbuffer *h = m->data; fprintf (stderr, " size: %d\n", h->ringbuffer.size);
fprintf (stderr, " SpaMetaRingbuffer:\n"); fprintf (stderr, " mask: %d\n", h->ringbuffer.mask);
fprintf (stderr, " readindex: %d\n", h->ringbuffer.readindex); }
fprintf (stderr, " writeindex: %d\n", h->ringbuffer.writeindex); else if (!strcmp (type_name, SPA_TYPE_META__Shared)) {
fprintf (stderr, " size: %d\n", h->ringbuffer.size); SpaMetaShared *h = m->data;
fprintf (stderr, " mask: %d\n", h->ringbuffer.mask); fprintf (stderr, " SpaMetaShared:\n");
break; fprintf (stderr, " flags: %d\n", h->flags);
} fprintf (stderr, " fd: %d\n", h->fd);
case SPA_META_TYPE_SHARED: fprintf (stderr, " offset: %d\n", h->offset);
{ fprintf (stderr, " size: %d\n", h->size);
SpaMetaShared *h = m->data; }
fprintf (stderr, " SpaMetaShared:\n"); else {
fprintf (stderr, " type: %d\n", h->type); fprintf (stderr, " Unknown:\n");
fprintf (stderr, " flags: %d\n", h->flags); spa_debug_dump_mem (m->data, m->size);
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;
} }
} }
fprintf (stderr, " n_datas: \t%u (at %p)\n", buffer->n_datas, buffer->datas); fprintf (stderr, " n_datas: \t%u (at %p)\n", buffer->n_datas, buffer->datas);
for (i = 0; i < buffer->n_datas; i++) { for (i = 0; i < buffer->n_datas; i++) {
SpaData *d = &buffer->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, " flags: %d\n", d->flags);
fprintf (stderr, " data: %p\n", d->data); fprintf (stderr, " data: %p\n", d->data);
fprintf (stderr, " fd: %d\n", d->fd); fprintf (stderr, " fd: %d\n", d->fd);

2
spa/lib/debug.h
View file

@ -34,7 +34,7 @@ extern "C" {
#include <spa/log.h> #include <spa/log.h>
SpaResult spa_debug_port_info (const SpaPortInfo *info, const SpaTypeMap *map); 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_props (const SpaProps *props, const SpaTypeMap *map);
SpaResult spa_debug_pod (const SpaPOD *pod, const SpaTypeMap *map); SpaResult spa_debug_pod (const SpaPOD *pod, const SpaTypeMap *map);
SpaResult spa_debug_format (const SpaFormat *format, const SpaTypeMap *map); SpaResult spa_debug_format (const SpaFormat *format, const SpaTypeMap *map);

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

@ -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); 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, 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->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, 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.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.ringbufferStride, SPA_POD_TYPE_INT, 0),
PROP (&f[1], this->type.alloc_param_meta_enable.ringbufferBlocks, SPA_POD_TYPE_INT, 1), 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++) { for (i = 0; i < n_buffers; i++) {
SpaALSABuffer *b = &this->buffers[i]; SpaALSABuffer *b = &this->buffers[i];
uint32_t type = buffers[i]->datas[0].type;
b->outbuf = buffers[i]; b->outbuf = buffers[i];
b->outstanding = true; b->outstanding = 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);
b->rb = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_RINGBUFFER); b->rb = spa_buffer_find_meta (b->outbuf, this->type.meta.Ringbuffer);
switch (buffers[i]->datas[0].type) { if ((type == this->type.data.MemFd ||
case SPA_DATA_TYPE_MEMFD: type == this->type.data.DmaBuf ||
case SPA_DATA_TYPE_DMABUF: type == this->type.data.MemPtr) &&
case SPA_DATA_TYPE_MEMPTR: buffers[i]->datas[0].data == NULL) {
if (buffers[i]->datas[0].data == NULL) { spa_log_error (this->log, "alsa-source: need mapped memory");
spa_log_error (this->log, "alsa-source: need mapped memory"); return SPA_RESULT_ERROR;
continue;
}
break;
default:
break;
} }
} }
this->n_buffers = n_buffers; this->n_buffers = n_buffers;

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

@ -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); 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, 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->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL; this->info.extra = NULL;
@ -482,22 +483,19 @@ spa_alsa_source_node_port_use_buffers (SpaNode *node,
} }
for (i = 0; i < n_buffers; i++) { for (i = 0; i < n_buffers; i++) {
SpaALSABuffer *b = &this->buffers[i]; SpaALSABuffer *b = &this->buffers[i];
SpaData *d = buffers[i]->datas;
b->outbuf = buffers[i]; b->outbuf = buffers[i];
b->outstanding = false; 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) { if (!((d[0].type == this->type.data.MemFd ||
case SPA_DATA_TYPE_MEMFD: d[0].type == this->type.data.DmaBuf ||
case SPA_DATA_TYPE_DMABUF: d[0].type == this->type.data.MemPtr) &&
case SPA_DATA_TYPE_MEMPTR: d[0].data != NULL)) {
if (buffers[i]->datas[0].data == NULL) { spa_log_error (this->log, "alsa-source: need mapped memory");
spa_log_error (this->log, "alsa-source: need mapped memory"); return SPA_RESULT_ERROR;
continue;
}
break;
default:
break;
} }
spa_list_insert (this->free.prev, &b->link); spa_list_insert (this->free.prev, &b->link);
} }

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

@ -67,6 +67,8 @@ typedef struct {
uint32_t prop_device_name; uint32_t prop_device_name;
uint32_t prop_card_name; uint32_t prop_card_name;
uint32_t prop_min_latency; uint32_t prop_min_latency;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeMediaSubtypeAudio media_subtype_audio; 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_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); 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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_media_subtype_audio_map (map, &type->media_subtype_audio); spa_type_media_subtype_audio_map (map, &type->media_subtype_audio);

23
spa/plugins/audiomixer/audiomixer.c
View file

@ -62,6 +62,8 @@ typedef struct {
SpaTypeFormatAudio format_audio; SpaTypeFormatAudio format_audio;
SpaTypeAudioFormat audio_format; SpaTypeAudioFormat audio_format;
SpaTypeCommandNode command_node; SpaTypeCommandNode command_node;
SpaTypeMeta meta;
SpaTypeData data;
} Type; } Type;
static inline void static inline void
@ -74,6 +76,8 @@ init_type (Type *type, SpaTypeMap *map)
spa_type_format_audio_map (map, &type->format_audio); spa_type_format_audio_map (map, &type->format_audio);
spa_type_audio_format_map (map, &type->audio_format); spa_type_audio_format_map (map, &type->audio_format);
spa_type_command_node_map (map, &type->command_node); 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 { struct _SpaAudioMixer {
@ -477,19 +481,14 @@ spa_audiomixer_node_port_use_buffers (SpaNode *node,
b = &port->buffers[i]; b = &port->buffers[i];
b->outbuf = buffers[i]; b->outbuf = buffers[i];
b->outstanding = direction == SPA_DIRECTION_INPUT ? true : false; 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) { if (!((d[0].type == this->type.data.MemPtr ||
case SPA_DATA_TYPE_MEMPTR: d[0].type == this->type.data.MemFd ||
case SPA_DATA_TYPE_MEMFD: d[0].type == this->type.data.DmaBuf) &&
case SPA_DATA_TYPE_DMABUF: d[0].data != NULL)) {
if (d[0].data == NULL) { spa_log_error (this->log, "volume %p: invalid memory on buffer %p", this, buffers[i]);
spa_log_error (this->log, "volume %p: invalid memory on buffer %p", this, buffers[i]); return SPA_RESULT_ERROR;
continue;
}
break;
default:
break;
} }
if (!b->outstanding) if (!b->outstanding)
spa_list_insert (port->queue.prev, &b->link); spa_list_insert (port->queue.prev, &b->link);

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

@ -48,6 +48,8 @@ typedef struct {
uint32_t prop_volume; uint32_t prop_volume;
uint32_t wave_sine; uint32_t wave_sine;
uint32_t wave_square; uint32_t wave_square;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeFormatAudio format_audio; 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->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_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"); 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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_audio_map (map, &type->format_audio); 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); 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, 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->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL; this->info.extra = NULL;
@ -725,20 +730,14 @@ spa_audiotestsrc_node_port_use_buffers (SpaNode *node,
b = &this->buffers[i]; b = &this->buffers[i];
b->outbuf = buffers[i]; b->outbuf = buffers[i];
b->outstanding = false; 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);
b->rb = spa_buffer_find_meta (buffers[i], SPA_META_TYPE_RINGBUFFER); b->rb = spa_buffer_find_meta (buffers[i], this->type.meta.Ringbuffer);
switch (d[0].type) { if ((d[0].type == this->type.data.MemPtr ||
case SPA_DATA_TYPE_MEMPTR: d[0].type == this->type.data.MemFd ||
case SPA_DATA_TYPE_MEMFD: d[0].type == this->type.data.DmaBuf) &&
case SPA_DATA_TYPE_DMABUF: d[0].data == NULL) {
if (d[0].data == NULL) { spa_log_error (this->log, "audiotestsrc %p: invalid memory on buffer %p", this, buffers[i]);
spa_log_error (this->log, "audiotestsrc %p: invalid memory on buffer %p", this, buffers[i]);
continue;
}
break;
default:
break;
} }
spa_list_insert (this->empty.prev, &b->link); spa_list_insert (this->empty.prev, &b->link);
} }

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

@ -80,6 +80,8 @@ typedef struct {
SpaTypeCommandNode command_node; SpaTypeCommandNode command_node;
SpaTypeAllocParamBuffers alloc_param_buffers; SpaTypeAllocParamBuffers alloc_param_buffers;
SpaTypeAllocParamMetaEnable alloc_param_meta_enable; SpaTypeAllocParamMetaEnable alloc_param_meta_enable;
SpaTypeMeta meta;
SpaTypeData data;
} Type; } Type;
static inline void static inline void
@ -101,6 +103,8 @@ init_type (Type *type, SpaTypeMap *map)
spa_type_command_node_map (map, &type->command_node); spa_type_command_node_map (map, &type->command_node);
spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers); 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_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 { typedef struct {

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

@ -121,7 +121,7 @@ spa_v4l2_clear_buffers (SpaV4l2Source *this)
munmap (b->outbuf->datas[0].data, b->outbuf->datas[0].maxsize); munmap (b->outbuf->datas[0].data, b->outbuf->datas[0].maxsize);
if (b->outbuf->datas[0].fd != -1) if (b->outbuf->datas[0].fd != -1)
close (b->outbuf->datas[0].fd); 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); 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, 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->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
state->info.extra = NULL; state->info.extra = NULL;
@ -959,9 +960,9 @@ mmap_read (SpaV4l2Source *this)
b = &state->buffers[buf.index]; b = &state->buffers[buf.index];
if (b->h) { if (b->h) {
b->h->flags = SPA_BUFFER_FLAG_NONE; b->h->flags = 0;
if (buf.flags & V4L2_BUF_FLAG_ERROR) 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->seq = buf.sequence;
b->h->pts = pts; b->h->pts = pts;
} }
@ -1007,17 +1008,19 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
SpaData *d; SpaData *d;
if (n_buffers > 0) { if (n_buffers > 0) {
switch (buffers[0]->datas[0].type) { SpaData *d = buffers[0]->datas;
case SPA_DATA_TYPE_MEMPTR:
case SPA_DATA_TYPE_MEMFD: if ((d[0].type == this->type.data.MemPtr ||
state->memtype = V4L2_MEMORY_USERPTR; d[0].type == this->type.data.MemFd) &&
break; d[0].data != NULL) {
case SPA_DATA_TYPE_DMABUF: state->memtype = V4L2_MEMORY_USERPTR;
state->memtype = V4L2_MEMORY_DMABUF; }
break; else if (d[0].type == this->type.data.DmaBuf) {
default: state->memtype = V4L2_MEMORY_DMABUF;
spa_log_error (state->log, "v4l2: can't use buffers"); }
return SPA_RESULT_ERROR; 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->outbuf = buffers[i];
b->outstanding = true; b->outstanding = true;
b->allocated = false; 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]); 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.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
b->v4l2_buffer.memory = state->memtype; b->v4l2_buffer.memory = state->memtype;
b->v4l2_buffer.index = i; b->v4l2_buffer.index = i;
switch (d[0].type) {
case SPA_DATA_TYPE_MEMPTR: if (d[0].type == this->type.data.MemPtr ||
case SPA_DATA_TYPE_MEMFD: d[0].type == this->type.data.MemFd) {
if (d[0].data == NULL) { b->v4l2_buffer.m.userptr = (unsigned long) d[0].data;
spa_log_error (state->log, "v4l2: need mmaped memory"); b->v4l2_buffer.length = d[0].maxsize;
continue; }
} else if (d[0].type == this->type.data.DmaBuf) {
b->v4l2_buffer.m.userptr = (unsigned long) d[0].data; b->v4l2_buffer.m.fd = d[0].fd;
b->v4l2_buffer.length = d[0].maxsize;
break;
case SPA_DATA_TYPE_DMABUF:
b->v4l2_buffer.m.fd = d[0].fd;
break;
default:
break;
} }
spa_v4l2_buffer_recycle (this, buffers[i]->id); spa_v4l2_buffer_recycle (this, buffers[i]->id);
} }
@ -1126,7 +1122,7 @@ mmap_init (SpaV4l2Source *this,
b->outbuf = buffers[i]; b->outbuf = buffers[i];
b->outstanding = true; b->outstanding = true;
b->allocated = 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); CLEAR (b->v4l2_buffer);
b->v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; b->v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
@ -1156,11 +1152,11 @@ mmap_init (SpaV4l2Source *this,
perror("VIDIOC_EXPBUF"); perror("VIDIOC_EXPBUF");
continue; continue;
} }
d[0].type = SPA_DATA_TYPE_DMABUF; d[0].type = this->type.data.DmaBuf;
d[0].fd = expbuf.fd; d[0].fd = expbuf.fd;
d[0].data = NULL; d[0].data = NULL;
} else { } else {
d[0].type = SPA_DATA_TYPE_MEMPTR; d[0].type = this->type.data.MemPtr;
d[0].fd = -1; d[0].fd = -1;
d[0].data = mmap (NULL, d[0].data = mmap (NULL,
b->v4l2_buffer.length, b->v4l2_buffer.length,

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

@ -46,6 +46,8 @@ typedef struct {
uint32_t prop_pattern; uint32_t prop_pattern;
uint32_t pattern_smpte_snow; uint32_t pattern_smpte_snow;
uint32_t pattern_snow; uint32_t pattern_snow;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeFormatVideo format_video; 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->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_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"); 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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_video_map (map, &type->format_video); 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); 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, 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->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL; this->info.extra = NULL;
@ -687,19 +692,13 @@ spa_videotestsrc_node_port_use_buffers (SpaNode *node,
b = &this->buffers[i]; b = &this->buffers[i];
b->outbuf = buffers[i]; b->outbuf = buffers[i];
b->outstanding = false; 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) { if ((d[0].type == this->type.data.MemPtr ||
case SPA_DATA_TYPE_MEMPTR: d[0].type == this->type.data.MemFd ||
case SPA_DATA_TYPE_MEMFD: d[0].type == this->type.data.DmaBuf) &&
case SPA_DATA_TYPE_DMABUF: d[0].data == NULL) {
if (d[0].data == NULL) { spa_log_error (this->log, "videotestsrc %p: invalid memory on buffer %p", this, buffers[i]);
spa_log_error (this->log, "videotestsrc %p: invalid memory on buffer %p", this, buffers[i]);
continue;
}
break;
default:
break;
} }
spa_list_insert (this->empty.prev, &b->link); spa_list_insert (this->empty.prev, &b->link);
} }

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

@ -66,6 +66,8 @@ typedef struct {
uint32_t props; uint32_t props;
uint32_t prop_volume; uint32_t prop_volume;
uint32_t prop_mute; uint32_t prop_mute;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeFormatAudio format_audio; 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->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_volume = spa_type_map_get_id (map, SPA_TYPE_PROPS__volume);
type->prop_mute = spa_type_map_get_id (map, SPA_TYPE_PROPS__mute); 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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_audio_map (map, &type->format_audio); 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); 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, 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->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
port->info.extra = NULL; port->info.extra = NULL;
@ -508,21 +513,18 @@ spa_volume_node_port_use_buffers (SpaNode *node,
b = &port->buffers[i]; b = &port->buffers[i];
b->outbuf = buffers[i]; b->outbuf = buffers[i];
b->outstanding = true; 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) { if ((d[0].type == this->type.data.MemPtr ||
case SPA_DATA_TYPE_MEMPTR: d[0].type == this->type.data.MemFd ||
case SPA_DATA_TYPE_MEMFD: d[0].type == this->type.data.DmaBuf) &&
case SPA_DATA_TYPE_DMABUF: d[0].data != NULL) {
if (d[0].data == NULL) { b->ptr = d[0].data;
spa_log_error (this->log, "volume %p: invalid memory on buffer %p", this, buffers[i]); b->size = d[0].maxsize;
continue; }
} else {
b->ptr = d[0].data; spa_log_error (this->log, "volume %p: invalid memory on buffer %p", this, buffers[i]);
b->size = d[0].maxsize; return SPA_RESULT_ERROR;
break;
default:
break;
} }
spa_list_insert (port->empty.prev, &b->link); spa_list_insert (port->empty.prev, &b->link);
} }

8
spa/tests/test-mixer.c
View file

@ -46,6 +46,8 @@ typedef struct {
uint32_t props_volume; uint32_t props_volume;
uint32_t props_min_latency; uint32_t props_min_latency;
uint32_t props_live; uint32_t props_live;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeFormatAudio format_audio; 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_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_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); 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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_audio_map (map, &type->format_audio); 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.seq = 0;
b->header.pts = 0; b->header.pts = 0;
b->header.dts_offset = 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].data = &b->header;
b->metas[0].size = sizeof (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].flags = 0;
b->datas[0].fd = -1; b->datas[0].fd = -1;
b->datas[0].mapoffset = 0; b->datas[0].mapoffset = 0;

10
spa/tests/test-ringbuffer.c
View file

@ -46,6 +46,8 @@ typedef struct {
uint32_t props_volume; uint32_t props_volume;
uint32_t props_min_latency; uint32_t props_min_latency;
uint32_t props_live; uint32_t props_live;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeFormatAudio format_audio; 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_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_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); 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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_audio_map (map, &type->format_audio); 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.seq = 0;
b->header.pts = 0; b->header.pts = 0;
b->header.dts_offset = 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].data = &b->header;
b->metas[0].size = sizeof (b->header); b->metas[0].size = sizeof (b->header);
spa_ringbuffer_init (&b->rb.ringbuffer, size); 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].data = &b->rb;
b->metas[1].size = sizeof (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].flags = 0;
b->datas[0].fd = -1; b->datas[0].fd = -1;
b->datas[0].mapoffset = 0; b->datas[0].mapoffset = 0;

20
spa/tests/test-v4l2.c
View file

@ -43,6 +43,9 @@ typedef struct {
uint32_t props; uint32_t props;
uint32_t format; uint32_t format;
uint32_t props_device; uint32_t props_device;
uint32_t SDL_Texture;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type; SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype; SpaTypeMediaSubtype media_subtype;
SpaTypeFormatVideo format_video; 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->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format); 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->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_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype); spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_video_map (map, &type->format_video); 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; metas = b->metas;
datas = b->datas; datas = b->datas;
if (metas[1].type == SPA_META_TYPE_POINTER && if (metas[1].type == data->type.meta.Pointer &&
strcmp (((SpaMetaPointer *)metas[1].data)->ptr_type, "SDL_Texture") == 0) { ((SpaMetaPointer *)metas[1].data)->type == data->type.SDL_Texture) {
SDL_Texture *texture; SDL_Texture *texture;
texture = ((SpaMetaPointer *)metas[1].data)->ptr; 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()); fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return; return;
} }
datas[0].type = SPA_DATA_TYPE_MEMPTR; datas[0].type = data->type.data.MemPtr;
datas[0].flags = 0; datas[0].flags = 0;
datas[0].fd = -1; datas[0].fd = -1;
datas[0].mapoffset = 0; datas[0].mapoffset = 0;
@ -328,17 +334,17 @@ alloc_buffers (AppData *data)
b->header.seq = 0; b->header.seq = 0;
b->header.pts = 0; b->header.pts = 0;
b->header.dts_offset = 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].data = &b->header;
b->metas[0].size = sizeof (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->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].data = &b->ptr;
b->metas[1].size = sizeof (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].flags = 0;
b->datas[0].fd = -1; b->datas[0].fd = -1;
b->datas[0].mapoffset = 0; b->datas[0].mapoffset = 0;