mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

implement set_format

Browse source 
Serialize the formats
Use SpaMemoryRef where we can
Add more debug
This commit is contained in:
Wim Taymans 2016-08-04 17:33:49 +02:00
parent 98679cbd53
commit 8f9222bf9e
19 changed files with 611 additions and 399 deletions
Download patch file Download diff file Expand all files Collapse all files

19
pinos/client/stream.c
View file

@ -603,7 +603,7 @@ parse_control (PinosStream *stream,
/* FIXME send update port status */ /* FIXME send update port status */
/* send state-change */ /* send state-change */
spa_control_builder_init_into (&builder, buffer, 1024, NULL, 0); spa_control_builder_init_into (&builder, buffer, sizeof(buffer), NULL, 0);
sc.state = SPA_NODE_STATE_READY; sc.state = SPA_NODE_STATE_READY;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_STATE_CHANGE, &sc); spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_STATE_CHANGE, &sc);
spa_control_builder_end (&builder, &control); spa_control_builder_end (&builder, &control);
@ -611,6 +611,7 @@ parse_control (PinosStream *stream,
if (spa_control_write (&control, priv->fd) < 0) if (spa_control_write (&control, priv->fd) < 0)
g_warning ("stream %p: error writing control", stream); g_warning ("stream %p: error writing control", stream);
spa_control_clear (&control);
break; break;
} }
case SPA_CONTROL_CMD_SET_PROPERTY: case SPA_CONTROL_CMD_SET_PROPERTY:
@ -647,8 +648,8 @@ parse_control (PinosStream *stream,
if (fd == -1) if (fd == -1)
break; break;
g_debug ("add mem %d, %d, %d", p.mem_id, fd, p.flags); g_debug ("add mem %d,%d, %d, %d", p.mem.pool_id, p.mem.id, fd, p.flags);
mem = spa_memory_import (0, p.mem_id); mem = spa_memory_import (&p.mem);
mem->flags = p.flags; mem->flags = p.flags;
mem->fd = fd; mem->fd = fd;
mem->ptr = NULL; mem->ptr = NULL;
@ -664,7 +665,7 @@ parse_control (PinosStream *stream,
break; break;
g_debug ("stream %p: stop", stream); g_debug ("stream %p: stop", stream);
mem = spa_memory_find (0, p.mem_id); mem = spa_memory_find (&p.mem);
if (--mem->refcount == 0) if (--mem->refcount == 0)
mem->notify (mem); mem->notify (mem);
break; break;
@ -679,13 +680,12 @@ parse_control (PinosStream *stream,
break; break;
g_debug ("add buffer %d", p.buffer_id); g_debug ("add buffer %d", p.buffer_id);
mem = spa_memory_find (0, p.mem_id); mem = spa_memory_find (&p.mem);
bid.cleanup = false; bid.cleanup = false;
bid.id = p.buffer_id; bid.id = p.buffer_id;
bid.offset = p.offset; bid.offset = p.offset;
bid.size = p.size; bid.size = p.size;
bid.buf = (SpaBuffer *)((uint8_t*) spa_memory_ensure_ptr (mem) + p.offset); bid.buf = SPA_MEMBER (spa_memory_ensure_ptr (mem), p.offset, SpaBuffer);
spa_debug_buffer (bid.buf);
g_array_append_val (priv->buffer_ids, bid); g_array_append_val (priv->buffer_ids, bid);
break; break;
@ -711,11 +711,8 @@ parse_control (PinosStream *stream,
if (spa_control_iter_parse_cmd (&it, &p) < 0) if (spa_control_iter_parse_cmd (&it, &p) < 0)
break; break;
if ((bid = find_buffer (stream, p.buffer_id))) { if ((bid = find_buffer (stream, p.buffer_id)))
priv->buffer = bid->buf; priv->buffer = bid->buf;
spa_debug_buffer (bid->buf);
}
break; break;
} }
case SPA_CONTROL_CMD_REUSE_BUFFER: case SPA_CONTROL_CMD_REUSE_BUFFER:

10
pinos/gst/gstpinossink.c
View file

@ -504,7 +504,7 @@ gst_pinos_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
GstMemory *mem = NULL; GstMemory *mem = NULL;
GstClockTime pts, dts, base; GstClockTime pts, dts, base;
gsize size; gsize size;
gboolean tmpfile, res; gboolean res;
pinossink = GST_PINOS_SINK (bsink); pinossink = GST_PINOS_SINK (bsink);
@ -517,6 +517,9 @@ gst_pinos_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
b = g_slice_new (SinkBuffer); b = g_slice_new (SinkBuffer);
b->buffer.id = pinos_fd_manager_get_id (pinossink->fdmanager); b->buffer.id = pinos_fd_manager_get_id (pinossink->fdmanager);
b->buffer.mem.pool_id = SPA_ID_INVALID;
b->buffer.mem.id = SPA_ID_INVALID;
b->buffer.offset = 0;
b->buffer.size = sizeof (SinkBuffer); b->buffer.size = sizeof (SinkBuffer);
b->buffer.n_metas = 1; b->buffer.n_metas = 1;
b->buffer.metas = offsetof (SinkBuffer, metas); b->buffer.metas = offsetof (SinkBuffer, metas);
@ -541,7 +544,6 @@ gst_pinos_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
if (gst_buffer_n_memory (buffer) == 1 if (gst_buffer_n_memory (buffer) == 1
&& gst_is_fd_memory (gst_buffer_peek_memory (buffer, 0))) { && gst_is_fd_memory (gst_buffer_peek_memory (buffer, 0))) {
mem = gst_buffer_get_memory (buffer, 0); mem = gst_buffer_get_memory (buffer, 0);
tmpfile = gst_is_tmpfile_memory (mem);
} else { } else {
GstMapInfo minfo; GstMapInfo minfo;
GstAllocationParams params = {0, 0, 0, 0, { NULL, }}; GstAllocationParams params = {0, 0, 0, 0, { NULL, }};
@ -553,7 +555,6 @@ gst_pinos_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
goto map_error; goto map_error;
gst_buffer_extract (buffer, 0, minfo.data, size); gst_buffer_extract (buffer, 0, minfo.data, size);
gst_memory_unmap (mem, &minfo); gst_memory_unmap (mem, &minfo);
tmpfile = TRUE;
} }
pinos_main_loop_lock (pinossink->loop); pinos_main_loop_lock (pinossink->loop);
@ -563,7 +564,8 @@ gst_pinos_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
b->mem = mem; b->mem = mem;
b->fd = gst_fd_memory_get_fd (mem); b->fd = gst_fd_memory_get_fd (mem);
b->datas[0].mem_id = 0; b->datas[0].mem.pool_id = SPA_ID_INVALID;
b->datas[0].mem.id = SPA_ID_INVALID;
b->datas[0].offset = mem->offset; b->datas[0].offset = mem->offset;
b->datas[0].size = mem->size; b->datas[0].size = mem->size;
b->datas[0].stride = 0; b->datas[0].stride = 0;

2
pinos/gst/gstpinossrc.c
View file

@ -388,7 +388,7 @@ on_new_buffer (GObject *gobject,
SpaData *d = &SPA_BUFFER_DATAS (b)[i]; SpaData *d = &SPA_BUFFER_DATAS (b)[i];
SpaMemory *mem; SpaMemory *mem;
mem = spa_memory_find (0, d->mem_id); mem = spa_memory_find (&d->mem);
if (mem->fd) { if (mem->fd) {
GstMemory *fdmem = NULL; GstMemory *fdmem = NULL;

2
pinos/modules/spa/spa-alsa-sink.c
View file

@ -444,7 +444,7 @@ on_received_buffer (PinosPort *port,
uint8_t *data; uint8_t *data;
size_t size, towrite, total; size_t size, towrite, total;
mem = spa_memory_find (0, d[i].mem_id); mem = spa_memory_find (&d[i].mem);
size = d[i].size; size = d[i].size;
data = (guint8*)mem->ptr + d[i].offset; data = (guint8*)mem->ptr + d[i].offset;

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

@ -28,6 +28,7 @@ typedef struct _SpaBuffer SpaBuffer;
typedef struct _SpaBufferGroup SpaBufferGroup; typedef struct _SpaBufferGroup SpaBufferGroup;
#include <spa/defs.h> #include <spa/defs.h>
#include <spa/memory.h>
/** /**
* SpaMetaType: * SpaMetaType:
@ -89,7 +90,7 @@ typedef struct {
/** /**
* SpaMeta: * SpaMeta:
* @type: metadata type * @type: metadata type
* @offset: offset of metadata * @offset: offset of metadata in the buffer structure
* @size: size of metadata * @size: size of metadata
*/ */
typedef struct { typedef struct {
@ -100,13 +101,13 @@ typedef struct {
/** /**
* SpaData: * SpaData:
* @mem_id: the memory id to use * @mem: reference to the memory to use
* @offset: offset of memory * @offset: ofset in memory
* @size: size of memory * @size: size of memory
* @stride: stride of memory if applicable * @stride: stride of memory if applicable
*/ */
typedef struct { typedef struct {
uint32_t mem_id; SpaMemoryRef mem;
off_t offset; off_t offset;
size_t size; size_t size;
size_t stride; size_t stride;
@ -115,9 +116,9 @@ typedef struct {
/** /**
* SpaBuffer: * SpaBuffer:
* @id: buffer id * @id: buffer id
* @mem_id: memory id of the buffer * @mem: reference to the memory for this buffer
* @offset: offset into the memory * @offset: offset inside memory
* @size: total size of the buffer structure * @size: of of memory
* @n_metas: number of metadata * @n_metas: number of metadata
* @metas: offset of array of @n_metas metadata * @metas: offset of array of @n_metas metadata
* @n_datas: number of data pointers * @n_datas: number of data pointers
@ -125,7 +126,7 @@ typedef struct {
*/ */
struct _SpaBuffer { struct _SpaBuffer {
uint32_t id; uint32_t id;
uint32_t mem_id; SpaMemoryRef mem;
off_t offset; off_t offset;
size_t size; size_t size;
unsigned int n_metas; unsigned int n_metas;

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

@ -145,7 +145,7 @@ typedef struct {
/* SPA_CONTROL_CMD_SET_FORMAT */ /* SPA_CONTROL_CMD_SET_FORMAT */
typedef struct { typedef struct {
uint32_t port_id; uint32_t port_id;
const SpaFormat *format; SpaFormat *format;
} SpaControlCmdSetFormat; } SpaControlCmdSetFormat;
/* SPA_CONTROL_CMD_SET_PROPERTY */ /* SPA_CONTROL_CMD_SET_PROPERTY */
@ -162,7 +162,7 @@ typedef struct {
/* SPA_CONTROL_CMD_ADD_MEM */ /* SPA_CONTROL_CMD_ADD_MEM */
typedef struct { typedef struct {
uint32_t port_id; uint32_t port_id;
uint32_t mem_id; SpaMemoryRef mem;
uint32_t mem_type; uint32_t mem_type;
uint32_t fd_index; uint32_t fd_index;
uint32_t flags; uint32_t flags;
@ -172,16 +172,16 @@ typedef struct {
/* SPA_CONTROL_CMD_REMOVE_MEM */ /* SPA_CONTROL_CMD_REMOVE_MEM */
typedef struct { typedef struct {
uint32_t port_id; uint32_t port_id;
uint32_t mem_id; SpaMemoryRef mem;
} SpaControlCmdRemoveMem; } SpaControlCmdRemoveMem;
/* SPA_CONTROL_CMD_ADD_BUFFER */ /* SPA_CONTROL_CMD_ADD_BUFFER */
typedef struct { typedef struct {
uint32_t port_id; uint32_t port_id;
uint32_t buffer_id; uint32_t buffer_id;
uint32_t mem_id; SpaMemoryRef mem;
uint64_t offset; off_t offset;
uint64_t size; size_t size;
} SpaControlCmdAddBuffer; } SpaControlCmdAddBuffer;
/* SPA_CONTROL_CMD_REMOVE_BUFFER */ /* SPA_CONTROL_CMD_REMOVE_BUFFER */
@ -207,8 +207,6 @@ typedef struct {
} SpaControlCmdReuseBuffer; } SpaControlCmdReuseBuffer;
struct _SpaControlIter { struct _SpaControlIter {
/*< private >*/ /*< private >*/
size_t x[16]; size_t x[16];

6
spa/include/spa/debug.h
View file

@ -27,10 +27,14 @@ extern "C" {
#include <spa/defs.h> #include <spa/defs.h>
#include <spa/port.h> #include <spa/port.h>
#include <spa/buffer.h> #include <spa/buffer.h>
#include <spa/props.h>
#include <spa/format.h>
SpaResult spa_debug_port_info (const SpaPortInfo *info); SpaResult spa_debug_port_info (const SpaPortInfo *info);
SpaResult spa_debug_buffer (const SpaBuffer *buffer); SpaResult spa_debug_buffer (const SpaBuffer *buffer);
SpaResult spa_debug_dump_mem (void *data, size_t size); SpaResult spa_debug_props (const SpaProps *props, bool print_ranges);
SpaResult spa_debug_format (const SpaFormat *format);
SpaResult spa_debug_dump_mem (const void *data, size_t size);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */

1
spa/include/spa/defs.h
View file

@ -73,6 +73,7 @@ typedef void (*SpaNotify) (void *data);
#define SPA_MAX(a,b) ((a)>(b) ? (a) : (b)) #define SPA_MAX(a,b) ((a)>(b) ? (a) : (b))
#define SPA_MEMBER(b,o,t) ((t*)((uint8_t*)(b) + (o))) #define SPA_MEMBER(b,o,t) ((t*)((uint8_t*)(b) + (o)))
#define SPA_PTRDIFF(p1,p2) ((uint8_t*)(p1) - (uint8_t*)(p2))
#define SPA_PTR_TO_INT(p) ((int) ((intptr_t) (p))) #define SPA_PTR_TO_INT(p) ((int) ((intptr_t) (p)))
#define SPA_INT_TO_PTR(u) ((void*) ((intptr_t) (u))) #define SPA_INT_TO_PTR(u) ((void*) ((intptr_t) (u)))

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

@ -25,6 +25,7 @@ extern "C" {
#endif #endif
typedef struct _SpaMemory SpaMemory; typedef struct _SpaMemory SpaMemory;
typedef struct _SpaMemoryRef SpaMemoryRef;
typedef struct _SpaMemoryPool SpaMemoryPool; typedef struct _SpaMemoryPool SpaMemoryPool;
#include <spa/defs.h> #include <spa/defs.h>
@ -43,6 +44,16 @@ typedef enum {
#define SPA_MEMORY_FLAG_READWRITE (SPA_MEMORY_FLAG_READABLE|SPA_MEMORY_FLAG_WRITABLE) #define SPA_MEMORY_FLAG_READWRITE (SPA_MEMORY_FLAG_READABLE|SPA_MEMORY_FLAG_WRITABLE)
/**
* SpaMemoryRef:
* @pool_id: the pool id
* @id: mem_id
*/
struct _SpaMemoryRef {
uint32_t pool_id;
uint32_t id;
};
/** /**
* SpaMemory: * SpaMemory:
* @refcount: a refcount * @refcount: a refcount
@ -58,8 +69,7 @@ typedef enum {
struct _SpaMemory { struct _SpaMemory {
int refcount; int refcount;
SpaNotify notify; SpaNotify notify;
uint32_t pool_id; SpaMemoryRef mem;
uint32_t id;
SpaMemoryFlags flags; SpaMemoryFlags flags;
const char *type; const char *type;
int fd; int fd;
@ -75,10 +85,10 @@ void spa_memory_pool_free (uint32_t);
SpaMemory * spa_memory_alloc (uint32_t pool_id); SpaMemory * spa_memory_alloc (uint32_t pool_id);
SpaMemory * spa_memory_alloc_with_fd (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_free (uint32_t pool_id, uint32_t id);
SpaMemory * spa_memory_import (uint32_t pool_id, uint32_t id);
SpaMemory * spa_memory_find (uint32_t pool_id, uint32_t id); SpaResult spa_memory_free (SpaMemoryRef *ref);
SpaMemory * spa_memory_import (SpaMemoryRef *ref);
SpaMemory * spa_memory_find (SpaMemoryRef *ref);
void * spa_memory_ensure_ptr (SpaMemory *mem); void * spa_memory_ensure_ptr (SpaMemory *mem);

223
spa/lib/control.c
View file

@ -26,6 +26,7 @@
#include <sys/socket.h> #include <sys/socket.h>
#include <spa/control.h> #include <spa/control.h>
#include <spa/debug.h>
#if 0 #if 0
#define SPA_DEBUG_CONTROL(format,args...) fprintf(stderr,format,##args) #define SPA_DEBUG_CONTROL(format,args...) fprintf(stderr,format,##args)
@ -339,6 +340,50 @@ spa_control_iter_get_data (SpaControlIter *iter, size_t *size)
return si->data; return si->data;
} }
static void
iter_parse_set_format (struct stack_iter *si, SpaControlCmdSetFormat *cmd)
{
uint32_t *p = si->data;
SpaProps *tp;
unsigned int i, j;
SpaPropInfo *pi;
SpaPropRangeInfo *ri;
cmd->port_id = *p++;
cmd->format = malloc (si->size - 4);
memcpy (cmd->format, p, si->size - 4);
tp = (SpaProps *) &cmd->format->props;
tp->prop_info = SPA_MEMBER (tp, SPA_PTR_TO_INT (tp->prop_info), SpaPropInfo);
tp->set_prop = spa_props_generic_set_prop;
tp->get_prop = spa_props_generic_get_prop;
tp->priv = NULL;
/* 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->default_value)
pi->default_value = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->default_value), void);
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->value)
ri->value = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->value), void);
}
}
}
SpaResult SpaResult
spa_control_iter_parse_cmd (SpaControlIter *iter, spa_control_iter_parse_cmd (SpaControlIter *iter,
void *command) void *command)
@ -399,12 +444,7 @@ spa_control_iter_parse_cmd (SpaControlIter *iter,
case SPA_CONTROL_CMD_SET_FORMAT: case SPA_CONTROL_CMD_SET_FORMAT:
{ {
SpaControlCmdSetFormat *cmd; iter_parse_set_format (si, command);
uint32_t *p = si->data;
cmd = command;
cmd->port_id = *p++;
cmd->format = (const SpaFormat *)p;
break; break;
} }
@ -507,7 +547,7 @@ spa_control_builder_init_full (SpaControlBuilder *builder,
sb->control.max_size = sizeof (SpaStackHeader) + 128; sb->control.max_size = sizeof (SpaStackHeader) + 128;
sb->control.data = malloc (sb->control.max_size); sb->control.data = malloc (sb->control.max_size);
sb->control.free_data = sb->control.data; sb->control.free_data = sb->control.data;
fprintf (stderr, "builder %p: realloc control memory %zd -> %zd\n", fprintf (stderr, "builder %p: alloc control memory %zd -> %zd\n",
builder, max_data, sb->control.max_size); builder, max_data, sb->control.max_size);
} else { } else {
sb->control.max_size = max_data; sb->control.max_size = max_data;
@ -620,7 +660,12 @@ spa_control_builder_add_fd (SpaControlBuilder *builder,
fprintf (stderr, "builder %p: realloc control fds %d -> %d\n", fprintf (stderr, "builder %p: realloc control fds %d -> %d\n",
builder, sb->control.max_fds, new_size); builder, sb->control.max_fds, new_size);
sb->control.max_fds = new_size; sb->control.max_fds = new_size;
if (sb->control.free_fds == NULL) {
sb->control.free_fds = malloc (new_size * sizeof (int));
memcpy (sb->control.free_fds, sb->control.fds, sb->control.n_fds * sizeof (int));
} else {
sb->control.free_fds = realloc (sb->control.free_fds, new_size * sizeof (int)); sb->control.free_fds = realloc (sb->control.free_fds, new_size * sizeof (int));
}
sb->control.fds = sb->control.free_fds; sb->control.fds = sb->control.free_fds;
} }
index = sb->control.n_fds; index = sb->control.n_fds;
@ -639,7 +684,12 @@ builder_ensure_size (struct stack_builder *sb, size_t size)
fprintf (stderr, "builder %p: realloc control memory %zd -> %zd\n", fprintf (stderr, "builder %p: realloc control memory %zd -> %zd\n",
sb, sb->control.max_size, new_size); sb, sb->control.max_size, new_size);
sb->control.max_size = new_size; sb->control.max_size = new_size;
if (sb->control.free_data == NULL) {
sb->control.free_data = malloc (new_size);
memcpy (sb->control.free_data, sb->control.data, sb->control.size);
} else {
sb->control.free_data = realloc (sb->control.free_data, new_size); sb->control.free_data = realloc (sb->control.free_data, new_size);
}
sb->sh = sb->control.data = sb->control.free_data; sb->sh = sb->control.data = sb->control.free_data;
} }
return (uint8_t *) sb->control.data + sb->control.size; return (uint8_t *) sb->control.data + sb->control.size;
@ -671,6 +721,143 @@ builder_add_cmd (struct stack_builder *sb, SpaControlCmd cmd, size_t size)
return p; return p;
} }
static void
builder_add_set_format (struct stack_builder *sb, SpaControlCmdSetFormat *sf)
{
size_t len, slen;
unsigned int i, j;
void *p, *base;
SpaFormat *tf;
SpaProps *tp;
const SpaProps *sp;
SpaPropInfo *pi, *bpi;
SpaPropRangeInfo *ri, *bri;
sp = &sf->format->props;
/* calculate length */
/* port_id + format + mask */
len = sizeof (uint32_t) + sizeof (SpaFormat) + sizeof (uint32_t);
for (i = 0; i < sp->n_prop_info; i++) {
pi = (SpaPropInfo *) &sp->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 and the default value */
len += pi->maxsize + pi->default_size;
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->size;
}
}
base = builder_add_cmd (sb, SPA_CONTROL_CMD_SET_FORMAT, len);
memcpy (base, &sf->port_id, sizeof (uint32_t));
tf = SPA_MEMBER (base, sizeof (uint32_t), SpaFormat);
tf->media_type = sf->format->media_type;
tf->media_subtype = sf->format->media_subtype;
tp = SPA_MEMBER (tf, offsetof (SpaFormat, props), SpaProps);
tp->n_prop_info = sp->n_prop_info;
tp->prop_info = SPA_INT_TO_PTR (sizeof (SpaFormat) + sizeof (uint32_t));
tp->set_prop = NULL;
tp->get_prop = NULL;
tp->priv = NULL;
/* write propinfo array, adjust offset of mask */
bpi = pi = (SpaPropInfo *) ((uint8_t *)tp + sizeof (SpaFormat) + sizeof (uint32_t));
for (i = 0; i < tp->n_prop_info; i++) {
memcpy (pi, &sp->prop_info[i], sizeof (SpaPropInfo));
pi->mask_offset = sizeof (SpaFormat);
pi->priv = NULL;
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, tf));
for (j = 0; j < pi->n_range_values; j++) {
memcpy (ri, &sp->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, tf));
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, tf));
p += slen;
} else {
pi->description = 0;
}
if (pi->default_value) {
memcpy (p, pi->default_value, pi->default_size);
pi->default_value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += pi->default_size;
} else {
pi->default_value = 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, tf));
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, tf));
p += slen;
} else {
ri->description = 0;
}
if (ri->size) {
memcpy (p, ri->value, ri->size);
ri->value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += ri->size;
} else {
ri->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 (sp, pi->offset, void), pi->maxsize);
pi->offset = SPA_PTRDIFF (p, tf);
p += pi->maxsize;
} else {
pi->offset = 0;
}
pi++;
}
}
/** /**
* spa_control_builder_add_cmd: * spa_control_builder_add_cmd:
* @builder: a #SpaControlBuilder * @builder: a #SpaControlBuilder
@ -736,20 +923,8 @@ spa_control_builder_add_cmd (SpaControlBuilder *builder,
break; break;
case SPA_CONTROL_CMD_SET_FORMAT: case SPA_CONTROL_CMD_SET_FORMAT:
{ builder_add_set_format (sb, command);
size_t len, slen;
SpaControlCmdSetFormat *sf = command;
uint32_t *p;
slen = strlen ("")+1;
/* port + string */
len = 4 + slen;
p = builder_add_cmd (sb, cmd, len);
*p++ = sf->port_id;
memcpy ((char*)p, sf->format, slen);
break; break;
}
case SPA_CONTROL_CMD_SET_PROPERTY: case SPA_CONTROL_CMD_SET_PROPERTY:
fprintf (stderr, "implement builder of %d\n", cmd); fprintf (stderr, "implement builder of %d\n", cmd);
@ -854,7 +1029,13 @@ spa_control_read (SpaControl *control,
if (sc->max_size < need) { if (sc->max_size < need) {
fprintf (stderr, "control: realloc receive memory %zd -> %zd\n", sc->max_size, need); fprintf (stderr, "control: realloc receive memory %zd -> %zd\n", sc->max_size, need);
sc->max_size = need; sc->max_size = need;
hdr = sc->data = sc->free_data = realloc (sc->free_data, need); if (sc->free_data == NULL) {
sc->free_data = malloc (need);
memcpy (sc->free_data, sc->data, len);
} else {
sc->free_data = realloc (sc->free_data, need);
}
hdr = sc->data = sc->free_data;
} }
sc->size = need; sc->size = need;

299
spa/lib/debug.c
View file

@ -21,6 +21,8 @@
#include "spa/debug.h" #include "spa/debug.h"
#include "spa/memory.h" #include "spa/memory.h"
#include "spa/props.h"
#include "spa/format.h"
SpaResult SpaResult
spa_debug_port_info (const SpaPortInfo *info) spa_debug_port_info (const SpaPortInfo *info)
@ -90,7 +92,8 @@ spa_debug_buffer (const SpaBuffer *buffer)
fprintf (stderr, "SpaBuffer %p:\n", buffer); fprintf (stderr, "SpaBuffer %p:\n", buffer);
fprintf (stderr, " id: %08X\n", buffer->id); fprintf (stderr, " id: %08X\n", buffer->id);
fprintf (stderr, " mem_id: %08X\n", buffer->mem_id); fprintf (stderr, " pool_id: %08X\n", buffer->mem.pool_id);
fprintf (stderr, " mem_id: %08X\n", buffer->mem.id);
fprintf (stderr, " offset: %zd\n", buffer->offset); fprintf (stderr, " offset: %zd\n", buffer->offset);
fprintf (stderr, " size: %zd\n", buffer->size); fprintf (stderr, " size: %zd\n", buffer->size);
fprintf (stderr, " n_metas: %u (offset %zd)\n", buffer->n_metas, buffer->metas); fprintf (stderr, " n_metas: %u (offset %zd)\n", buffer->n_metas, buffer->metas);
@ -126,11 +129,11 @@ spa_debug_buffer (const SpaBuffer *buffer)
SpaData *d = &SPA_BUFFER_DATAS (buffer)[i]; SpaData *d = &SPA_BUFFER_DATAS (buffer)[i];
SpaMemory *mem; SpaMemory *mem;
mem = spa_memory_find (0, d->mem_id); mem = spa_memory_find (&d->mem);
fprintf (stderr, " data %d: (memory %p)\n", i, mem); fprintf (stderr, " data %d: (memory %p)\n", i, mem);
if (mem) { if (mem) {
fprintf (stderr, " pool_id: %u\n", mem->pool_id); fprintf (stderr, " pool_id: %u\n", mem->mem.pool_id);
fprintf (stderr, " id: %u\n", mem->id); fprintf (stderr, " id: %u\n", mem->mem.id);
fprintf (stderr, " flags: %08x\n", mem->flags); fprintf (stderr, " flags: %08x\n", mem->flags);
fprintf (stderr, " type: %s\n", mem->type ? mem->type : "*unknown*"); fprintf (stderr, " type: %s\n", mem->type ? mem->type : "*unknown*");
fprintf (stderr, " fd: %d\n", mem->fd); fprintf (stderr, " fd: %d\n", mem->fd);
@ -147,9 +150,9 @@ spa_debug_buffer (const SpaBuffer *buffer)
} }
SpaResult SpaResult
spa_debug_dump_mem (void *mem, size_t size) spa_debug_dump_mem (const void *mem, size_t size)
{ {
uint8_t *t = mem; const uint8_t *t = mem;
int i; int i;
if (mem == NULL) if (mem == NULL)
@ -162,3 +165,287 @@ spa_debug_dump_mem (void *mem, size_t size)
} }
return SPA_RESULT_OK; return SPA_RESULT_OK;
} }
struct media_type_name {
const char *name;
} media_type_names[] = {
{ "unknown" },
{ "audio" },
{ "video" },
};
struct media_subtype_name {
const char *name;
} media_subtype_names[] = {
{ "unknown" },
{ "raw" },
{ "h264" },
{ "mjpg" },
};
struct prop_type_name {
const char *name;
const char *CCName;
} prop_type_names[] = {
{ "invalid", "*Invalid*" },
{ "bool", "Boolean" },
{ "int8", "Int8" },
{ "uint8", "UInt8" },
{ "int16", "Int16" },
{ "uint16", "UInt16" },
{ "int32", "Int32" },
{ "uint32", "UInt32" },
{ "int64", "Int64" },
{ "uint64", "UInt64" },
{ "int", "Int" },
{ "uint", "UInt" },
{ "float", "Float" },
{ "double", "Double" },
{ "string", "String" },
{ "rectangle", "Rectangle" },
{ "fraction", "Fraction" },
{ "bitmask", "Bitmask" },
{ "pointer", "Pointer" },
};
static void
print_value (const SpaPropInfo *info, int size, const void *value)
{
SpaPropType type = info->type;
bool enum_string = false;
if (info->range_type == SPA_PROP_RANGE_TYPE_ENUM) {
int i;
for (i = 0; i < info->n_range_values; i++) {
if (memcmp (info->range_values[i].value, value, size) == 0) {
if (info->range_values[i].name) {
type = SPA_PROP_TYPE_STRING;
value = info->range_values[i].name;
enum_string = true;
}
}
}
}
switch (type) {
case SPA_PROP_TYPE_INVALID:
fprintf (stderr, "invalid");
break;
case SPA_PROP_TYPE_BOOL:
fprintf (stderr, "%s", *(bool *)value ? "true" : "false");
break;
case SPA_PROP_TYPE_INT8:
fprintf (stderr, "%" PRIi8, *(int8_t *)value);
break;
case SPA_PROP_TYPE_UINT8:
fprintf (stderr, "%" PRIu8, *(uint8_t *)value);
break;
case SPA_PROP_TYPE_INT16:
fprintf (stderr, "%" PRIi16, *(int16_t *)value);
break;
case SPA_PROP_TYPE_UINT16:
fprintf (stderr, "%" PRIu16, *(uint16_t *)value);
break;
case SPA_PROP_TYPE_INT32:
fprintf (stderr, stderr, "%" PRIi32, *(int32_t *)value);
break;
case SPA_PROP_TYPE_UINT32:
fprintf (stderr, "%" PRIu32, *(uint32_t *)value);
break;
case SPA_PROP_TYPE_INT64:
fprintf (stderr, "%" PRIi64 "\n", *(int64_t *)value);
break;
case SPA_PROP_TYPE_UINT64:
fprintf (stderr, "%" PRIu64 "\n", *(uint64_t *)value);
break;
case SPA_PROP_TYPE_INT:
fprintf (stderr, "%d", *(int *)value);
break;
case SPA_PROP_TYPE_UINT:
fprintf (stderr, "%u", *(unsigned int *)value);
break;
case SPA_PROP_TYPE_FLOAT:
fprintf (stderr, "%f", *(float *)value);
break;
case SPA_PROP_TYPE_DOUBLE:
fprintf (stderr, "%g", *(double *)value);
break;
case SPA_PROP_TYPE_STRING:
if (enum_string)
fprintf (stderr, "%s", (char *)value);
else
fprintf (stderr, "\"%s\"", (char *)value);
break;
case SPA_PROP_TYPE_RECTANGLE:
{
const SpaRectangle *r = value;
fprintf (stderr, "%"PRIu32"x%"PRIu32, r->width, r->height);
break;
}
case SPA_PROP_TYPE_FRACTION:
{
const SpaFraction *f = value;
fprintf (stderr, "%"PRIu32"/%"PRIu32, f->num, f->denom);
break;
}
case SPA_PROP_TYPE_BITMASK:
break;
case SPA_PROP_TYPE_POINTER:
fprintf (stderr, "%p", value);
break;
default:
break;
}
}
SpaResult
spa_debug_props (const SpaProps *props, bool print_ranges)
{
SpaResult res;
const SpaPropInfo *info;
int i, j;
if (props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
fprintf (stderr, "Properties (%d items):\n", props->n_prop_info);
for (i = 0; i < props->n_prop_info; i++) {
SpaPropValue value;
info = &props->prop_info[i];
fprintf (stderr, " %-20s: %s\n", info->name, info->description);
fprintf (stderr, "%-23.23s flags: ", "");
if (info->flags & SPA_PROP_FLAG_READABLE)
fprintf (stderr, "readable ");
if (info->flags & SPA_PROP_FLAG_WRITABLE)
fprintf (stderr, "writable ");
if (info->flags & SPA_PROP_FLAG_OPTIONAL)
fprintf (stderr, "optional ");
if (info->flags & SPA_PROP_FLAG_DEPRECATED)
fprintf (stderr, "deprecated ");
fprintf (stderr, "\n");
fprintf (stderr, "%-23.23s %s. ", "", prop_type_names[info->type].CCName);
fprintf (stderr, "Default: ");
if (info->default_value)
print_value (info, info->default_size, info->default_value);
else
fprintf (stderr, "None");
res = props->get_prop (props, i, &value);
fprintf (stderr, ". Current: ");
if (res == SPA_RESULT_OK)
print_value (info, value.size, value.value);
else if (res == SPA_RESULT_PROPERTY_UNSET)
fprintf (stderr, "Unset");
else
fprintf (stderr, "Error %d", res);
fprintf (stderr, ".\n");
if (!print_ranges)
continue;
if (info->range_type != SPA_PROP_RANGE_TYPE_NONE) {
fprintf (stderr, "%-23.23s ", "");
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
fprintf (stderr, "Range");
break;
case SPA_PROP_RANGE_TYPE_STEP:
fprintf (stderr, "Step");
break;
case SPA_PROP_RANGE_TYPE_ENUM:
fprintf (stderr, "Enum");
break;
case SPA_PROP_RANGE_TYPE_FLAGS:
fprintf (stderr, "Flags");
break;
default:
fprintf (stderr, "Unknown");
break;
}
fprintf (stderr, ".\n");
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
fprintf (stderr, "%-23.23s ", "");
print_value (info, rinfo->size, rinfo->value);
fprintf (stderr, "\t: %-12s - %s \n", rinfo->name, rinfo->description);
}
}
if (info->tags) {
fprintf (stderr, "Tags: ");
for (j = 0; info->tags[j]; j++) {
fprintf (stderr, "\"%s\" ", info->tags[j]);
}
fprintf (stderr, "\n");
}
}
return SPA_RESULT_OK;
}
SpaResult
spa_debug_format (const SpaFormat *format)
{
const SpaProps *props;
int i;
if (format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
props = &format->props;
fprintf (stderr, "%-6s %s/%s\n", "", media_type_names[format->media_type].name,
media_subtype_names[format->media_subtype].name);
for (i = 0; i < props->n_prop_info; i++) {
const SpaPropInfo *info = &props->prop_info[i];
SpaPropValue value;
SpaResult res;
res = props->get_prop (props, i, &value);
if (res == SPA_RESULT_PROPERTY_UNSET && info->flags & SPA_PROP_FLAG_OPTIONAL)
continue;
fprintf (stderr, " %20s : (%s) ", info->name, prop_type_names[info->type].name);
if (res == SPA_RESULT_OK) {
print_value (info, value.size, value.value);
} else if (res == SPA_RESULT_PROPERTY_UNSET) {
int j;
const char *ssep, *esep, *sep;
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
case SPA_PROP_RANGE_TYPE_STEP:
ssep = "[ ";
sep = ", ";
esep = " ]";
break;
default:
case SPA_PROP_RANGE_TYPE_ENUM:
case SPA_PROP_RANGE_TYPE_FLAGS:
ssep = "{ ";
sep = ", ";
esep = " }";
break;
}
fprintf (stderr, ssep);
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
print_value (info, rinfo->size, rinfo->value);
fprintf (stderr, "%s", j + 1 < info->n_range_values ? sep : "");
}
fprintf (stderr, esep);
} else {
fprintf (stderr, "*Error*");
}
fprintf (stderr, "\n");
}
return SPA_RESULT_OK;
}

33
spa/lib/memory.c
View file

@ -114,8 +114,8 @@ spa_memory_alloc (uint32_t pool_id)
mem = &pool->memories[id]; mem = &pool->memories[id];
mem->refcount = 1; mem->refcount = 1;
mem->notify = NULL; mem->notify = NULL;
mem->pool_id = pool_id; mem->mem.pool_id = pool_id;
mem->id = id; mem->mem.id = id;
return mem; return mem;
} }
@ -159,16 +159,20 @@ spa_memory_alloc_with_fd (uint32_t pool_id, void *data, size_t size)
SpaMemory * SpaMemory *
spa_memory_import (uint32_t pool_id, uint32_t id) spa_memory_import (SpaMemoryRef *ref)
{ {
SpaMemory *mem = NULL; SpaMemory *mem = NULL;
SpaMemoryPool *pool; SpaMemoryPool *pool;
int i; int i;
bool init = false; bool init = false;
uint32_t id, pool_id;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid) if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return NULL; return NULL;
id = ref->id;
pool_id = ref->pool_id;
pool = &pools[pool_id]; pool = &pools[pool_id];
for (i = 0; i < pool->n_free; i++) { for (i = 0; i < pool->n_free; i++) {
@ -184,42 +188,41 @@ spa_memory_import (uint32_t pool_id, uint32_t id)
if (init) { if (init) {
mem->refcount = 1; mem->refcount = 1;
mem->notify = NULL; mem->notify = NULL;
mem->pool_id = pool_id; mem->mem = *ref;
mem->id = id;
} }
return mem; return mem;
} }
SpaResult SpaResult
spa_memory_free (uint32_t pool_id, uint32_t id) spa_memory_free (SpaMemoryRef *ref)
{ {
SpaMemoryPool *pool; SpaMemoryPool *pool;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid) if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return SPA_RESULT_INVALID_ARGUMENTS; return SPA_RESULT_INVALID_ARGUMENTS;
pool = &pools[pool_id]; pool = &pools[ref->pool_id];
pool->free_mem[pool->n_free] = id; pool->free_mem[pool->n_free] = ref->id;
pool->n_free++; pool->n_free++;
return SPA_RESULT_OK; return SPA_RESULT_OK;
} }
SpaMemory * SpaMemory *
spa_memory_find (uint32_t pool_id, uint32_t id) spa_memory_find (SpaMemoryRef *ref)
{ {
SpaMemoryPool *pool; SpaMemoryPool *pool;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid) if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return NULL; return NULL;
pool = &pools[pool_id]; pool = &pools[ref->pool_id];
if (id >= MAX_MEMORIES || pool->memories[id].refcount <= 0) if (ref->id >= MAX_MEMORIES || pool->memories[ref->id].refcount <= 0)
return NULL; return NULL;
return &pool->memories[id]; return &pool->memories[ref->id];
} }
void * void *

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

@ -597,12 +597,12 @@ add_port_data (SpaAudioMixer *this, SpaBuffer *out, SpaAudioMixerPort *port)
while (true) { while (true) {
if (op == NULL) { if (op == NULL) {
mem = spa_memory_find (0, odatas[oi].mem_id); mem = spa_memory_find (&odatas[oi].mem);
op = (uint8_t*)mem->ptr + odatas[oi].offset; op = (uint8_t*)mem->ptr + odatas[oi].offset;
os = odatas[oi].size; os = odatas[oi].size;
} }
if (ip == NULL) { if (ip == NULL) {
mem = spa_memory_find (0, idatas[port->buffer_index].mem_id); mem = spa_memory_find (&idatas[port->buffer_index].mem);
ip = (uint8_t*)mem->ptr + odatas[oi].offset; ip = (uint8_t*)mem->ptr + odatas[oi].offset;
is = idatas[port->buffer_index].size; is = idatas[port->buffer_index].size;
ip += port->buffer_offset; ip += port->buffer_offset;

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

@ -442,7 +442,7 @@ spa_proxy_node_port_set_format (SpaNode *node,
spa_control_builder_init_into (&builder, buf, sizeof (buf), NULL, 0); spa_control_builder_init_into (&builder, buf, sizeof (buf), NULL, 0);
sf.port_id = port_id; sf.port_id = port_id;
sf.format = format; sf.format = (SpaFormat *) format;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_SET_FORMAT, &sf); spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_SET_FORMAT, &sf);
spa_control_builder_end (&builder, &control); spa_control_builder_end (&builder, &control);
@ -563,19 +563,19 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
spa_control_builder_init_into (&builder, buf, sizeof (buf), fds, sizeof (fds)); spa_control_builder_init_into (&builder, buf, sizeof (buf), fds, sizeof (fds));
if (buffer->mem_id == SPA_ID_INVALID) { if (buffer->mem.id == SPA_ID_INVALID) {
fprintf (stderr, "proxy %p: alloc buffer space\n", this); fprintf (stderr, "proxy %p: alloc buffer space\n", this);
bmem = spa_memory_alloc_with_fd (0, buffer, buffer->size); bmem = spa_memory_alloc_with_fd (0, buffer, buffer->size);
b = spa_memory_ensure_ptr (bmem); b = spa_memory_ensure_ptr (bmem);
b->mem_id = bmem->id; b->mem = bmem->mem;
b->offset = 0; b->offset = 0;
} else { } else {
bmem = spa_memory_find (0, buffer->mem_id); bmem = spa_memory_find (&buffer->mem);
b = buffer; b = buffer;
} }
am.port_id = port_id; am.port_id = port_id;
am.mem_id = bmem->id; am.mem = bmem->mem;
am.mem_type = 0; am.mem_type = 0;
am.fd_index = spa_control_builder_add_fd (&builder, bmem->fd, false); am.fd_index = spa_control_builder_add_fd (&builder, bmem->fd, false);
am.flags = bmem->flags; am.flags = bmem->flags;
@ -586,13 +586,13 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
SpaData *d = &SPA_BUFFER_DATAS (b)[i]; SpaData *d = &SPA_BUFFER_DATAS (b)[i];
SpaMemory *mem; SpaMemory *mem;
if (!(mem = spa_memory_find (0, d->mem_id))) { if (!(mem = spa_memory_find (&d->mem))) {
fprintf (stderr, "proxy %p: error invalid memory\n", this); fprintf (stderr, "proxy %p: error invalid memory\n", this);
continue; continue;
} }
am.port_id = port_id; am.port_id = port_id;
am.mem_id = mem->id; am.mem = mem->mem;
am.mem_type = 0; am.mem_type = 0;
am.fd_index = spa_control_builder_add_fd (&builder, mem->fd, false); am.fd_index = spa_control_builder_add_fd (&builder, mem->fd, false);
am.flags = mem->flags; am.flags = mem->flags;
@ -601,7 +601,7 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
} }
ab.port_id = port_id; ab.port_id = port_id;
ab.buffer_id = b->id; ab.buffer_id = b->id;
ab.mem_id = bmem->id; ab.mem = bmem->mem;
ab.offset = b->offset; ab.offset = b->offset;
ab.size = b->size; ab.size = b->size;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_BUFFER, &ab); spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_BUFFER, &ab);
@ -632,14 +632,14 @@ remove_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
rb.buffer_id = buffer->id; rb.buffer_id = buffer->id;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_BUFFER, &rb); spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_BUFFER, &rb);
rm.port_id = port_id; rm.port_id = port_id;
rm.mem_id = buffer->mem_id; rm.mem = buffer->mem;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_MEM, &rm); spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_MEM, &rm);
for (i = 0; i < buffer->n_datas; i++) { for (i = 0; i < buffer->n_datas; i++) {
SpaData *d = &SPA_BUFFER_DATAS (buffer)[i]; SpaData *d = &SPA_BUFFER_DATAS (buffer)[i];
rm.port_id = port_id; rm.port_id = port_id;
rm.mem_id = d->mem_id; rm.mem = d->mem;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_MEM, &rm); spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_MEM, &rm);
} }
spa_control_builder_end (&builder, &control); spa_control_builder_end (&builder, &control);

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

