mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-10-31 22:25:38 -04:00
Make buffer data point to memory blocks
Make buffer data point to a registered memory block by its mem_id. Add some more helpers to allocate memfd backed memory. Allocate buffers in memfd so that we easily share them between client and server. Update pts and seq in v4l2 now that this change will actually be visible at the client.
This commit is contained in:
Wim Taymans
parent
98993c680b
commit
1169c2419b
19 changed files with 383 additions and 356 deletions
|
|
@ -21,6 +21,7 @@
|
|||
#include <stdio.h>
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/memory.h>
|
||||
#include <spa/audio/format.h>
|
||||
|
||||
#define MAX_PORTS 128
|
||||
|
|
@ -590,16 +591,19 @@ add_port_data (SpaAudioMixer *this, SpaBuffer *out, SpaAudioMixerPort *port)
|
|||
size_t os, is, chunk;
|
||||
SpaData *odatas = SPA_BUFFER_DATAS (out);
|
||||
SpaData *idatas = SPA_BUFFER_DATAS (port->buffer);
|
||||
SpaMemory *mem;
|
||||
|
||||
op = ip = NULL;
|
||||
|
||||
while (true) {
|
||||
if (op == NULL) {
|
||||
op = odatas[oi].ptr;
|
||||
mem = spa_memory_find (0, odatas[oi].mem_id);
|
||||
op = (uint8_t*)mem->ptr + odatas[oi].offset;
|
||||
os = odatas[oi].size;
|
||||
}
|
||||
if (ip == NULL) {
|
||||
ip = idatas[port->buffer_index].ptr;
|
||||
mem = spa_memory_find (0, idatas[port->buffer_index].mem_id);
|
||||
ip = (uint8_t*)mem->ptr + odatas[oi].offset;
|
||||
is = idatas[port->buffer_index].size;
|
||||
ip += port->buffer_offset;
|
||||
is -= port->buffer_offset;
|
||||
|
|
|
|||
|
|
@ -17,8 +17,6 @@
|
|||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <string.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
|
|
@ -31,6 +29,7 @@
|
|||
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/memory.h>
|
||||
#include <spa/control.h>
|
||||
|
||||
#define MAX_INPUTS 64
|
||||
|
|
@ -548,25 +547,6 @@ spa_proxy_node_port_get_status (SpaNode *node,
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static int
|
||||
tmpfile_create (void *data, size_t size)
|
||||
{
|
||||
char filename[] = "/dev/shm/tmpfilepay.XXXXXX";
|
||||
int fd;
|
||||
|
||||
fd = mkostemp (filename, O_CLOEXEC);
|
||||
if (fd == -1) {
|
||||
fprintf (stderr, "Failed to create temporary file: %s\n", strerror (errno));
|
||||
return -1;
|
||||
}
|
||||
unlink (filename);
|
||||
|
||||
if (write (fd, data, size) != (ssize_t) size)
|
||||
fprintf (stderr, "Failed to write data: %s\n", strerror (errno));
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
|
||||
{
|
||||
|
|
@ -574,53 +554,57 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
|
|||
SpaControlBuilder builder;
|
||||
uint8_t buf[1024];
|
||||
int fds[16];
|
||||
SpaControlCmdAddMem am;
|
||||
SpaControlCmdAddBuffer ab;
|
||||
int fd, i;
|
||||
int i;
|
||||
SpaResult res;
|
||||
SpaBuffer *b;
|
||||
SpaMemory *bmem;
|
||||
|
||||
spa_control_builder_init_into (&builder, buf, sizeof (buf), fds, sizeof (fds));
|
||||
|
||||
fd = tmpfile_create (buffer, buffer->size);
|
||||
if (buffer->mem_id == SPA_ID_INVALID) {
|
||||
fprintf (stderr, "proxy %p: alloc buffer space\n", this);
|
||||
bmem = spa_memory_alloc_with_fd (0, buffer, buffer->size);
|
||||
b = spa_memory_ensure_ptr (bmem);
|
||||
b->mem_id = bmem->id;
|
||||
b->offset = 0;
|
||||
} else {
|
||||
bmem = spa_memory_find (0, buffer->mem_id);
|
||||
b = buffer;
|
||||
}
|
||||
|
||||
am.port_id = port_id;
|
||||
am.mem_id = bmem->id;
|
||||
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);
|
||||
|
||||
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;
|
||||
SpaMemory *mem;
|
||||
|
||||
if (d->type == SPA_DATA_TYPE_FD) {
|
||||
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);
|
||||
if (!(mem = spa_memory_find (0, d->mem_id))) {
|
||||
fprintf (stderr, "proxy %p: error invalid memory\n", this);
|
||||
continue;
|
||||
}
|
||||
|
||||
am.port_id = port_id;
|
||||
am.mem_id = b->id * 64 + i;
|
||||
am.mem_id = mem->id;
|
||||
am.mem_type = 0;
|
||||
am.fd_index = spa_control_builder_add_fd (&builder, fd, tmpfile ? true : false);
|
||||
am.offset = d->offset;
|
||||
am.size = d->size;
|
||||
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);
|
||||
|
||||
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_id = b->id;
|
||||
ab.fd_index = spa_control_builder_add_fd (&builder, fd, true);
|
||||
ab.offset = 0;
|
||||
ab.mem_id = bmem->id;
|
||||
ab.offset = b->offset;
|
||||
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);
|
||||
|
||||
|
|
@ -632,6 +616,71 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static SpaResult
|
||||
add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
|
||||
{
|
||||
SpaControl control;
|
||||
SpaControlBuilder builder;
|
||||
uint8_t buf[1024];
|
||||
int fds[16];
|
||||
SpaControlCmdAddMem am;
|
||||
SpaControlCmdAddBuffer ab;
|
||||
int i;
|
||||
SpaResult res;
|
||||
SpaBuffer *b;
|
||||
SpaMemory *bmem;
|
||||
|
||||
spa_control_builder_init_into (&builder, buf, sizeof (buf), fds, sizeof (fds));
|
||||
|
||||
bmem = spa_memory_alloc_with_fd (0, buffer, buffer->size);
|
||||
b = spa_memory_ensure_ptr (bmem);
|
||||
b->mem_id = bmem->id;
|
||||
b->offset = 0;
|
||||
|
||||
am.port_id = port_id;
|
||||
am.mem_id = bmem->id;
|
||||
am.mem_type = 0;
|
||||
am.fd_index = spa_control_builder_add_fd (&builder, bmem->fd, false);
|
||||
am.offset = 0;
|
||||
am.size = buffer->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 (0, d->mem_id))) {
|
||||
fprintf (stderr, "proxy %p: error invalid memory\n", this);
|
||||
continue;
|
||||
}
|
||||
|
||||
am.port_id = port_id;
|
||||
am.mem_id = mem->id;
|
||||
am.mem_type = 0;
|
||||
am.fd_index = spa_control_builder_add_fd (&builder, mem->fd, false);
|
||||
am.offset = d->offset;
|
||||
am.size = d->size;
|
||||
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_MEM, &am);
|
||||
}
|
||||
ab.port_id = port_id;
|
||||
ab.buffer_id = b->id;
|
||||
ab.mem_id = bmem->id;
|
||||
ab.offset = 0;
|
||||
ab.size = b->size;
|
||||
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_BUFFER, &ab);
|
||||
|
||||
spa_control_builder_end (&builder, &control);
|
||||
|
||||
if ((res = spa_control_write (&control, this->fds[0].fd)) < 0)
|
||||
fprintf (stderr, "proxy %p: error writing control\n", this);
|
||||
|
||||
spa_control_clear (&control);
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
static SpaResult
|
||||
remove_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@
|
|||
#include <linux/videodev2.h>
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/memory.h>
|
||||
#include <spa/video/format.h>
|
||||
#include <spa/debug.h>
|
||||
|
||||
|
|
@ -54,8 +55,7 @@ struct _V4l2Buffer {
|
|||
SpaMeta metas[1];
|
||||
SpaMetaHeader header;
|
||||
SpaData datas[1];
|
||||
SpaV4l2Source *source;
|
||||
SpaBuffer *imported;
|
||||
SpaBuffer *outbuf;
|
||||
bool outstanding;
|
||||
struct v4l2_buffer v4l2_buffer;
|
||||
V4l2Buffer *next;
|
||||
|
|
@ -102,7 +102,8 @@ typedef struct {
|
|||
enum v4l2_memory memtype;
|
||||
|
||||
struct v4l2_requestbuffers reqbuf;
|
||||
V4l2Buffer buffers[MAX_BUFFERS];
|
||||
SpaMemory *alloc_mem;
|
||||
V4l2Buffer *alloc_buffers;
|
||||
V4l2Buffer *ready;
|
||||
uint32_t ready_count;
|
||||
|
||||
|
|
|
|||
|
|
@ -408,7 +408,7 @@ spa_v4l2_set_format (SpaV4l2Source *this, V4l2Format *f, bool try_only)
|
|||
state->info.params = state->params;
|
||||
state->params[0] = &state->param_buffers.param;
|
||||
state->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
|
||||
state->param_buffers.param.size = sizeof (&state->buffers);
|
||||
state->param_buffers.param.size = sizeof (state->param_buffers);
|
||||
state->param_buffers.minsize = fmt.fmt.pix.sizeimage;
|
||||
state->param_buffers.stride = fmt.fmt.pix.bytesperline;
|
||||
state->param_buffers.min_buffers = 2;
|
||||
|
|
@ -459,7 +459,9 @@ mmap_read (SpaV4l2Source *this)
|
|||
}
|
||||
}
|
||||
|
||||
b = &state->buffers[buf.index];
|
||||
b = &state->alloc_buffers[buf.index];
|
||||
b->header.seq = buf.sequence;
|
||||
b->header.pts = (uint64_t)buf.timestamp.tv_sec * 1000000000lu + (uint64_t)buf.timestamp.tv_usec * 1000lu;
|
||||
b->next = state->ready;
|
||||
state->ready = b;
|
||||
state->ready_count++;
|
||||
|
|
@ -489,7 +491,7 @@ static void
|
|||
spa_v4l2_buffer_recycle (SpaV4l2Source *this, uint32_t buffer_id)
|
||||
{
|
||||
SpaV4l2State *state = &this->state[0];
|
||||
V4l2Buffer *b = &state->buffers[buffer_id];
|
||||
V4l2Buffer *b = &state->alloc_buffers[buffer_id];
|
||||
|
||||
b->outstanding = false;
|
||||
|
||||
|
|
@ -523,24 +525,39 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
|
|||
}
|
||||
state->reqbuf = reqbuf;
|
||||
|
||||
if (state->alloc_mem)
|
||||
spa_memory_free (state->alloc_mem->pool_id, state->alloc_mem->id);
|
||||
state->alloc_mem = spa_memory_alloc_with_fd (0, NULL, sizeof (V4l2Buffer) * reqbuf.count);
|
||||
state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem);
|
||||
|
||||
for (i = 0; i < reqbuf.count; i++) {
|
||||
V4l2Buffer *b;
|
||||
uint32_t mem_id;
|
||||
SpaMemory *mem;
|
||||
SpaData *d = SPA_BUFFER_DATAS (buffers[i]);
|
||||
|
||||
b = &state->buffers[i];
|
||||
b = &state->alloc_buffers[i];
|
||||
b->buffer.mem_id = state->alloc_mem->id;
|
||||
b->buffer.offset = sizeof (V4l2Buffer) * i;
|
||||
b->buffer.size = sizeof (V4l2Buffer);
|
||||
b->buffer.id = SPA_ID_INVALID;
|
||||
b->outbuf = buffers[i];
|
||||
b->outstanding = true;
|
||||
|
||||
fprintf (stderr, "import buffer %p\n", buffers[i]);
|
||||
|
||||
b->source = this;
|
||||
b->buffer.id = SPA_ID_INVALID;
|
||||
b->imported = buffers[i];
|
||||
b->outstanding = true;
|
||||
mem_id = SPA_BUFFER_DATAS (buffers[i])[0].mem_id;
|
||||
if (!(mem = spa_memory_find (0, mem_id))) {
|
||||
fprintf (stderr, "invalid memory on buffer %p\n", buffers[i]);
|
||||
continue;
|
||||
}
|
||||
|
||||
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_BUFFER_DATAS (buffers[i])[0].ptr;
|
||||
b->v4l2_buffer.length = SPA_BUFFER_DATAS (buffers[i])[0].size;
|
||||
b->v4l2_buffer.m.userptr = (unsigned long) ((uint8_t*)mem->ptr + d[0].offset);
|
||||
b->v4l2_buffer.length = d[0].size;
|
||||
|
||||
spa_v4l2_buffer_recycle (this, buffers[i]->id);
|
||||
}
|
||||
|
|
@ -584,9 +601,15 @@ mmap_init (SpaV4l2Source *this,
|
|||
|
||||
state->reqbuf = reqbuf;
|
||||
|
||||
if (state->alloc_mem)
|
||||
spa_memory_free (state->alloc_mem->pool_id, state->alloc_mem->id);
|
||||
state->alloc_mem = spa_memory_alloc_with_fd (0, 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;
|
||||
|
||||
CLEAR (buf);
|
||||
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
|
|
@ -598,13 +621,14 @@ mmap_init (SpaV4l2Source *this,
|
|||
return SPA_RESULT_ERROR;
|
||||
}
|
||||
|
||||
b = &state->buffers[i];
|
||||
b = &state->alloc_buffers[i];
|
||||
b->buffer.id = i;
|
||||
b->buffer.mem_id = state->alloc_mem->id;
|
||||
b->buffer.offset = sizeof (V4l2Buffer) * i;
|
||||
b->buffer.size = sizeof (V4l2Buffer);
|
||||
|
||||
buffers[i] = &b->buffer;
|
||||
|
||||
b->source = this;
|
||||
b->buffer.id = i;
|
||||
b->buffer.size = sizeof (V4l2Buffer);
|
||||
b->buffer.n_metas = 1;
|
||||
b->buffer.metas = offsetof (V4l2Buffer, metas);
|
||||
b->buffer.n_datas = 1;
|
||||
|
|
@ -619,6 +643,14 @@ mmap_init (SpaV4l2Source *this,
|
|||
b->metas[0].offset = offsetof (V4l2Buffer, header);
|
||||
b->metas[0].size = sizeof (b->header);
|
||||
|
||||
mem = spa_memory_alloc (0);
|
||||
mem->flags = SPA_MEMORY_FLAG_READABLE;
|
||||
mem->size = buf.length;
|
||||
b->datas[0].mem_id = mem->id;
|
||||
b->datas[0].offset = 0;
|
||||
b->datas[0].size = buf.length;
|
||||
b->datas[0].stride = state->fmt.fmt.pix.bytesperline;
|
||||
|
||||
if (state->export_buf) {
|
||||
struct v4l2_exportbuffer expbuf;
|
||||
|
||||
|
|
@ -630,39 +662,25 @@ mmap_init (SpaV4l2Source *this,
|
|||
continue;
|
||||
}
|
||||
|
||||
mem->fd = expbuf.fd;
|
||||
mem->type = "dmabuf";
|
||||
mem->ptr = NULL;
|
||||
b->dmafd = expbuf.fd;
|
||||
b->datas[0].type = SPA_DATA_TYPE_FD;
|
||||
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,
|
||||
buf.length,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED,
|
||||
state->fd,
|
||||
buf.m.offset);
|
||||
b->datas[0].offset = 0;
|
||||
b->datas[0].size = buf.length;
|
||||
if (b->datas[0].ptr == MAP_FAILED) {
|
||||
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) {
|
||||
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->outbuf = &b->buffer;
|
||||
b->outstanding = true;
|
||||
|
||||
CLEAR (b->v4l2_buffer);
|
||||
|
|
@ -772,17 +790,20 @@ spa_v4l2_stop (SpaV4l2Source *this)
|
|||
|
||||
for (i = 0; i < state->reqbuf.count; i++) {
|
||||
V4l2Buffer *b;
|
||||
SpaMemory *mem;
|
||||
|
||||
b = &state->buffers[i];
|
||||
b = &state->alloc_buffers[i];
|
||||
if (b->outstanding) {
|
||||
fprintf (stderr, "queueing outstanding buffer %p\n", b);
|
||||
spa_v4l2_buffer_recycle (this, i);
|
||||
}
|
||||
mem = spa_memory_find (0, b->datas[0].mem_id);
|
||||
if (state->export_buf) {
|
||||
close (b->dmafd);
|
||||
close (mem->fd);
|
||||
} else {
|
||||
munmap (b->datas[0].ptr, b->datas[0].size);
|
||||
munmap (mem->ptr, mem->size);
|
||||
}
|
||||
spa_memory_free (0, mem->id);
|
||||
}
|
||||
state->have_buffers = false;
|
||||
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@
|
|||
#include <stddef.h>
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/memory.h>
|
||||
#include <spa/audio/format.h>
|
||||
|
||||
typedef struct _SpaVolume SpaVolume;
|
||||
|
|
@ -550,6 +551,7 @@ 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;
|
||||
|
|
@ -581,16 +583,11 @@ spa_volume_node_port_pull_output (SpaNode *node,
|
|||
sd = &SPA_BUFFER_DATAS (sbuf)[si];
|
||||
dd = &SPA_BUFFER_DATAS (dbuf)[di];
|
||||
|
||||
if (sd->type != SPA_DATA_TYPE_MEMPTR) {
|
||||
si++;
|
||||
continue;
|
||||
}
|
||||
if (dd->type != SPA_DATA_TYPE_MEMPTR) {
|
||||
di++;
|
||||
continue;
|
||||
}
|
||||
src = (uint16_t*) ((uint8_t*)sd->ptr + soff);
|
||||
dst = (uint16_t*) ((uint8_t*)dd->ptr + doff);
|
||||
sm = spa_memory_find (0, sd->mem_id);
|
||||
dm = spa_memory_find (0, dd->mem_id);
|
||||
|
||||
src = (uint16_t*) ((uint8_t*)sm->ptr + sd->offset + soff);
|
||||
dst = (uint16_t*) ((uint8_t*)dm->ptr + dd->offset + doff);
|
||||
|
||||
n_bytes = SPA_MIN (sd->size - soff, dd->size - doff);
|
||||
n_samples = n_bytes / sizeof (uint16_t);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue