Improve upload

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.

spa/plugins/alsa/alsa-utils.c

@@ -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);
 

spa/plugins/audiomixer/audiomixer.c

@@ -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;
     }

spa/plugins/audiotestsrc/audiotestsrc.c

@@ -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;

spa/plugins/v4l2/v4l2-utils.c

@@ -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;

spa/plugins/videotestsrc/videotestsrc.c

@@ -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:

spa/plugins/volume/volume.c

@@ -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;
     }