@ -526,18 +526,18 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
state->reqbuf = reqbuf; state->reqbuf = reqbuf;
if (state->alloc_mem) if (state->alloc_mem)
spa_memory_free (state->alloc_mem->pool_id, state->alloc_mem->id); spa_memory_free (&state->alloc_mem->mem);
state->alloc_mem = spa_memory_alloc_with_fd (0, NULL, sizeof (V4l2Buffer) * reqbuf.count); state->alloc_mem = spa_memory_alloc_with_fd (0, NULL, sizeof (V4l2Buffer) * reqbuf.count);
state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem); state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem);
for (i = 0; i < reqbuf.count; i++) { for (i = 0; i < reqbuf.count; i++) {
V4l2Buffer *b; V4l2Buffer *b;
uint32_t mem_id; SpaMemoryRef *mem_ref;
SpaMemory *mem; SpaMemory *mem;
SpaData *d = SPA_BUFFER_DATAS (buffers[i]); SpaData *d = SPA_BUFFER_DATAS (buffers[i]);
b = &state->alloc_buffers[i]; b = &state->alloc_buffers[i];
b->buffer.mem_id = state->alloc_mem->id; b->buffer.mem = state->alloc_mem->mem;
b->buffer.offset = sizeof (V4l2Buffer) * i; b->buffer.offset = sizeof (V4l2Buffer) * i;
b->buffer.size = sizeof (V4l2Buffer); b->buffer.size = sizeof (V4l2Buffer);
b->buffer.id = SPA_ID_INVALID; b->buffer.id = SPA_ID_INVALID;
@ -546,8 +546,8 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
fprintf (stderr, "import buffer %p\n", buffers[i]); fprintf (stderr, "import buffer %p\n", buffers[i]);
mem_id = SPA_BUFFER_DATAS (buffers[i])[0].mem_id; mem_ref = &SPA_BUFFER_DATAS (buffers[i])[0].mem;
if (!(mem = spa_memory_find (0, mem_id))) { if (!(mem = spa_memory_find (mem_ref))) {
fprintf (stderr, "invalid memory on buffer %p\n", buffers[i]); fprintf (stderr, "invalid memory on buffer %p\n", buffers[i]);
continue; continue;
} }
@ -559,8 +559,6 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
b->v4l2_buffer.m.userptr = (unsigned long) ((uint8_t*)mem->ptr + d[0].offset); b->v4l2_buffer.m.userptr = (unsigned long) ((uint8_t*)mem->ptr + d[0].offset);
b->v4l2_buffer.length = d[0].size; b->v4l2_buffer.length = d[0].size;
spa_debug_buffer (b->outbuf);
spa_v4l2_buffer_recycle (this, buffers[i]->id); spa_v4l2_buffer_recycle (this, buffers[i]->id);
} }
state->have_buffers = true; state->have_buffers = true;
@ -604,7 +602,7 @@ mmap_init (SpaV4l2Source *this,
state->reqbuf = reqbuf; state->reqbuf = reqbuf;
if (state->alloc_mem) if (state->alloc_mem)
spa_memory_free (state->alloc_mem->pool_id, state->alloc_mem->id); spa_memory_free (&state->alloc_mem->mem);
state->alloc_mem = spa_memory_alloc_with_fd (0, NULL, sizeof (V4l2Buffer) * reqbuf.count); state->alloc_mem = spa_memory_alloc_with_fd (0, NULL, sizeof (V4l2Buffer) * reqbuf.count);
state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem); state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem);
@ -625,7 +623,7 @@ mmap_init (SpaV4l2Source *this,
b = &state->alloc_buffers[i]; b = &state->alloc_buffers[i];
b->buffer.id = i; b->buffer.id = i;
b->buffer.mem_id = state->alloc_mem->id; b->buffer.mem = state->alloc_mem->mem;
b->buffer.offset = sizeof (V4l2Buffer) * i; b->buffer.offset = sizeof (V4l2Buffer) * i;
b->buffer.size = sizeof (V4l2Buffer); b->buffer.size = sizeof (V4l2Buffer);
@ -648,7 +646,7 @@ mmap_init (SpaV4l2Source *this,
mem = spa_memory_alloc (0); mem = spa_memory_alloc (0);
mem->flags = SPA_MEMORY_FLAG_READABLE; mem->flags = SPA_MEMORY_FLAG_READABLE;
mem->size = buf.length; mem->size = buf.length;
b->datas[0].mem_id = mem->id; b->datas[0].mem = mem->mem;
b->datas[0].offset = 0; b->datas[0].offset = 0;
b->datas[0].size = buf.length; b->datas[0].size = buf.length;
b->datas[0].stride = state->fmt.fmt.pix.bytesperline; b->datas[0].stride = state->fmt.fmt.pix.bytesperline;
@ -690,8 +688,6 @@ mmap_init (SpaV4l2Source *this,
b->v4l2_buffer.memory = state->memtype; b->v4l2_buffer.memory = state->memtype;
b->v4l2_buffer.index = i; b->v4l2_buffer.index = i;
spa_debug_buffer (b->outbuf);
spa_v4l2_buffer_recycle (this, i); spa_v4l2_buffer_recycle (this, i);
} }
state->have_buffers = true; state->have_buffers = true;
@ -799,13 +795,13 @@ spa_v4l2_stop (SpaV4l2Source *this)
fprintf (stderr, "queueing outstanding buffer %p\n", b); fprintf (stderr, "queueing outstanding buffer %p\n", b);
spa_v4l2_buffer_recycle (this, i); spa_v4l2_buffer_recycle (this, i);
} }
mem = spa_memory_find (0, b->datas[0].mem_id); mem = spa_memory_find (&b->datas[0].mem);
if (state->export_buf) { if (state->export_buf) {
close (mem->fd); close (mem->fd);
} else { } else {
munmap (mem->ptr, mem->size); munmap (mem->ptr, mem->size);
} }
spa_memory_free (0, mem->id); spa_memory_free (&mem->mem);
} }
state->have_buffers = false; state->have_buffers = false;

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

