mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

mem: remove memory stuff

Browse source 
Remove the memory stuff from the spa API, we can do thing more simple
and efficiently if we always allocate buffers outside of the plugins and
only implement an alloc function on the node when it can do something
clever.
Move serialize code to the props/format/buffer code
Make it possible to copy a format and properties.
This commit is contained in:
Wim Taymans 2016-09-29 18:18:59 +02:00
parent fe37e2bc1b
commit 24108e01c1
46 changed files with 901 additions and 1546 deletions
Download patch file Download diff file Expand all files Collapse all files

18
pinos/client/format.c
View file

@ -23,27 +23,21 @@
static SpaFormat *
format_copy (SpaFormat *format)
{
SpaMemory *mem;
SpaFormat *f;
void *p;
size_t size;
if (format == NULL)
return NULL;
mem = spa_memory_alloc_size (format->mem.mem.pool_id, format, format->mem.size);
f = spa_memory_ensure_ptr (mem);
f->mem.mem = mem->mem;
f->mem.offset = 0;
f->mem.size = format->mem.size;
return spa_memory_ensure_ptr (mem);
size = spa_format_get_size (format);
p = malloc (size);
return spa_format_copy_into (p, format);
}
static void
format_free (SpaFormat *format)
{
g_return_if_fail (format != NULL);
spa_memory_unref (&format->mem.mem);
g_free (format);
}
G_DEFINE_BOXED_TYPE (SpaFormat, spa_format,

2
pinos/client/pinos.c
View file

@ -20,7 +20,6 @@
#include <glib.h>
#include "pinos/client/pinos.h"
#include "spa/include/spa/memory.h"
const gchar g_log_domain_pinos[] = "Pinos";
@ -45,7 +44,6 @@ pinos_error_quark (void)
void
pinos_init (int *argc, char **argv[])
{
spa_memory_init ();
}
/**

108
pinos/client/stream.c
View file

@ -20,10 +20,10 @@
#include <sys/socket.h>
#include <string.h>
#include <sys/mman.h>
#include <errno.h>
#include "spa/include/spa/control.h"
#include "spa/include/spa/debug.h"
#include "spa/include/spa/memory.h"
#include <gio/gio.h>
#include <gio/gunixfdlist.h>
@ -43,7 +43,15 @@
#define MAX_OUTPUTS 64
typedef struct {
uint32_t id;
int fd;
uint32_t flags;
void *ptr;
size_t size;
bool cleanup;
} MemId;
typedef struct {
uint32_t id;
bool used;
SpaBuffer *buf;
@ -90,6 +98,7 @@ struct _PinosStreamPrivate
guint8 send_data[MAX_BUFFER_SIZE];
int send_fds[MAX_FDS];
GArray *mem_ids;
GArray *buffer_ids;
gboolean in_order;
@ -134,7 +143,6 @@ clear_buffers (PinosStream *stream)
BufferId *bid = &g_array_index (priv->buffer_ids, BufferId, i);
g_signal_emit (stream, signals[SIGNAL_REMOVE_BUFFER], 0, bid->id);
spa_memory_unref (&bid->buf->mem.mem);
bid->buf = NULL;
}
g_array_set_size (priv->buffer_ids, 0);
@ -207,7 +215,7 @@ pinos_stream_set_property (GObject *_object,
case PROP_FORMAT:
if (priv->format)
spa_format_unref (priv->format);
g_boxed_free (SPA_TYPE_FORMAT, priv->format);
priv->format = g_value_dup_boxed (value);
break;
@ -338,7 +346,7 @@ pinos_stream_finalize (GObject * object)
if (priv->possible_formats)
g_ptr_array_unref (priv->possible_formats);
if (priv->format)
spa_format_unref (priv->format);
g_boxed_free (SPA_TYPE_FORMAT, priv->format);
g_free (priv->path);
g_clear_error (&priv->error);
@ -507,6 +515,7 @@ pinos_stream_init (PinosStream * stream)
priv->state = PINOS_STREAM_STATE_UNCONNECTED;
priv->node_state = SPA_NODE_STATE_INIT;
priv->mem_ids = g_array_sized_new (FALSE, FALSE, sizeof (MemId), 64);
priv->buffer_ids = g_array_sized_new (FALSE, FALSE, sizeof (BufferId), 64);
priv->pending_seq = SPA_ID_INVALID;
}
@ -809,6 +818,20 @@ do_node_init (PinosStream *stream)
spa_control_clear (&control);
}
static MemId *
find_mem (PinosStream *stream, uint32_t id)
{
PinosStreamPrivate *priv = stream->priv;
guint i;
for (i = 0; i < priv->mem_ids->len; i++) {
MemId *mid = &g_array_index (priv->mem_ids, MemId, i);
if (mid->id == id)
return mid;
}
return NULL;
}
static BufferId *
find_buffer (PinosStream *stream, uint32_t id)
{
@ -987,24 +1010,15 @@ parse_control (PinosStream *stream,
case SPA_CONTROL_CMD_SET_FORMAT:
{
SpaControlCmdSetFormat p;
SpaMemory *mem;
void *data;
size_t size;
gpointer mem;
data = spa_control_iter_get_data (&it, &size);
mem = spa_memory_alloc_size (SPA_MEMORY_POOL_LOCAL, data, size);
spa_control_iter_set_data (&it, spa_memory_ensure_ptr (mem), size);
if (spa_control_iter_parse_cmd (&it, &p) < 0) {
spa_memory_unref (&mem->mem);
if (spa_control_iter_parse_cmd (&it, &p) < 0)
break;
}
if (priv->format)
spa_format_unref (priv->format);
if (p.format)
p.format->mem.mem = mem->mem;
priv->format = p.format;
g_free (priv->format);
mem = malloc (spa_format_get_size (p.format));
priv->format = spa_format_copy_into (mem, p.format);
spa_debug_format (p.format);
priv->pending_seq = p.seq;
@ -1018,8 +1032,8 @@ parse_control (PinosStream *stream,
case SPA_CONTROL_CMD_ADD_MEM:
{
SpaControlCmdAddMem p;
SpaMemory *mem;
int fd;
MemId mid;
if (spa_control_iter_parse_cmd (&it, &p) < 0)
break;
@ -1028,32 +1042,34 @@ parse_control (PinosStream *stream,
if (fd == -1)
break;
mem = spa_memory_import (&p.mem);
if (mem->fd == -1) {
g_debug ("add mem %u:%u, fd %d, flags %d", p.mem.pool_id, p.mem.id, fd, p.flags);
mem->flags = p.flags;
mem->fd = fd;
mem->ptr = NULL;
mem->size = p.size;
}
mid.id = p.mem_id;
mid.fd = fd;
mid.flags = p.flags;
mid.ptr = NULL;
mid.size = p.size;
g_debug ("add mem %u, fd %d, flags %d", p.mem_id, fd, p.flags);
g_array_append_val (priv->mem_ids, mid);
break;
}
case SPA_CONTROL_CMD_REMOVE_MEM:
{
SpaControlCmdRemoveMem p;
MemId *mid;
if (spa_control_iter_parse_cmd (&it, &p) < 0)
break;
g_debug ("stream %p: remove mem", stream);
spa_memory_unref (&p.mem);
g_debug ("stream %p: remove mem %d", stream, p.mem_id);
if ((mid = find_mem (stream, p.mem_id)))
mid->cleanup = true;
break;
}
case SPA_CONTROL_CMD_USE_BUFFERS:
{
SpaControlCmdUseBuffers p;
BufferId bid;
unsigned int i;
unsigned int i, j;
SpaControlBuilder builder;
SpaControl control;
@ -1064,12 +1080,34 @@ parse_control (PinosStream *stream,
clear_buffers (stream);
for (i = 0; i < p.n_buffers; i++) {
bid.buf = p.buffers[i];
bid.cleanup = false;
MemId *mid = find_mem (stream, p.buffers[i].mem_id);
if (mid == NULL) {
g_warning ("unknown memory id %u", mid->id);
continue;
}
if (mid->ptr == NULL) {
mid->ptr = mmap (NULL, mid->size, PROT_READ | PROT_WRITE, MAP_SHARED, mid->fd, 0);
if (mid->ptr == MAP_FAILED) {
mid->ptr = NULL;
g_warning ("Failed to mmap memory %zd %p: %s", mid->size, mid, strerror (errno));
continue;
}
}
bid.buf = spa_buffer_deserialize (mid->ptr, p.buffers[i].offset);
bid.id = bid.buf->id;
g_debug ("add buffer %d: %u:%u, %zd-%zd", bid.id,
bid.buf->mem.mem.pool_id, bid.buf->mem.mem.id,
bid.buf->mem.offset, bid.buf->mem.size);
spa_debug_dump_mem (mid->ptr, 256);
g_debug ("add buffer %d %zd", bid.id, p.buffers[i].offset);
for (j = 0; j < bid.buf->n_datas; j++) {
SpaData *d = &bid.buf->datas[j];
MemId *bmid = find_mem (stream, SPA_PTR_TO_UINT32 (d->data));
d->data = SPA_INT_TO_PTR (bmid->fd);
g_debug (" data %d %u -> %d", j, bmid->id, bmid->fd);
}
if (bid.id != priv->buffer_ids->len) {
g_warning ("unexpected id %u found, expected %u", bid.id, priv->buffer_ids->len);

2
pinos/daemon/main.c
View file

@ -23,7 +23,6 @@
#include <pinos/client/pinos.h>
#include <pinos/server/daemon.h>
#include <pinos/server/module.h>
#include <spa/include/spa/memory.h>
#include "daemon-config.h"
@ -37,7 +36,6 @@ main (gint argc, gchar *argv[])
GError *err = NULL;
pinos_init (&argc, &argv);
spa_memory_init ();
loop = g_main_loop_new (NULL, FALSE);

12
pinos/gst/gstpinosformat.c
View file

@ -288,7 +288,6 @@ convert_1 (GstCapsFeatures *cf, GstStructure *cs)
{
const GValue *val;
guint size, n_infos = 0, n_ranges = 0, n_datas = 0;
SpaMemory *mem;
ConvertData d;
d.cf = cf;
@ -301,12 +300,7 @@ convert_1 (GstCapsFeatures *cf, GstStructure *cs)
size += n_ranges * sizeof (SpaPropRangeInfo);
size += n_datas;
mem = spa_memory_alloc_size (SPA_MEMORY_POOL_LOCAL, NULL, size);
d.f = spa_memory_ensure_ptr (mem);
d.f->mem.mem = mem->mem;
d.f->mem.offset = 0;
d.f->mem.size = mem->size;
d.f = malloc (size);
d.bpi = SPA_MEMBER (d.f, sizeof (SpaFormat), SpaPropInfo);
d.bri = SPA_MEMBER (d.bpi, n_infos * sizeof (SpaPropInfo), SpaPropRangeInfo);
d.p = SPA_MEMBER (d.bri, n_ranges * sizeof (SpaPropRangeInfo), void);
@ -474,9 +468,7 @@ gst_caps_to_format_all (GstCaps *caps)
{
GPtrArray *res;
res = g_ptr_array_new_full (gst_caps_get_size (caps),
(GDestroyNotify)spa_format_unref);
res = g_ptr_array_new_full (gst_caps_get_size (caps), (GDestroyNotify)g_free);
gst_caps_foreach (caps, (GstCapsForeachFunc) foreach_func, res);
return res;

22
pinos/gst/gstpinossink.c
View file

@ -371,33 +371,31 @@ on_add_buffer (GObject *gobject,
data.header = NULL;
for (i = 0; i < b->n_metas; i++) {
SpaMeta *m = &SPA_BUFFER_METAS(b)[i];
SpaMeta *m = &b->metas[i];
switch (m->type) {
case SPA_META_TYPE_HEADER:
data.header = SPA_MEMBER (b, m->offset, SpaMetaHeader);
data.header = m->data;
break;
default:
break;
}
}
for (i = 0; i < b->n_datas; i++) {
SpaData *d = &SPA_BUFFER_DATAS (b)[i];
SpaMemory *mem;
SpaData *d = &b->datas[i];
mem = spa_memory_find (&d->mem.mem);
if (mem->fd) {
if (d->type == SPA_DATA_TYPE_FD) {
GstMemory *fdmem = NULL;
gint fd = *(int*)d->data;
fdmem = gst_fd_allocator_alloc (pinossink->allocator, dup (mem->fd),
d->mem.offset + d->mem.size, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (fdmem, d->mem.offset, d->mem.size);
fdmem = gst_fd_allocator_alloc (pinossink->allocator, dup (fd),
d->offset + d->size, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (fdmem, d->offset, d->size);
gst_buffer_append_memory (buf, fdmem);
} else {
gst_buffer_append_memory (buf,
gst_memory_new_wrapped (0, mem->ptr, mem->size, d->mem.offset,
d->mem.size, NULL, NULL));
gst_memory_new_wrapped (0, d->data, d->offset + d->size, d->offset,
d->size, NULL, NULL));
}
}
data.flags = GST_BUFFER_FLAGS (buf);

30
pinos/gst/gstpinossrc.c
View file

@ -45,7 +45,6 @@
#include <gst/allocators/gstfdmemory.h>
#include <gst/video/video.h>
#include <spa/include/spa/memory.h>
#include <spa/include/spa/buffer.h>
#include "gstpinosclock.h"
@ -387,34 +386,29 @@ on_add_buffer (GObject *gobject,
data.header = NULL;
for (i = 0; i < b->n_metas; i++) {
SpaMeta *m = &SPA_BUFFER_METAS(b)[i];
SpaMeta *m = &b->metas[i];
switch (m->type) {
case SPA_META_TYPE_HEADER:
data.header = SPA_MEMBER (b, m->offset, SpaMetaHeader);
data.header = m->data;
break;
default:
break;
}
}
for (i = 0; i < b->n_datas; i++) {
SpaData *d = &SPA_BUFFER_DATAS(b)[i];
SpaMemory *mem;
SpaData *d = &b->datas[i];
GstMemory *gmem;
mem = spa_memory_find (&d->mem.mem);
if (mem == NULL) {
g_warning ("failed to get buffer memory");
continue;
}
if (d->type == SPA_DATA_TYPE_FD) {
gint fd = SPA_PTR_TO_INT (d->data);
if (mem->fd) {
gmem = gst_fd_allocator_alloc (pinossrc->fd_allocator, dup (mem->fd),
mem->size, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (gmem, d->mem.offset, d->mem.size);
gmem = gst_fd_allocator_alloc (pinossrc->fd_allocator, dup (fd),
d->offset + d->size, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (gmem, d->offset, d->size);
} else {
gmem = gst_memory_new_wrapped (0, mem->ptr, mem->size, d->mem.offset,
d->mem.size, NULL, NULL);
gmem = gst_memory_new_wrapped (0, d->data, d->offset + d->size, d->offset,
d->size, NULL, NULL);
}
gst_buffer_append_memory (buf, gmem);
}
@ -472,9 +466,9 @@ on_new_buffer (GObject *gobject,
GST_BUFFER_OFFSET (buf) = h->seq;
}
for (i = 0; i < data->buf->n_datas; i++) {
SpaData *d = &SPA_BUFFER_DATAS(data->buf)[i];
SpaData *d = &data->buf->datas[i];
GstMemory *mem = gst_buffer_get_memory (buf, i);
gst_memory_resize (mem, 0, d->mem.size);
gst_memory_resize (mem, 0, d->size);
}
g_queue_push_tail (&pinossrc->queue, buf);

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

@ -136,7 +136,7 @@ pinos_client_node_get_socket_pair (PinosClientNode *this,
spa_node_get_props (node->node, &props);
value.value = &priv->fd;
value.size = sizeof (int);
spa_props_set_prop (props, spa_props_index_for_name (props, "socket"), &value);
spa_props_set_value (props, spa_props_index_for_name (props, "socket"), &value);
spa_node_set_props (node->node, props);
}
return g_object_ref (priv->sockets[1]);
@ -172,7 +172,7 @@ pinos_client_node_dispose (GObject * object)
spa_node_get_props (node->node, &props);
value.value = &fd;
value.size = sizeof (int);
spa_props_set_prop (props, spa_props_index_for_name (props, "socket"), &value);
spa_props_set_value (props, spa_props_index_for_name (props, "socket"), &value);
spa_node_set_props (node->node, props);
G_OBJECT_CLASS (pinos_client_node_parent_class)->dispose (object);

109
pinos/server/link.c
View file

@ -350,8 +350,6 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
const SpaPortInfo *iinfo, *oinfo;
SpaPortInfoFlags in_flags, out_flags;
GError *error = NULL;
unsigned int max_buffers = MAX_BUFFERS;
SpaAllocParamBuffers *in_alloc, *out_alloc;
if (in_state != SPA_NODE_STATE_READY && out_state != SPA_NODE_STATE_READY)
return SPA_RESULT_OK;
@ -377,14 +375,6 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
in_flags = iinfo->flags;
out_flags = oinfo->flags;
max_buffers = MAX_BUFFERS;
in_alloc = find_param (iinfo, SPA_ALLOC_PARAM_TYPE_BUFFERS);
if (in_alloc)
max_buffers = in_alloc->max_buffers == 0 ? max_buffers : SPA_MIN (in_alloc->max_buffers, max_buffers);
out_alloc = find_param (oinfo, SPA_ALLOC_PARAM_TYPE_BUFFERS);
if (out_alloc)
max_buffers = out_alloc->max_buffers == 0 ? max_buffers : SPA_MIN (out_alloc->max_buffers, max_buffers);
if (out_flags & SPA_PORT_INFO_FLAG_LIVE) {
this->output->node->live = true;
this->input->node->live = true;
@ -401,27 +391,8 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
in_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
} else if ((out_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) &&
(in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS)) {
priv->n_buffers = max_buffers;
out_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
in_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
if ((res = spa_buffer_alloc (oinfo->params, oinfo->n_params,
priv->buffers,
&priv->n_buffers)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error buffer alloc: %d", res);
goto error;
}
priv->allocated = TRUE;
memcpy (this->output->buffers, priv->buffers, priv->n_buffers * sizeof (SpaBuffer*));
memcpy (this->input->buffers, priv->buffers, priv->n_buffers * sizeof (SpaBuffer*));
this->output->n_buffers = priv->n_buffers;
this->input->n_buffers = priv->n_buffers;
this->output->allocated = FALSE;
this->input->allocated = FALSE;
g_debug ("allocated %d buffers %p", priv->n_buffers, priv->buffers);
} else if ((out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) &&
(in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS)) {
out_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
@ -446,38 +417,68 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
spa_debug_port_info (oinfo);
spa_debug_port_info (iinfo);
if (in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS && this->input->n_buffers == 0) {
this->input->n_buffers = max_buffers;
if ((res = spa_node_port_alloc_buffers (this->input->node->node, this->input->port,
oinfo->params, oinfo->n_params,
this->input->buffers, &this->input->n_buffers)) < 0) {
if (!priv->allocated) {
SpaAllocParamBuffers *in_alloc, *out_alloc;
guint max_buffers = MAX_BUFFERS;
SpaBufferAllocFlags flags = 0;
max_buffers = MAX_BUFFERS;
in_alloc = find_param (iinfo, SPA_ALLOC_PARAM_TYPE_BUFFERS);
if (in_alloc)
max_buffers = in_alloc->max_buffers == 0 ? max_buffers : SPA_MIN (in_alloc->max_buffers, max_buffers);
out_alloc = find_param (oinfo, SPA_ALLOC_PARAM_TYPE_BUFFERS);
if (out_alloc)
max_buffers = out_alloc->max_buffers == 0 ? max_buffers : SPA_MIN (out_alloc->max_buffers, max_buffers);
if ((in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) ||
(out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS))
flags |= SPA_BUFFER_ALLOC_FLAG_NO_MEM;
priv->n_buffers = max_buffers;
if ((res = spa_buffer_alloc (flags,
oinfo->params, oinfo->n_params,
priv->buffers,
&priv->n_buffers)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error alloc input buffers: %d", res);
"error buffer alloc: %d", res);
goto error;
}
this->input->allocated = TRUE;
g_debug ("allocated %d buffers %p from input port", this->input->n_buffers, this->input->buffers);
}
else if (out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS && this->output->n_buffers == 0) {
this->output->n_buffers = max_buffers;
if ((res = spa_node_port_alloc_buffers (this->output->node->node, this->output->port,
iinfo->params, iinfo->n_params,
this->output->buffers, &this->output->n_buffers)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error alloc output buffers: %d", res);
goto error;
g_debug ("allocated %d buffers %p", priv->n_buffers, priv->buffers);
priv->allocated = TRUE;
if (in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) {
if ((res = spa_node_port_alloc_buffers (this->input->node->node, this->input->port,
oinfo->params, oinfo->n_params,
priv->buffers, &priv->n_buffers)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error alloc input buffers: %d", res);
goto error;
}
this->input->allocated = TRUE;
g_debug ("allocated %d buffers %p from input port", priv->n_buffers, priv->buffers);
}
else if (out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) {
if ((res = spa_node_port_alloc_buffers (this->output->node->node, this->output->port,
iinfo->params, iinfo->n_params,
priv->buffers, &priv->n_buffers)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error alloc output buffers: %d", res);
goto error;
}
this->output->allocated = TRUE;
g_debug ("allocated %d buffers %p from output port", priv->n_buffers, priv->buffers);
}
this->output->allocated = TRUE;
g_debug ("allocated %d buffers %p from output port", this->output->n_buffers, this->output->buffers);
}
if (in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) {
g_debug ("using output buffers %p on input port", this->output->buffers);
g_debug ("using %d buffers %p on input port", priv->n_buffers, priv->buffers);
if ((res = spa_node_port_use_buffers (this->input->node->node, this->input->port,
this->output->buffers, this->output->n_buffers)) < 0) {
priv->buffers, priv->n_buffers)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
@ -487,9 +488,9 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
this->input->allocated = FALSE;
}
else if (out_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) {
g_debug ("using %d in_buffers %p on output port", this->input->n_buffers, this->input->buffers);
g_debug ("using %d buffers %p on output port", priv->n_buffers, priv->buffers);
if ((res = spa_node_port_use_buffers (this->output->node->node, this->output->port,
this->input->buffers, this->input->n_buffers)) < 0) {
priv->buffers, priv->n_buffers)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,

2
pinos/server/link.h
View file

@ -44,8 +44,6 @@ typedef struct {
PinosNode *node;
uint32_t port;
gboolean allocated;
SpaBuffer *buffers[16];
guint n_buffers;
} PinosPort;
/**

3
pinos/server/node.c
View file

@ -62,7 +62,6 @@ find_node_port (GList *ports, PinosNode *node, uint32_t port)
GList *walk;
for (walk = ports; walk; walk = g_list_next (walk)) {
NodePort *np = walk->data;
g_debug ("%p %d <-> %p %d", np->port.node, np->port.port, node, port);
if (np->port.node == node && np->port.port == port)
return np;
}
@ -285,14 +284,12 @@ suspend_node (PinosNode *this)
if ((res = spa_node_port_set_format (this->node, p->port.port, 0, NULL)) < 0)
g_warning ("error unset format output: %d", res);
p->port.allocated = FALSE;
p->port.n_buffers = 0;
}
for (walk = priv->output_ports; walk; walk = g_list_next (walk)) {
NodePort *p = walk->data;
if ((res = spa_node_port_set_format (this->node, p->port.port, 0, NULL)) < 0)
g_warning ("error unset format output: %d", res);
p->port.allocated = FALSE;
p->port.n_buffers = 0;
}
return res;
}

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

@ -25,7 +25,6 @@ extern "C" {
#endif
typedef struct _SpaBuffer SpaBuffer;
typedef struct _SpaBufferGroup SpaBufferGroup;
/**
* SpaMetaType:
@ -41,7 +40,6 @@ typedef enum {
} SpaMetaType;
#include <spa/defs.h>
#include <spa/memory.h>
#include <spa/port.h>
/**
@ -106,29 +104,48 @@ typedef struct {
/**
* SpaMeta:
* @type: metadata type
* @offset: offset of metadata in the buffer structure
* @data: pointer to metadata
* @size: size of metadata
*/
typedef struct {
SpaMetaType type;
off_t offset;
void *data;
size_t size;
} SpaMeta;
/**
* SpaDataType:
* @SPA_DATA_TYPE_INVALID: invalid data, should be ignored
* @SPA_DATA_TYPE_MEMPTR: data points to CPU accessible memory
* @SPA_DATA_TYPE_FD: data is an int file descriptor, use SPA_PTR_TO_INT
* @SPA_DATA_TYPE_ID: data is an id use SPA_PTR_TO_INT32
*/
typedef enum {
SPA_DATA_TYPE_INVALID = 0,
SPA_DATA_TYPE_MEMPTR,
SPA_DATA_TYPE_FD,
SPA_DATA_TYPE_ID,
} SpaDataType;
/**
* SpaData:
* @mem: reference to the memory to use
* @stride: stride of memory if applicable
* @type: memory type
* @data: pointer to memory
* @offset: offset in @data
* @size: size of @data
* @stride: stride of data if applicable
*/
typedef struct {
SpaMemoryChunk mem;
SpaDataType type;
void *data;
off_t offset;
size_t size;
ssize_t stride;
} SpaData;
/**
* SpaBuffer:
* @id: buffer id
* @mem: reference to the memory for this buffer
* @n_metas: number of metadata
* @metas: offset of array of @n_metas metadata
* @n_datas: number of data pointers
@ -136,23 +153,32 @@ typedef struct {
*/
struct _SpaBuffer {
uint32_t id;
SpaMemoryChunk mem;
unsigned int n_metas;
off_t metas;
SpaMeta *metas;
unsigned int n_datas;
off_t datas;
SpaData *datas;
};
#define SPA_BUFFER_METAS(b) (SPA_MEMBER ((b), (b)->metas, SpaMeta))
#define SPA_BUFFER_DATAS(b) (SPA_MEMBER ((b), (b)->datas, SpaData))
#define spa_buffer_ref(b) spa_memory_ref (&(b)->mem)
#define spa_buffer_unref(b) spa_memory_unref (&(b)->mem)
size_t spa_buffer_get_size (const SpaBuffer *buffer);
size_t spa_buffer_serialize (void *dest, const SpaBuffer *buffer);
SpaBuffer * spa_buffer_deserialize (void *src, off_t offset);
SpaResult spa_buffer_alloc (SpaAllocParam **params,
unsigned int n_params,
SpaBuffer **buffers,
unsigned int *n_buffers);
/**
* SpaBufferAllocFlags:
* @SPA_BUFFER_ALLOC_FLAG_NONE: no flags
* @SPA_BUFFER_ALLOC_FLAG_NO_MEM: don't allocate memory
*/
typedef enum {
SPA_BUFFER_ALLOC_FLAG_NONE = 0,
SPA_BUFFER_ALLOC_FLAG_NO_MEM,
} SpaBufferAllocFlags;
SpaResult spa_buffer_alloc (SpaBufferAllocFlags flags,
SpaAllocParam **params,
unsigned int n_params,
SpaBuffer **buffers,
unsigned int *n_buffers);
#ifdef __cplusplus
} /* extern "C" */

