mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-11-02 09:01:50 -05:00
Make buffer structure sharable
Use stucture offsets instead of pointers so that we can share the buffer structure between client and server. We can then pass an fd wrapping the memory of the buffer to the client. Add beginnings of a memory pool
This commit is contained in:
Wim Taymans
parent
3ace7e9648
commit
98993c680b
23 changed files with 456 additions and 583 deletions
|
|
@ -160,7 +160,6 @@ spa_control_clear (SpaControl *control)
|
|||
free (sc->free_data);
|
||||
for (i = 0; i < sc->n_fds; i++) {
|
||||
if (sc->fds[i] > 0) {
|
||||
SPA_DEBUG_CONTROL ("%p: close %d %d", control, i, sc->fds[i]);
|
||||
if (close (sc->fds[i]) < 0)
|
||||
perror ("close");
|
||||
}
|
||||
|
|
@ -340,6 +339,7 @@ spa_control_iter_get_data (SpaControlIter *iter, size_t *size)
|
|||
return si->data;
|
||||
}
|
||||
|
||||
#if 0
|
||||
typedef struct {
|
||||
SpaBuffer buffer;
|
||||
SpaMeta metas[16];
|
||||
|
|
@ -360,16 +360,16 @@ parse_add_buffer (struct stack_iter *si,
|
|||
b->buffer.id = *(uint32_t *)p++;
|
||||
b->buffer.size = *(uint32_t *)p++;
|
||||
b->buffer.n_metas = *(uint32_t *)p++;
|
||||
b->buffer.metas = b->metas;
|
||||
b->buffer.metas = offsetof (MyBuffer, metas);
|
||||
b->buffer.n_datas = *(uint32_t *)p++;
|
||||
b->buffer.datas = b->datas;
|
||||
b->buffer.datas = offsetof (MyBuffer, datas);
|
||||
|
||||
for (i = 0; i < b->buffer.n_metas; i++) {
|
||||
SpaMeta *m = &b->metas[i];
|
||||
m->type = *p++;
|
||||
m->size = *p++;
|
||||
m->data = p;
|
||||
p = p + m->size / 4;
|
||||
m->offset = 0;
|
||||
p = p + (m->size + 3) / 4;
|
||||
}
|
||||
for (i = 0; i < b->buffer.n_datas; i++) {
|
||||
SpaData *d = &b->datas[i];
|
||||
|
|
@ -385,6 +385,7 @@ parse_add_buffer (struct stack_iter *si,
|
|||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
SpaResult
|
||||
spa_control_iter_parse_cmd (SpaControlIter *iter,
|
||||
|
|
@ -477,7 +478,9 @@ spa_control_iter_parse_cmd (SpaControlIter *iter,
|
|||
break;
|
||||
|
||||
case SPA_CONTROL_CMD_ADD_BUFFER:
|
||||
res = parse_add_buffer (si, command);
|
||||
if (si->size < sizeof (SpaControlCmdAddBuffer))
|
||||
return SPA_RESULT_ERROR;
|
||||
memcpy (command, si->data, sizeof (SpaControlCmdAddBuffer));
|
||||
break;
|
||||
|
||||
case SPA_CONTROL_CMD_REMOVE_BUFFER:
|
||||
|
|
@ -716,6 +719,7 @@ builder_add_cmd (struct stack_builder *sb, SpaControlCmd cmd, size_t size)
|
|||
return p;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static SpaResult
|
||||
build_add_buffer (struct stack_builder *sb,
|
||||
SpaControlCmdAddBuffer *command)
|
||||
|
|
@ -767,6 +771,7 @@ build_add_buffer (struct stack_builder *sb,
|
|||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* spa_control_builder_add_cmd:
|
||||
|
|
@ -869,7 +874,8 @@ spa_control_builder_add_cmd (SpaControlBuilder *builder,
|
|||
break;
|
||||
|
||||
case SPA_CONTROL_CMD_ADD_BUFFER:
|
||||
res = build_add_buffer (sb, (SpaControlCmdAddBuffer *) command);
|
||||
p = builder_add_cmd (sb, cmd, sizeof (SpaControlCmdAddBuffer));
|
||||
memcpy (p, command, sizeof (SpaControlCmdAddBuffer));
|
||||
break;
|
||||
|
||||
case SPA_CONTROL_CMD_REMOVE_BUFFER:
|
||||
|
|
@ -980,7 +986,7 @@ spa_control_read (SpaControl *control,
|
|||
}
|
||||
sc->magic = SSC_MAGIC;
|
||||
|
||||
SPA_DEBUG_CONTROL ("read %zd bytes and %d fds\n", len, sc->n_fds);
|
||||
SPA_DEBUG_CONTROL ("control %p: read %zd bytes and %d fds\n", sc, len, sc->n_fds);
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
|
||||
|
|
@ -1009,16 +1015,21 @@ spa_control_write (SpaControl *control,
|
|||
iov[0].iov_len = sc->size;
|
||||
msg.msg_iov = iov;
|
||||
msg.msg_iovlen = 1;
|
||||
msg.msg_control = cmsgbuf;
|
||||
msg.msg_controllen = CMSG_SPACE (fds_len);
|
||||
cmsg = CMSG_FIRSTHDR(&msg);
|
||||
cmsg->cmsg_level = SOL_SOCKET;
|
||||
cmsg->cmsg_type = SCM_RIGHTS;
|
||||
cmsg->cmsg_len = CMSG_LEN (fds_len);
|
||||
cm = (int*)CMSG_DATA (cmsg);
|
||||
for (i = 0; i < fds_len; i++)
|
||||
cm[i] = sc->fds[i] > 0 ? sc->fds[i] : -sc->fds[i];
|
||||
msg.msg_controllen = cmsg->cmsg_len;
|
||||
if (sc->n_fds > 0) {
|
||||
msg.msg_control = cmsgbuf;
|
||||
msg.msg_controllen = CMSG_SPACE (fds_len);
|
||||
cmsg = CMSG_FIRSTHDR(&msg);
|
||||
cmsg->cmsg_level = SOL_SOCKET;
|
||||
cmsg->cmsg_type = SCM_RIGHTS;
|
||||
cmsg->cmsg_len = CMSG_LEN (fds_len);
|
||||
cm = (int*)CMSG_DATA (cmsg);
|
||||
for (i = 0; i < sc->n_fds; i++)
|
||||
cm[i] = sc->fds[i] > 0 ? sc->fds[i] : -sc->fds[i];
|
||||
msg.msg_controllen = cmsg->cmsg_len;
|
||||
} else {
|
||||
msg.msg_control = NULL;
|
||||
msg.msg_controllen = 0;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
len = sendmsg (fd, &msg, 0);
|
||||
|
|
@ -1033,7 +1044,7 @@ spa_control_write (SpaControl *control,
|
|||
if (len != (ssize_t) sc->size)
|
||||
return SPA_RESULT_ERROR;
|
||||
|
||||
SPA_DEBUG_CONTROL ("written %zd bytes\n", len);
|
||||
SPA_DEBUG_CONTROL ("control %p: written %zd bytes and %d fds\n", sc, len, sc->n_fds);
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
|
||||
|
|
|
|||
|
|
@ -79,6 +79,72 @@ spa_debug_port_info (const SpaPortInfo *info)
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaResult
|
||||
spa_debug_buffer (const SpaBuffer *buffer)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (buffer == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
fprintf (stderr, "SpaBuffer %p:\n", buffer);
|
||||
fprintf (stderr, " id: \t%08x\n", buffer->id);
|
||||
fprintf (stderr, " size: \t%zd\n", buffer->size);
|
||||
fprintf (stderr, " n_metas: \t%u (offset %zd)\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);
|
||||
switch (m->type) {
|
||||
case SPA_META_TYPE_HEADER:
|
||||
{
|
||||
SpaMetaHeader *h = SPA_MEMBER (buffer, m->offset, SpaMetaHeader);
|
||||
fprintf (stderr, " SpaMetaHeader:\n");
|
||||
fprintf (stderr, " flags: %08x\n", h->flags);
|
||||
fprintf (stderr, " seq: %u\n", h->seq);
|
||||
fprintf (stderr, " pts: %"PRIi64"\n", h->pts);
|
||||
fprintf (stderr, " dts_offset: %"PRIi64"\n", h->dts_offset);
|
||||
break;
|
||||
}
|
||||
case SPA_META_TYPE_POINTER:
|
||||
fprintf (stderr, " SpaMetaPointer:\n");
|
||||
spa_debug_dump_mem (SPA_MEMBER (buffer, m->offset, void), 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);
|
||||
break;
|
||||
default:
|
||||
spa_debug_dump_mem (SPA_MEMBER (buffer, m->offset, void), m->size);
|
||||
break;
|
||||
}
|
||||
}
|
||||
fprintf (stderr, " n_datas: \t%u (offset %zd)\n", buffer->n_datas, buffer->datas);
|
||||
for (i = 0; i < buffer->n_datas; i++) {
|
||||
SpaData *d = &SPA_BUFFER_DATAS (buffer)[i];
|
||||
fprintf (stderr, " data %d: type %d\n", i, d->type);
|
||||
switch (d->type) {
|
||||
case SPA_DATA_TYPE_MEMPTR:
|
||||
fprintf (stderr, " memptr %p\n", d->ptr);
|
||||
break;
|
||||
case SPA_DATA_TYPE_FD:
|
||||
fprintf (stderr, " fd %d\n", SPA_PTR_TO_INT (d->ptr));
|
||||
break;
|
||||
case SPA_DATA_TYPE_MEMID:
|
||||
fprintf (stderr, " memid %d\n", SPA_PTR_TO_UINT32 (d->ptr));
|
||||
break;
|
||||
case SPA_DATA_TYPE_POINTER:
|
||||
fprintf (stderr, " pointer %p\n", d->ptr);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
SpaResult
|
||||
spa_debug_dump_mem (void *mem, size_t size)
|
||||
{
|
||||
|
|
@ -90,7 +156,7 @@ spa_debug_dump_mem (void *mem, size_t size)
|
|||
|
||||
for (i = 0; i < size; i++) {
|
||||
printf ("%02x ", t[i]);
|
||||
if (i % 16 == 8 || i == size - 1)
|
||||
if (i % 16 == 15 || i == size - 1)
|
||||
printf ("\n");
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
|
|
|
|||
141
spa/lib/memory.c
Normal file
141
spa/lib/memory.c
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
/* 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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "spa/memory.h"
|
||||
|
||||
#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;
|
||||
|
||||
for (i = 0; i < MAX_MEMORIES; i++)
|
||||
pool->free_mem[i] = MAX_MEMORIES - 1 - i;
|
||||
pool->n_free = MAX_MEMORIES;
|
||||
pool->id = id;
|
||||
pool->valid = true;
|
||||
}
|
||||
|
||||
void
|
||||
spa_memory_init (void)
|
||||
{
|
||||
static bool initialized = false;
|
||||
|
||||
if (!initialized) {
|
||||
spa_memory_pool_init (&pools[0], 0);
|
||||
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->pool_id = pool_id;
|
||||
mem->id = id;
|
||||
|
||||
return mem;
|
||||
}
|
||||
|
||||
SpaResult
|
||||
spa_memory_free (uint32_t pool_id, uint32_t id)
|
||||
{
|
||||
SpaMemoryPool *pool;
|
||||
|
||||
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
pool = &pools[pool_id];
|
||||
pool->free_mem[pool->n_free] = id;
|
||||
pool->n_free++;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaMemory *
|
||||
spa_memory_find (uint32_t pool_id, uint32_t id)
|
||||
{
|
||||
SpaMemoryPool *pool;
|
||||
|
||||
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
|
||||
return NULL;
|
||||
|
||||
pool = &pools[pool_id];
|
||||
|
||||
if (id >= MAX_MEMORIES || pool->memories[id].refcount <= 0)
|
||||
return NULL;
|
||||
|
||||
return &pool->memories[id];
|
||||
}
|
||||
|
|
@ -1,6 +1,7 @@
|
|||
spalib_sources = ['audio-raw.c',
|
||||
'control.c',
|
||||
'debug.c',
|
||||
'memory.c',
|
||||
'props.c',
|
||||
'ringbuffer.c',
|
||||
'video-raw.c']
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue