[WIP]samples: video: capture: Add support for m2m transformation

Some boards need additional processing from a m2m device to correctly
displays the image, e.g. the LCD on RT1170 is in portrait orientation
while the camera image is in landscape.

This is to add such a transformation to the capture sample.

Signed-off-by: Phi Bang Nguyen <phibang.nguyen@nxp.com>

Author: ngphibang

drivers/video/video_sw_generator.c

@@ -52,7 +52,7 @@ struct video_sw_generator_data {
 		.width_min = 64,                                                                   \
 		.width_max = 1920,                                                                 \
 		.height_min = 64,                                                                  \
-		.height_max = 1080,                                                                \
+		.height_max = 1280,                                                                \
 		.width_step = 1,                                                                   \
 		.height_step = 1,                                                                  \
 	}

include/zephyr/drivers/video.h

@@ -144,10 +144,10 @@ struct video_caps {
  * Represent a video frame.
  */
 struct video_buffer {
-	/** type of the buffer */
-	enum video_buf_type type;
 	/** pointer to driver specific data. */
 	void *driver_data;
+	/** type of the buffer */
+	enum video_buf_type type;
 	/** pointer to the start of the buffer. */
 	uint8_t *buffer;
 	/** index of the buffer, optionally set by the application */

samples/drivers/video/capture/boards/mimxrt1170_evk_mimxrt1176_cm7.conf

@@ -1 +1,2 @@
-CONFIG_VIDEO_BUFFER_POOL_SZ_MAX=3686800
+CONFIG_VIDEO_BUFFER_POOL_SZ_MAX=6530200
+CONFIG_VIDEO_BUFFER_POOL_NUM_MAX=3

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

@@ -120,6 +120,9 @@ int main(void)
 
 	LOG_INF("Video device: %s", video_dev->name);
 
+	/* Get PxP device */
+	const struct device *const transform_dev = DEVICE_DT_GET(DT_NODELABEL(pxp));
+
 	/* Get capabilities */
 	caps.type = type;
 	if (video_get_caps(video_dev, &caps)) {
@@ -206,6 +209,25 @@ int main(void)
 		return 0;
 	}
 
+	/* Set format PxP */
+	fmt.type = VIDEO_BUF_TYPE_INPUT;
+	if (video_set_format(transform_dev, &fmt)) {
+		LOG_ERR("Unable to set input format for PxP");
+		return 0;
+	}
+	fmt.type = VIDEO_BUF_TYPE_OUTPUT;
+
+	struct video_format fmt_out = {.pixelformat = fmt.pixelformat,
+		.width = fmt.height,
+		.height = fmt.width,
+		.type = VIDEO_BUF_TYPE_OUTPUT,};
+
+	if (video_set_format(transform_dev, &fmt_out)) {
+		LOG_ERR("Unable to set output format for PxP");
+		return 0;
+	}
+
+	/* Get and enumerate frame interval */
 	if (!video_get_frmival(video_dev, &frmival)) {
 		LOG_INF("- Default frame rate : %f fps",
 			1.0 * frmival.denominator / frmival.numerator);
@@ -257,6 +279,11 @@ int main(void)
 		video_set_ctrl(video_dev, &ctrl);
 	}
 
+	/* Rotate image 90 degree with PxP */
+	ctrl.id = VIDEO_CID_ROTATE;
+	ctrl.val = 90;
+	video_set_ctrl(transform_dev, &ctrl);
+
 #if DT_HAS_CHOSEN(zephyr_display)
 	const struct device *const display_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_display));
 
@@ -265,7 +292,7 @@ int main(void)
 		return 0;
 	}
 
-	err = display_setup(display_dev, fmt.pixelformat);
+	err = display_setup(display_dev, fmt_out.pixelformat);
 	if (err) {
 		LOG_ERR("Unable to set up display");
 		return err;
@@ -292,7 +319,10 @@ int main(void)
 			return 0;
 		}
 		buffers[i]->type = type;
-		video_enqueue(video_dev, buffers[i]);
+
+		if (i < 2) {
+			video_enqueue(video_dev, buffers[i]);
+		}
 	}
 
 	/* Start video capture */
@@ -321,8 +351,44 @@ int main(void)
 		}
 #endif
 
+		/* PxP m2m handling */
+		vbuf->type = VIDEO_BUF_TYPE_INPUT;
+		err = video_enqueue(transform_dev, vbuf);
+		if (err) {
+			LOG_ERR("Unable to enqueue PxP video buf in");
+			return 0;
+		}
+
+		buffers[2]->type = VIDEO_BUF_TYPE_OUTPUT;
+		err = video_enqueue(transform_dev, buffers[2]);
+		if (err) {
+			LOG_ERR("Unable to enqueue PxP video buf out");
+			return 0;
+		}
+
+		/* same start for both input and output */
+		if (video_stream_start(transform_dev, VIDEO_BUF_TYPE_INPUT)) {
+			LOG_ERR("Unable to start PxP");
+			return 0;
+		}
+
+		err = video_dequeue(transform_dev, &vbuf, K_FOREVER);
+		if (err) {
+			LOG_ERR("Unable to dequeue PxP video buf in");
+			return 0;
+		}
+
+		// buffers[2]->type = VIDEO_BUF_TYPE_OUTPUT; => rework buffer management
+		struct video_buffer *vbuf_out = &(struct video_buffer){};
+		vbuf_out->type = VIDEO_BUF_TYPE_OUTPUT;
+		err = video_dequeue(transform_dev, &vbuf_out, K_FOREVER);
+		if (err) {
+			LOG_ERR("Unable to dequeue PxP video buf out");
+			return 0;
+		}
+
 #if DT_HAS_CHOSEN(zephyr_display)
-		video_display_frame(display_dev, vbuf, fmt);
+		video_display_frame(display_dev, vbuf_out, fmt_out);
 #endif
 
 		err = video_enqueue(video_dev, vbuf);