@ -583,8 +583,8 @@ spa_volume_node_port_pull_output (SpaNode *node,
sd = &SPA_BUFFER_DATAS (sbuf)[si]; sd = &SPA_BUFFER_DATAS (sbuf)[si];
dd = &SPA_BUFFER_DATAS (dbuf)[di]; dd = &SPA_BUFFER_DATAS (dbuf)[di];
sm = spa_memory_find (0, sd->mem_id); sm = spa_memory_find (&sd->mem);
dm = spa_memory_find (0, dd->mem_id); dm = spa_memory_find (&dd->mem);
src = (uint16_t*) ((uint8_t*)sm->ptr + sd->offset + soff); src = (uint16_t*) ((uint8_t*)sm->ptr + sd->offset + soff);
dst = (uint16_t*) ((uint8_t*)dm->ptr + dd->offset + doff); dst = (uint16_t*) ((uint8_t*)dm->ptr + dd->offset + doff);

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

@ -150,7 +150,7 @@ on_source_event (SpaNode *node, SpaEvent *event, void *user_data)
fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError()); fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return; return;
} }
mem = spa_memory_find (0, datas[0].mem_id); mem = spa_memory_find (&datas[0].mem);
mem->ptr = sdata; mem->ptr = sdata;
mem->type = "sysmem"; mem->type = "sysmem";
mem->size = sstride * 240; mem->size = sstride * 240;
@ -162,7 +162,7 @@ on_source_event (SpaNode *node, SpaEvent *event, void *user_data)
fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError()); fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return; return;
} }
mem = spa_memory_find (0, datas[0].mem_id); mem = spa_memory_find (&datas[0].mem);
sdata = spa_memory_ensure_ptr (mem); sdata = spa_memory_ensure_ptr (mem);
sstride = datas[0].stride; sstride = datas[0].stride;
@ -252,6 +252,9 @@ alloc_buffers (AppData *data)
} }
b->buffer.id = i; b->buffer.id = i;
b->buffer.mem.pool_id = SPA_ID_INVALID;
b->buffer.mem.id = SPA_ID_INVALID;
b->buffer.offset = 0;
b->buffer.size = sizeof (SDLBuffer); b->buffer.size = sizeof (SDLBuffer);
b->buffer.n_metas = 2; b->buffer.n_metas = 2;
b->buffer.metas = offsetof (SDLBuffer, metas); b->buffer.metas = offsetof (SDLBuffer, metas);
@ -279,7 +282,7 @@ alloc_buffers (AppData *data)
mem->ptr = ptr; mem->ptr = ptr;
mem->size = stride * 240; mem->size = stride * 240;
b->datas[0].mem_id = mem->id; b->datas[0].mem = mem->mem;
b->datas[0].offset = 0; b->datas[0].offset = 0;
b->datas[0].size = mem->size; b->datas[0].size = mem->size;
b->datas[0].stride = stride; b->datas[0].stride = stride;

