WIP

buffer.c

@@ -10,14 +10,10 @@ buffer_t *buffer_open(const char *name, buffer_list_t *buf_list, int index) {
   buf->index = index;
   buf->buf_list = buf_list;
   buf->dma_fd = -1;
-
+  buf->mmap_reflinks = 1;
-  if (!buf_list->do_mmap) {
+  buf->used = 0;
-    // nothing to do here
-    return buf;
-  }
 
   buf->v4l2_buffer.type = buf_list->type;
-  buf->v4l2_buffer.memory = V4L2_MEMORY_MMAP;
   buf->v4l2_buffer.index = index;
 
   if (buf_list->do_mplanes) {
@@ -25,6 +21,14 @@ buffer_t *buffer_open(const char *name, buffer_list_t *buf_list, int index) {
     buf->v4l2_buffer.m.planes = &buf->v4l2_plane;
   }
 
+  if (!buf_list->do_mmap) {
+    // nothing to do here
+    buf->v4l2_buffer.memory = V4L2_MEMORY_DMABUF;
+    return buf;
+  }
+
+  buf->v4l2_buffer.memory = V4L2_MEMORY_MMAP;
+
   E_XIOCTL(buf_list, dev->fd, VIDIOC_QUERYBUF, &buf->v4l2_buffer, "Cannot query buffer %d", index);
 
   if (buf_list->do_mplanes) {
@@ -49,10 +53,9 @@ buffer_t *buffer_open(const char *name, buffer_list_t *buf_list, int index) {
     buf->dma_fd = v4l2_exp.fd;
   }
 
-  // enqueue buffer
+  if (buf_list->do_capture) {
-  buf->used = 0;
+    buffer_consumed(buf);
-  buf->mmap_reflinks = 1;
+  }
-  buffer_consumed(buf);
 
   return buf;
 

buffer.h

@@ -16,6 +16,7 @@ typedef struct buffer_s {
 
   int mmap_reflinks;
   struct buffer_s *mmap_source;
+  bool enqueued;
 } buffer_t;
 
 buffer_t *buffer_open(const char *name, struct buffer_list_s *buf_list, int buffer);

buffer_list.h

@@ -29,6 +29,7 @@ int buffer_list_request(buffer_list_t *buf_list, int nbufs);
 
 int buffer_list_stream(buffer_list_t *buf_list, bool do_on);
 
-buffer_t *buffer_list_dequeue(buffer_list_t *buf_list, int mmap);
+buffer_t *buffer_list_find_slot(buffer_list_t *buf_list);
+buffer_t *buffer_list_dequeue(buffer_list_t *buf_list);
 
-buffer_t *buffer_list_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf);
+int buffer_list_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf);

buffer_queue.c

@@ -2,20 +2,13 @@
 #include "buffer_list.h"
 #include "device.h"
 
-bool buffer_output_dequeue(buffer_t *buf)
-{
-  // if (buf->enqueued || buf->buf_list->do_capture) {
-  //   return false;
-  // }
-
-  return false;
-}
-
 bool buffer_consumed(buffer_t *buf)
 {
   if (buf->mmap_reflinks > 0) {
     buf->mmap_reflinks--;
+  }
 
+  if (!buf->enqueued && buf->mmap_reflinks == 0) {
     // update used bytes
     if (buf->buf_list->do_mplanes) {
       buf->v4l2_plane.bytesused = buf->used;
@@ -23,15 +16,20 @@ bool buffer_consumed(buffer_t *buf)
       buf->v4l2_buffer.bytesused = buf->used;
     }
 
-    if (buf->mmap_reflinks == 0) {
+#if 0
-      E_LOG_DEBUG(buf, "Queuing buffer...");
+    uint64_t now = get_now_monotonic_u64();
-      E_XIOCTL(buf, buf->buf_list->device->fd, VIDIOC_QBUF, &buf->v4l2_buffer, "Can't queue buffer.");
+    struct timeval ts = {
-    }
+      .tv_sec = now / 1000000,
-  }
+      .tv_usec = now % 1000000,
+    };
 
-  if (buf->mmap_source) {
+    buf->v4l2_buffer.timestamp.tv_sec = ts.tv_sec;
-    buffer_consumed(buf->mmap_source);
+    buf->v4l2_buffer.timestamp.tv_usec = ts.tv_usec;
-    buf->mmap_source = NULL;
+#endif
+
+    E_LOG_DEBUG(buf, "Queuing buffer... used=%zu length=%zu (linked=%s)", buf->used, buf->length, buf->mmap_source ? buf->mmap_source->name : NULL);
+    E_XIOCTL(buf, buf->buf_list->device->fd, VIDIOC_QBUF, &buf->v4l2_buffer, "Can't queue buffer.");
+    buf->enqueued = true;
   }
 
   return true;
@@ -40,108 +38,64 @@ error:
   return false;
 }
 
-buffer_t *_buffer_list_enqueue_mmap(buffer_list_t *buf_list, buffer_t *dma_buf)
+buffer_t *buffer_list_find_slot(buffer_list_t *buf_list)
-{
-  buffer_t *buf = NULL;
-
-  buf = buffer_list_dequeue(buf_list, true);
-  if (!buf) {
-    return NULL;
-  }
-
-  if (dma_buf->used > buf->length) {
-    E_LOG_PERROR(buf_list, "The dma_buf (%s) is too long: %zu vs space=%zu",
-      dma_buf->name, dma_buf->used, buf->length);
-  }
-
-  E_LOG_DEBUG(buf, "mmap copy: dest=%p, src=%p (%s), size=%zu, space=%zu",
-    buf->start, dma_buf->start, dma_buf->name, dma_buf->used, buf->length);
-  memcpy(buf->start, dma_buf->start, dma_buf->used);
-  buffer_consumed(buf);
-
-  return NULL;
-error:
-  return NULL;
-}
-
-buffer_t *_buffer_list_enqueue_dmabuf(buffer_list_t *buf_list, buffer_t *dma_buf)
 {
   buffer_t *buf = NULL;
 
   for (int i = 0; i < buf_list->nbufs; i++) {
-    if (!buf_list->bufs[i]->mmap_source) {
+    if (!buf_list->bufs[i]->enqueued) {
       buf = buf_list->bufs[i];
       break;
     }
   }
-  if (!buf) {
-    return NULL;
-  }
 
-  struct v4l2_buffer v4l2_buf = {0};
-  struct v4l2_plane v4l2_plane = {0};
-
-  v4l2_buf.type = buf_list->type;
-  v4l2_buf.memory = V4L2_MEMORY_DMABUF;
-  v4l2_buf.index = buf->index;
-
-  if (buf_list->do_mplanes) {
-    v4l2_buf.length = 1;
-    v4l2_buf.m.planes = &v4l2_plane;
-    v4l2_plane.m.fd = dma_buf->dma_fd;
-		v4l2_plane.bytesused = dma_buf->used;
-		v4l2_plane.length = dma_buf->used;
-  } else {
-    v4l2_buf.m.fd = dma_buf->dma_fd;
-		v4l2_buf.bytesused = dma_buf->used;
-		v4l2_buf.length = dma_buf->used;
-  }
-
-	// uint64_t now = get_now_monotonic_u64();
-	// struct timeval ts = {
-	// 	.tv_sec = now / 1000000,
-	// 	.tv_usec = now % 1000000,
-	// };
-
-	// v4l2_buf.timestamp.tv_sec = ts.tv_sec;
-	// v4l2_buf.timestamp.tv_usec = ts.tv_usec;
-
-  E_LOG_DEBUG(buf, "dmabuf copy: dest=%p, src=%p (%s, dma_fd=%d), size=%zu",
-    buf->start, dma_buf->start, dma_buf->name, dma_buf->dma_fd, dma_buf->used);
-
-  E_XIOCTL(buf_list, buf_list->device->fd, VIDIOC_QBUF, &v4l2_buf, "Can't push DMA buffer");
-
-  buf->mmap_source = dma_buf;
-  buf_list->frames++;
   return buf;
-error:
-  return NULL;
 }
 
-buffer_t *buffer_list_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf)
+int buffer_list_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf)
 {
-  buffer_t *buf = NULL;
-
   if (!buf_list->do_mmap && !dma_buf->buf_list->do_mmap) {
     E_LOG_PERROR(buf_list, "Cannot enqueue non-mmap to non-mmap: %s.", dma_buf->name);
   }
 
-  if (buf_list->do_mmap) {
+  buffer_t *buf = buffer_list_find_slot(buf_list);
-    return _buffer_list_enqueue_mmap(buf_list, dma_buf);
+  if (!buf) {
-  } else {
+    return 0;
-    return _buffer_list_enqueue_dmabuf(buf_list, dma_buf);
   }
 
+  if (buf_list->do_mmap) {
+    if (dma_buf->used > buf->length) {
+      E_LOG_PERROR(buf_list, "The dma_buf (%s) is too long: %zu vs space=%zu",
+        dma_buf->name, dma_buf->used, buf->length);
+    }
+
+    E_LOG_DEBUG(buf, "mmap copy: dest=%p, src=%p (%s), size=%zu, space=%zu",
+      buf->start, dma_buf->start, dma_buf->name, dma_buf->used, buf->length);
+
+    memcpy(buf->start, dma_buf->start, dma_buf->used);
+  } else {
+    if (buf_list->do_mplanes) {
+      buf->v4l2_plane.m.fd = dma_buf->dma_fd;
+    } else {
+      buf->v4l2_buffer.m.fd = dma_buf->dma_fd;
+    }
+
+    E_LOG_DEBUG(buf, "dmabuf copy: dest=%p, src=%p (%s, dma_fd=%d), size=%zu",
+      buf->start, dma_buf->start, dma_buf->name, dma_buf->dma_fd, dma_buf->used);
+
+    buf->mmap_source = dma_buf;
+    dma_buf->mmap_reflinks++;
+  }
+
+  buf->used = dma_buf->used;
+  buffer_consumed(buf);
+  return 1;
 error:
-  return NULL;
+  return -1;
 }
 
-buffer_t *buffer_list_dequeue(buffer_list_t *buf_list, int mmap)
+buffer_t *buffer_list_dequeue(buffer_list_t *buf_list)
 {
-  if (mmap != buf_list->do_mmap) {
-    return NULL;
-  }
-
 	struct v4l2_buffer v4l2_buf = {0};
 	struct v4l2_plane v4l2_plane = {0};
 
@@ -156,27 +110,28 @@ buffer_t *buffer_list_dequeue(buffer_list_t *buf_list, int mmap)
 	E_XIOCTL(buf_list, buf_list->device->fd, VIDIOC_DQBUF, &v4l2_buf, "Can't grab capture buffer");
 
   buffer_t *buf = buf_list->bufs[v4l2_buf.index];
-  buf->v4l2_plane = v4l2_plane;
-  buf->v4l2_buffer = v4l2_buf;
 	if (buf_list->do_mplanes) {
-		buf->v4l2_buffer.m.planes = &buf->v4l2_plane;
+    buf->used = v4l2_plane.bytesused;
-    buf->used = buf->v4l2_plane.bytesused;
   } else {
-    buf->used = buf->v4l2_buffer.bytesused;
+    buf->used = v4l2_buf.bytesused;
   }
 
-	E_LOG_DEBUG(buf_list, "Grabbed mmap buffer=%u, bytes=%d, used=%d, frame=%d",
+  buf->enqueued = false;
-    buf->index, buf->length, buf->used, buf_list->frames);
+  buf->mmap_reflinks = 1;
 
-  if (buf_list->do_mmap) {
+	E_LOG_DEBUG(buf_list, "Grabbed mmap buffer=%u, bytes=%d, used=%d, frame=%d, linked=%s",
-    buf->mmap_reflinks = 1;
+    buf->index, buf->length, buf->used, buf_list->frames, buf->mmap_source ? buf->mmap_source->name : NULL);
-    buf_list->frames++;
+
-  } else {
+  if (buf->mmap_source) {
-    buf->mmap_reflinks = 0;
+    buf->mmap_source->used = 0;
+    buffer_consumed(buf->mmap_source);
+    buf->mmap_source = NULL;
   }
 
+  buf_list->frames++;
   return buf;
 
 error:
   return NULL;
 }
+

links.c

@@ -34,9 +34,6 @@ int _build_fds(link_t *all_links, struct pollfd *fds, link_t **links, buffer_lis
       if (!output || !output->output_list || n >= max_n) {
         return -EINVAL;
       }
-      if (output->output_list->do_mmap) {
-        continue;
-      }
       if (!output->output_list->streaming) {
         continue;
       }
@@ -70,7 +67,7 @@ int links_step(link_t *all_links, int timeout)
 
     if (fds[i].revents & POLLIN) {
       E_LOG_DEBUG(buf_list, "POLLIN");
-      if (buf = buffer_list_dequeue(buf_list, true)) {
+      if (buf = buffer_list_dequeue(buf_list)) {
         for (int j = 0; link->outputs[j]; j++) {
           buffer_list_enqueue(link->outputs[j]->output_list, buf);
         }
@@ -84,9 +81,7 @@ int links_step(link_t *all_links, int timeout)
     }
     if (fds[i].revents & POLLOUT) {
       E_LOG_DEBUG(buf_list, "POLLOUT");
-      if (buf = buffer_list_dequeue(buf_list, false)) {
+      buffer_list_dequeue(buf_list);
-        buffer_consumed(buf);
-      }
     }
   }
   return 0;

v4l2.c

@@ -1,6 +1,6 @@
 #include "v4l2.h"
 
-int xioctl(int fd, int request, void *arg)
+int xioctl(const char *name, int fd, int request, void *arg)
 {
 	int retries = XIOCTL_RETRIES;
 	int retval = -1;
@@ -19,7 +19,7 @@ int xioctl(int fd, int request, void *arg)
 
 	// cppcheck-suppress knownConditionTrueFalse
 	if (retval && retries <= 0) {
-		E_LOG_PERROR(NULL, "ioctl(%d) retried %u times; giving up", request, XIOCTL_RETRIES);
+		E_LOG_PERROR(NULL, "%s: ioctl(%08x) retried %u times; giving up", name, request, XIOCTL_RETRIES);
 	}
 	return retval;
 }

v4l2.h

@@ -37,11 +37,11 @@ typedef struct {
 
 fourcc_string fourcc_to_string(unsigned format);
 unsigned fourcc_to_stride(unsigned width, unsigned format);
-int xioctl(int fd, int request, void *arg);
+int xioctl(const char *name, int fd, int request, void *arg);
 
 #define E_XIOCTL(dev, _fd, _request, _value, _msg, ...) do { \
 		int ret; \
-		if ((ret = xioctl(_fd, _request, _value)) < 0) { \
+		if ((ret = xioctl(dev_name(dev), _fd, _request, _value)) < 0) { \
 			E_LOG_ERROR(dev, "xioctl(ret=%d): " _msg, ret, ##__VA_ARGS__); \
 		} \
 	} while(0)