drivers: video: Expose buffers request instead of buffers alloc

The video subsystem holds an internal buffer pool and allocate buffers
of this pool on its own heap.

So, the application should not call alloc_buffers() but request_buffers()
instead. This lets the subsystem controls the buffer pool via index.

Request is not cumulative. Each new request fully replaces the old one.
This is the essential change compared to the old code where buffers are
allowed to be allocated at different time and hence, cannot be
controlled by index if allocation is done in different code modules.

Signed-off-by: Phi Bang Nguyen <[email protected]>

Author: ngphibang

drivers/video/video_common.c

@@ -100,26 +100,49 @@ void video_buffer_release(struct video_buffer *vbuf)
 	}
 }
 
-int video_enqueue(const struct device *dev, struct video_buffer *buf)
+/* To be completed */
+int video_request_buffers(uint8_t count, size_t size, enum video_buf_type type)
+{
+	struct video_buffer *buffer;
+
+	/* TODO: Input request vs Output request for m2m devices */
+	if (count > CONFIG_VIDEO_BUFFER_POOL_NUM_MAX) {
+		return -EINVAL;
+	}
+
+	/* TODO: Buffer request is not cumulative. For each new request, free all the buffers
+	 * that are previously requested
+	 */
+
+	/* Allocate buffers */
+	for (uint8_t i = 0; i < count; i++) {
+		buffer =
+			video_buffer_aligned_alloc(size, CONFIG_VIDEO_BUFFER_POOL_ALIGN, K_FOREVER);
+		buffer->type = type;
+		buffer->index = i;
+	}
+
+	return 0;
+}
+
+int video_enqueue(const struct device *dev, uint8_t index)
 {
 	const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
 	__ASSERT_NO_MSG(dev != NULL);
-	__ASSERT_NO_MSG(buf != NULL);
-	__ASSERT_NO_MSG(buf->buffer != NULL);
 
 	api = (const struct video_driver_api *)dev->api;
 	if (api->enqueue == NULL) {
 		return -ENOSYS;
 	}
 
-	if (video_buf[buf->index].state != VIDEO_BUF_STATE_DONE) {
+	if (video_buf[index].state != VIDEO_BUF_STATE_DONE) {
 		return -EINVAL;
 	}
 
-	video_buf[buf->index].state = VIDEO_BUF_STATE_QUEUED;
+	video_buf[index].state = VIDEO_BUF_STATE_QUEUED;
 
-	return api->enqueue(dev, &video_buf[buf->index]);
+	return api->enqueue(dev, &video_buf[index]);
 }
 
 int video_format_caps_index(const struct video_format_cap *fmts, const struct video_format *fmt,

include/zephyr/drivers/video.h

@@ -583,13 +583,13 @@ static inline int video_enum_frmival(const struct device *dev, struct video_frmi
  * endpoint incoming queue.
  *
  * @param dev Pointer to the device structure for the driver instance.
- * @param buf Pointer to the video buffer.
+ * @param index Index of the buffer to be queued
  *
  * @retval 0 Is successful.
  * @retval -EINVAL If parameters are invalid.
  * @retval -EIO General input / output error.
  */
-int video_enqueue(const struct device *dev, struct video_buffer *buf);
+int video_enqueue(const struct device *dev, uint8_t index);
 
 /**
  * @brief Dequeue a video buffer.
@@ -895,33 +895,7 @@ static inline int video_get_selection(const struct device *dev, struct video_sel
 	return api->get_selection(dev, sel);
 }
 
-/**
- * @brief Allocate aligned video buffer.
- *
- * @param size Size of the video buffer (in bytes).
- * @param align Alignment of the requested memory, must be a power of two.
- * @param timeout Timeout duration or K_NO_WAIT
- *
- * @retval pointer to allocated video buffer
- */
-struct video_buffer *video_buffer_aligned_alloc(size_t size, size_t align, k_timeout_t timeout);
-
-/**
- * @brief Allocate video buffer.
- *
- * @param size Size of the video buffer (in bytes).
- * @param timeout Timeout duration or K_NO_WAIT
- *
- * @retval pointer to allocated video buffer
- */
-struct video_buffer *video_buffer_alloc(size_t size, k_timeout_t timeout);
-
-/**
- * @brief Release a video buffer.
- *
- * @param buf Pointer to the video buffer to release.
- */
-void video_buffer_release(struct video_buffer *buf);
+int video_request_buffers(uint8_t count, size_t size, enum video_buf_type type);
 
 /**
  * @brief Search for a format that matches in a list of capabilities

samples/drivers/video/capture/src/main.c

@@ -279,21 +279,15 @@ int main(void)
 		bsize = fmt.pitch * caps.min_line_count;
 	}
 
-	/* Alloc video buffers and enqueue for capture */
+	err = video_request_buffers(ARRAY_SIZE(buffers), bsize, VIDEO_BUF_TYPE_OUTPUT);
+	if (err) {
+		LOG_ERR("Unable to request video buf");
+		return 0;
+	}
+
+	/* Enqueue buffers for capture */
 	for (i = 0; i < ARRAY_SIZE(buffers); i++) {
-		/*
-		 * For some hardwares, such as the PxP used on i.MX RT1170 to do image rotation,
-		 * buffer alignment is needed in order to achieve the best performance
-		 */
-		buffers[i] = video_buffer_aligned_alloc(bsize, CONFIG_VIDEO_BUFFER_POOL_ALIGN,
-							K_FOREVER);
-		if (buffers[i] == NULL) {
-			LOG_ERR("Unable to alloc video buffer");
-			return 0;
-		}
-		buffers[i]->type = type;
-		buffers[i]->index = i;
-		video_enqueue(video_dev, buffers[i]);
+		video_enqueue(video_dev, i);
 	}
 
 	/* Start video capture */
@@ -326,7 +320,7 @@ int main(void)
 		video_display_frame(display_dev, vbuf, fmt);
 #endif
 
-		err = video_enqueue(video_dev, vbuf);
+		err = video_enqueue(video_dev, vbuf->index);
 		if (err) {
 			LOG_ERR("Unable to requeue video buf");
 			return 0;