usb: uvc: remove application decisions from the UVC class

The UVC class was deciding the format list for itself, which does not
allow the application to convert the format, or filter which formats
to expose to thoe host. Remove this logic out of the UVC class and
expose an extra API to add formats to the list.

Signed-off-by: Josuah Demangeon <me@josuah.net>

Author: josuah

include/zephyr/usb/class/usbd_uvc.h

@@ -26,20 +26,38 @@
  */
 
 /**
- * @brief Set the video device that a UVC instance will use.
+ * @brief Set the video device that a UVC instance will use for control requests.
  *
- * It will query its supported controls, formats and frame rates, and use this information to
- * generate USB descriptors sent to the host.
- *
- * At runtime, it will forward all USB controls from the host to this device.
+ * It will query its supported video controls and frame intervals and use this information to
+ * generate the USB descriptors presented to the host. At runtime, it will forward all USB controls
+ * from the host to this device.
  *
  * @note This function must be called before @ref usbd_enable.
  *
  * @param uvc_dev The UVC device
- * @param video_dev The video device that this UVC instance controls
+ * @param video_dev The video device that this UVC instance send controls requests to
  */
 void uvc_set_video_dev(const struct device *uvc_dev, const struct device *video_dev);
 
+/**
+ * @brief Set the video format capabilities that a UVC instance will present to the host.
+ *
+ * This information will be used to generate USB descriptors.
+ * The minimum and maximum values are considered as discrete values, as width and height ranges
+ * are not supported by the UVC protocol, but only discrete values.
+ *
+ * The format selected by the host can then be queried through the @ref video_get_format API.
+ *
+ * @note This function must be called before @ref usbd_enable.
+ *
+ * @note The @p fmts memory pointed should remain valid for the entire lifetime of @p uvc_dev.
+ *
+ * @param uvc_dev The UVC device
+ * @param fmt The video format to add
+ * @return 0 on success, negative error code otherwise
+ */
+int uvc_add_format(const struct device *const dev, const struct video_format *const fmt);
+
 /**
  * @}
  */

samples/subsys/usb/uvc/src/main.c

@@ -17,15 +17,66 @@
 
 LOG_MODULE_REGISTER(uvc_sample, LOG_LEVEL_INF);
 
-const struct device *const uvc_dev = DEVICE_DT_GET(DT_NODELABEL(uvc));
-const struct device *const video_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_camera));
+const static struct device *const uvc_dev = DEVICE_DT_GET(DT_NODELABEL(uvc));
+const static struct device *const video_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_camera));
+
+/* Format capabilities of video_dev, usd everywhere through the sampel */
+static struct video_caps video_caps = {.type = VIDEO_BUF_TYPE_OUTPUT};
+
+static size_t app_get_min_buf_size(const struct video_format *const fmt)
+{
+	if (video_caps.min_line_count == LINE_COUNT_HEIGHT) {
+		return fmt->pitch * fmt->height;
+	} else {
+		return fmt->pitch * video_caps.min_line_count;
+	}
+}
+
+static void app_add_format(uint32_t pixfmt, uint16_t width, uint16_t height)
+{
+	struct video_format fmt = {
+		.pixelformat = pixfmt,
+		.width = width,
+		.height = height,
+		.type = VIDEO_BUF_TYPE_OUTPUT,
+	};
+	int ret;
+
+	/* Set the format to get the pitch */
+	ret = video_set_format(video_dev, &fmt);
+	if (ret != 0) {
+		LOG_ERR("Could not set the format of %s", video_dev->name);
+		return;
+	}
+
+	if (app_get_min_buf_size(&fmt) > CONFIG_VIDEO_BUFFER_POOL_SZ_MAX) {
+		LOG_WRN("Skipping format %ux%u", fmt.width, fmt.height);
+		return;
+	}
+
+	uvc_add_format(uvc_dev, &fmt);
+}
+
+/* Submit to UVC only the formats expected to be working (enough memory for the size, etc.) */
+static void app_add_filtered_formats(void)
+{
+	for (int i = 0; video_caps.format_caps[i].pixelformat != 0; i++) {
+		const struct video_format_cap *vcap = &video_caps.format_caps[i];
+
+		app_add_format(vcap->pixelformat, vcap->width_min, vcap->height_min);
+
+		if (vcap->width_min != vcap->width_max || vcap->height_min != vcap->height_max) {
+			app_add_format(vcap->pixelformat, vcap->width_max, vcap->height_max);
+		}
+	}
+}
 
 int main(void)
 {
 	struct usbd_context *sample_usbd;
 	struct video_buffer *vbuf;
 	struct video_format fmt = {0};
-	struct video_caps caps;
+	struct video_frmival frmival = {0};
 	struct k_poll_signal sig;
 	struct k_poll_event evt[1];
 	k_timeout_t timeout = K_FOREVER;
@@ -37,16 +88,18 @@ int main(void)
 		return -ENODEV;
 	}
 
