Rework buffer memory layout

Move offset, size and stride to separate chunk structure that we
can keep in shared memory.
Add shared metadata type to hold the memory block holding the
metadata.

spa/include/spa/buffer.h

@@ -36,6 +36,7 @@ typedef struct _SpaBuffer SpaBuffer;
  * @SPA_META_TYPE_POINTER: a generic pointer
  * @SPA_META_TYPE_VIDEO_CROP: video cropping region
  * @SPA_META_TYPE_RINGBUFFER: a ringbuffer
+ * @SPA_META_TYPE_SHARED: buffer data and metadata memory can be shared
  */
 typedef enum {
   SPA_META_TYPE_INVALID               = 0,
@@ -43,6 +44,7 @@ typedef enum {
   SPA_META_TYPE_POINTER,
   SPA_META_TYPE_VIDEO_CROP,
   SPA_META_TYPE_RINGBUFFER,
+  SPA_META_TYPE_SHARED,
 } SpaMetaType;
 
 /**
@@ -119,6 +121,21 @@ typedef struct {
   SpaRingbuffer ringbuffer;
 } SpaMetaRingbuffer;
 
+/**
+ * SpaMetaShared:
+ * @type:
+ * @flags:
+ * @fd:
+ * @size:
+ */
+typedef struct {
+  SpaDataType    type;
+  int            flags;
+  int            fd;
+  off_t          offset;
+  size_t         size;
+} SpaMetaShared;
+
 /**
  * SpaMeta:
  * @type: metadata type
@@ -131,26 +148,36 @@ typedef struct {
   size_t       size;
 } SpaMeta;
 
+/**
+ * SpaChunk:
+ * @offset: offset of valid data
+ * @size: size of valid data
+ * @stride: stride of data if applicable
+ */
+typedef struct {
+  off_t          offset;
+  size_t         size;
+  ssize_t        stride;
+} SpaChunk;
+
 /**
  * SpaData:
  * @type: memory type
  * @flags: memory flags
- * @data: pointer to memory
  * @fd: file descriptor
+ * @offset: start offset when mapping @fd
  * @maxsize: maximum size of the memory
- * @offset: offset in @data
- * @size: valid size of @data
- * @stride: stride of data if applicable
+ * @data: pointer to memory
+ * @chunk: pointer to chunk with valid offset
  */
 typedef struct {
   SpaDataType    type;
   int            flags;
-  void          *data;
   int            fd;
-  size_t         maxsize;
   off_t          offset;
   size_t         size;
-  ssize_t        stride;
+  void          *data;
+  SpaChunk      *chunk;
 } SpaData;
 
 /**
@@ -169,6 +196,12 @@ struct _SpaBuffer {
   SpaData       *datas;
 };
 
+
+typedef struct {
+  unsigned int   n_buffers;
+  SpaBuffer    **buffers;
+} SpaBufferArray;
+
 static inline void *
 spa_buffer_find_meta (SpaBuffer *b, SpaMetaType type)
 {
@@ -189,6 +222,7 @@ spa_meta_type_get_size (SpaMetaType  type)
     sizeof (SpaMetaPointer),
     sizeof (SpaMetaVideoCrop),
     sizeof (SpaMetaRingbuffer),
+    sizeof (SpaMetaShared),
   };
   if (type <= 0 || type >= SPA_N_ELEMENTS (header_sizes))
     return 0;

spa/lib/debug.c

@@ -30,6 +30,7 @@ struct meta_type_name {
   { "SpaMetaPointer" },
   { "SpaMetaVideoCrop" },
   { "SpaMetaRingbuffer" },
+  { "SpaMetaShared" },
   { "invalid" },
 };
 #define META_TYPE_NAME(t)  meta_type_names[SPA_CLAMP(t,0,SPA_N_ELEMENTS(meta_type_names)-1)].name
@@ -172,6 +173,17 @@ spa_debug_buffer (const SpaBuffer *buffer)
         fprintf (stderr, "      mask2:       %zd\n", h->ringbuffer.mask2);
         break;
       }
+      case SPA_META_TYPE_SHARED:
+      {
+        SpaMetaShared *h = m->data;
+        fprintf (stderr, "    SpaMetaShared:\n");
+        fprintf (stderr, "      type:   %d\n", h->type);
+        fprintf (stderr, "      flags:  %d\n", h->flags);
+        fprintf (stderr, "      fd:     %d\n", h->fd);
+        fprintf (stderr, "      offset: %zd\n", h->offset);
+        fprintf (stderr, "      size:   %zd\n", h->size);
+        break;
+      }
       default:
         spa_debug_dump_mem (m->data, m->size);
         break;
@@ -184,10 +196,12 @@ 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, "   maxsize: %zd\n", d->maxsize);
     fprintf (stderr, "   offset:  %zd\n", d->offset);
-    fprintf (stderr, "   size:    %zd\n", d->size);
-    fprintf (stderr, "   stride:  %zd\n", d->stride);
+    fprintf (stderr, "   maxsize: %zd\n", d->size);
+    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, "    stride: %zd\n", d->chunk->stride);
   }
   return SPA_RESULT_OK;
 }

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].maxsize);
+        munmap (b->outbuf->datas[0].data, b->outbuf->datas[0].size);
       if (b->outbuf->datas[0].fd != -1)
         close (b->outbuf->datas[0].fd);
       b->outbuf->datas[0].type = SPA_DATA_TYPE_INVALID;
@@ -876,7 +876,9 @@ mmap_read (SpaV4l2Source *this)
   }
 
   d = b->outbuf->datas;
-  d[0].size = buf.bytesused;
+  d[0].chunk->offset = 0;
+  d[0].chunk->size = buf.bytesused;
+  d[0].chunk->stride = state->fmt.fmt.pix.bytesperline;
 
   spa_list_insert (state->ready.prev, &b->list);
 
@@ -970,7 +972,7 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
           spa_log_error (state->log, "v4l2: need mmaped memory");
           continue;
         }
-        b->v4l2_buffer.m.userptr = (unsigned long) SPA_MEMBER (d[0].data, d[0].offset, void *);
+        b->v4l2_buffer.m.userptr = (unsigned long) d[0].data;
         b->v4l2_buffer.length = d[0].size;
         break;
       case SPA_DATA_TYPE_DMABUF:
@@ -1047,8 +1049,9 @@ mmap_init (SpaV4l2Source   *this,
     d = buffers[i]->datas;
     d[0].offset = 0;
     d[0].size = b->v4l2_buffer.length;
-    d[0].maxsize = b->v4l2_buffer.length;
-    d[0].stride = state->fmt.fmt.pix.bytesperline;
+    d[0].chunk->offset = 0;
+    d[0].chunk->size = b->v4l2_buffer.length;
+    d[0].chunk->stride = state->fmt.fmt.pix.bytesperline;
 
     if (state->export_buf) {
       struct v4l2_exportbuffer expbuf;

spa/plugins/videotestsrc/videotestsrc.c

@@ -658,7 +658,7 @@ spa_videotestsrc_node_port_use_buffers (SpaNode         *node,
           continue;
         }
         b->ptr = SPA_MEMBER (d[0].data, d[0].offset, void);
-        b->stride = d[0].stride;
+        b->stride = d[0].chunk->stride;
         break;
       default:
         break;