1
spa/tools/meson.build
View file

@ -1,4 +1,5 @@
executable('spa-inspect', 'spa-inspect.c', executable('spa-inspect', 'spa-inspect.c',
include_directories : inc, include_directories : inc,
dependencies : [dl_lib], dependencies : [dl_lib],
link_with : spalib,
install : true) install : true)

282
spa/tools/spa-inspect.c
View file

@ -24,279 +24,7 @@
#include <dlfcn.h> #include <dlfcn.h>
#include <spa/node.h> #include <spa/node.h>
#include <spa/debug.h>
struct media_type_name {
const char *name;
} media_type_names[] = {
{ "unknown" },
{ "audio" },
{ "video" },
};
struct media_subtype_name {
const char *name;
} media_subtype_names[] = {
{ "unknown" },
{ "raw" },
{ "h264" },
{ "mjpg" },
};
struct prop_type_name {
const char *name;
const char *CCName;
} prop_type_names[] = {
{ "invalid", "*Invalid*" },
{ "bool", "Boolean" },
{ "int8", "Int8" },
{ "uint8", "UInt8" },
{ "int16", "Int16" },
{ "uint16", "UInt16" },
{ "int32", "Int32" },
{ "uint32", "UInt32" },
{ "int64", "Int64" },
{ "uint64", "UInt64" },
{ "int", "Int" },
{ "uint", "UInt" },
{ "double", "Double" },
{ "string", "String" },
{ "rectangle", "Rectangle" },
{ "fraction", "Fraction" },
{ "bitmask", "Bitmask" },
{ "pointer", "Pointer" },
};
static void
print_value (const SpaPropInfo *info, int size, const void *value)
{
SpaPropType type = info->type;
bool enum_string = false;
if (info->range_type == SPA_PROP_RANGE_TYPE_ENUM) {
int i;
for (i = 0; i < info->n_range_values; i++) {
if (memcmp (info->range_values[i].value, value, size) == 0) {
if (info->range_values[i].name) {
type = SPA_PROP_TYPE_STRING;
value = info->range_values[i].name;
enum_string = true;
}
}
}
}
switch (type) {
case SPA_PROP_TYPE_INVALID:
printf ("invalid");
break;
case SPA_PROP_TYPE_BOOL:
printf ("%s", *(bool *)value ? "true" : "false");
break;
case SPA_PROP_TYPE_INT8:
printf ("%" PRIi8, *(int8_t *)value);
break;
case SPA_PROP_TYPE_UINT8:
printf ("%" PRIu8, *(uint8_t *)value);
break;
case SPA_PROP_TYPE_INT16:
printf ("%" PRIi16, *(int16_t *)value);
break;
case SPA_PROP_TYPE_UINT16:
printf ("%" PRIu16, *(uint16_t *)value);
break;
case SPA_PROP_TYPE_INT32:
printf ("%" PRIi32, *(int32_t *)value);
break;
case SPA_PROP_TYPE_UINT32:
printf ("%" PRIu32, *(uint32_t *)value);
break;
case SPA_PROP_TYPE_INT64:
printf ("%" PRIi64 "\n", *(int64_t *)value);
break;
case SPA_PROP_TYPE_UINT64:
printf ("%" PRIu64 "\n", *(uint64_t *)value);
break;
case SPA_PROP_TYPE_INT:
printf ("%d", *(int *)value);
break;
case SPA_PROP_TYPE_UINT:
printf ("%u", *(unsigned int *)value);
break;
case SPA_PROP_TYPE_FLOAT:
printf ("%f", *(float *)value);
break;
case SPA_PROP_TYPE_DOUBLE:
printf ("%g", *(double *)value);
break;
case SPA_PROP_TYPE_STRING:
if (enum_string)
printf ("%s", (char *)value);
else
printf ("\"%s\"", (char *)value);
break;
case SPA_PROP_TYPE_RECTANGLE:
{
const SpaRectangle *r = value;
printf ("%"PRIu32"x%"PRIu32, r->width, r->height);
break;
}
case SPA_PROP_TYPE_FRACTION:
{
const SpaFraction *f = value;
printf ("%"PRIu32"/%"PRIu32, f->num, f->denom);
break;
}
case SPA_PROP_TYPE_BITMASK:
break;
case SPA_PROP_TYPE_POINTER:
printf ("%p", value);
break;
default:
break;
}
}
static void
print_props (const SpaProps *props, int print_ranges)
{
SpaResult res;
const SpaPropInfo *info;
int i, j;
printf ("Properties (%d items):\n", props->n_prop_info);
for (i = 0; i < props->n_prop_info; i++) {
SpaPropValue value;
info = &props->prop_info[i];
printf (" %-20s: %s\n", info->name, info->description);
printf ("%-23.23s flags: ", "");
if (info->flags & SPA_PROP_FLAG_READABLE)
printf ("readable ");
if (info->flags & SPA_PROP_FLAG_WRITABLE)
printf ("writable ");
if (info->flags & SPA_PROP_FLAG_OPTIONAL)
printf ("optional ");
if (info->flags & SPA_PROP_FLAG_DEPRECATED)
printf ("deprecated ");
printf ("\n");
printf ("%-23.23s %s. ", "", prop_type_names[info->type].CCName);
printf ("Default: ");
if (info->default_value)
print_value (info, info->default_size, info->default_value);
else
printf ("None");
res = props->get_prop (props, i, &value);
printf (". Current: ");
if (res == SPA_RESULT_OK)
print_value (info, value.size, value.value);
else if (res == SPA_RESULT_PROPERTY_UNSET)
printf ("Unset");
else
printf ("Error %d", res);
printf (".\n");
if (!print_ranges)
continue;
if (info->range_type != SPA_PROP_RANGE_TYPE_NONE) {
printf ("%-23.23s ", "");
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
printf ("Range");
break;
case SPA_PROP_RANGE_TYPE_STEP:
printf ("Step");
break;
case SPA_PROP_RANGE_TYPE_ENUM:
printf ("Enum");
break;
case SPA_PROP_RANGE_TYPE_FLAGS:
printf ("Flags");
break;
default:
printf ("Unknown");
break;
}
printf (".\n");
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
printf ("%-23.23s ", "");
print_value (info, rinfo->size, rinfo->value);
printf ("\t: %-12s - %s \n", rinfo->name, rinfo->description);
}
}
if (info->tags) {
printf ("Tags: ");
for (j = 0; info->tags[j]; j++) {
printf ("\"%s\" ", info->tags[j]);
}
printf ("\n");
}
}
}
static void
print_format (const SpaFormat *format)
{
const SpaProps *props = &format->props;
int i;
printf ("%-6s %s/%s\n", "", media_type_names[format->media_type].name,
media_subtype_names[format->media_subtype].name);
for (i = 0; i < props->n_prop_info; i++) {
const SpaPropInfo *info = &props->prop_info[i];
SpaPropValue value;
SpaResult res;
res = props->get_prop (props, i, &value);
if (res == SPA_RESULT_PROPERTY_UNSET && info->flags & SPA_PROP_FLAG_OPTIONAL)
continue;
printf (" %20s : (%s) ", info->name, prop_type_names[info->type].name);
if (res == SPA_RESULT_OK) {
print_value (info, value.size, value.value);
} else if (res == SPA_RESULT_PROPERTY_UNSET) {
int j;
const char *ssep, *esep, *sep;
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
case SPA_PROP_RANGE_TYPE_STEP:
ssep = "[ ";
sep = ", ";
esep = " ]";
break;
default:
case SPA_PROP_RANGE_TYPE_ENUM:
case SPA_PROP_RANGE_TYPE_FLAGS:
ssep = "{ ";
sep = ", ";
esep = " }";
break;
}
printf (ssep);
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
print_value (info, rinfo->size, rinfo->value);
printf ("%s", j + 1 < info->n_range_values ? sep : "");
}
printf (esep);
} else {
printf ("*Error*");
}
printf ("\n");
}
}
static void static void
inspect_node (SpaNode *node) inspect_node (SpaNode *node)
@ -310,7 +38,7 @@ inspect_node (SpaNode *node)
if ((res = node->get_props (node, &props)) < 0) if ((res = node->get_props (node, &props)) < 0)
printf ("can't get properties: %d\n", res); printf ("can't get properties: %d\n", res);
else else
print_props (props, 1); spa_debug_props (props, true);
if ((res = node->get_n_ports (node, &n_input, &max_input, &n_output, &max_output)) < 0) if ((res = node->get_n_ports (node, &n_input, &max_input, &n_output, &max_output)) < 0)
printf ("can't get n_ports: %d\n", res); printf ("can't get n_ports: %d\n", res);
@ -324,12 +52,12 @@ inspect_node (SpaNode *node)
break; break;
} }
if (format) if (format)
print_format (format); spa_debug_format (format);
} }
if ((res = node->port_get_props (node, 0, &props)) < 0) if ((res = node->port_get_props (node, 0, &props)) < 0)
printf ("port_get_props error: %d\n", res); printf ("port_get_props error: %d\n", res);
else else
print_props (props, 1); spa_debug_props (props, true);
} }
static void static void
@ -343,7 +71,7 @@ inspect_factory (const SpaHandleFactory *factory)
printf ("factory name:\t\t'%s'\n", factory->name); printf ("factory name:\t\t'%s'\n", factory->name);
printf ("factory info:\n"); printf ("factory info:\n");
if (factory->info) if (factory->info)
print_props (factory->info, 1); spa_debug_props (factory->info, true);
else else
printf (" none\n"); printf (" none\n");