mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-31 22:25:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Make buffer structure sharable

Browse source 
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 2016-08-03 15:59:17 +02:00
parent 3ace7e9648
commit 98993c680b
23 changed files with 456 additions and 583 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -588,17 +588,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);
op = ip = NULL;
while (true) {
if (op == NULL) {
op = out->datas[oi].ptr;
os = out->datas[oi].size;
op = odatas[oi].ptr;
os = odatas[oi].size;
}
if (ip == NULL) {
ip = port->buffer->datas[port->buffer_index].ptr;
is = port->buffer->datas[port->buffer_index].size;
ip = idatas[port->buffer_index].ptr;
is = idatas[port->buffer_index].size;
ip += port->buffer_offset;
is -= port->buffer_offset;
}

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

@ -55,8 +55,9 @@ typedef struct {
SpaPortInfo info;
SpaPortStatus status;
SpaFormat formats[2];
SpaBuffer **buffers;
unsigned int n_buffers;
SpaBuffer **buffers;
SpaBuffer *remote_buffers[128];
} SpaProxyPort;
struct _SpaProxy {
@ -566,13 +567,6 @@ tmpfile_create (void *data, size_t size)
return fd;
}
typedef struct {
SpaBuffer buffer;
SpaData datas[16];
int idx[16];
SpaBuffer *orig;
} MyBuffer;
static SpaResult
add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
{
@ -581,51 +575,53 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
uint8_t buf[1024];
int fds[16];
SpaControlCmdAddBuffer ab;
bool tmpfile = false;
unsigned int i;
MyBuffer b;
int fd, i;
SpaResult res;
SpaBuffer *b;
spa_control_builder_init_into (&builder, buf, sizeof (buf), fds, sizeof (fds));
b.buffer.id = buffer->id;
b.buffer.size = buffer->size;
b.buffer.n_metas = buffer->n_metas;
b.buffer.metas = buffer->metas;
b.buffer.n_datas = buffer->n_datas;
b.buffer.datas = b.datas;
fd = tmpfile_create (buffer, buffer->size);
for (i = 0; i < buffer->n_datas; i++) {
SpaData *d = &buffer->datas[i];
b = mmap (NULL, buffer->size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
for (i = 0; i < b->n_datas; i++) {
SpaData *d = &SPA_BUFFER_DATAS (b)[i];
int fd;
SpaControlCmdAddMem am;
bool tmpfile;
if (d->type == SPA_DATA_TYPE_FD) {
fd = *((int *)d->ptr);
} else {
fd = SPA_PTR_TO_INT (d->ptr);
tmpfile = false;
} else if (d->type == SPA_DATA_TYPE_MEMPTR) {
fd = tmpfile_create (d->ptr, d->size + d->offset);
tmpfile = true;
} else {
fprintf (stderr, "proxy %p: invalid mem type received %d\n", this, d->type);
continue;
}
am.port_id = port_id;
am.mem_id = buffer->id * 64 + i;
am.mem_id = b->id * 64 + i;
am.mem_type = 0;
am.fd_index = spa_control_builder_add_fd (&builder, fd, tmpfile ? true : false);
am.offset = 0;
am.size = d->offset + d->size;
am.offset = d->offset;
am.size = d->size;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_MEM, &am);
b.idx[i] = am.mem_id;
b.datas[i].type = SPA_DATA_TYPE_MEMID;
b.datas[i].ptr_type = NULL;
b.datas[i].ptr = &b.idx[i];
b.datas[i].offset = d->offset;
b.datas[i].size = d->size;
b.datas[i].stride = d->stride;
d->type = SPA_DATA_TYPE_MEMID;
d->ptr_type = NULL;
d->ptr = SPA_UINT32_TO_PTR (am.mem_id);
d->offset = 0;
}
ab.port_id = port_id;
ab.buffer = &b.buffer;
fprintf (stderr, "proxy %p: add buffer %d\n", this, b.buffer.id);
ab.buffer_id = b->id;
ab.fd_index = spa_control_builder_add_fd (&builder, fd, true);
ab.offset = 0;
ab.size = b->size;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_BUFFER, &ab);
munmap (b, buffer->size);
spa_control_builder_end (&builder, &control);
if ((res = spa_control_write (&control, this->fds[0].fd)) < 0)
@ -654,7 +650,7 @@ remove_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
for (i = 0; i < buffer->n_datas; i++) {
SpaControlCmdRemoveMem rm;
rm.port_id = port_id;
rm.mem_id = i;
rm.mem_id = buffer->id * 64 + i;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_MEM, &rm);
}
spa_control_builder_end (&builder, &control);
@ -868,8 +864,6 @@ parse_control (SpaProxy *this,
while (spa_control_iter_next (&it) == SPA_RESULT_OK) {
SpaControlCmd cmd = spa_control_iter_get_cmd (&it);
fprintf (stderr, "proxy %p: got control %d\n", this, cmd);
switch (cmd) {
case SPA_CONTROL_CMD_ADD_PORT:
case SPA_CONTROL_CMD_REMOVE_PORT:

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

@ -26,6 +26,7 @@
#include <spa/node.h>
#include <spa/video/format.h>
#include <spa/debug.h>
typedef struct _SpaV4l2Source SpaV4l2Source;
@ -721,7 +722,7 @@ v4l2_source_init (const SpaHandleFactory *factory,
this->state[0].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[0].status.flags = SPA_PORT_STATUS_FLAG_NONE;
this->state[0].export_buf = false;
this->state[0].export_buf = true;
return SPA_RESULT_OK;
}

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

@ -531,12 +531,7 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
fprintf (stderr, "import buffer %p\n", buffers[i]);
b->source = this;
b->buffer.id = buffers[i]->id;
b->buffer.size = buffers[i]->size;
b->buffer.n_metas = buffers[i]->n_metas;
b->buffer.metas = buffers[i]->metas;
b->buffer.n_datas = buffers[i]->n_datas;
b->buffer.datas = buffers[i]->datas;
b->buffer.id = SPA_ID_INVALID;
b->imported = buffers[i];
b->outstanding = true;
@ -544,8 +539,8 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
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) b->buffer.datas[0].ptr;
b->v4l2_buffer.length = b->buffer.datas[0].size;
b->v4l2_buffer.m.userptr = (unsigned long) SPA_BUFFER_DATAS (buffers[i])[0].ptr;
b->v4l2_buffer.length = SPA_BUFFER_DATAS (buffers[i])[0].size;
spa_v4l2_buffer_recycle (this, buffers[i]->id);
}
@ -609,11 +604,11 @@ mmap_init (SpaV4l2Source *this,
b->source = this;
b->buffer.id = i;
b->buffer.size = buf.length;
b->buffer.size = sizeof (V4l2Buffer);
b->buffer.n_metas = 1;
b->buffer.metas = b->metas;
b->buffer.metas = offsetof (V4l2Buffer, metas);
b->buffer.n_datas = 1;
b->buffer.datas = b->datas;
b->buffer.datas = offsetof (V4l2Buffer, datas);
b->header.flags = 0;
b->header.seq = 0;
@ -621,7 +616,7 @@ mmap_init (SpaV4l2Source *this,
b->header.dts_offset = 0;
b->metas[0].type = SPA_META_TYPE_HEADER;
b->metas[0].data = &b->header;
b->metas[0].offset = offsetof (V4l2Buffer, header);
b->metas[0].size = sizeof (b->header);
if (state->export_buf) {
@ -637,12 +632,13 @@ mmap_init (SpaV4l2Source *this,
b->dmafd = expbuf.fd;
b->datas[0].type = SPA_DATA_TYPE_FD;
b->datas[0].ptr = &b->dmafd;
b->datas[0].ptr = SPA_INT_TO_PTR (b->dmafd);
b->datas[0].ptr_type = "dmabuf";
b->datas[0].offset = 0;
b->datas[0].size = buf.length;
b->datas[0].stride = state->fmt.fmt.pix.bytesperline;
} else {
#if 1
b->datas[0].type = SPA_DATA_TYPE_MEMPTR;
b->datas[0].ptr_type = "sysmem";
b->datas[0].ptr = mmap (NULL,
@ -653,11 +649,18 @@ mmap_init (SpaV4l2Source *this,
buf.m.offset);
b->datas[0].offset = 0;
b->datas[0].size = buf.length;
b->datas[0].stride = state->fmt.fmt.pix.bytesperline;
if (b->datas[0].ptr == MAP_FAILED) {
perror ("mmap");
continue;
}
#else
b->datas[0].type = SPA_DATA_TYPE_FD;
b->datas[0].ptr = &state->fd;
b->datas[0].ptr_type = "dmabuf";
b->datas[0].offset = buf.m.offset;
b->datas[0].size = buf.length;
b->datas[0].stride = state->fmt.fmt.pix.bytesperline;
#endif
}
b->imported = &b->buffer;
b->outstanding = true;
@ -667,6 +670,8 @@ mmap_init (SpaV4l2Source *this,
b->v4l2_buffer.memory = state->memtype;
b->v4l2_buffer.index = i;
spa_debug_buffer (&b->buffer);
spa_v4l2_buffer_recycle (this, i);
}
state->have_buffers = true;

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

@ -578,8 +578,8 @@ spa_volume_node_port_pull_output (SpaNode *node,
if (si == sbuf->n_datas || di == dbuf->n_datas)
break;
sd = &sbuf->datas[si];
dd = &dbuf->datas[di];
sd = &SPA_BUFFER_DATAS (sbuf)[si];
dd = &SPA_BUFFER_DATAS (dbuf)[di];
if (sd->type != SPA_DATA_TYPE_MEMPTR) {
si++;