samples: drivers: video: update video capture sample.

Update this sample is dedicated to support usb host
video. This sample can enumerate UVC device, configure
UVC device and start video stream transfers then
display it on LCD.

Signed-off-by: Aiden Hu <[email protected]>

Author: AidenHu

samples/drivers/display/sample.yaml

@@ -111,6 +111,7 @@ tests:
       - platform:frdm_mcxn236/mcxn236:SHIELD=lcd_par_s035_8080
       - platform:frdm_mcxa156/mcxa156:SHIELD=lcd_par_s035_8080
       - platform:frdm_rw612:SHIELD=lcd_par_s035_spi
+      - platform:rd_rw612_bga:SHIELD=lcd_par_s035_spi
       - platform:ek_ra8d1:SHIELD=rtkmipilcdb00000be
       - platform:ek_ra8d1:SHIELD=rtk7eka6m3b00001bu
       - platform:nucleo_g071rb/stm32g071xx:SHIELD=x_nucleo_gfx01m2

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

@@ -0,0 +1,16 @@
+CONFIG_UHC_DRIVER=y
+CONFIG_USB_HOST_STACK=y
+CONFIG_USBH_VIDEO_CLASS=y
+
+# Video buffer configuration
+CONFIG_VIDEO_BUFFER_POOL_SZ_MAX=30720
+CONFIG_VIDEO_BUFFER_POOL_NUM_MAX=4
+CONFIG_VIDEO_BUFFER_POOL_ALIGN=32
+
+
+# Memory configuration for USB transfers
+CONFIG_HEAP_MEM_POOL_SIZE=32768
+CONFIG_MAIN_STACK_SIZE=8192
+CONFIG_USBH_USB_DEVICE_HEAP=8192
+CONFIG_NOCACHE_MEMORY=y
+CONFIG_UHC_BUF_POOL_SIZE=2048 

samples/drivers/video/capture/boards/rd_rw612_bga.overlay

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2025 NXP
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/ {
+	uvc_host: uvc_host {
+		compatible = "zephyr,uvc-host";
+	};
+};

samples/drivers/video/capture/prj.conf

@@ -1,8 +1,12 @@
-CONFIG_VIDEO=y
+CONFIG_POLL=y
+CONFIG_EVENTS=y
 CONFIG_SHELL=y
 CONFIG_DEVICE_SHELL=y
+CONFIG_VIDEO=y
+CONFIG_USB_HOST_STACK=y
 CONFIG_PRINTK=y
 CONFIG_LOG=y
 CONFIG_DISPLAY=y
 CONFIG_REQUIRES_FLOAT_PRINTF=y
 CONFIG_LOG_MODE_DEFERRED=y
+CONFIG_USBH_VIDEO_LOG_LEVEL_WRN=y

samples/drivers/video/capture/sample.yaml

@@ -4,6 +4,7 @@ tests:
   sample.video.capture:
     tags:
       - video
+      - usb
       - shield
       - samples
     extra_args:
@@ -13,9 +14,11 @@ tests:
       - platform:frdm_mcxn947/mcxn947/cpu0:SHIELD="dvp_20pin_ov7670;lcd_par_s035_8080"
       - platform:frdm_mcxn236/mcxn236:SHIELD="dvp_20pin_ov7670;lcd_par_s035_8080"
       - platform:stm32h7b3i_dk:SHIELD="st_b_cams_omv_mb1683"
+      - platform:rd_rw612_bga/rw612:SHIELD="usb_camera;lcd_par_s035_8080"
     extra_configs:
       - CONFIG_TEST=y
       - CONFIG_FPU=y
+      - CONFIG_USB_HOST=y
     harness: console
     harness_config:
       fixture: fixture_camera
@@ -31,15 +34,19 @@ tests:
       - mimxrt1064_evk/mimxrt1064
       - mimxrt1170_evk/mimxrt1176/cm7
       - mimxrt1170_evk@B/mimxrt1176/cm7
+      - rd_rw612_bga/rw612
       - frdm_mcxn947/mcxn947/cpu0
       - frdm_mcxn236/mcxn236
       - mm_swiftio
       - esp32s3_eye/esp32s3/procpu
       - stm32h7b3i_dk