23
spa/include/spa/control.h
View file

@ -35,7 +35,6 @@ typedef struct _SpaControlBuilder SpaControlBuilder;
#include <spa/format.h>
#include <spa/port.h>
#include <spa/node.h>
#include <spa/memory.h>
struct _SpaControl {
size_t x[16];
@ -153,28 +152,32 @@ typedef struct {
/* SPA_CONTROL_CMD_ADD_MEM */
typedef struct {
uint32_t seq;
uint32_t port_id;
SpaMemoryRef mem;
uint32_t mem_type;
uint32_t mem_id;
unsigned int fd_index;
uint32_t flags;
off_t offset;
size_t size;
} SpaControlCmdAddMem;
/* SPA_CONTROL_CMD_REMOVE_MEM */
typedef struct {
uint32_t seq;
uint32_t port_id;
SpaMemoryRef mem;
uint32_t mem_id;
} SpaControlCmdRemoveMem;
typedef struct {
uint32_t mem_id;
off_t offset;
size_t size;
} SpaControlMemRef;
/* SPA_CONTROL_CMD_USE_BUFFERS */
typedef struct {
uint32_t seq;
uint32_t port_id;
unsigned int n_buffers;
SpaBuffer **buffers;
uint32_t seq;
uint32_t port_id;
unsigned int n_buffers;
SpaControlMemRef *buffers;
} SpaControlCmdUseBuffers;
/* SPA_CONTROL_CMD_PROCESS_BUFFER */

31
spa/include/spa/format.h
View file

@ -28,7 +28,6 @@ typedef struct _SpaFormat SpaFormat;
#include <spa/defs.h>
#include <spa/props.h>
#include <spa/memory.h>
typedef enum {
SPA_MEDIA_TYPE_INVALID = 0,
@ -83,38 +82,30 @@ typedef enum {
/**
* SpaFormat:
* @props: properties
* @media_type: media type
* @media_subtype: subtype
* @mem: memory reference
* @offset: offset in memory
* @size: size in memory
* @props: properties
*/
struct _SpaFormat {
SpaProps props;
SpaMediaType media_type;
SpaMediaSubType media_subtype;
SpaMemoryChunk mem;
SpaProps props;
};
static inline void
spa_format_ref (SpaFormat *format)
{
spa_memory_ref (&format->mem.mem);
}
static inline void
spa_format_unref (SpaFormat *format)
{
spa_memory_unref (&format->mem.mem);
}
typedef enum {
SPA_PROP_ID_INVALID = 0,
SPA_PROP_ID_MEDIA_CUSTOM_START = 200,
} SpaFormatProps;
SpaResult spa_format_fixate (SpaFormat *format);
SpaResult spa_format_fixate (SpaFormat *format);
size_t spa_format_get_size (const SpaFormat *format);
size_t spa_format_serialize (void *dest, const SpaFormat *format);
SpaFormat * spa_format_deserialize (void *src, off_t offset);
SpaFormat * spa_format_copy_into (void *dest, const SpaFormat *format);
#ifdef __cplusplus
} /* extern "C" */

123
spa/include/spa/memory.h
View file

@ -1,123 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2016 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_MEMORY_H__
#define __SPA_MEMORY_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _SpaMemory SpaMemory;
typedef struct _SpaMemoryRef SpaMemoryRef;
typedef struct _SpaMemoryChunk SpaMemoryChunk;
typedef struct _SpaMemoryPool SpaMemoryPool;
#include <spa/defs.h>
/**
* SpaMemoryFlags:
* @SPA_MEMORY_FLAG_NONE: no flag
* @SPA_MEMORY_FLAG_READABLE: memory is writable
* @SPA_MEMORY_FLAG_WRITABLE: memory is readable
*/
typedef enum {
SPA_MEMORY_FLAG_NONE = 0,
SPA_MEMORY_FLAG_READABLE = (1 << 0),
SPA_MEMORY_FLAG_WRITABLE = (1 << 1),
} SpaMemoryFlags;
#define SPA_MEMORY_FLAG_READWRITE (SPA_MEMORY_FLAG_READABLE|SPA_MEMORY_FLAG_WRITABLE)
/**
* SpaMemoryRef:
* @pool_id: the pool id
* @id: mem_id
*
* A reference to a block of memory
*/
struct _SpaMemoryRef {
uint32_t pool_id;
uint32_t id;
};
/**
* SpaMemoryChunk:
* @mem: the memory
* @offset: the offset in the memory
* @size: the size in the memory
*
* A reference to a part of memory
*/
struct _SpaMemoryChunk {
SpaMemoryRef mem;
off_t offset;
size_t size;
};
/**
* SpaMemory:
* @refcount: a refcount
* @notify: notify when refcount is 0
* @user_data: owner specific user data
* @pool_id: the id of the pool
* @id: the memory id
* @flags: extra memory flags
* @type: memory type
* @fd: fd of memory of -1 if not known
* @ptr: ptr to memory accessible with CPU
* @size: size of memory
*/
struct _SpaMemory {
int refcount;
SpaNotify notify;
void *user_data;
SpaMemoryRef mem;
SpaMemoryFlags flags;
const char *type;
int fd;
void *ptr;
size_t size;
};
#define SPA_MEMORY_POOL_SHARED 0
#define SPA_MEMORY_POOL_LOCAL 1
void spa_memory_init (void);
uint32_t spa_memory_pool_get (uint32_t type);
uint32_t spa_memory_pool_new (void);
void spa_memory_pool_free (uint32_t);
SpaMemory * spa_memory_alloc (uint32_t pool_id);
SpaMemory * spa_memory_alloc_size (uint32_t pool_id, void *data, size_t size);
SpaMemory * spa_memory_alloc_with_fd (uint32_t pool_id, void *data, size_t size);
SpaResult spa_memory_ref (SpaMemoryRef *ref);
SpaResult spa_memory_unref (SpaMemoryRef *ref);
SpaMemory * spa_memory_import (SpaMemoryRef *ref);
SpaMemory * spa_memory_find (SpaMemoryRef *ref);
void * spa_memory_ensure_ptr (SpaMemory *mem);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_MEMORY_H__ */

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

@ -430,7 +430,7 @@ struct _SpaNode {
* @buffers: an array of buffer pointers
* @n_buffers: number of elements in @buffers
*
* Tell the port to allocate buffers.
* Tell the port to allocate memory for @buffers.
*
* For input ports, the buffers will be dequeued and ready to be filled
* and pushed into the port. A notify should be configured so that you can

19
spa/include/spa/props.h
View file

@ -199,7 +199,7 @@ spa_props_index_for_name (const SpaProps *props, const char *name)
/**
* spa_props_set_prop:
* spa_props_set_value:
* @props: a #SpaProps
* @index: the index of the property in the prop_info array
* @value: the value to set
@ -212,29 +212,36 @@ spa_props_index_for_name (const SpaProps *props, const char *name)
* #SPA_RESULT_INVALID_PROPERTY_INDEX when @index is not valid
* #SPA_RESULT_WRONG_PROPERTY_TYPE when type is not correct
*/
SpaResult spa_props_set_prop (SpaProps *props,
SpaResult spa_props_set_value (SpaProps *props,
unsigned int index,
const SpaPropValue *value);
/**
* spa_props_get_prop:
* spa_props_get_value:
* @props: a #SpaProps
* @index: the property index in the prop_info array
* @value: a location for the type, size and value
*
* Get the type, size and value of the property at @index.
* Get the size and value of the property at @index.
*
* Returns: #SPA_RESULT_OK on success.
* #SPA_RESULT_INVALID_PROPERTY_INDEX when @index is not valid
* #SPA_RESULT_PROPERTY_UNSET when no value has been set yet
*/
SpaResult spa_props_get_prop (const SpaProps *props,
SpaResult spa_props_get_value (const SpaProps *props,
unsigned int index,
SpaPropValue *value);
SpaResult spa_props_copy (const SpaProps *src,
SpaResult spa_props_copy_values (const SpaProps *src,
SpaProps *dest);
size_t spa_props_get_size (const SpaProps *props);
size_t spa_props_serialize (void *dest, const SpaProps *props);
SpaProps * spa_props_deserialize (void *src, off_t offset);
SpaProps * spa_props_copy_into (void *dest, const SpaProps *props);
#ifdef __cplusplus
} /* extern "C" */
#endif

4
spa/lib/audio-raw.c
View file

@ -288,7 +288,7 @@ spa_format_audio_parse (const SpaFormat *format,
props = &format->props;
idx = spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_INFO);
if ((res = spa_props_get_prop (props, idx, &value)) < 0)
if ((res = spa_props_get_value (props, idx, &value)) < 0)
goto fallback;
if (props->prop_info[idx].type != SPA_PROP_TYPE_POINTER)
@ -300,7 +300,7 @@ spa_format_audio_parse (const SpaFormat *format,
return SPA_RESULT_OK;
fallback:
res = spa_props_copy (props, &aformat->format.props);
res = spa_props_copy_values (props, &aformat->format.props);
return res;
}

115
spa/lib/buffer.c
View file

@ -35,16 +35,16 @@ typedef struct {
} Buffer;
SpaResult
spa_buffer_alloc (SpaAllocParam **params,
unsigned int n_params,
SpaBuffer **buffers,
unsigned int *n_buffers)
spa_buffer_alloc (SpaBufferAllocFlags flags,
SpaAllocParam **params,
unsigned int n_params,
SpaBuffer **buffers,
unsigned int *n_buffers)
{
unsigned int i, nbufs;
size_t size = 0, stride = 0;
SpaMemory *bmem, *dmem;
void *mem;
Buffer *bufs;
Buffer *b;
bool add_header = false;
int n_metas = 0;
@ -91,28 +91,26 @@ spa_buffer_alloc (SpaAllocParam **params,
*n_buffers = nbufs;
bmem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED,
NULL, sizeof (Buffer) * nbufs);
dmem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED,
NULL, size * nbufs);
if (flags & SPA_BUFFER_ALLOC_FLAG_NO_MEM)
size = 0;
bufs = spa_memory_ensure_ptr (bmem);
mem = calloc (nbufs, sizeof (Buffer) + size);
bufs = mem;
for (i = 0; i < nbufs; i++) {
int mi = 0;
Buffer *b;
b = &bufs[i];
b->buffer.id = i;
b->buffer.mem.mem = bmem->mem;
b->buffer.mem.offset = sizeof (Buffer) * i;
b->buffer.mem.size = sizeof (Buffer);
buffers[i] = &b->buffer;
b->buffer.n_metas = n_metas;
b->buffer.metas = offsetof (Buffer, metas);
b->buffer.metas = b->metas;
b->buffer.n_datas = 1;
b->buffer.datas = offsetof (Buffer, datas);
b->buffer.datas = b->datas;
if (add_header) {
b->header.flags = 0;
@ -121,15 +119,92 @@ spa_buffer_alloc (SpaAllocParam **params,
b->header.dts_offset = 0;
b->metas[mi].type = SPA_META_TYPE_HEADER;
b->metas[mi].offset = offsetof (Buffer, header);
b->metas[mi].data = &b->header;
b->metas[mi].size = sizeof (b->header);
mi++;
}
b->datas[0].mem.mem = dmem->mem;
b->datas[0].mem.offset = size * i;
b->datas[0].mem.size = size;
if (size == 0) {
b->datas[0].type = SPA_DATA_TYPE_INVALID;
b->datas[0].data = NULL;
} else {
b->datas[0].type = SPA_DATA_TYPE_MEMPTR;
b->datas[0].data = mem + sizeof (Buffer);
}
b->datas[0].offset = size * i;
b->datas[0].size = size;
b->datas[0].stride = stride;
}
return SPA_RESULT_OK;
}
size_t
spa_buffer_get_size (const SpaBuffer *buffer)
{
size_t size;
unsigned int i;
if (buffer == NULL)
return 0;
size = sizeof (SpaBuffer);
for (i = 0; i < buffer->n_metas; i++)
size += buffer->metas[i].size * sizeof (SpaMeta);
for (i = 0; i < buffer->n_datas; i++)
size += sizeof (SpaData);
return size;
}
size_t
spa_buffer_serialize (void *dest, const SpaBuffer *buffer)
{
SpaBuffer *tb;
SpaMeta *mp;
SpaData *dp;
void *p;
unsigned int i;
if (buffer == NULL)
return 0;
tb = dest;
memcpy (tb, buffer, sizeof (SpaBuffer));
mp = SPA_MEMBER (tb, sizeof(SpaBuffer), SpaMeta);
dp = SPA_MEMBER (mp, sizeof(SpaMeta) * tb->n_metas, SpaData);
p = SPA_MEMBER (dp, sizeof(SpaData) * tb->n_datas, void);
tb->metas = SPA_INT_TO_PTR (SPA_PTRDIFF (mp, tb));
tb->datas = SPA_INT_TO_PTR (SPA_PTRDIFF (dp, tb));
for (i = 0; i < tb->n_metas; i++) {
memcpy (&mp[i], &buffer->metas[i], sizeof (SpaMeta));
memcpy (p, mp[i].data, mp[i].size);
mp[i].data = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tb));
p += mp[i].size;
}
for (i = 0; i < tb->n_datas; i++)
memcpy (&dp[i], &buffer->datas[i], sizeof (SpaData));
return SPA_PTRDIFF (p, tb);
}
SpaBuffer *
spa_buffer_deserialize (void *src, off_t offset)
{
SpaBuffer *b;
unsigned int i;
b = SPA_MEMBER (src, offset, SpaBuffer);
if (b->metas)
b->metas = SPA_MEMBER (b, SPA_PTR_TO_INT (b->metas), SpaMeta);
for (i = 0; i < b->n_metas; i++) {
SpaMeta *m = &b->metas[i];
if (m->data)
m->data = SPA_MEMBER (b, SPA_PTR_TO_INT (m->data), void);
}
if (b->datas)
b->datas = SPA_MEMBER (b, SPA_PTR_TO_INT (b->datas), SpaData);
return b;
}

283
spa/lib/control.c
View file

@ -340,65 +340,12 @@ spa_control_iter_get_data (SpaControlIter *iter, size_t *size)
return si->data;
}
static SpaProps *
parse_props (void *p, off_t offset)
{
SpaProps *tp;
unsigned int i, j;
SpaPropInfo *pi;
SpaPropRangeInfo *ri;
tp = SPA_MEMBER (p, offset, SpaProps);
tp->prop_info = SPA_MEMBER (tp, SPA_PTR_TO_INT (tp->prop_info), SpaPropInfo);
/* now fix all the pointers */
for (i = 0; i < tp->n_prop_info; i++) {
pi = (SpaPropInfo *) &tp->prop_info[i];
if (pi->name)
pi->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->name), char);
if (pi->description)
pi->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->description), char);
if (pi->range_values)
pi->range_values = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->range_values), SpaPropRangeInfo);
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *) &pi->range_values[j];
if (ri->name)
ri->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->name), char);
if (ri->description)
ri->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->description), char);
if (ri->val.value)
ri->val.value = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->val.value), void);
}
}
return tp;
}
static SpaFormat *
parse_format (void *p, size_t size, off_t offset)
{
SpaFormat *f;
if (offset == 0)
return NULL;
f = SPA_MEMBER (p, offset, SpaFormat);
f->mem.mem.pool_id = 0;
f->mem.mem.id = 0;
f->mem.offset = offset;
f->mem.size = size - offset;
parse_props (f, offsetof (SpaFormat, props));
return f;
}
static void
iter_parse_node_update (struct stack_iter *si, SpaControlCmdNodeUpdate *nu)
{
memcpy (nu, si->data, sizeof (SpaControlCmdNodeUpdate));
if (nu->props)
nu->props = parse_props (si->data, SPA_PTR_TO_INT (nu->props));
nu->props = spa_props_deserialize (si->data, SPA_PTR_TO_INT (nu->props));
}
static void
@ -415,14 +362,16 @@ iter_parse_port_update (struct stack_iter *si, SpaControlCmdPortUpdate *pu)
pu->possible_formats = SPA_MEMBER (p,
SPA_PTR_TO_INT (pu->possible_formats), SpaFormat *);
for (i = 0; i < pu->n_possible_formats; i++) {
pu->possible_formats[i] = parse_format (p, si->size,
SPA_PTR_TO_INT (pu->possible_formats[i]));
if (pu->possible_formats[i]) {
pu->possible_formats[i] = spa_format_deserialize (p,
SPA_PTR_TO_INT (pu->possible_formats[i]));
}
}
if (pu->format)
pu->format = parse_format (p, si->size, SPA_PTR_TO_INT (pu->format));
pu->format = spa_format_deserialize (p, SPA_PTR_TO_INT (pu->format));
if (pu->props)
pu->props = parse_props (p, SPA_PTR_TO_INT (pu->props));
pu->props = spa_props_deserialize (p, SPA_PTR_TO_INT (pu->props));
if (pu->info) {
SpaPortInfo *pi;
@ -440,28 +389,19 @@ static void
iter_parse_set_format (struct stack_iter *si, SpaControlCmdSetFormat *cmd)
{
memcpy (cmd, si->data, sizeof (SpaControlCmdSetFormat));
cmd->format = parse_format (si->data, si->size, SPA_PTR_TO_INT (cmd->format));
if (cmd->format)
cmd->format = spa_format_deserialize (si->data, SPA_PTR_TO_INT (cmd->format));
}
static void
iter_parse_use_buffers (struct stack_iter *si, SpaControlCmdUseBuffers *cmd)
{
void *p;
int i;
p = si->data;
memcpy (cmd, p, sizeof (SpaControlCmdUseBuffers));
if (cmd->buffers)
cmd->buffers = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->buffers), SpaBuffer *);
for (i = 0; i < cmd->n_buffers; i++) {
SpaMemoryChunk *mc;
SpaMemory *mem;
mc = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->buffers[i]), SpaMemoryChunk);
mem = spa_memory_find (&mc->mem);
cmd->buffers[i] = mem ? SPA_MEMBER (spa_memory_ensure_ptr (mem), mc->offset, SpaBuffer) : NULL;
}
cmd->buffers = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->buffers), SpaControlMemRef);
}
static void
@ -819,161 +759,6 @@ builder_add_cmd (struct stack_builder *sb, SpaControlCmd cmd, size_t size)
return p;
}
static size_t
calc_props_len (const SpaProps *props)
{
size_t len;
unsigned int i, j;
SpaPropInfo *pi;
SpaPropRangeInfo *ri;
if (props == NULL)
return 0;
/* props and unset mask */
len = sizeof (SpaProps) + sizeof (uint32_t);
for (i = 0; i < props->n_prop_info; i++) {
pi = (SpaPropInfo *) &props->prop_info[i];
len += sizeof (SpaPropInfo);
len += pi->name ? strlen (pi->name) + 1 : 0;
len += pi->description ? strlen (pi->description) + 1 : 0;
/* for the value */
len += pi->maxsize;
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *)&pi->range_values[j];
len += sizeof (SpaPropRangeInfo);
len += ri->name ? strlen (ri->name) + 1 : 0;
len += ri->description ? strlen (ri->description) + 1 : 0;
/* the size of the range value */
len += ri->val.size;
}
}
return len;
}
static size_t
write_props (void *p, const SpaProps *props, off_t offset)
{
size_t len, slen;
unsigned int i, j;
SpaProps *tp;
SpaPropInfo *pi, *bpi;
SpaPropRangeInfo *ri, *bri;
tp = p;
memcpy (tp, props, sizeof (SpaProps));
tp->prop_info = SPA_INT_TO_PTR (offset + sizeof (uint32_t));
/* write propinfo array */
bpi = pi = SPA_MEMBER (tp, SPA_PTR_TO_INT (tp->prop_info), SpaPropInfo);
for (i = 0; i < tp->n_prop_info; i++) {
memcpy (pi, &props->prop_info[i], sizeof (SpaPropInfo));
pi++;
}
bri = ri = (SpaPropRangeInfo *) pi;
pi = bpi;
/* write range info arrays, adjust offset to it */
for (i = 0; i < tp->n_prop_info; i++) {
pi->range_values = SPA_INT_TO_PTR (SPA_PTRDIFF (ri, tp));
for (j = 0; j < pi->n_range_values; j++) {
memcpy (ri, &props->prop_info[i].range_values[j], sizeof (SpaPropRangeInfo));
ri++;
}
pi++;
}
p = ri;
pi = bpi;
ri = bri;
/* strings and default values from props and ranges */
for (i = 0; i < tp->n_prop_info; i++) {
if (pi->name) {
slen = strlen (pi->name) + 1;
memcpy (p, pi->name, slen);
pi->name = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += slen;
} else {
pi->name = 0;
}
if (pi->description) {
slen = strlen (pi->description) + 1;
memcpy (p, pi->description, slen);
pi->description = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += slen;
} else {
pi->description = 0;
}
for (j = 0; j < pi->n_range_values; j++) {
if (ri->name) {
slen = strlen (ri->name) + 1;
memcpy (p, ri->name, slen);
ri->name = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += slen;
} else {
ri->name = 0;
}
if (ri->description) {
slen = strlen (ri->description) + 1;
memcpy (p, ri->description, slen);
ri->description = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += slen;
} else {
ri->description = 0;
}
if (ri->val.size) {
memcpy (p, ri->val.value, ri->val.size);
ri->val.value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += ri->val.size;
} else {
ri->val.value = 0;
}
ri++;
}
pi++;
}
/* and the actual values */
pi = bpi;
for (i = 0; i < tp->n_prop_info; i++) {
if (pi->offset) {
memcpy (p, SPA_MEMBER (props, pi->offset, void), pi->maxsize);
pi->offset = SPA_PTRDIFF (p, tp);
p += pi->maxsize;
} else {
pi->offset = 0;
}
pi++;
}
len = SPA_PTRDIFF (p, tp);
return len;
}
static size_t
calc_format_len (const SpaFormat *format)
{
if (format == NULL)
return 0;
return calc_props_len (&format->props) - sizeof (SpaProps) + sizeof (SpaFormat);
}
static size_t
write_format (void *p, const SpaFormat *format)
{
SpaFormat *tf;
tf = p;
tf->media_type = format->media_type;
tf->media_subtype = format->media_subtype;
tf->mem.mem.pool_id = 0;
tf->mem.mem.id = 0;
tf->mem.offset = 0;
tf->mem.size = 0;
p = SPA_MEMBER (tf, offsetof (SpaFormat, props), void);
return write_props (p, &format->props, sizeof (SpaFormat));
}
static size_t
write_port_info (void *p, const SpaPortInfo *info)
{
@ -1016,7 +801,7 @@ builder_add_node_update (struct stack_builder *sb, SpaControlCmdNodeUpdate *nu)
/* calc len */
len = sizeof (SpaControlCmdNodeUpdate);
len += calc_props_len (nu->props);
len += spa_props_get_size (nu->props);
p = builder_add_cmd (sb, SPA_CONTROL_CMD_NODE_UPDATE, len);
memcpy (p, nu, sizeof (SpaControlCmdNodeUpdate));
@ -1024,7 +809,7 @@ builder_add_node_update (struct stack_builder *sb, SpaControlCmdNodeUpdate *nu)
p = SPA_MEMBER (d, sizeof (SpaControlCmdNodeUpdate), void);
if (nu->props) {
len = write_props (p, nu->props, sizeof (SpaProps));
len = spa_props_serialize (p, nu->props);
d->props = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
} else {
d->props = 0;
@ -1043,10 +828,11 @@ builder_add_port_update (struct stack_builder *sb, SpaControlCmdPortUpdate *pu)
/* calc len */
len = sizeof (SpaControlCmdPortUpdate);
len += pu->n_possible_formats * sizeof (SpaFormat *);
for (i = 0; i < pu->n_possible_formats; i++)
len += calc_format_len (pu->possible_formats[i]);
len += calc_format_len (pu->format);
len += calc_props_len (pu->props);
for (i = 0; i < pu->n_possible_formats; i++) {
len += spa_format_get_size (pu->possible_formats[i]);
}
len += spa_format_get_size (pu->format);
len += spa_props_get_size (pu->props);
if (pu->info) {
len += sizeof (SpaPortInfo);
len += pu->info->n_params * sizeof (SpaAllocParam *);
@ -1068,19 +854,19 @@ builder_add_port_update (struct stack_builder *sb, SpaControlCmdPortUpdate *pu)
p = SPA_MEMBER (p, sizeof (SpaFormat*) * pu->n_possible_formats, void);
for (i = 0; i < pu->n_possible_formats; i++) {
len = write_format (p, pu->possible_formats[i]);
len = spa_format_serialize (p, pu->possible_formats[i]);
bfa[i] = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
p = SPA_MEMBER (p, len, void);
}
if (pu->format) {
len = write_format (p, pu->format);
len = spa_format_serialize (p, pu->format);
d->format = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
p = SPA_MEMBER (p, len, void);
} else {
d->format = 0;
}
if (pu->props) {
len = write_props (p, pu->props, sizeof (SpaProps));
len = spa_props_serialize (p, pu->props);
d->props = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
p = SPA_MEMBER (p, len, void);
} else {
@ -1103,14 +889,14 @@ builder_add_set_format (struct stack_builder *sb, SpaControlCmdSetFormat *sf)
/* calculate length */
/* port_id + format + mask */
len = sizeof (SpaControlCmdSetFormat) + calc_format_len (sf->format);
len = sizeof (SpaControlCmdSetFormat) + spa_format_get_size (sf->format);
p = builder_add_cmd (sb, SPA_CONTROL_CMD_SET_FORMAT, len);
memcpy (p, sf, sizeof (SpaControlCmdSetFormat));
sf = p;
p = SPA_MEMBER (sf, sizeof (SpaControlCmdSetFormat), void);
if (sf->format) {
len = write_format (p, sf->format);
len = spa_format_serialize (p, sf->format);
sf->format = SPA_INT_TO_PTR (SPA_PTRDIFF (p, sf));
} else
sf->format = 0;
@ -1120,35 +906,26 @@ static void
builder_add_use_buffers (struct stack_builder *sb, SpaControlCmdUseBuffers *ub)
{
size_t len;
void *p;
int i;
SpaMemoryChunk **bmc;
SpaControlCmdUseBuffers *d;
SpaControlMemRef *mr;
/* calculate length */
/* port_id + format + mask */
len = sizeof (SpaControlCmdUseBuffers);
len += ub->n_buffers * sizeof (SpaBuffer *);
len += ub->n_buffers * sizeof (SpaMemoryChunk);
len += ub->n_buffers * sizeof (SpaControlMemRef);
p = builder_add_cmd (sb, SPA_CONTROL_CMD_USE_BUFFERS, len);
memcpy (p, ub, sizeof (SpaControlCmdUseBuffers));
d = p;
d = builder_add_cmd (sb, SPA_CONTROL_CMD_USE_BUFFERS, len);
memcpy (d, ub, sizeof (SpaControlCmdUseBuffers));
p = SPA_MEMBER (d, sizeof (SpaControlCmdUseBuffers), void);
bmc = p;
mr = SPA_MEMBER (d, sizeof (SpaControlCmdUseBuffers), void);
if (d->n_buffers)
d->buffers = SPA_INT_TO_PTR (SPA_PTRDIFF (bmc, d));
d->buffers = SPA_INT_TO_PTR (SPA_PTRDIFF (mr, d));
else
d->buffers = 0;
p = SPA_MEMBER (p, sizeof (SpaMemoryChunk*) * ub->n_buffers, void);
for (i = 0; i < ub->n_buffers; i++) {
memcpy (p, &ub->buffers[i]->mem, sizeof (SpaMemoryChunk));
bmc[i] = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
p = SPA_MEMBER (p, sizeof (SpaMemoryChunk), void);
}
for (i = 0; i < ub->n_buffers; i++)
memcpy (&mr[i], &ub->buffers[i], sizeof (SpaControlMemRef));
}
static void

48
spa/lib/debug.c
View file

@ -20,7 +20,6 @@
#include <stdio.h>
#include "spa/debug.h"
#include "spa/memory.h"
#include "spa/props.h"
#include "spa/format.h"
@ -92,18 +91,14 @@ spa_debug_buffer (const SpaBuffer *buffer)
fprintf (stderr, "SpaBuffer %p:\n", buffer);
fprintf (stderr, " id: %08X\n", buffer->id);
fprintf (stderr, " pool_id: %08X\n", buffer->mem.mem.pool_id);
fprintf (stderr, " mem_id: %08X\n", buffer->mem.mem.id);
fprintf (stderr, " offset: %zd\n", buffer->mem.offset);
fprintf (stderr, " size: %zd\n", buffer->mem.size);
fprintf (stderr, " n_metas: %u (offset %zd)\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++) {
SpaMeta *m = &SPA_BUFFER_METAS (buffer)[i];
fprintf (stderr, " meta %d: type %d, offset %zd, size %zd:\n", i, m->type, m->offset, m->size);
SpaMeta *m = &buffer->metas[i];
fprintf (stderr, " meta %d: type %d, data %p, size %zd:\n", i, m->type, m->data, m->size);
switch (m->type) {
case SPA_META_TYPE_HEADER:
{
SpaMetaHeader *h = SPA_MEMBER (buffer, m->offset, SpaMetaHeader);
SpaMetaHeader *h = m->data;
fprintf (stderr, " SpaMetaHeader:\n");
fprintf (stderr, " flags: %08x\n", h->flags);
fprintf (stderr, " seq: %u\n", h->seq);
@ -113,37 +108,24 @@ spa_debug_buffer (const SpaBuffer *buffer)
}
case SPA_META_TYPE_POINTER:
fprintf (stderr, " SpaMetaPointer:\n");
spa_debug_dump_mem (SPA_MEMBER (buffer, m->offset, void), m->size);
spa_debug_dump_mem (m->data, m->size);
break;
case SPA_META_TYPE_VIDEO_CROP:
fprintf (stderr, " SpaMetaVideoCrop:\n");
spa_debug_dump_mem (SPA_MEMBER (buffer, m->offset, void), m->size);
spa_debug_dump_mem (m->data, m->size);
break;
default:
spa_debug_dump_mem (SPA_MEMBER (buffer, m->offset, void), m->size);
spa_debug_dump_mem (m->data, m->size);
break;
}
}
fprintf (stderr, " n_datas: \t%u (offset %zd)\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++) {
SpaData *d = &SPA_BUFFER_DATAS (buffer)[i];
SpaMemory *mem;
mem = spa_memory_find (&d->mem.mem);
fprintf (stderr, " data %d: (memory %p)\n", i, mem);
if (mem) {
fprintf (stderr, " pool_id: %u\n", mem->mem.pool_id);
fprintf (stderr, " id: %u\n", mem->mem.id);
fprintf (stderr, " flags: %08x\n", mem->flags);
fprintf (stderr, " type: %s\n", mem->type ? mem->type : "*unknown*");
fprintf (stderr, " fd: %d\n", mem->fd);
fprintf (stderr, " ptr: %p\n", mem->ptr);
fprintf (stderr, " size: %zd\n", mem->size);
} else {
fprintf (stderr, " invalid memory reference\n");
}
fprintf (stderr, " offset: %zd\n", d->mem.offset);
fprintf (stderr, " size: %zd\n", d->mem.size);
SpaData *d = &buffer->datas[i];
fprintf (stderr, " type: %d\n", d->type);
fprintf (stderr, " data: %p\n", d->data);
fprintf (stderr, " offset: %zd\n", d->offset);
fprintf (stderr, " size: %zd\n", d->size);
fprintf (stderr, " stride: %zd\n", d->stride);
}
return SPA_RESULT_OK;
@ -361,7 +343,7 @@ spa_debug_props (const SpaProps *props, bool print_ranges)
fprintf (stderr, "%-23.23s %s. ", "", prop_type_names[info->type].CCName);
res = spa_props_get_prop (props, i, &value);
res = spa_props_get_value (props, i, &value);
fprintf (stderr, "Current: ");
if (res == SPA_RESULT_OK)
@ -453,7 +435,7 @@ spa_debug_format (const SpaFormat *format)
SpaPropValue value;
SpaResult res;
res = spa_props_get_prop (props, i, &value);
res = spa_props_get_value (props, i, &value);
if (info->flags & SPA_PROP_FLAG_INFO)
continue;

58
spa/lib/format.c
View file

@ -23,15 +23,8 @@
#include <string.h>
#include <spa/format.h>
#include <spa/debug.h>
SpaResult
spa_format_to_string (const SpaFormat *format, char **result)
{
if (format == NULL || result == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return SPA_RESULT_OK;
}
SpaResult
spa_format_fixate (SpaFormat *format)
@ -43,3 +36,52 @@ spa_format_fixate (SpaFormat *format)
return SPA_RESULT_OK;
}
size_t
spa_format_get_size (const SpaFormat *format)
{
if (format == NULL)
return 0;
return spa_props_get_size (&format->props) - sizeof (SpaProps) + sizeof (SpaFormat);
}
size_t
spa_format_serialize (void *dest, const SpaFormat *format)
{
SpaFormat *tf;
size_t size;
if (format == NULL)
return 0;
tf = dest;
tf->media_type = format->media_type;
tf->media_subtype = format->media_subtype;
dest = SPA_MEMBER (tf, offsetof (SpaFormat, props), void);
size = spa_props_serialize (dest, &format->props) - sizeof (SpaProps) + sizeof (SpaFormat);
return size;
}
SpaFormat *
spa_format_deserialize (void *src, off_t offset)
{
SpaFormat *f;
f = SPA_MEMBER (src, offset, SpaFormat);
spa_props_deserialize (f, offsetof (SpaFormat, props));
return f;
}
SpaFormat *
spa_format_copy_into (void *dest, const SpaFormat *format)
{
if (format == NULL)
return NULL;
spa_format_serialize (dest, format);
return spa_format_deserialize (dest, 0);
}

341
spa/lib/memory.c
View file

@ -1,341 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2016 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.
*/
#define _GNU_SOURCE
#include <string.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/socket.h>
#include <errno.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include "spa/memory.h"
#include "memfd-wrappers.h"
#undef USE_MEMFD
#if 1
#define SPA_DEBUG_MEMORY(format,args...) fprintf(stderr,format,##args)
#else
#define SPA_DEBUG_MEMORY(format,args...)
#endif
#define MAX_POOLS 16
#define MAX_MEMORIES 1024
struct _SpaMemoryPool {
bool valid;
uint32_t id;
SpaMemory memories[MAX_MEMORIES];
unsigned int n_free;
uint32_t free_mem[MAX_MEMORIES];
};
static SpaMemoryPool pools[MAX_POOLS];
static void
spa_memory_pool_init (SpaMemoryPool *pool, uint32_t id)
{
int i;
memset (pool, 0, sizeof (SpaMemoryPool));
for (i = 0; i < MAX_MEMORIES; i++)
pool->free_mem[i] = MAX_MEMORIES - 1 - i;
pool->n_free = MAX_MEMORIES - 1;
pool->id = id;
pool->valid = true;
}
void
spa_memory_init (void)
{
static bool initialized = false;
if (!initialized) {
spa_memory_pool_init (&pools[0], SPA_MEMORY_POOL_SHARED);
spa_memory_pool_init (&pools[1], SPA_MEMORY_POOL_LOCAL);
initialized = true;
}
}
uint32_t
spa_memory_pool_get (uint32_t type)
{
return pools[type].id;
}
uint32_t
spa_memory_pool_new (void)
{
int i;
for (i = 0; i < MAX_POOLS; i++) {
if (!pools[i].valid) {
spa_memory_pool_init (&pools[i], i);
return i;
}
}
return SPA_ID_INVALID;
}
void
spa_memory_pool_free (uint32_t pool_id)
{
pools[pool_id].valid = false;
}
SpaMemory *
spa_memory_alloc (uint32_t pool_id)
{
SpaMemory *mem;
SpaMemoryPool *pool;
uint32_t id;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
return NULL;
pool = &pools[pool_id];
if (pool->n_free == 0)
return NULL;
id = pool->free_mem[pool->n_free - 1];
pool->n_free--;
mem = &pool->memories[id];
mem->refcount = 1;
mem->notify = NULL;
mem->fd = -1;
mem->ptr = NULL;
mem->mem.pool_id = pool_id;
mem->mem.id = id;
SPA_DEBUG_MEMORY ("mem %p: alloc %u:%u\n", mem, pool_id, id);
return mem;
}
SpaMemory *
spa_memory_alloc_size (uint32_t pool_id, void *data, size_t size)
{
SpaMemory *mem;
if (!(mem = spa_memory_alloc (pool_id)))
return NULL;
mem->flags = SPA_MEMORY_FLAG_READWRITE;
mem->ptr = malloc (size);
mem->size = size;
if (data)
memcpy (mem->ptr, data, size);
return mem;
}
SpaMemory *
spa_memory_alloc_with_fd (uint32_t pool_id, void *data, size_t size)
{
SpaMemory *mem;
if (!(mem = spa_memory_alloc (pool_id)))
return NULL;
#ifdef USE_MEMFD
mem->fd = memfd_create ("spa-memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING);
#else
{
char filename[] = "/dev/shm/spa-tmpfile.XXXXXX";
mem->fd = mkostemp (filename, O_CLOEXEC);
if (mem->fd == -1) {
fprintf (stderr, "Failed to create temporary file: %s\n", strerror (errno));
return NULL;
}
unlink (filename);
}
#endif
if (data) {
if (write (mem->fd, data, size) != (ssize_t) size) {
fprintf (stderr, "Failed to write data: %s\n", strerror (errno));
close (mem->fd);
return NULL;
}
} else {
if (ftruncate (mem->fd, size) < 0) {
fprintf (stderr, "Failed to truncate temporary file: %s\n", strerror (errno));
close (mem->fd);
return NULL;
}
}
#ifdef USE_MEMFD
{
unsigned int seals;
seals = F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEAL;
if (fcntl (mem->fd, F_ADD_SEALS, seals) == -1) {
fprintf (stderr, "Failed to add seals: %s\n", strerror (errno));
close (mem->fd);
return NULL;
}
}
#endif
mem->flags = SPA_MEMORY_FLAG_READWRITE;
mem->size = size;
return mem;
}
SpaMemory *
spa_memory_import (SpaMemoryRef *ref)
{
SpaMemory *mem = NULL;
SpaMemoryPool *pool;
int i;
bool init = false;
uint32_t id, pool_id;
if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return NULL;
id = ref->id;
pool_id = ref->pool_id;
pool = &pools[pool_id];
for (i = 0; i < pool->n_free; i++) {
if (pool->free_mem[i] == id) {
pool->free_mem[i] = pool->free_mem[pool->n_free - 1];
pool->n_free--;
init = true;
break;
}
}
mem = &pool->memories[id];
if (init) {
mem->refcount = 1;
mem->notify = NULL;
mem->mem = *ref;
mem->ptr = NULL;
mem->fd = -1;
} else {
mem->refcount++;
}
SPA_DEBUG_MEMORY ("mem %p: import %u:%u\n", mem, pool_id, id);
return mem;
}
SpaResult
spa_memory_ref (SpaMemoryRef *ref)
{
SpaMemory *mem;
if (!(mem = spa_memory_find (ref)))
return SPA_RESULT_ERROR;
if (mem->mem.id > 0)
mem->refcount++;
return SPA_RESULT_OK;
}
static void
spa_memory_free (SpaMemory *mem)
{
SpaMemoryPool *pool;
SPA_DEBUG_MEMORY ("mem %p: free %u:%u\n", mem, mem->mem.pool_id, mem->mem.id);
if (mem->fd != -1) {
if (mem->ptr)
munmap (mem->ptr, mem->size);
close (mem->fd);
} else {
if (mem->ptr)
free (mem->ptr);
}
pool = &pools[mem->mem.pool_id];
pool->free_mem[pool->n_free] = mem->mem.id;
pool->n_free++;
}
SpaResult
spa_memory_unref (SpaMemoryRef *ref)
{
SpaMemory *mem;
if (!(mem = spa_memory_find (ref)))
return SPA_RESULT_ERROR;
if (mem->mem.id > 0 && --mem->refcount == 0) {
if (mem->notify)
mem->notify (mem);
if (mem->refcount == 0)
spa_memory_free (mem);
}
return SPA_RESULT_OK;
}
SpaMemory *
spa_memory_find (SpaMemoryRef *ref)
{
SpaMemoryPool *pool;
if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid || ref->id <= 0)
return NULL;
pool = &pools[ref->pool_id];
if (ref->id >= MAX_MEMORIES || pool->memories[ref->id].refcount <= 0) {
SPA_DEBUG_MEMORY ("can't find mem %u:%u\n", ref->pool_id, ref->id);
}
return &pool->memories[ref->id];
}
void *
spa_memory_ensure_ptr (SpaMemory *mem)
{
int prot = 0;
if (mem == NULL)
return NULL;
if (mem->ptr)
return mem->ptr;
if (mem->flags & SPA_MEMORY_FLAG_READABLE)
prot |= PROT_READ;
if (mem->flags & SPA_MEMORY_FLAG_WRITABLE)
prot |= PROT_WRITE;
mem->ptr = mmap (NULL, mem->size, prot, MAP_SHARED, mem->fd, 0);
if (mem->ptr == MAP_FAILED) {
mem->ptr = NULL;
fprintf (stderr, "Failed to mmap memory %zd %p: %s\n", mem->size, mem, strerror (errno));
}
return mem->ptr;
}

5
spa/lib/meson.build
View file

@ -3,7 +3,6 @@ spalib_sources = ['audio-raw.c',
'control.c',
'debug.c',
'format.c',
'memory.c',
'props.c',
'ringbuffer.c',
'video-raw.c']
@ -12,10 +11,6 @@ spalib = shared_library('spa-lib',
spalib_sources,
include_directories : spa_inc,
install : true)
#spalibs = static_library('spa-lib',
# spalib_sources,
# include_directories : spa_inc,
# install : true)
spalib_dep = declare_dependency(link_with : spalib,
include_directories : spa_inc,

180
spa/lib/props.c
View file

@ -25,9 +25,9 @@
#include <spa/props.h>
SpaResult
spa_props_set_prop (SpaProps *props,
unsigned int index,
const SpaPropValue *value)
spa_props_set_value (SpaProps *props,
unsigned int index,
const SpaPropValue *value)
{
const SpaPropInfo *info;
@ -51,9 +51,9 @@ spa_props_set_prop (SpaProps *props,
SpaResult
spa_props_get_prop (const SpaProps *props,
unsigned int index,
SpaPropValue *value)
spa_props_get_value (const SpaProps *props,
unsigned int index,
SpaPropValue *value)
{
const SpaPropInfo *info;
@ -76,8 +76,8 @@ spa_props_get_prop (const SpaProps *props,
}
SpaResult
spa_props_copy (const SpaProps *src,
SpaProps *dest)
spa_props_copy_values (const SpaProps *src,
SpaProps *dest)
{
int i;
SpaResult res;
@ -91,7 +91,7 @@ spa_props_copy (const SpaProps *src,
if (!(info->flags & SPA_PROP_FLAG_WRITABLE))
continue;
if ((res = spa_props_get_prop (src, spa_props_index_for_id (src, info->id), &value)) < 0)
if ((res = spa_props_get_value (src, spa_props_index_for_id (src, info->id), &value)) < 0)
continue;
if (value.size > info->maxsize)
return SPA_RESULT_WRONG_PROPERTY_SIZE;
@ -102,3 +102,165 @@ spa_props_copy (const SpaProps *src,
}
return SPA_RESULT_OK;
}
size_t
spa_props_get_size (const SpaProps *props)
{
size_t len;
unsigned int i, j;
SpaPropInfo *pi;
SpaPropRangeInfo *ri;
if (props == NULL)
return 0;
len = sizeof (SpaProps);
for (i = 0; i < props->n_prop_info; i++) {
pi = (SpaPropInfo *) &props->prop_info[i];
len += sizeof (SpaPropInfo);
len += pi->name ? strlen (pi->name) + 1 : 0;
len += pi->description ? strlen (pi->description) + 1 : 0;
/* for the value */
len += pi->maxsize;
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *)&pi->range_values[j];
len += sizeof (SpaPropRangeInfo);
len += ri->name ? strlen (ri->name) + 1 : 0;
len += ri->description ? strlen (ri->description) + 1 : 0;
/* the size of the range value */
len += ri->val.size;
}
}
return len;
}
size_t
spa_props_serialize (void *p, const SpaProps *props)
{
size_t len, slen;
unsigned int i, j, c;
SpaProps *tp;
SpaPropInfo *pi;
SpaPropRangeInfo *ri;
if (props == NULL)
return 0;
tp = p;
memcpy (tp, props, sizeof (SpaProps));
pi = SPA_MEMBER (tp, sizeof(SpaProps), SpaPropInfo);
ri = SPA_MEMBER (pi, sizeof(SpaPropInfo) * tp->n_prop_info, SpaPropRangeInfo);
tp->prop_info = SPA_INT_TO_PTR (SPA_PTRDIFF (pi, tp));
/* write propinfo array */
for (i = 0, c = 0; i < tp->n_prop_info; i++) {
memcpy (&pi[i], &props->prop_info[i], sizeof (SpaPropInfo));
pi[i].range_values = SPA_INT_TO_PTR (SPA_PTRDIFF (&ri[c], tp));
for (j = 0; j < pi[i].n_range_values; j++, c++) {
memcpy (&ri[c], &props->prop_info[i].range_values[j], sizeof (SpaPropRangeInfo));
}
}
p = &ri[c];
/* strings and default values from props and ranges */
for (i = 0, c = 0; i < tp->n_prop_info; i++) {
if (pi[i].name) {
slen = strlen (pi[i].name) + 1;
memcpy (p, pi[i].name, slen);
pi[i].name = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += slen;
} else {
pi[i].name = 0;
}
if (pi[i].description) {
slen = strlen (pi[i].description) + 1;
memcpy (p, pi[i].description, slen);
pi[i].description = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += slen;
} else {
pi[i].description = 0;
}
for (j = 0; j < pi[i].n_range_values; j++, c++) {
if (ri[c].name) {
slen = strlen (ri[c].name) + 1;
memcpy (p, ri[c].name, slen);
ri[c].name = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += slen;
} else {
ri[c].name = 0;
}
if (ri[c].description) {
slen = strlen (ri[c].description) + 1;
memcpy (p, ri[c].description, slen);
ri[c].description = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += slen;
} else {
ri[c].description = 0;
}
if (ri[c].val.size) {
memcpy (p, ri[c].val.value, ri[c].val.size);
ri[c].val.value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += ri[c].val.size;
} else {
ri[c].val.value = 0;
}
}
}
/* and the actual values */
for (i = 0; i < tp->n_prop_info; i++) {
if (pi[i].offset) {
memcpy (p, SPA_MEMBER (props, pi[i].offset, void), pi[i].maxsize);
pi[i].offset = SPA_PTRDIFF (p, tp);
p += pi[i].maxsize;
} else {
pi[i].offset = 0;
}
}
len = SPA_PTRDIFF (p, tp);
return len;
}
SpaProps *
spa_props_deserialize (void *p, off_t offset)
{
SpaProps *tp;
unsigned int i, j;
SpaPropInfo *pi;
SpaPropRangeInfo *ri;
tp = SPA_MEMBER (p, offset, SpaProps);
if (tp->prop_info)
tp->prop_info = SPA_MEMBER (tp, SPA_PTR_TO_INT (tp->prop_info), SpaPropInfo);
/* now fix all the pointers */
for (i = 0; i < tp->n_prop_info; i++) {
pi = (SpaPropInfo *) &tp->prop_info[i];
if (pi->name)
pi->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->name), char);
if (pi->description)
pi->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->description), char);
if (pi->range_values)
pi->range_values = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->range_values), SpaPropRangeInfo);
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *) &pi->range_values[j];
if (ri->name)
ri->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->name), char);
if (ri->description)
ri->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->description), char);
if (ri->val.value)
ri->val.value = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->val.value), void);
}
}
return tp;
}
SpaProps *
spa_props_copy_into (void *dest, const SpaProps *props)
{
if (props == NULL)
return NULL;
spa_props_serialize (dest, props);
return spa_props_deserialize (dest, 0);
}

