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

Improve upload

Browse source 
Only send a buffer when we have received a NEED_DATA message.
Add a signal to pulla buffer from the sink. Restructure the sink to use
a queue like the source and only push a buffer when we can.
Improve SpaData. Offset and size should be between 0 and maxsize, make
sure we clamp correctly when needed.
node_process_output completes the processing of the output after
receiving HAVE_OUTPUT for async elements. It instructs the node that
it now can produce more output.
This commit is contained in:
Wim Taymans 2016-12-20 16:51:57 +01:00
parent 8ce3f949e2
commit 5b0b9c43d0
18 changed files with 201 additions and 112 deletions
Download patch file Download diff file Expand all files Collapse all files

15
pinos/client/stream.c
View file

@ -192,6 +192,7 @@ pinos_stream_new (PinosContext *context,
pinos_signal_init (&this->add_buffer);
pinos_signal_init (&this->remove_buffer);
pinos_signal_init (&this->new_buffer);
pinos_signal_init (&this->need_buffer);
this->state = PINOS_STREAM_STATE_UNCONNECTED;
@ -473,6 +474,9 @@ on_rtsocket_condition (SpaSource *source,
handle_rtnode_event (stream, ev);
}
}
if (cmd & PINOS_TRANSPORT_CMD_NEED_DATA) {
pinos_signal_emit (&stream->need_buffer, stream);
}
}
}
@ -1080,16 +1084,15 @@ pinos_stream_send_buffer (PinosStream *stream,
{
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
BufferId *bid;
uint8_t cmd = PINOS_TRANSPORT_CMD_HAVE_DATA;
if ((bid = find_buffer (stream, id))) {
uint8_t cmd = PINOS_TRANSPORT_CMD_HAVE_DATA;
bid->used = true;
impl->trans->outputs[0].buffer_id = id;
impl->trans->outputs[0].status = SPA_RESULT_OK;
write (impl->rtfd, &cmd, 1);
return true;
} else {
return true;
if (write (impl->rtfd, &cmd, 1) < 1)
perror ("write");
}
return true;
}

2
pinos/client/stream.h
View file

@ -91,6 +91,8 @@ struct _PinosStream {
PINOS_SIGNAL (new_buffer, (PinosListener *listener,
PinosStream *stream,
uint32_t id));
PINOS_SIGNAL (need_buffer, (PinosListener *listener,
PinosStream *stream));
};
PinosStream * pinos_stream_new (PinosContext *context,

1
pinos/gst/gstpinospool.c
View file

@ -75,6 +75,7 @@ acquire_buffer (GstBufferPool * pool, GstBuffer ** buffer,
GST_OBJECT_LOCK (pool);
while (p->available.length == 0) {
GST_WARNING ("queue empty");
g_cond_wait (&p->cond, GST_OBJECT_GET_LOCK (pool));
}
*buffer = g_queue_pop_head (&p->available);

80
pinos/gst/gstpinossink.c
View file

@ -230,6 +230,8 @@ gst_pinos_sink_init (GstPinosSink * sink)
sink->buf_ids = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
(GDestroyNotify) gst_buffer_unref);
g_queue_init (&sink->queue);
sink->loop = pinos_loop_new ();
sink->main_loop = pinos_thread_main_loop_new (sink->loop, "pinos-sink-loop");
GST_DEBUG ("loop %p %p", sink->loop, sink->main_loop);
@ -347,6 +349,7 @@ typedef struct {
SpaBuffer *buf;
SpaMetaHeader *header;
guint flags;
goffset offset;
} ProcessMemData;
static void
@ -403,13 +406,15 @@ on_add_buffer (PinosListener *listener,
case SPA_DATA_TYPE_DMABUF:
{
gmem = gst_fd_allocator_alloc (pinossink->allocator, dup (d->fd),
d->size, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (gmem, d->chunk->offset, d->chunk->size);
d->mapoffset + d->maxsize, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size);
data.offset = d->mapoffset;
break;
}
case SPA_DATA_TYPE_MEMPTR:
gmem = gst_memory_new_wrapped (0, d->data, d->size, d->chunk->offset,
gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, d->chunk->offset,
d->chunk->size, NULL, NULL);
data.offset = 0;
break;
default:
break;
@ -466,6 +471,51 @@ on_new_buffer (PinosListener *listener,
}
}
static void
do_send_buffer (GstPinosSink *pinossink)
{
GstBuffer *buffer;
ProcessMemData *data;
gboolean res;
guint i;
buffer = g_queue_pop_head (&pinossink->queue);
if (buffer == NULL)
return;
data = gst_mini_object_get_qdata (GST_MINI_OBJECT_CAST (buffer),
process_mem_data_quark);
if (data->header) {
data->header->seq = GST_BUFFER_OFFSET (buffer);
data->header->pts = GST_BUFFER_PTS (buffer);
data->header->dts_offset = GST_BUFFER_DTS (buffer);
}
for (i = 0; i < data->buf->n_datas; i++) {
SpaData *d = &data->buf->datas[i];
GstMemory *mem = gst_buffer_peek_memory (buffer, i);
d->chunk->offset = mem->offset - data->offset;
d->chunk->size = mem->size;
}
if (!(res = pinos_stream_send_buffer (pinossink->stream, data->id)))
g_warning ("can't send buffer");
pinossink->need_ready--;
}
static void
on_need_buffer (PinosListener *listener,
PinosStream *stream)
{
GstPinosSink *pinossink = SPA_CONTAINER_OF (listener, GstPinosSink, stream_need_buffer);
pinossink->need_ready++;
GST_DEBUG ("need buffer %u", pinossink->need_ready);
do_send_buffer (pinossink);
}
static void
on_state_changed (PinosListener *listener,
PinosStream *stream)
@ -610,9 +660,6 @@ static GstFlowReturn
gst_pinos_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
{
GstPinosSink *pinossink;
gboolean res;
ProcessMemData *data;
guint i;
pinossink = GST_PINOS_SINK (bsink);
@ -633,25 +680,11 @@ gst_pinos_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
buffer = b;
}
data = gst_mini_object_get_qdata (GST_MINI_OBJECT_CAST (buffer),
process_mem_data_quark);
if (data->header) {
data->header->seq = GST_BUFFER_OFFSET (buffer);
data->header->pts = GST_BUFFER_PTS (buffer);
data->header->dts_offset = GST_BUFFER_DTS (buffer);
}
for (i = 0; i < data->buf->n_datas; i++) {
SpaData *d = &data->buf->datas[i];
GstMemory *mem = gst_buffer_peek_memory (buffer, i);
d->chunk->offset = mem->offset;
d->chunk->size = mem->size;
}
gst_buffer_ref (buffer);
g_queue_push_tail (&pinossink->queue, buffer);
if (!(res = pinos_stream_send_buffer (pinossink->stream, data->id)))
g_warning ("can't send buffer");
if (pinossink->need_ready)
do_send_buffer (pinossink);
done:
pinos_thread_main_loop_unlock (pinossink->main_loop);
@ -707,6 +740,7 @@ gst_pinos_sink_start (GstBaseSink * basesink)
pinos_signal_add (&pinossink->stream->add_buffer, &pinossink->stream_add_buffer, on_add_buffer);
pinos_signal_add (&pinossink->stream->remove_buffer, &pinossink->stream_remove_buffer, on_remove_buffer);
pinos_signal_add (&pinossink->stream->new_buffer, &pinossink->stream_new_buffer, on_new_buffer);
pinos_signal_add (&pinossink->stream->need_buffer, &pinossink->stream_need_buffer, on_need_buffer);
pinos_thread_main_loop_unlock (pinossink->main_loop);
return TRUE;

3
pinos/gst/gstpinossink.h
View file

@ -89,6 +89,7 @@ struct _GstPinosSink {
PinosListener stream_add_buffer;
PinosListener stream_remove_buffer;
PinosListener stream_new_buffer;
PinosListener stream_need_buffer;
GstAllocator *allocator;
GstStructure *properties;
@ -96,6 +97,8 @@ struct _GstPinosSink {
GstPinosPool *pool;
GHashTable *buf_ids;
GQueue queue;
guint need_ready;
};
struct _GstPinosSinkClass {

28
pinos/gst/gstpinossrc.c
View file

@ -173,13 +173,19 @@ clock_disabled:
}
}
static void
clear_queue (GstPinosSrc *pinossrc)
{
g_queue_foreach (&pinossrc->queue, (GFunc) gst_mini_object_unref, NULL);
g_queue_clear (&pinossrc->queue);
}
static void
gst_pinos_src_finalize (GObject * object)
{
GstPinosSrc *pinossrc = GST_PINOS_SRC (object);
g_queue_foreach (&pinossrc->queue, (GFunc) gst_mini_object_unref, NULL);
g_queue_clear (&pinossrc->queue);
clear_queue (pinossrc);
pinos_thread_main_loop_destroy (pinossrc->main_loop);
pinossrc->main_loop = NULL;
@ -340,6 +346,7 @@ typedef struct {
SpaBuffer *buf;
SpaMetaHeader *header;
guint flags;
goffset offset;
} ProcessMemData;
static void
@ -417,13 +424,15 @@ on_add_buffer (PinosListener *listener,
case SPA_DATA_TYPE_DMABUF:
{
gmem = gst_fd_allocator_alloc (pinossrc->fd_allocator, dup (d->fd),
d->size, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (gmem, d->chunk->offset, d->chunk->size);
d->maxsize, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (gmem, d->chunk->offset + d->mapoffset, d->chunk->size);
data.offset = d->mapoffset;
break;
}
case SPA_DATA_TYPE_MEMPTR:
gmem = gst_memory_new_wrapped (0, d->data, d->size, d->chunk->offset,
gmem = gst_memory_new_wrapped (0, d->data, d->maxsize, d->chunk->offset + d->mapoffset,
d->chunk->size, NULL, NULL);
data.offset = 0;
default:
break;
}
@ -488,7 +497,7 @@ on_new_buffer (PinosListener *listener,
for (i = 0; i < data->buf->n_datas; i++) {
SpaData *d = &data->buf->datas[i];
GstMemory *mem = gst_buffer_peek_memory (buf, i);
mem->offset = d->chunk->offset;
mem->offset = d->chunk->offset + data->offset;
mem->size = d->chunk->size;
}
g_queue_push_tail (&pinossrc->queue, buf);
@ -937,13 +946,6 @@ gst_pinos_src_start (GstBaseSrc * basesrc)
return TRUE;
}
static void
clear_queue (GstPinosSrc *pinossrc)
{
g_queue_foreach (&pinossrc->queue, (GFunc) gst_mini_object_unref, NULL);
g_queue_clear (&pinossrc->queue);
}
static gboolean
gst_pinos_src_stop (GstBaseSrc * basesrc)
{

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

@ -195,6 +195,11 @@ spa_proxy_node_send_command (SpaNode *node,
PINOS_MESSAGE_NODE_COMMAND,
&cnc,
true);
if (command->type == SPA_NODE_COMMAND_START) {
uint8_t cmd = PINOS_TRANSPORT_CMD_NEED_DATA;
write (this->data_source.fd, &cmd, 1);
}
res = SPA_RESULT_RETURN_ASYNC (cnc.seq);
break;
}
@ -686,8 +691,8 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
am.type = d->type;
am.memfd = d->fd;
am.flags = d->flags;
am.offset = d->offset;
am.size = d->size;
am.offset = d->mapoffset;
am.size = d->maxsize;
pinos_resource_send_message (this->resource,
PINOS_MESSAGE_ADD_MEM,
&am,
@ -698,7 +703,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
break;
case SPA_DATA_TYPE_MEMPTR:
b->buffer.datas[j].data = SPA_INT_TO_PTR (b->size);
b->size += d->size;
b->size += d->maxsize;
break;
default:
b->buffer.datas[j].type = SPA_DATA_TYPE_INVALID;
@ -863,8 +868,6 @@ static SpaResult
spa_proxy_node_process_input (SpaNode *node)
{
SpaProxy *this;
unsigned int i;
bool have_error = false;
uint8_t cmd;
if (node == NULL)
@ -872,22 +875,29 @@ spa_proxy_node_process_input (SpaNode *node)
this = SPA_CONTAINER_OF (node, SpaProxy, node);
for (i = 0; i < this->n_inputs; i++) {
SpaProxyPort *port = &this->in_ports[i];
SpaPortInput *input;
#if 0
{
unsigned int i;
bool have_error = false;
if ((input = port->io) == NULL)
continue;
for (i = 0; i < this->n_inputs; i++) {
SpaProxyPort *port = &this->in_ports[i];
SpaPortInput *input;
if (!CHECK_PORT_BUFFER (this, input->buffer_id, port)) {
input->status = SPA_RESULT_INVALID_BUFFER_ID;
have_error = true;
continue;
if ((input = port->io) == NULL)
continue;
if (!CHECK_PORT_BUFFER (this, input->buffer_id, port)) {
input->status = SPA_RESULT_INVALID_BUFFER_ID;
have_error = true;
continue;
}
copy_meta_out (this, port, input->buffer_id);
}
copy_meta_out (this, port, input->buffer_id);
if (have_error)
return SPA_RESULT_ERROR;
}
if (have_error)
return SPA_RESULT_ERROR;
#endif
cmd = PINOS_TRANSPORT_CMD_HAVE_DATA;
write (this->data_source.fd, &cmd, 1);
@ -899,28 +909,37 @@ static SpaResult
spa_proxy_node_process_output (SpaNode *node)
{
SpaProxy *this;
unsigned int i;
bool have_error = false;
uint8_t cmd;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, SpaProxy, node);
for (i = 0; i < this->n_outputs; i++) {
SpaProxyPort *port = &this->out_ports[i];
SpaPortOutput *output;
#if 0
{
unsigned int i;
bool have_error = false;
if ((output = port->io) == NULL)
continue;
for (i = 0; i < this->n_outputs; i++) {
SpaProxyPort *port = &this->out_ports[i];
SpaPortOutput *output;
copy_meta_in (this, port, output->buffer_id);
if ((output = port->io) == NULL)
continue;
if (output->status != SPA_RESULT_OK)
have_error = true;
copy_meta_in (this, port, output->buffer_id);
if (output->status != SPA_RESULT_OK)
have_error = true;
}
if (have_error)
return SPA_RESULT_ERROR;
}
if (have_error)
return SPA_RESULT_ERROR;
#endif
cmd = PINOS_TRANSPORT_CMD_NEED_DATA;
write (this->data_source.fd, &cmd, 1);
return SPA_RESULT_OK;
}
@ -1052,6 +1071,17 @@ proxy_on_data_fd_events (SpaSource *source)
}
if (cmd & PINOS_TRANSPORT_CMD_HAVE_DATA) {
SpaNodeEventHaveOutput ho;
unsigned int i;
for (i = 0; i < this->n_outputs; i++) {
SpaProxyPort *port = &this->out_ports[i];
SpaPortOutput *output;
if ((output = port->io) == NULL)
continue;
copy_meta_in (this, port, output->buffer_id);
}
ho.event.type = SPA_NODE_EVENT_TYPE_HAVE_OUTPUT;
ho.event.size = sizeof (ho);
ho.port_id = 0;

8
pinos/server/link.c
View file

@ -324,10 +324,10 @@ alloc_buffers (PinosLink *this,
d->type = SPA_DATA_TYPE_MEMFD;
d->flags = 0;
d->fd = mem->fd;
d->offset = 0;
d->size = mem->size;
d->data = mem->ptr;
d->chunk->offset = SPA_PTRDIFF (ddp, d->data);
d->mapoffset = SPA_PTRDIFF (ddp, mem->ptr);
d->maxsize = data_sizes[j];
d->data = SPA_MEMBER (mem->ptr, d->mapoffset, void);
d->chunk->offset = 0;
d->chunk->size = data_sizes[j];
d->chunk->stride = data_strides[j];
ddp += data_sizes[j];

9
pinos/server/node.c
View file

@ -328,11 +328,6 @@ on_node_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
PinosPort *port = this->output_port_map[ho->port_id];
PinosLink *link;
if ((res = spa_node_process_output (node)) < 0) {
pinos_log_warn ("node %p: got pull error %d, %d", this, res, po->status);
break;
}
spa_list_for_each (link, &port->rt.links, rt.output_link) {
size_t offset;
@ -356,6 +351,10 @@ on_node_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
if ((res = spa_node_port_reuse_buffer (node, ho->port_id, po->buffer_id)) < 0)
pinos_log_warn ("node %p: error reuse buffer: %d", node, res);
}
if ((res = spa_node_process_output (node)) < 0) {
pinos_log_warn ("node %p: got pull error %d, %d", this, res, po->status);
break;
}
break;
}
case SPA_NODE_EVENT_TYPE_REUSE_BUFFER:

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

@ -174,8 +174,8 @@ typedef struct {
SpaDataType type;
int flags;
int fd;
off_t offset;
size_t size;
off_t mapoffset;
size_t maxsize;
void *data;
SpaChunk *chunk;
} SpaData;

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

@ -568,8 +568,8 @@ struct _SpaNode {
* Returns: #SPA_RESULT_OK on success
* #SPA_RESULT_HAVE_ENOUGH_INPUT when output can be produced.
*/
SpaResult (*process_input) (SpaNode *node);
SpaResult (*process_output) (SpaNode *node);
SpaResult (*process_input) (SpaNode *node);
SpaResult (*process_output) (SpaNode *node);
};

6
spa/lib/debug.c
View file

@ -196,11 +196,11 @@ spa_debug_buffer (const SpaBuffer *buffer)
fprintf (stderr, " flags: %d\n", d->flags);
fprintf (stderr, " data: %p\n", d->data);
fprintf (stderr, " fd: %d\n", d->fd);
fprintf (stderr, " offset: %zd\n", d->offset);
fprintf (stderr, " maxsize: %zd\n", d->size);
fprintf (stderr, " offset: %zd\n", d->mapoffset);
fprintf (stderr, " maxsize: %zu\n", d->maxsize);
fprintf (stderr, " chunk: %p\n", d->chunk);
fprintf (stderr, " offset: %zd\n", d->chunk->offset);
fprintf (stderr, " size: %zd\n", d->chunk->size);
fprintf (stderr, " size: %zu\n", d->chunk->size);
fprintf (stderr, " stride: %zd\n", d->chunk->stride);
}
return SPA_RESULT_OK;

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

@ -268,22 +268,35 @@ pull_frames_queue (SpaALSAState *state,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t frames)
{
if (spa_list_is_empty (&state->ready)) {
SpaNodeEventNeedInput ni;
ni.event.type = SPA_NODE_EVENT_TYPE_NEED_INPUT;
ni.event.size = sizeof (ni);
ni.port_id = 0;
state->event_cb (&state->node, &ni.event, state->user_data);
}
if (!spa_list_is_empty (&state->ready)) {
uint8_t *src, *dst;
size_t n_bytes;
size_t n_bytes, size;
off_t offs;
SpaALSABuffer *b;
b = spa_list_first (&state->ready, SpaALSABuffer, list);
src = SPA_MEMBER (b->outbuf->datas[0].data, b->outbuf->datas[0].offset + state->ready_offset, uint8_t);
offs = SPA_MIN (b->outbuf->datas[0].chunk->offset, b->outbuf->datas[0].maxsize);
src = SPA_MEMBER (b->outbuf->datas[0].data, offs, uint8_t);
size = SPA_MIN (b->outbuf->datas[0].chunk->size, b->outbuf->datas[0].maxsize - offs);
src = SPA_MEMBER (src, state->ready_offset, uint8_t);
dst = SPA_MEMBER (my_areas[0].addr, offset * state->frame_size, uint8_t);
n_bytes = SPA_MIN (b->outbuf->datas[0].size - state->ready_offset, frames * state->frame_size);
n_bytes = SPA_MIN (size - state->ready_offset, frames * state->frame_size);
frames = SPA_MIN (frames, n_bytes / state->frame_size);
memcpy (dst, src, n_bytes);
state->ready_offset += n_bytes;
if (state->ready_offset >= b->outbuf->datas[0].size) {
if (state->ready_offset >= size) {
SpaNodeEventReuseBuffer rb;
spa_list_remove (&b->list);
@ -298,7 +311,7 @@ pull_frames_queue (SpaALSAState *state,
state->ready_offset = 0;
}
} else {
spa_log_warn (state->log, "underrun");
spa_log_warn (state->log, "underrun, want %zd frames", frames);
snd_pcm_areas_silence (my_areas, offset, state->channels, frames, state->format);
}
return frames;
@ -318,7 +331,7 @@ pull_frames_ringbuffer (SpaALSAState *state,
b = state->ringbuffer;
src = SPA_MEMBER (b->outbuf->datas[0].data, b->outbuf->datas[0].offset, void);
src = b->outbuf->datas[0].data;
dst = SPA_MEMBER (my_areas[0].addr, offset * state->frame_size, uint8_t);
avail = spa_ringbuffer_get_read_areas (&b->rb->ringbuffer, areas);
@ -442,8 +455,8 @@ mmap_read (SpaALSAState *state)
b = spa_list_first (&state->free, SpaALSABuffer, list);
spa_list_remove (&b->list);
dest = SPA_MEMBER (b->outbuf->datas[0].data, b->outbuf->datas[0].offset, void);
destsize = b->outbuf->datas[0].size;
dest = b->outbuf->datas[0].data;
destsize = b->outbuf->datas[0].maxsize;
if (b->h) {
b->h->seq = state->sample_count;
@ -484,7 +497,9 @@ mmap_read (SpaALSAState *state)
SpaData *d;
d = b->outbuf->datas;
d[0].size = avail * state->frame_size;
d[0].chunk->offset = 0;
d[0].chunk->size = avail * state->frame_size;
d[0].chunk->stride = 0;
spa_list_insert (state->ready.prev, &b->list);

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

@ -598,12 +598,12 @@ add_port_data (SpaAudioMixer *this, SpaBuffer *out, SpaAudioMixerPort *port)
while (true) {
if (op == NULL) {
op = (uint8_t*)odatas[oi].data + odatas[oi].offset;
os = odatas[oi].size;
op = (uint8_t*)odatas[oi].data + odatas[oi].chunk->offset;
os = odatas[oi].chunk->size;
}
if (ip == NULL) {
ip = (uint8_t*)idatas[port->buffer_index].data + idatas[port->buffer_index].offset;
is = idatas[port->buffer_index].size;
ip = (uint8_t*)idatas[port->buffer_index].data + idatas[port->buffer_index].chunk->offset;
is = idatas[port->buffer_index].chunk->size;
ip += port->buffer_offset;
is -= port->buffer_offset;
}

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

@ -690,8 +690,8 @@ spa_audiotestsrc_node_port_use_buffers (SpaNode *node,
spa_log_error (this->log, "audiotestsrc %p: invalid memory on buffer %p", this, buffers[i]);
continue;
}
b->ptr = SPA_MEMBER (d[0].data, d[0].offset, void);
b->size = d[0].size;
b->ptr = d[0].data;
b->size = d[0].maxsize;
break;
default:
break;

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

@ -117,7 +117,7 @@ spa_v4l2_clear_buffers (SpaV4l2Source *this)
}
if (b->allocated) {
if (b->outbuf->datas[0].data)
munmap (b->outbuf->datas[0].data, b->outbuf->datas[0].size);
munmap (b->outbuf->datas[0].data, b->outbuf->datas[0].maxsize);
if (b->outbuf->datas[0].fd != -1)
close (b->outbuf->datas[0].fd);
b->outbuf->datas[0].type = SPA_DATA_TYPE_INVALID;
@ -973,7 +973,7 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
continue;
}
b->v4l2_buffer.m.userptr = (unsigned long) d[0].data;
b->v4l2_buffer.length = d[0].size;
b->v4l2_buffer.length = d[0].maxsize;
break;
case SPA_DATA_TYPE_DMABUF:
b->v4l2_buffer.m.fd = d[0].fd;
@ -1047,8 +1047,8 @@ mmap_init (SpaV4l2Source *this,
}
d = buffers[i]->datas;
d[0].offset = 0;
d[0].size = b->v4l2_buffer.length;
d[0].mapoffset = 0;
d[0].maxsize = b->v4l2_buffer.length;
d[0].chunk->offset = 0;
d[0].chunk->size = b->v4l2_buffer.length;
d[0].chunk->stride = state->fmt.fmt.pix.bytesperline;

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

@ -657,7 +657,7 @@ spa_videotestsrc_node_port_use_buffers (SpaNode *node,
spa_log_error (this->log, "videotestsrc %p: invalid memory on buffer %p", this, buffers[i]);
continue;
}
b->ptr = SPA_MEMBER (d[0].data, d[0].offset, void);
b->ptr = SPA_MEMBER (d[0].data, d[0].chunk->offset, void);
b->stride = d[0].chunk->stride;
break;
default:

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

@ -582,10 +582,10 @@ spa_volume_node_process_output (SpaNode *node)
sd = &sbuf->datas[si];
dd = &dbuf->datas[di];
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*)sd->data + sd->chunk->offset + soff);
dst = (uint16_t*) ((uint8_t*)dd->data + dd->chunk->offset + doff);
n_bytes = SPA_MIN (sd->size - soff, dd->size - doff);
n_bytes = SPA_MIN (sd->chunk->size - soff, dd->chunk->size - doff);
n_samples = n_bytes / sizeof (uint16_t);
for (i = 0; i < n_samples; i++)
@ -594,11 +594,11 @@ spa_volume_node_process_output (SpaNode *node)
soff += n_bytes;
doff += n_bytes;
if (soff >= sd->size) {
if (soff >= sd->chunk->size) {
si++;
soff = 0;
}
if (doff >= dd->size) {
if (doff >= dd->chunk->size) {
di++;
doff = 0;
}