-    depends_on: video
+    depends_on:
+      - video
+      - usbh
     integration_platforms:
       - mimxrt1064_evk/mimxrt1064
       - mimxrt1170_evk/mimxrt1176/cm7
+      - rd_rw612_bga/rw612      
   sample.video.capture.shell:
     tags:
       - video

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

@@ -5,13 +5,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include <zephyr/init.h>
 #include <zephyr/kernel.h>
+#include <stdio.h>
+#include <errno.h>
 #include <zephyr/device.h>
 
 #include <zephyr/drivers/display.h>
 #include <zephyr/drivers/video.h>
 #include <zephyr/drivers/video-controls.h>
-
+#include <zephyr/usb/usbh.h>
 #include <zephyr/logging/log.h>
 
 #ifdef CONFIG_TEST
@@ -22,9 +25,8 @@ LOG_MODULE_REGISTER(main, LOG_LEVEL_DBG);
 LOG_MODULE_REGISTER(main, CONFIG_LOG_DEFAULT_LEVEL);
 #endif
 
-#if !DT_HAS_CHOSEN(zephyr_camera)
-#error No camera chosen in devicetree. Missing "--shield" or "--snippet video-sw-generator" flag?
-#endif
+USBH_CONTROLLER_DEFINE(uhs_ctx, DEVICE_DT_GET(DT_NODELABEL(zephyr_uhc0)));
+const struct device *const uvc_host = DEVICE_DT_GET(DT_NODELABEL(uvc_host));
 
 #if DT_HAS_CHOSEN(zephyr_display)
 static inline int display_setup(const struct device *const display_dev, const uint32_t pixfmt)