6
spa/lib/video-raw.c
View file

@ -464,7 +464,7 @@ spa_prop_info_fill_video (SpaPropInfo *info,
return SPA_RESULT_INVALID_PROPERTY_INDEX;
memcpy (info, &format_prop_info[i], sizeof (SpaPropInfo));
info->offset = offset;
info->offset = offset - sizeof (SpaFormat) + sizeof (SpaProps);
return SPA_RESULT_OK;
}
@ -619,7 +619,7 @@ spa_format_video_parse (const SpaFormat *format,
props = &format->props;
idx = spa_props_index_for_id (props, SPA_PROP_ID_VIDEO_INFO);
if ((res = spa_props_get_prop (props, idx, &value)) < 0)
if ((res = spa_props_get_value (props, idx, &value)) < 0)
goto fallback;
if (props->prop_info[idx].type != SPA_PROP_TYPE_POINTER)
@ -631,7 +631,7 @@ spa_format_video_parse (const SpaFormat *format,
return SPA_RESULT_OK;
fallback:
res = spa_props_copy (props, &vformat->format.props);
res = spa_props_copy_values (props, &vformat->format.props);
return res;
}

1
spa/plugins/alsa/alsa-monitor.c
View file

@ -28,7 +28,6 @@
#include <spa/poll.h>
#include <spa/monitor.h>
#include <spa/memory.h>
#include <spa/debug.h>
extern const SpaHandleFactory spa_alsa_source_factory;

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

@ -142,7 +142,7 @@ spa_alsa_sink_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}
@ -420,10 +420,6 @@ spa_alsa_sink_node_port_alloc_buffers (SpaNode *node,
uint32_t *n_buffers)
{
SpaALSASink *this;
SpaALSABuffer *b;
unsigned int i, n_bufs;
size_t buffer_size;
uint8_t *bufmem;
if (node == NULL || node->handle == NULL || buffers == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -436,63 +432,7 @@ spa_alsa_sink_node_port_alloc_buffers (SpaNode *node,
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
n_bufs = *n_buffers;
buffer_size = this->buffer_frames * this->frame_size;
if (!this->alloc_bufmem)
this->alloc_bufmem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED, NULL, buffer_size * n_bufs);
bufmem = spa_memory_ensure_ptr (this->alloc_bufmem);
if (!this->alloc_mem)
this->alloc_mem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED, NULL, sizeof (SpaALSABuffer) * n_bufs);
this->alloc_buffers = spa_memory_ensure_ptr (this->alloc_mem);
this->n_buffers = n_bufs;
for (i = 0; i < n_bufs; i++) {
b = &this->alloc_buffers[i];
b->buffer.id = i;
b->buffer.mem.mem = this->alloc_mem->mem;
b->buffer.mem.offset = sizeof (SpaALSABuffer) * i;
b->buffer.mem.size = sizeof (SpaALSABuffer);
b->buffer.n_metas = 2;
b->buffer.metas = offsetof (SpaALSABuffer, metas);
b->buffer.n_datas = 1;
b->buffer.datas = offsetof (SpaALSABuffer, datas);
b->header.flags = 0;
b->header.seq = 0;
b->header.pts = 0;
b->header.dts_offset = 0;
b->metas[0].type = SPA_META_TYPE_HEADER;
b->metas[0].offset = offsetof (SpaALSABuffer, header);
b->metas[0].size = sizeof (b->header);
b->ringbuffer.readindex = 0;
b->ringbuffer.writeindex = 0;
b->ringbuffer.size = 0;
b->ringbuffer.size_mask = 0;
b->metas[1].type = SPA_META_TYPE_RINGBUFFER;
b->metas[1].offset = offsetof (SpaALSABuffer, ringbuffer);
b->metas[1].size = sizeof (b->ringbuffer);
b->datas[0].mem.mem = this->alloc_bufmem->mem;
b->datas[0].mem.offset = buffer_size * i;
b->datas[0].mem.size = buffer_size;
b->datas[0].stride = 0;
b->ptr = bufmem + buffer_size * i;
buffers[i] = &b->buffer;
}
*n_buffers = n_bufs;
this->have_buffers = true;
update_state (this, SPA_NODE_STATE_PAUSED);
return SPA_RESULT_OK;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
@ -556,7 +496,7 @@ spa_alsa_sink_node_port_push_input (SpaNode *node,
have_enough = true;
continue;
}
SPA_QUEUE_PUSH_TAIL (&this->ready, SpaALSABuffer, next, &this->alloc_buffers[info[i].buffer_id]);
SPA_QUEUE_PUSH_TAIL (&this->ready, SpaALSABuffer, next, &this->buffers[info[i].buffer_id]);
}
info[i].status = SPA_RESULT_OK;
}

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