-	caps.type = VIDEO_BUF_TYPE_OUTPUT;
-
-	if (video_get_caps(video_dev, &caps)) {
+	ret = video_get_caps(video_dev, &video_caps);
+	if (ret != 0) {
 		LOG_ERR("Unable to retrieve video capabilities");
 		return 0;
 	}
 
-	/* Must be done before initializing USB */
+	/* Must be called before usb_enable() */
 	uvc_set_video_dev(uvc_dev, video_dev);
 
+	/* Must be called before uvc_set_video_dev() */
+	app_add_filtered_formats();
+
 	sample_usbd = sample_usbd_init_device(NULL);
 	if (sample_usbd == NULL) {
 		return -ENODEV;
@@ -59,7 +112,6 @@ int main(void)
 
 	LOG_INF("Waiting the host to select the video format");
 
-	/* Get the video format once it is selected by the host */
 	while (true) {
 		fmt.type = VIDEO_BUF_TYPE_INPUT;
 
@@ -75,17 +127,32 @@ int main(void)
 		k_sleep(K_MSEC(10));
 	}
 
-	LOG_INF("The host selected format '%s' %ux%u, preparing %u buffers of %u bytes",
+	ret = video_get_frmival(uvc_dev, &frmival);
+	if (ret != 0) {
+		LOG_ERR("Failed to get the video frame interval");
+		return ret;
+	}
+
+	LOG_INF("The host selected format '%s' %ux%u at frame interval %u/%u",
 		VIDEO_FOURCC_TO_STR(fmt.pixelformat), fmt.width, fmt.height,
-		CONFIG_VIDEO_BUFFER_POOL_NUM_MAX, fmt.pitch * fmt.height);
+		frmival.numerator, frmival.denominator);
 
-	/* Size to allocate for each buffer */
-	if (caps.min_line_count == LINE_COUNT_HEIGHT) {
-		bsize = fmt.pitch * fmt.height;
-	} else {
-		bsize = fmt.pitch * caps.min_line_count;
+	fmt.type = VIDEO_BUF_TYPE_OUTPUT;
+
+	ret = video_set_format(video_dev, &fmt);
+	if (ret != 0) {
+		LOG_WRN("Could not set the format of %s", video_dev->name);
 	}
 
+	ret = video_set_frmival(video_dev, &frmival);
+	if (ret != 0) {
+		LOG_WRN("Could not set the framerate of %s", video_dev->name);
+	}
+
+	bsize = app_get_min_buf_size(&fmt);
+
+	LOG_INF("Preparing %u buffers of %u bytes", CONFIG_VIDEO_BUFFER_POOL_NUM_MAX, bsize);
+
 	for (int i = 0; i < CONFIG_VIDEO_BUFFER_POOL_NUM_MAX; i++) {
 		vbuf = video_buffer_alloc(bsize, K_NO_WAIT);
 		if (vbuf == NULL) {