@@ -75,8 +77,8 @@ static inline int display_setup(const struct device *const display_dev, const ui
 }
 
 static inline void video_display_frame(const struct device *const display_dev,
-				       const struct video_buffer *const vbuf,
-				       const struct video_format fmt)
+					   const struct video_buffer *const vbuf,
+					   const struct video_format fmt)
 {
 	struct display_buffer_descriptor buf_desc = {
 		.buf_size = vbuf->bytesused,
@@ -89,15 +91,22 @@ static inline void video_display_frame(const struct device *const display_dev,
 }
 #endif
 
+/* TODO: handle disconnection,etc.. */
+static void video_uvc_device_signal_handler(void)
+{
+}
+
 int main(void)
 {
 	struct video_buffer *buffers[CONFIG_VIDEO_BUFFER_POOL_NUM_MAX];
 	struct video_buffer *vbuf = &(struct video_buffer){};
-	const struct device *video_dev;
 	struct video_format fmt;
 	struct video_caps caps;
 	struct video_frmival frmival;
 	struct video_frmival_enum fie;
+	struct k_poll_signal sig;
+	struct k_poll_event evt[1];
+	k_timeout_t timeout = K_FOREVER;
 	enum video_buf_type type = VIDEO_BUF_TYPE_OUTPUT;
 #if (CONFIG_VIDEO_SOURCE_CROP_WIDTH && CONFIG_VIDEO_SOURCE_CROP_HEIGHT) ||	\
 	CONFIG_VIDEO_FRAME_HEIGHT || CONFIG_VIDEO_FRAME_WIDTH
@@ -116,17 +125,58 @@ int main(void)
 		return 0;
 	}
 
-	video_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_camera));
-	if (!device_is_ready(video_dev)) {
-		LOG_ERR("%s: video device is not ready", video_dev->name);
+	if (!device_is_ready(uvc_host)) {
+		LOG_ERR("%s: USB host is not ready", uvc_host->name);
 		return 0;
 	}
+	LOG_INF("USB host: %s", uvc_host->name);
 
-	LOG_INF("Video device: %s", video_dev->name);
+	err = usbh_init(&uhs_ctx);
+	if (err) {
+		LOG_ERR("Failed to initialize host support");
+		return err;
+	}
+
+	err = usbh_enable(&uhs_ctx);
+	if (err) {
+		LOG_ERR("Failed to enable USB host support");
+		return err;
+	}
+
+	k_poll_signal_init(&sig);
+	k_poll_event_init(&evt[0], K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY, &sig);
+
+	err = video_set_signal(uvc_host, &sig);
+	if (err != 0) {
+		LOG_WRN("Failed to setup the signal on %s output endpoint", uvc_host->name);
+		timeout = K_MSEC(10);
+	}
+
+	/* Wait for UVC device connection event */
+	while (true) {
+		err = k_poll(evt, ARRAY_SIZE(evt), timeout);
+		if (err != 0) {
+			LOG_WRN("Poll failed with error %d, retrying...", err);
+			continue;
+		}
+		
+		int signaled, result;
+		k_poll_signal_check(&sig, &signaled, &result);
+		
+		if (signaled && result == USBH_DEVICE_CONNECTED) {
+			LOG_INF("UVC device connected successfully!");
+			k_poll_signal_reset(&sig);
+			break;
+		}
+		
+		/* Received other signal, reset and continue waiting */
+		k_poll_signal_reset(&sig);
+		LOG_DBG("Received signal %d, waiting for device connection...", result);
+	}
 
 	/* Get capabilities */
 	caps.type = type;
-	if (video_get_caps(video_dev, &caps)) {
+	if (video_get_caps(uvc_host, &caps)) {
 		LOG_ERR("Unable to retrieve video capabilities");
 		return 0;
 	}
@@ -144,7 +194,7 @@ int main(void)
 
 	/* Get default/native format */
 	fmt.type = type;
-	if (video_get_format(video_dev, &fmt)) {
+	if (video_get_format(uvc_host, &fmt)) {
 		LOG_ERR("Unable to retrieve video format");
 		return 0;
 	}
@@ -156,7 +206,7 @@ int main(void)
 	sel.rect.top = CONFIG_VIDEO_SOURCE_CROP_TOP;
 	sel.rect.width = CONFIG_VIDEO_SOURCE_CROP_WIDTH;
 	sel.rect.height = CONFIG_VIDEO_SOURCE_CROP_HEIGHT;
-	if (video_set_selection(video_dev, &sel)) {
+	if (video_set_selection(uvc_host, &sel)) {
 		LOG_ERR("Unable to set selection crop");
 		return 0;
 	}
@@ -178,7 +228,7 @@ int main(void)
 	 * and if compose is necessary
 	 */
 	sel.target = VIDEO_SEL_TGT_CROP;
-	err = video_get_selection(video_dev, &sel);
+	err = video_get_selection(uvc_host, &sel);
 	if (err < 0 && err != -ENOSYS) {
 		LOG_ERR("Unable to get selection crop");
 		return 0;
@@ -190,7 +240,7 @@ int main(void)
 		sel.rect.top = 0;
 		sel.rect.width = fmt.width;
 		sel.rect.height = fmt.height;
-		err = video_set_selection(video_dev, &sel);
+		err = video_set_selection(uvc_host, &sel);
 		if (err < 0 && err != -ENOSYS) {
 			LOG_ERR("Unable to set selection compose");
 			return 0;
@@ -201,24 +251,31 @@ int main(void)
 	if (strcmp(CONFIG_VIDEO_PIXEL_FORMAT, "")) {
 		fmt.pixelformat = VIDEO_FOURCC_FROM_STR(CONFIG_VIDEO_PIXEL_FORMAT);
 	}
+#if CONFIG_VIDEO_FRAME_WIDTH > 0
+	fmt.width = CONFIG_VIDEO_FRAME_WIDTH;
+#endif
+
+#if CONFIG_VIDEO_FRAME_HEIGHT > 0
+	fmt.height = CONFIG_VIDEO_FRAME_HEIGHT;
+#endif
 
 	LOG_INF("- Video format: %s %ux%u",
 		VIDEO_FOURCC_TO_STR(fmt.pixelformat), fmt.width, fmt.height);
 
-	if (video_set_format(video_dev, &fmt)) {
+	if (video_set_format(uvc_host, &fmt)) {
 		LOG_ERR("Unable to set format");
 		return 0;
 	}
 
-	if (!video_get_frmival(video_dev, &frmival)) {
+	if (!video_get_frmival(uvc_host, &frmival)) {
 		LOG_INF("- Default frame rate : %f fps",
 			1.0 * frmival.denominator / frmival.numerator);
 	}
 
 	LOG_INF("- Supported frame intervals for the default format:");
 	memset(&fie, 0, sizeof(fie));
 	fie.format = &fmt;
-	while (video_enum_frmival(video_dev, &fie) == 0) {
+	while (video_enum_frmival(uvc_host, &fie) == 0) {
 		if (fie.type == VIDEO_FRMIVAL_TYPE_DISCRETE) {
 			LOG_INF("   %u/%u", fie.discrete.numerator, fie.discrete.denominator);
 		} else {
@@ -233,7 +290,7 @@ int main(void)
 	/* Get supported controls */
 	LOG_INF("- Supported controls:");
 	const struct device *last_dev = NULL;
-	struct video_ctrl_query cq = {.dev = video_dev, .id = VIDEO_CTRL_FLAG_NEXT_CTRL};
+	struct video_ctrl_query cq = {.dev = uvc_host, .id = VIDEO_CTRL_FLAG_NEXT_CTRL};
 
 	while (!video_query_ctrl(&cq)) {
 		if (cq.dev != last_dev) {
@@ -249,17 +306,17 @@ int main(void)
 	int tp_set_ret = -ENOTSUP;
 
 	if (IS_ENABLED(CONFIG_VIDEO_CTRL_HFLIP)) {
-		video_set_ctrl(video_dev, &ctrl);
+		video_set_ctrl(uvc_host, &ctrl);
 	}
 
 	if (IS_ENABLED(CONFIG_VIDEO_CTRL_VFLIP)) {
 		ctrl.id = VIDEO_CID_VFLIP;
-		video_set_ctrl(video_dev, &ctrl);
+		video_set_ctrl(uvc_host, &ctrl);
 	}
 
 	if (IS_ENABLED(CONFIG_TEST)) {
 		ctrl.id = VIDEO_CID_TEST_PATTERN;
-		tp_set_ret = video_set_ctrl(video_dev, &ctrl);
+		video_set_ctrl(uvc_host, &ctrl);
 	}
 
 #if DT_HAS_CHOSEN(zephyr_display)
@@ -273,8 +330,10 @@ int main(void)
 	err = display_setup(display_dev, fmt.pixelformat);
 	if (err) {
 		LOG_ERR("Unable to set up display");
+		/* TODO: Use the format that this display supported, then need to do format covertion when streaming */
 		return err;
 	}
+
 #endif
 
 	/* Size to allocate for each buffer */
@@ -284,6 +343,12 @@ int main(void)
 		bsize = fmt.pitch * caps.min_line_count;
 	}
 
+	/* Start video capture */
+	if (video_stream_start(uvc_host, type)) {
+		LOG_ERR("Unable to start capture (interface)");
+		return 0;
+	}
+
 	/* Alloc video buffers and enqueue for capture */
 	for (i = 0; i < ARRAY_SIZE(buffers); i++) {
 		/*
@@ -297,21 +362,20 @@ int main(void)
 			return 0;
 		}
 		buffers[i]->type = type;
-		video_enqueue(video_dev, buffers[i]);
-	}
-
-	/* Start video capture */
-	if (video_stream_start(video_dev, type)) {
-		LOG_ERR("Unable to start capture (interface)");
-		return 0;
+		video_enqueue(uvc_host, buffers[i]);
 	}
 
 	LOG_INF("Capture started");
 
 	/* Grab video frames */
 	vbuf->type = type;
 	while (1) {
-		err = video_dequeue(video_dev, &vbuf, K_FOREVER);
+		err = k_poll(evt, ARRAY_SIZE(evt), timeout);
+		if (err != 0 && err != -EAGAIN) {
+			LOG_ERR("Poll exited with status %d", err);
+			return err;
+		}
+		err = video_dequeue(uvc_host, &vbuf, K_FOREVER);
 		if (err) {
 			LOG_ERR("Unable to dequeue video buf");
 			return 0;
@@ -329,13 +393,15 @@ int main(void)
 #endif
 
 #if DT_HAS_CHOSEN(zephyr_display)
+		vbuf->type = VIDEO_BUF_TYPE_INPUT;
 		video_display_frame(display_dev, vbuf, fmt);
 #endif
-
-		err = video_enqueue(video_dev, vbuf);
+		err = video_enqueue(uvc_host, vbuf);
 		if (err) {
 			LOG_ERR("Unable to requeue video buf");
 			return 0;
 		}
+
+		video_uvc_device_signal_handler();
 	}
 }