@ -144,7 +144,7 @@ spa_alsa_source_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}
@ -301,38 +301,23 @@ recycle_buffer (SpaALSASource *this, uint32_t buffer_id)
{
SpaALSABuffer *b;
b = &this->alloc_buffers[buffer_id];
b = &this->buffers[buffer_id];
if (!b->outstanding)
return;
b->outstanding = false;
b->next = NULL;
SPA_QUEUE_PUSH_TAIL (&this->free, SpaALSABuffer, next, b);
}
static SpaResult
spa_alsa_clear_buffers (SpaALSASource *this)
{
int i;
if (!this->have_buffers)
return SPA_RESULT_OK;
for (i = 0; i < this->n_buffers; i++) {
SpaALSABuffer *b;
b = &this->alloc_buffers[i];
if (b->outstanding) {
fprintf (stderr, "queueing outstanding buffer %p\n", b);
recycle_buffer (this, i);
}
}
if (this->alloc_bufmem)
spa_memory_unref (&this->alloc_bufmem->mem);
if (this->alloc_mem)
spa_memory_unref (&this->alloc_mem->mem);
this->alloc_mem = NULL;
this->alloc_bufmem = NULL;
SPA_QUEUE_INIT (&this->free);
SPA_QUEUE_INIT (&this->ready);
this->n_buffers = 0;
this->have_buffers = false;
@ -459,6 +444,7 @@ spa_alsa_source_node_port_use_buffers (SpaNode *node,
{
SpaALSASource *this;
SpaResult res;
int i;
if (node == NULL || node->handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -475,8 +461,17 @@ spa_alsa_source_node_port_use_buffers (SpaNode *node,
if ((res = spa_alsa_clear_buffers (this)) < 0)
return res;
}
if (buffers != NULL)
return SPA_RESULT_NOT_IMPLEMENTED;
if (n_buffers > 0) {
for (i = 0; i < n_buffers; i++) {
SpaALSABuffer *b = &this->buffers[i];
b->outbuf = buffers[i];
b->outstanding = false;
b->next = NULL;
SPA_QUEUE_PUSH_TAIL (&this->free, SpaALSABuffer, next, b);
}
this->n_buffers = n_buffers;
this->have_buffers = true;
}
if (this->have_buffers)
update_state (this, SPA_NODE_STATE_PAUSED);
@ -496,10 +491,6 @@ spa_alsa_source_node_port_alloc_buffers (SpaNode *node,
uint32_t *n_buffers)
{
SpaALSASource *this;
SpaALSABuffer *b;
unsigned int i, n_bufs;
uint8_t *bufmem;
size_t buffer_size;
if (node == NULL || node->handle == NULL || buffers == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -512,73 +503,7 @@ spa_alsa_source_node_port_alloc_buffers (SpaNode *node,
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
n_bufs = *n_buffers;
SPA_QUEUE_INIT (&this->free);
SPA_QUEUE_INIT (&this->ready);
buffer_size = this->buffer_frames * this->frame_size;
if (!this->alloc_bufmem)
this->alloc_bufmem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED,
NULL,
buffer_size * n_bufs);
bufmem = spa_memory_ensure_ptr (this->alloc_bufmem);
if (!this->alloc_mem)
this->alloc_mem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED, NULL, sizeof (SpaALSABuffer) * n_bufs);
this->alloc_buffers = spa_memory_ensure_ptr (this->alloc_mem);
this->n_buffers = n_bufs;
for (i = 0; i < n_bufs; i++) {
b = &this->alloc_buffers[i];
b->buffer.id = i;
b->buffer.mem.mem = this->alloc_mem->mem;
b->buffer.mem.offset = sizeof (SpaALSABuffer) * i;
b->buffer.mem.size = sizeof (SpaALSABuffer);
b->buffer.n_metas = 2;
b->buffer.metas = offsetof (SpaALSABuffer, metas);
b->buffer.n_datas = 1;
b->buffer.datas = offsetof (SpaALSABuffer, datas);
b->header.flags = 0;
b->header.seq = 0;
b->header.pts = 0;
b->header.dts_offset = 0;
b->metas[0].type = SPA_META_TYPE_HEADER;
b->metas[0].offset = offsetof (SpaALSABuffer, header);
b->metas[0].size = sizeof (b->header);
b->ringbuffer.readindex = 0;
b->ringbuffer.writeindex = 0;
b->ringbuffer.size = 0;
b->ringbuffer.size_mask = 0;
b->metas[1].type = SPA_META_TYPE_RINGBUFFER;
b->metas[1].offset = offsetof (SpaALSABuffer, ringbuffer);
b->metas[1].size = sizeof (b->ringbuffer);
b->datas[0].mem.mem = this->alloc_bufmem->mem;
b->datas[0].mem.offset = buffer_size * i;
b->datas[0].mem.size = buffer_size;
b->datas[0].stride = 0;
b->ptr = bufmem + buffer_size * i;
b->h = &b->header;
buffers[i] = b->outbuf = &b->buffer;
b->outstanding = true;
recycle_buffer (this, b->outbuf->id);
}
*n_buffers = n_bufs;
this->have_buffers = true;
update_state (this, SPA_NODE_STATE_PAUSED);
return SPA_RESULT_OK;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult

6
spa/plugins/alsa/alsa-utils.c
View file

@ -309,7 +309,7 @@ mmap_read (SpaALSAState *state)
SpaALSABuffer *b;
snd_htimestamp_t htstamp = { 0, 0 };
int64_t now;
uint8_t *dest;
uint8_t *dest = NULL;
snd_pcm_status_alloca(&status);
@ -374,8 +374,8 @@ mmap_read (SpaALSAState *state)
SpaNodeEventHaveOutput ho;
SpaData *d;
d = SPA_BUFFER_DATAS (b->outbuf);
d[0].mem.size = avail * state->frame_size;
d = b->outbuf->datas;
d[0].size = avail * state->frame_size;
b->next = NULL;
SPA_QUEUE_PUSH_TAIL (&state->ready, SpaALSABuffer, next, b);

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

@ -45,12 +45,9 @@ typedef struct {
bool period_event;
} SpaALSAProps;
#define MAX_BUFFERS 16
struct _SpaALSABuffer {
SpaBuffer buffer;
SpaMeta metas[2];
SpaMetaHeader header;
SpaMetaRingbuffer ringbuffer;
SpaData datas[1];
SpaBuffer *outbuf;
SpaMetaHeader *h;
void *ptr;
@ -90,9 +87,7 @@ struct _SpaALSAState {
SpaPortStatus status;
bool have_buffers;
SpaMemory *alloc_bufmem;
SpaMemory *alloc_mem;
SpaALSABuffer *alloc_buffers;
SpaALSABuffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
SpaQueue free;

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

@ -21,7 +21,6 @@
#include <stdio.h>
#include <spa/node.h>
#include <spa/memory.h>
#include <spa/audio/format.h>
#define MAX_PORTS 128
@ -126,7 +125,7 @@ spa_audiomixer_node_set_props (SpaNode *node,
reset_audiomixer_props (p);
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}
@ -531,7 +530,7 @@ spa_audiomixer_node_port_push_input (SpaNode *node,
continue;
}
this->ports[idx].buffer = buffer;
this->ports[idx].buffer_queued = buffer->mem.size;
this->ports[idx].buffer_queued = 0;
this->ports[idx].buffer_index = 0;
this->ports[idx].buffer_offset = 0;
this->port_queued++;
@ -567,22 +566,19 @@ add_port_data (SpaAudioMixer *this, SpaBuffer *out, SpaAudioMixerPort *port)
int i, oi = 0;
uint8_t *op, *ip;
size_t os, is, chunk;
SpaData *odatas = SPA_BUFFER_DATAS (out);
SpaData *idatas = SPA_BUFFER_DATAS (port->buffer);
SpaMemory *mem;
SpaData *odatas = out->datas;
SpaData *idatas = port->buffer->datas;
op = ip = NULL;
while (true) {
if (op == NULL) {
mem = spa_memory_find (&odatas[oi].mem.mem);
op = (uint8_t*)mem->ptr + odatas[oi].mem.offset;
os = odatas[oi].mem.size;
op = (uint8_t*)odatas[oi].data + odatas[oi].offset;
os = odatas[oi].size;
}
if (ip == NULL) {
mem = spa_memory_find (&idatas[port->buffer_index].mem.mem);
ip = (uint8_t*)mem->ptr + odatas[oi].mem.offset;
is = idatas[port->buffer_index].mem.size;
ip = (uint8_t*)idatas[port->buffer_index].data + idatas[port->buffer_index].offset;
is = idatas[port->buffer_index].size;
ip += port->buffer_offset;
is -= port->buffer_offset;
}

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

@ -42,13 +42,11 @@ typedef struct {
bool live;
} SpaAudioTestSrcProps;
#define MAX_BUFFERS 16
typedef struct _ATSBuffer ATSBuffer;
struct _ATSBuffer {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaBuffer *outbuf;
bool outstanding;
ATSBuffer *next;
@ -83,8 +81,7 @@ struct _SpaAudioTestSrc {
size_t bpf;
bool have_buffers;
SpaMemory *alloc_mem;
ATSBuffer *alloc_buffers;
ATSBuffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
bool started;
@ -205,7 +202,7 @@ spa_audiotestsrc_node_set_props (SpaNode *node,
if (props == NULL) {
res = reset_audiotestsrc_props (p);
} else {
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
}
if (this->props[1].live)
@ -528,13 +525,8 @@ clear_buffers (SpaAudioTestSrc *this)
{
if (this->have_buffers) {
fprintf (stderr, "audiotestsrc %p: clear buffers\n", this);
if (this->alloc_mem)
spa_memory_unref (&this->alloc_mem->mem);
this->alloc_mem = NULL;
this->alloc_buffers = NULL;
this->n_buffers = 0;
this->have_buffers = false;
this->info.flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
SPA_QUEUE_INIT (&this->empty);
SPA_QUEUE_INIT (&this->ready);
}
@ -675,26 +667,16 @@ spa_audiotestsrc_node_port_use_buffers (SpaNode *node,
return SPA_RESULT_NO_FORMAT;
clear_buffers (this);
if (buffers != NULL && n_buffers != 0) {
unsigned int i, j;
this->alloc_mem = spa_memory_alloc_size (SPA_MEMORY_POOL_LOCAL,
NULL,
sizeof (ATSBuffer) * n_buffers);
this->alloc_buffers = spa_memory_ensure_ptr (this->alloc_mem);
for (i = 0; i < n_buffers; i++) {
ATSBuffer *b;
SpaMemoryRef *mem_ref;
SpaMemory *mem;
SpaData *d = SPA_BUFFER_DATAS (buffers[i]);
SpaMeta *m = SPA_BUFFER_METAS (buffers[i]);
SpaData *d = buffers[i]->datas;
SpaMeta *m = buffers[i]->metas;
b = &this->alloc_buffers[i];
b->buffer.mem.mem = this->alloc_mem->mem;
b->buffer.mem.offset = sizeof (ATSBuffer) * i;
b->buffer.mem.size = sizeof (ATSBuffer);
b->buffer.id = SPA_ID_INVALID;
b = &this->buffers[i];
b->outbuf = buffers[i];
b->outstanding = true;
b->h = NULL;
@ -702,29 +684,25 @@ spa_audiotestsrc_node_port_use_buffers (SpaNode *node,
for (j = 0; j < buffers[i]->n_metas; j++) {
switch (m[j].type) {
case SPA_META_TYPE_HEADER:
b->h = SPA_MEMBER (buffers[i], m[j].offset, SpaMetaHeader);
b->h = m[j].data;
break;
default:
break;
}
}
mem_ref = &d[0].mem.mem;
if (!(mem = spa_memory_find (mem_ref))) {
if (buffers[i]->n_datas < 1 || d[0].type != SPA_DATA_TYPE_MEMPTR) {
fprintf (stderr, "audiotestsrc %p: invalid memory on buffer %p\n", this, buffers[i]);
continue;
}
b->ptr = SPA_MEMBER (spa_memory_ensure_ptr (mem), d[0].mem.offset, void);
b->size = d[0].mem.size;
b->ptr = SPA_MEMBER (d[0].data, d[0].offset, void);
b->size = d[0].size;
b->next = NULL;
SPA_QUEUE_PUSH_TAIL (&this->empty, ATSBuffer, next, b);
}
this->n_buffers = n_buffers;
this->have_buffers = true;
this->info.flags |= SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
} else {
this->info.flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
}
if (this->have_buffers) {
@ -745,7 +723,6 @@ spa_audiotestsrc_node_port_alloc_buffers (SpaNode *node,
uint32_t *n_buffers)
{
SpaAudioTestSrc *this;
unsigned int i;
if (node == NULL || node->handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -761,12 +738,7 @@ spa_audiotestsrc_node_port_alloc_buffers (SpaNode *node,
if (!this->have_buffers)
return SPA_RESULT_NO_BUFFERS;
*n_buffers = SPA_MIN (*n_buffers, this->n_buffers);
for (i = 0; i < *n_buffers; i++)
buffers[i] = this->alloc_buffers[i].outbuf;
return SPA_RESULT_OK;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
@ -791,7 +763,7 @@ spa_audiotestsrc_node_port_reuse_buffer (SpaNode *node,
if (buffer_id >= this->n_buffers)
return SPA_RESULT_INVALID_BUFFER_ID;
b = &this->alloc_buffers[buffer_id];
b = &this->buffers[buffer_id];
if (!b->outstanding)
return SPA_RESULT_OK;

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

@ -122,7 +122,7 @@ spa_ffmpeg_dec_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}

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

@ -128,7 +128,7 @@ spa_ffmpeg_enc_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}

2
spa/plugins/libva/libva-dec.c
View file

@ -116,7 +116,7 @@ spa_libva_dec_node_set_props (SpaHandle *handle,
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}

2
spa/plugins/libva/libva-enc.c
View file

@ -116,7 +116,7 @@ spa_libva_enc_node_set_props (SpaHandle *handle,
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}

223
spa/plugins/remote/proxy.c
View file

@ -30,19 +30,33 @@
#include <spa/control.h>
#include <spa/debug.h>
#include <spa/memory.h>
#include <spa/node.h>
#include <spa/queue.h>
#include <spa/queue.h>
#include "../lib/memfd-wrappers.h"
#define MAX_INPUTS 64
#define MAX_OUTPUTS 64
#define MAX_PORTS (MAX_INPUTS + MAX_OUTPUTS)
#define MAX_BUFFERS 16
#define CHECK_FREE_PORT_ID(this,id) ((id) < MAX_PORTS && !(this)->ports[id].valid)
#define CHECK_PORT_ID(this,id) ((id) < MAX_PORTS && (this)->ports[id].valid)
#define CHECK_PORT_ID_IN(this,id) (CHECK_PORT_ID(this,id) && (id < this->max_inputs))
#define CHECK_PORT_ID_OUT(this,id) (CHECK_PORT_ID(this,id) && (id >= this->max_inputs))
typedef struct _SpaProxy SpaProxy;
typedef struct _ProxyBuffer ProxyBuffer;
struct _ProxyBuffer {
SpaBuffer *outbuf;
SpaBuffer buffer;
SpaData datas[4];
off_t offset;
size_t size;
};
typedef struct {
SpaProps props;
@ -56,9 +70,17 @@ typedef struct {
unsigned int n_formats;
SpaFormat **formats;
SpaPortStatus status;
unsigned int n_buffers;
SpaBuffer **buffers;
ProxyBuffer buffers[MAX_BUFFERS];
uint32_t buffer_mem_id;
int buffer_mem_fd;
size_t buffer_mem_size;
void *buffer_mem_ptr;
uint32_t buffer_id;
SpaQueue ready;
} SpaProxyPort;
struct _SpaProxy {
@ -144,6 +166,19 @@ send_async_complete (SpaProxy *this, uint32_t seq, SpaResult res)
this->event_cb (&this->node, &event, this->user_data);
}
static SpaResult
clear_buffers (SpaProxy *this, SpaProxyPort *port)
{
if (port->n_buffers) {
fprintf (stderr, "proxy %p: clear buffers\n", this);
port->n_buffers = 0;
SPA_QUEUE_INIT (&port->ready);
}
return SPA_RESULT_OK;
}
static SpaResult
spa_proxy_node_get_props (SpaNode *node,
SpaProps **props)
@ -183,7 +218,7 @@ spa_proxy_node_set_props (SpaNode *node,
}
/* copy new properties */
res = spa_props_copy (props, &np->props);
res = spa_props_copy_values (props, &np->props);
/* compare changes */
if (op->socketfd != np->socketfd)
@ -340,15 +375,26 @@ do_update_port (SpaProxy *this,
{
SpaProxyPort *port;
unsigned int i;
size_t size;
port = &this->ports[pu->port_id];
if (pu->change_mask & SPA_CONTROL_CMD_PORT_UPDATE_POSSIBLE_FORMATS) {
port->n_formats = pu->n_possible_formats;
port->formats = pu->possible_formats;
for (i = 0; i < port->n_formats; i++)
free (port->formats[i]);
port->n_formats = pu->n_possible_formats;
port->formats = realloc (port->formats, port->n_formats * sizeof (SpaFormat *));
for (i = 0; i < port->n_formats; i++) {
size = spa_format_get_size (pu->possible_formats[i]);
port->formats[i] = spa_format_copy_into (malloc (size), pu->possible_formats[i]);
spa_debug_format (port->formats[i]);
}
}
if (pu->change_mask & SPA_CONTROL_CMD_PORT_UPDATE_FORMAT) {
if (port->format)
free (port->format);
size = spa_format_get_size (pu->format);
port->format = spa_format_copy_into (malloc (size), pu->format);
}
if (pu->change_mask & SPA_CONTROL_CMD_PORT_UPDATE_PROPS) {
@ -386,7 +432,7 @@ do_uninit_port (SpaProxy *this,
port->valid = false;
if (port->format)
spa_format_unref (port->format);
free (port->format);
port->format = NULL;
}
@ -406,11 +452,13 @@ spa_proxy_node_add_port (SpaNode *node,
return SPA_RESULT_INVALID_PORT;
pu.change_mask = SPA_CONTROL_CMD_PORT_UPDATE_POSSIBLE_FORMATS |
SPA_CONTROL_CMD_PORT_UPDATE_FORMAT |
SPA_CONTROL_CMD_PORT_UPDATE_PROPS |
SPA_CONTROL_CMD_PORT_UPDATE_INFO;
pu.port_id = port_id;
pu.n_possible_formats = 0;
pu.possible_formats = NULL;
pu.format = NULL;
pu.props = NULL;
pu.info = NULL;
do_update_port (this, &pu);
@ -476,7 +524,6 @@ spa_proxy_node_port_set_format (SpaNode *node,
const SpaFormat *format)
{
SpaProxy *this;
SpaProxyPort *port;
SpaControl control;
SpaControlBuilder builder;
SpaControlCmdSetFormat sf;
@ -491,11 +538,8 @@ spa_proxy_node_port_set_format (SpaNode *node,
if (!CHECK_PORT_ID (this, port_id))
return SPA_RESULT_INVALID_PORT;
port = &this->ports[port_id];
spa_control_builder_init_into (&builder, buf, sizeof (buf), NULL, 0);
sf.seq = this->seq++;
sf.port_id = port_id;
sf.flags = flags;
sf.format = (SpaFormat *) format;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_SET_FORMAT, &sf);
@ -506,8 +550,6 @@ spa_proxy_node_port_set_format (SpaNode *node,
spa_control_clear (&control);
port->format = format;
return SPA_RESULT_RETURN_ASYNC (sf.seq);
}
@ -602,58 +644,6 @@ spa_proxy_node_port_get_status (SpaNode *node,
return SPA_RESULT_OK;
}
static SpaResult
add_buffer_mem (SpaProxy *this, SpaControlBuilder *builder, uint32_t port_id, SpaBuffer *buffer)
{
SpaControlCmdAddMem am;
int i;
SpaBuffer *b;
SpaMemory *bmem;
if (buffer->mem.mem.id == SPA_ID_INVALID) {
fprintf (stderr, "proxy %p: alloc buffer space %zd\n", this, buffer->mem.size);
bmem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED, buffer, buffer->mem.size);
b = spa_memory_ensure_ptr (bmem);
b->mem.mem = bmem->mem;
b->mem.offset = 0;
} else {
bmem = spa_memory_find (&buffer->mem.mem);
b = buffer;
}
am.port_id = port_id;
am.mem = bmem->mem;
am.mem_type = 0;
am.fd_index = spa_control_builder_add_fd (builder, bmem->fd, false);
am.flags = bmem->flags;
am.size = bmem->size;
spa_control_builder_add_cmd (builder, SPA_CONTROL_CMD_ADD_MEM, &am);
for (i = 0; i < b->n_datas; i++) {
SpaData *d = &SPA_BUFFER_DATAS (b)[i];
SpaMemory *mem;
if (!(mem = spa_memory_find (&d->mem.mem))) {
fprintf (stderr, "proxy %p: error invalid memory\n", this);
continue;
}
if (mem->fd == -1) {
fprintf (stderr, "proxy %p: error memory without fd\n", this);
continue;
}
am.port_id = port_id;
am.mem = mem->mem;
am.mem_type = 0;
am.fd_index = spa_control_builder_add_fd (builder, mem->fd, false);
am.flags = mem->flags;
am.size = mem->size;
spa_control_builder_add_cmd (builder, SPA_CONTROL_CMD_ADD_MEM, &am);
}
return SPA_RESULT_OK;
}
static SpaResult
spa_proxy_node_port_use_buffers (SpaNode *node,
uint32_t port_id,
@ -662,13 +652,17 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
{
SpaProxy *this;
SpaProxyPort *port;
unsigned int i;
unsigned int i, j;
SpaControl control;
SpaControlBuilder builder;
uint8_t buf[4096];
int fds[32];
SpaResult res;
SpaControlCmdAddMem am;
SpaControlCmdUseBuffers ub;
size_t size, n_mem;
SpaControlMemRef *memref;
void *p;
if (node == NULL || node->handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -684,25 +678,85 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
if (!port->format)
return SPA_RESULT_NO_FORMAT;
if (port->n_buffers == n_buffers && port->buffers == buffers)
return SPA_RESULT_OK;
clear_buffers (this, port);
spa_control_builder_init_into (&builder, buf, sizeof (buf), fds, SPA_N_ELEMENTS (fds));
if (buffers == NULL || n_buffers == 0) {
port->buffers = NULL;
port->n_buffers = 0;
} else {
port->buffers = buffers;
port->n_buffers = n_buffers;
/* find size to store buffers */
size = 0;
n_mem = 0;
for (i = 0; i < n_buffers; i++) {
ProxyBuffer *b = &port->buffers[i];
b->outbuf = buffers[i];
memcpy (&b->buffer, buffers[i], sizeof (SpaBuffer));
b->buffer.datas = b->datas;
b->size = spa_buffer_get_size (buffers[i]);
b->offset = size;
size += b->size;
for (j = 0; j < buffers[i]->n_datas; j++) {
SpaData *d = &buffers[i]->datas[j];
memcpy (&b->buffer.datas[j], d, sizeof (SpaData));
am.port_id = port_id;
am.mem_id = n_mem;
am.fd_index = spa_control_builder_add_fd (&builder, SPA_PTR_TO_INT (d->data), false);
am.flags = 0;
am.offset = d->offset;
am.size = d->size;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_MEM, &am);
b->buffer.datas[j].data = SPA_UINT32_TO_PTR (n_mem);
n_mem++;
}
}
for (i = 0; i < port->n_buffers; i++)
add_buffer_mem (this, &builder, port_id, port->buffers[i]);
/* make mem for the buffers */
port->buffer_mem_id = n_mem;
port->buffer_mem_size = size;
port->buffer_mem_fd = memfd_create ("spa-memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING);
if (ftruncate (port->buffer_mem_fd, size) < 0) {
fprintf (stderr, "Failed to truncate temporary file: %s\n", strerror (errno));
close (port->buffer_mem_fd);
}
{
unsigned int seals = F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEAL;
if (fcntl (port->buffer_mem_fd, F_ADD_SEALS, seals) == -1) {
fprintf (stderr, "Failed to add seals: %s\n", strerror (errno));
close (port->buffer_mem_fd);
}
}
p = port->buffer_mem_ptr = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, port->buffer_mem_fd, 0);
for (i = 0; i < n_buffers; i++)
p += spa_buffer_serialize (p, &port->buffers[i].buffer);
am.port_id = port_id;
am.mem_id = port->buffer_mem_id;
am.fd_index = spa_control_builder_add_fd (&builder, port->buffer_mem_fd, false);
am.flags = 0;
am.offset = 0;
am.size = size;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_MEM, &am);
memref = alloca (n_mem * sizeof (SpaControlMemRef));
for (i = 0; i < n_buffers; i++) {
memref[i].mem_id = port->buffer_mem_id;
memref[i].offset = port->buffers[i].offset;
memref[i].size = port->buffers[i].size;
}
port->n_buffers = n_buffers;
ub.seq = this->seq++;
ub.port_id = port_id;
ub.n_buffers = port->n_buffers;
ub.buffers = port->buffers;
ub.buffers = memref;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_USE_BUFFERS, &ub);
spa_control_builder_end (&builder, &control);
@ -981,24 +1035,13 @@ parse_control (SpaProxy *this,
{
SpaControlCmdPortUpdate pu;
bool remove;
SpaMemory *mem;
void *data;
size_t size;
data = spa_control_iter_get_data (&it, &size);
mem = spa_memory_alloc_size (SPA_MEMORY_POOL_LOCAL, data, size);
spa_control_iter_set_data (&it, spa_memory_ensure_ptr (mem), size);
fprintf (stderr, "proxy %p: got port update %d\n", this, cmd);
if (spa_control_iter_parse_cmd (&it, &pu) < 0) {
spa_memory_unref (&mem->mem);
if (spa_control_iter_parse_cmd (&it, &pu) < 0)
break;
}
if (pu.port_id >= MAX_PORTS) {
spa_memory_unref (&mem->mem);
if (pu.port_id >= MAX_PORTS)
break;
}
remove = (pu.change_mask == 0);

1
spa/plugins/v4l2/v4l2-monitor.c
View file

@ -28,7 +28,6 @@
#include <spa/poll.h>
#include <spa/monitor.h>
#include <spa/memory.h>
#include <spa/debug.h>
extern const SpaHandleFactory spa_v4l2_source_factory;

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

@ -25,7 +25,6 @@
#include <linux/videodev2.h>
#include <spa/node.h>
#include <spa/memory.h>
#include <spa/video/format.h>
#include <spa/debug.h>
#include <spa/queue.h>
@ -53,15 +52,11 @@ reset_v4l2_source_props (SpaV4l2SourceProps *props)
typedef struct _V4l2Buffer V4l2Buffer;
struct _V4l2Buffer {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaBuffer *outbuf;
SpaMetaHeader *h;
bool outstanding;
struct v4l2_buffer v4l2_buffer;
V4l2Buffer *next;
int dmafd;
};
typedef struct _V4l2Format V4l2Format;
@ -104,8 +99,7 @@ typedef struct {
enum v4l2_memory memtype;
struct v4l2_requestbuffers reqbuf;
SpaMemory *alloc_mem;
V4l2Buffer *alloc_buffers;
V4l2Buffer buffers[MAX_BUFFERS];
SpaQueue ready;
SpaPollFd fds[1];
@ -206,7 +200,7 @@ spa_v4l2_source_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}
@ -421,7 +415,7 @@ spa_v4l2_source_node_port_set_format (SpaNode *node,
spa_v4l2_format_init (f);
f->fmt.media_type = format->media_type;
f->fmt.media_subtype = format->media_subtype;
if ((res = spa_props_copy (&format->props, &f->fmt.props) < 0))
if ((res = spa_props_copy_values (&format->props, &f->fmt.props) < 0))
return res;
} else {
f = (V4l2Format*)format;

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

@ -75,7 +75,7 @@ static SpaResult
spa_v4l2_buffer_recycle (SpaV4l2Source *this, uint32_t buffer_id)
{
SpaV4l2State *state = &this->state[0];
V4l2Buffer *b = &state->alloc_buffers[buffer_id];
V4l2Buffer *b = &state->buffers[buffer_id];
if (!b->outstanding)
return SPA_RESULT_OK;
@ -100,18 +100,13 @@ spa_v4l2_clear_buffers (SpaV4l2Source *this)
for (i = 0; i < state->reqbuf.count; i++) {
V4l2Buffer *b;
b = &state->alloc_buffers[i];
b = &state->buffers[i];
if (b->outstanding) {
fprintf (stderr, "queueing outstanding buffer %p\n", b);
spa_v4l2_buffer_recycle (this, i);
}
if (b->buffer.n_datas > 0)
spa_memory_unref (&b->datas[0].mem.mem);
}
if (state->alloc_mem)
spa_memory_unref (&state->alloc_mem->mem);
state->alloc_mem = NULL;
state->have_buffers = false;
return SPA_RESULT_OK;
@ -317,7 +312,7 @@ enum_filter_format (const SpaFormat *filter, unsigned int index)
if (pi->type != SPA_PROP_TYPE_UINT32)
return SPA_VIDEO_FORMAT_UNKNOWN;
res = spa_props_get_prop (&filter->props, idx, &val);
res = spa_props_get_value (&filter->props, idx, &val);
if (res >= 0) {
if (index == 0)
video_format = *((SpaVideoFormat *)val.value);
@ -501,7 +496,7 @@ next_frmsize:
if (pi->type != SPA_PROP_TYPE_RECTANGLE)
return SPA_RESULT_ENUM_END;
res = spa_props_get_prop (&filter->props, idx, &val);
res = spa_props_get_value (&filter->props, idx, &val);
if (res >= 0) {
const SpaRectangle *size = val.value;
@ -588,7 +583,6 @@ have_size:
fmt->fmt.props.prop_info = fmt->infos;
fmt->fmt.props.n_prop_info = pi = 0;
fmt->fmt.props.unset_mask = 0;
fmt->fmt.mem.mem.pool_id = SPA_ID_INVALID;
if (info->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
spa_prop_info_fill_video (&fmt->infos[pi],
@ -642,7 +636,7 @@ have_size:
if (pi->type != SPA_PROP_TYPE_FRACTION)
return SPA_RESULT_ENUM_END;
res = spa_props_get_prop (&filter->props, idx, &val);
res = spa_props_get_value (&filter->props, idx, &val);
if (res == 0) {
if (filter_framerate (&state->frmival, val.value,
val.value,
@ -814,6 +808,7 @@ mmap_read (SpaV4l2Source *this)
struct v4l2_buffer buf;
V4l2Buffer *b;
SpaData *d;
int64_t pts;
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
@ -830,24 +825,27 @@ mmap_read (SpaV4l2Source *this)
}
}
b = &state->alloc_buffers[buf.index];
b->header.flags = SPA_BUFFER_FLAG_NONE;
if (buf.flags & V4L2_BUF_FLAG_ERROR)
b->header.flags |= SPA_BUFFER_FLAG_CORRUPTED;
state->last_ticks = (int64_t)buf.timestamp.tv_sec * SPA_USEC_PER_SEC + (uint64_t)buf.timestamp.tv_usec;
b->header.seq = buf.sequence;
b->header.pts = state->last_ticks * 1000;
pts = state->last_ticks * 1000;
if (buf.flags & V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC)
state->last_monotonic = b->header.pts;
state->last_monotonic = pts;
else
state->last_monotonic = SPA_TIME_INVALID;
d = SPA_BUFFER_DATAS (b->outbuf);
d[0].mem.size = buf.bytesused;
b = &state->buffers[buf.index];
if (b->h) {
b->h->flags = SPA_BUFFER_FLAG_NONE;
if (buf.flags & V4L2_BUF_FLAG_ERROR)
b->h->flags |= SPA_BUFFER_FLAG_CORRUPTED;
b->h->seq = buf.sequence;
b->h->pts = pts;
}
d = b->outbuf->datas;
d[0].size = buf.bytesused;
b->next = NULL;
SPA_QUEUE_PUSH_TAIL (&state->ready, V4l2Buffer, next, b);
return SPA_RESULT_OK;
@ -900,49 +898,28 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
}
state->reqbuf = reqbuf;
if (state->alloc_mem)
spa_memory_unref (&state->alloc_mem->mem);
state->alloc_mem = spa_memory_alloc_size (SPA_MEMORY_POOL_LOCAL,
NULL,
sizeof (V4l2Buffer) * reqbuf.count);
state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem);
for (i = 0; i < reqbuf.count; i++) {
V4l2Buffer *b;
SpaMemoryRef *mem_ref;
SpaMemory *mem;
SpaData *d;
b = &state->alloc_buffers[i];
b->buffer.mem.mem = state->alloc_mem->mem;
b->buffer.mem.offset = sizeof (V4l2Buffer) * i;
b->buffer.mem.size = sizeof (V4l2Buffer);
b->buffer.id = SPA_ID_INVALID;
b->buffer.n_metas = 0;
b->buffer.n_datas = 0;
b = &state->buffers[i];
b->outbuf = buffers[i];
b->outstanding = true;
fprintf (stderr, "import buffer %p\n", buffers[i]);
d = SPA_BUFFER_DATAS (buffers[i]);
mem_ref = &d[0].mem.mem;
if (!(mem = spa_memory_find (mem_ref))) {
fprintf (stderr, "invalid memory on buffer %p\n", buffers[i]);
continue;
}
if (buffers[i]->n_datas < 1) {
fprintf (stderr, "invalid memory on buffer %p\n", buffers[i]);
continue;
}
d = buffers[i]->datas;
CLEAR (b->v4l2_buffer);
b->v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
b->v4l2_buffer.memory = state->memtype;
b->v4l2_buffer.index = i;
b->v4l2_buffer.m.userptr = (unsigned long) SPA_MEMBER (mem->ptr, d[0].mem.offset, void *);
b->v4l2_buffer.length = d[0].mem.size;
b->v4l2_buffer.m.userptr = (unsigned long) SPA_MEMBER (d[0].data, d[0].offset, void *);
b->v4l2_buffer.length = d[0].size;
spa_v4l2_buffer_recycle (this, buffers[i]->id);
}
@ -986,57 +963,33 @@ mmap_init (SpaV4l2Source *this,
state->reqbuf = reqbuf;
if (state->alloc_mem)
spa_memory_unref (&state->alloc_mem->mem);
state->alloc_mem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED,
NULL,
sizeof (V4l2Buffer) * reqbuf.count);
state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem);
for (i = 0; i < reqbuf.count; i++) {
struct v4l2_buffer buf;
V4l2Buffer *b;
SpaMemory *mem;
SpaData *d;
CLEAR (buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = state->memtype;
buf.index = i;
if (buffers[i]->n_datas < 1) {
fprintf (stderr, "invalid buffer data\n");
return SPA_RESULT_ERROR;
}
if (xioctl (state->fd, VIDIOC_QUERYBUF, &buf) < 0) {
b = &state->buffers[i];
b->outbuf = buffers[i];
b->outstanding = true;
CLEAR (b->v4l2_buffer);
b->v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
b->v4l2_buffer.memory = state->memtype;
b->v4l2_buffer.index = i;
if (xioctl (state->fd, VIDIOC_QUERYBUF, &b->v4l2_buffer) < 0) {
perror ("VIDIOC_QUERYBUF");
return SPA_RESULT_ERROR;
}
b = &state->alloc_buffers[i];
b->buffer.id = i;
b->buffer.mem.mem = state->alloc_mem->mem;
b->buffer.mem.offset = sizeof (V4l2Buffer) * i;
b->buffer.mem.size = sizeof (V4l2Buffer);
buffers[i] = &b->buffer;
b->buffer.n_metas = 1;
b->buffer.metas = offsetof (V4l2Buffer, metas);
b->buffer.n_datas = 1;
b->buffer.datas = offsetof (V4l2Buffer, datas);
b->header.flags = 0;
b->header.seq = 0;
b->header.pts = 0;
b->header.dts_offset = 0;
b->metas[0].type = SPA_META_TYPE_HEADER;
b->metas[0].offset = offsetof (V4l2Buffer, header);
b->metas[0].size = sizeof (b->header);
mem = spa_memory_alloc (SPA_MEMORY_POOL_SHARED);
mem->flags = SPA_MEMORY_FLAG_READABLE;
mem->size = buf.length;
b->datas[0].mem.mem = mem->mem;
b->datas[0].mem.offset = 0;
b->datas[0].mem.size = buf.length;
b->datas[0].stride = state->fmt.fmt.pix.bytesperline;
d = buffers[i]->datas;
d[0].offset = 0;
d[0].size = b->v4l2_buffer.length;
d[0].stride = state->fmt.fmt.pix.bytesperline;
if (state->export_buf) {
struct v4l2_exportbuffer expbuf;
@ -1048,33 +1001,21 @@ mmap_init (SpaV4l2Source *this,
perror("VIDIOC_EXPBUF");
continue;
}
mem->fd = expbuf.fd;
mem->type = "dmabuf";
mem->ptr = NULL;
b->dmafd = expbuf.fd;
d[0].type = SPA_DATA_TYPE_FD;
d[0].data = SPA_INT_TO_PTR (expbuf.fd);
} else {
mem->fd = -1;
mem->type = "sysmem";
mem->ptr = mmap (NULL,
buf.length,
PROT_READ | PROT_WRITE,
MAP_SHARED,
state->fd,
buf.m.offset);
if (mem->ptr == MAP_FAILED) {
d[0].type = SPA_DATA_TYPE_MEMPTR;
d[0].data = mmap (NULL,
b->v4l2_buffer.length,
PROT_READ | PROT_WRITE,
MAP_SHARED,
state->fd,
b->v4l2_buffer.m.offset);
if (d[0].data == MAP_FAILED) {
perror ("mmap");
continue;
}
}
b->outbuf = &b->buffer;
b->outstanding = true;
CLEAR (b->v4l2_buffer);
b->v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
b->v4l2_buffer.memory = state->memtype;
b->v4l2_buffer.index = i;
spa_v4l2_buffer_recycle (this, i);
}
state->have_buffers = true;
@ -1103,18 +1044,9 @@ spa_v4l2_alloc_buffers (SpaV4l2Source *this,
{
SpaResult res;
SpaV4l2State *state = &this->state[0];
unsigned int i;
if (state->have_buffers) {
if (*n_buffers < state->reqbuf.count)
return SPA_RESULT_NO_BUFFERS;
*n_buffers = state->reqbuf.count;
for (i = 0; i < state->reqbuf.count; i++) {
buffers[i] = &state->alloc_buffers[i].buffer;
}
return SPA_RESULT_OK;
}
if (state->have_buffers)
return SPA_RESULT_ERROR;
if (state->cap.capabilities & V4L2_CAP_STREAMING) {
if ((res = mmap_init (this, params, n_params, buffers, n_buffers)) < 0)
@ -1194,7 +1126,7 @@ spa_v4l2_pause (SpaV4l2Source *this)
for (i = 0; i < state->reqbuf.count; i++) {
V4l2Buffer *b;
b = &state->alloc_buffers[i];
b = &state->buffers[i];
if (!b->outstanding)
if (xioctl (state->fd, VIDIOC_QBUF, &b->v4l2_buffer) < 0)
perror ("VIDIOC_QBUF");

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

@ -45,13 +45,11 @@ typedef struct {
bool live;
} SpaVideoTestSrcProps;
#define MAX_BUFFERS 16
typedef struct _VTSBuffer VTSBuffer;
struct _VTSBuffer {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaBuffer *outbuf;
bool outstanding;
VTSBuffer *next;
@ -86,8 +84,7 @@ struct _SpaVideoTestSrc {
size_t bpp;
bool have_buffers;
SpaMemory *alloc_mem;
VTSBuffer *alloc_buffers;
VTSBuffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
bool started;
@ -158,7 +155,7 @@ spa_videotestsrc_node_set_props (SpaNode *node,
if (props == NULL) {
res = reset_videotestsrc_props (p);
} else {
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
}
if (this->props[1].live)
@ -476,13 +473,8 @@ clear_buffers (SpaVideoTestSrc *this)
{
if (this->have_buffers) {
fprintf (stderr, "videotestsrc %p: clear buffers\n", this);
if (this->alloc_mem)
spa_memory_unref (&this->alloc_mem->mem);
this->alloc_mem = NULL;
this->alloc_buffers = NULL;
this->n_buffers = 0;
this->have_buffers = false;
this->info.flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
SPA_QUEUE_INIT (&this->empty);
SPA_QUEUE_INIT (&this->ready);
}
@ -627,23 +619,12 @@ spa_videotestsrc_node_port_use_buffers (SpaNode *node,
if (buffers != NULL && n_buffers != 0) {
unsigned int i, j;
this->alloc_mem = spa_memory_alloc_size (SPA_MEMORY_POOL_LOCAL,
NULL,
sizeof (VTSBuffer) * n_buffers);
this->alloc_buffers = spa_memory_ensure_ptr (this->alloc_mem);
for (i = 0; i < n_buffers; i++) {
VTSBuffer *b;
SpaMemoryRef *mem_ref;
SpaMemory *mem;
SpaData *d = SPA_BUFFER_DATAS (buffers[i]);
SpaMeta *m = SPA_BUFFER_METAS (buffers[i]);
VTSBuffer *b = &this->buffers[i];
SpaData *d = buffers[i]->datas;
SpaMeta *m = buffers[i]->metas;
b = &this->alloc_buffers[i];
b->buffer.mem.mem = this->alloc_mem->mem;
b->buffer.mem.offset = sizeof (VTSBuffer) * i;
b->buffer.mem.size = sizeof (VTSBuffer);
b->buffer.id = SPA_ID_INVALID;
b = &this->buffers[i];
b->outbuf = buffers[i];
b->outstanding = true;
b->h = NULL;
@ -651,19 +632,18 @@ spa_videotestsrc_node_port_use_buffers (SpaNode *node,
for (j = 0; j < buffers[i]->n_metas; j++) {
switch (m[j].type) {
case SPA_META_TYPE_HEADER:
b->h = SPA_MEMBER (buffers[i], m[j].offset, SpaMetaHeader);
b->h = m[j].data;
break;
default:
break;
}
}
mem_ref = &d[0].mem.mem;
if (!(mem = spa_memory_find (mem_ref))) {
if (d[0].type != SPA_DATA_TYPE_MEMPTR) {
fprintf (stderr, "videotestsrc %p: invalid memory on buffer %p\n", this, buffers[i]);
continue;
}
b->ptr = SPA_MEMBER (spa_memory_ensure_ptr (mem), d[0].mem.offset, void);
b->ptr = SPA_MEMBER (d[0].data, d[0].offset, void);
b->stride = d[0].stride;
b->next = NULL;
@ -713,7 +693,7 @@ spa_videotestsrc_node_port_alloc_buffers (SpaNode *node,
*n_buffers = SPA_MIN (*n_buffers, this->n_buffers);
for (i = 0; i < *n_buffers; i++)
buffers[i] = this->alloc_buffers[i].outbuf;
buffers[i] = this->buffers[i].outbuf;
return SPA_RESULT_OK;
}
@ -740,7 +720,7 @@ spa_videotestsrc_node_port_reuse_buffer (SpaNode *node,
if (buffer_id >= this->n_buffers)
return SPA_RESULT_INVALID_BUFFER_ID;
b = &this->alloc_buffers[buffer_id];
b = &this->buffers[buffer_id];
if (!b->outstanding)
return SPA_RESULT_OK;

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

@ -21,7 +21,6 @@
#include <stddef.h>
#include <spa/node.h>
#include <spa/memory.h>
#include <spa/audio/format.h>
typedef struct _SpaVolume SpaVolume;
@ -137,7 +136,7 @@ spa_volume_node_set_props (SpaNode *node,
reset_volume_props (p);
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}
@ -527,7 +526,6 @@ spa_volume_node_port_pull_output (SpaNode *node,
SpaData *sd, *dd;
uint16_t *src, *dst;
double volume;
SpaMemory *sm, *dm;
if (node == NULL || node->handle == NULL || n_info == 0 || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -556,16 +554,13 @@ spa_volume_node_port_pull_output (SpaNode *node,
if (si == sbuf->n_datas || di == dbuf->n_datas)
break;
sd = &SPA_BUFFER_DATAS (sbuf)[si];
dd = &SPA_BUFFER_DATAS (dbuf)[di];
sd = &sbuf->datas[si];
dd = &dbuf->datas[di];
sm = spa_memory_find (&sd->mem.mem);
dm = spa_memory_find (&dd->mem.mem);
src = (uint16_t*) ((uint8_t*)sd->data + sd->offset + soff);
dst = (uint16_t*) ((uint8_t*)dd->data + dd->offset + doff);
src = (uint16_t*) ((uint8_t*)sm->ptr + sd->mem.offset + soff);
dst = (uint16_t*) ((uint8_t*)dm->ptr + dd->mem.offset + doff);
n_bytes = SPA_MIN (sd->mem.size - soff, dd->mem.size - doff);
n_bytes = SPA_MIN (sd->size - soff, dd->size - doff);
n_samples = n_bytes / sizeof (uint16_t);
for (i = 0; i < n_samples; i++)
@ -574,11 +569,11 @@ spa_volume_node_port_pull_output (SpaNode *node,
soff += n_bytes;
doff += n_bytes;
if (soff >= sd->mem.size) {
if (soff >= sd->size) {
si++;
soff = 0;
}
if (doff >= dd->mem.size) {
if (doff >= dd->size) {
di++;
doff = 0;
}

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

@ -159,7 +159,7 @@ spa_xv_sink_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
res = spa_props_copy_values (props, &p->props);
return res;
}

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

@ -190,7 +190,7 @@ make_nodes (AppData *data)
value.value = "hw:0";
value.size = strlen (value.value)+1;
spa_props_set_prop (props, spa_props_index_for_name (props, "device"), &value);
spa_props_set_value (props, spa_props_index_for_name (props, "device"), &value);
if ((res = spa_node_set_props (data->sink, props)) < 0)
printf ("got set_props error %d\n", res);
@ -232,16 +232,16 @@ negotiate_formats (AppData *data)
value.value = &val;
val = SPA_AUDIO_FORMAT_S16LE;
if ((res = spa_props_set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_FORMAT), &value)) < 0)
if ((res = spa_props_set_value (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_FORMAT), &value)) < 0)
return res;
val = 1;
if ((res = spa_props_set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_LAYOUT), &value)) < 0)
if ((res = spa_props_set_value (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_LAYOUT), &value)) < 0)
return res;
val = 44100;
if ((res = spa_props_set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_RATE), &value)) < 0)
if ((res = spa_props_set_value (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_RATE), &value)) < 0)
return res;
val = 2;
if ((res = spa_props_set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_CHANNELS), &value)) < 0)
if ((res = spa_props_set_value (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_CHANNELS), &value)) < 0)
return res;
if ((res = spa_node_port_set_format (data->sink, 0, false, format)) < 0)

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

@ -30,7 +30,6 @@
#include <spa/node.h>
#include <spa/debug.h>
#include <spa/memory.h>
#include <spa/video/format.h>
#define MAX_BUFFERS 8
@ -126,19 +125,18 @@ on_source_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
uint8_t *src, *dst;
SpaMeta *metas;
SpaData *datas;
SpaMemory *mem;
if ((res = spa_node_port_pull_output (data->source, 1, info)) < 0)
printf ("got pull error %d\n", res);
b = data->bp[info->buffer_id];
metas = SPA_BUFFER_METAS (b);
datas = SPA_BUFFER_DATAS (b);
metas = b->metas;
datas = b->datas;
if (metas[1].type == SPA_META_TYPE_POINTER &&
strcmp (SPA_MEMBER (b, metas[1].offset, SpaMetaPointer)->ptr_type, "SDL_Texture") == 0) {
strcmp (((SpaMetaPointer *)metas[1].data)->ptr_type, "SDL_Texture") == 0) {
SDL_Texture *texture;
texture = SPA_MEMBER (b, metas[1].offset, SpaMetaPointer)->ptr;
texture = ((SpaMetaPointer *)metas[1].data)->ptr;
SDL_UnlockTexture(texture);
@ -150,21 +148,17 @@ on_source_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return;
}
mem = spa_memory_find (&datas[0].mem.mem);
mem->ptr = sdata;
mem->type = "sysmem";
mem->size = sstride * 240;
datas[0].mem.size = sstride * 240;
datas[0].type = SPA_DATA_TYPE_MEMPTR;
datas[0].data = sdata;
datas[0].offset = 0;
datas[0].size = sstride * 240;
datas[0].stride = sstride;
} else {
if (SDL_LockTexture (data->texture, NULL, &ddata, &dstride) < 0) {
fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return;
}
mem = spa_memory_find (&datas[0].mem.mem);
sdata = spa_memory_ensure_ptr (mem);
sdata = datas[0].data;
sstride = datas[0].stride;
for (i = 0; i < 240; i++) {
@ -204,7 +198,7 @@ make_nodes (AppData *data, const char *device)
SpaProps *props;
SpaPropValue value;
if ((res = make_node (&data->source, "plugins/v4l2/libspa-v4l2.so", "v4l2-source")) < 0) {
if ((res = make_node (&data->source, "spa/plugins/v4l2/libspa-v4l2.so", "v4l2-source")) < 0) {
printf ("can't create v4l2-source: %d\n", res);
return res;
}
@ -215,7 +209,7 @@ make_nodes (AppData *data, const char *device)
value.value = device ? device : "/dev/video0";
value.size = strlen (value.value)+1;
spa_props_set_prop (props, spa_props_index_for_name (props, "device"), &value);
spa_props_set_value (props, spa_props_index_for_name (props, "device"), &value);
if ((res = spa_node_set_props (data->source, props)) < 0)
printf ("got set_props error %d\n", res);
@ -231,7 +225,6 @@ alloc_buffers (AppData *data)
for (i = 0; i < MAX_BUFFERS; i++) {
SDLBuffer *b = &data->buffers[i];
SDL_Texture *texture;
SpaMemory *mem;
void *ptr;
int stride;
@ -251,39 +244,29 @@ alloc_buffers (AppData *data)
}
b->buffer.id = i;
b->buffer.mem.mem.pool_id = SPA_ID_INVALID;
b->buffer.mem.mem.id = SPA_ID_INVALID;
b->buffer.mem.offset = 0;
b->buffer.mem.size = sizeof (SDLBuffer);
b->buffer.n_metas = 2;
b->buffer.metas = offsetof (SDLBuffer, metas);
b->buffer.metas = b->metas;
b->buffer.n_datas = 1;
b->buffer.datas = offsetof (SDLBuffer, datas);
b->buffer.datas = b->datas;
b->header.flags = 0;
b->header.seq = 0;
b->header.pts = 0;
b->header.dts_offset = 0;
b->metas[0].type = SPA_META_TYPE_HEADER;
b->metas[0].offset = offsetof (SDLBuffer, header);
b->metas[0].data = &b->header;
b->metas[0].size = sizeof (b->header);
b->ptr.ptr_type = "SDL_Texture";
b->ptr.ptr = texture;
b->metas[1].type = SPA_META_TYPE_POINTER;
b->metas[1].offset = offsetof (SDLBuffer, ptr);
b->metas[1].data = &b->ptr;
b->metas[1].size = sizeof (b->ptr);
mem = spa_memory_alloc (SPA_MEMORY_POOL_LOCAL);
mem->flags = SPA_MEMORY_FLAG_READWRITE;
mem->type = "sysmem";
mem->fd = -1;
mem->ptr = ptr;
mem->size = stride * 240;
b->datas[0].mem.mem = mem->mem;
b->datas[0].mem.offset = 0;
b->datas[0].mem.size = mem->size;
b->datas[0].type = SPA_DATA_TYPE_MEMPTR;
b->datas[0].data = ptr;
b->datas[0].offset = 0;
b->datas[0].size = stride * 240;
b->datas[0].stride = stride;
}
data->n_buffers = MAX_BUFFERS;
@ -432,8 +415,6 @@ main (int argc, char *argv[])
AppData data;
SpaResult res;
spa_memory_init ();
data.use_buffer = true;
if (SDL_Init (SDL_INIT_VIDEO) < 0) {