Merge pull request #1 from hathach/kkitayam-add_uvc

minor code clean up without functional changes

2 files changed, 386 insertions, 344 deletions

diff --git a/src/class/video/video.h b/src/class/video/video.h
index 3c27c8093..b24eb0bcc 100644
--- a/src/class/video/video.h
+++ b/src/class/video/video.h
@@ -29,18 +29,20 @@
 
 #include "common/tusb_common.h"
 
+// Table 3-19 Color Matching Descriptor
 typedef enum {
   VIDEO_COLOR_PRIMARIES_UNDEFINED = 0x00,
-  VIDEO_COLOR_PRIMARIES_BT709,
+  VIDEO_COLOR_PRIMARIES_BT709, // sRGB (default)
   VIDEO_COLOR_PRIMARIES_BT470_2M,
   VIDEO_COLOR_PRIMARIES_BT470_2BG,
   VIDEO_COLOR_PRIMARIES_SMPTE170M,
   VIDEO_COLOR_PRIMARIES_SMPTE240M,
 } video_color_primaries_t;
 
+// Table 3-19 Color Matching Descriptor
 typedef enum {
   VIDEO_COLOR_XFER_CH_UNDEFINED = 0x00,
-  VIDEO_COLOR_XFER_CH_BT709,
+  VIDEO_COLOR_XFER_CH_BT709, // default
   VIDEO_COLOR_XFER_CH_BT470_2M,
   VIDEO_COLOR_XFER_CH_BT470_2BG,
   VIDEO_COLOR_XFER_CH_SMPTE170M,
@@ -49,30 +51,31 @@ typedef enum {
   VIDEO_COLOR_XFER_CH_SRGB,
 } video_color_transfer_characteristics_t;
 
+// Table 3-19 Color Matching Descriptor
 typedef enum {
   VIDEO_COLOR_COEF_UNDEFINED = 0x00,
   VIDEO_COLOR_COEF_BT709,
   VIDEO_COLOR_COEF_FCC,
   VIDEO_COLOR_COEF_BT470_2BG,
-  VIDEO_COLOR_COEF_SMPTE170M,
+  VIDEO_COLOR_COEF_SMPTE170M, // BT.601 default
   VIDEO_COLOR_COEF_SMPTE240M,
 } video_color_matrix_coefficients_t;
 
-/* 4.2.1.2 */
+/* 4.2.1.2 Request Error Code Control */
 typedef enum {
-  VIDEO_NO_ERROR = 0, /* The request succeeded. */
-  VIDEO_NOT_READY,
-  VIDEO_WRONG_STATE,
-  VIDEO_POWER,
-  VIDEO_OUT_OF_RANGE,
-  VIDEO_INVALID_UNIT,
-  VIDEO_INVALID_CONTROL,
-  VIDEO_INVALID_REQUEST,
-  VIDEO_INVALID_VALUE_WITHIN_RANGE,
-  VIDEO_UNKNOWN = 0xFF,
+  VIDEO_ERROR_NONE = 0, /* The request succeeded. */
+  VIDEO_ERROR_NOT_READY,
+  VIDEO_ERROR_WRONG_STATE,
+  VIDEO_ERROR_POWER,
+  VIDEO_ERROR_OUT_OF_RANGE,
+  VIDEO_ERROR_INVALID_UNIT,
+  VIDEO_ERROR_INVALID_CONTROL,
+  VIDEO_ERROR_INVALID_REQUEST,
+  VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE,
+  VIDEO_ERROR_UNKNOWN = 0xFF,
 } video_error_code_t;
 
-/* A.2 */
+/* A.2 Interface Subclass */
 typedef enum {
   VIDEO_SUBCLASS_UNDEFINED = 0x00,
   VIDEO_SUBCLASS_CONTROL,
@@ -80,79 +83,86 @@ typedef enum {
   VIDEO_SUBCLASS_INTERFACE_COLLECTION,
 } video_subclass_type_t;
 
-/* A.3 */
+/* A.3 Interface Protocol */
 typedef enum {
-  VIDEO_INT_PROTOCOL_CODE_UNDEF = 0x00,
-  VIDEO_INT_PROTOCOL_CODE_15,
+  VIDEO_ITF_PROTOCOL_UNDEFINED = 0x00,
+  VIDEO_ITF_PROTOCOL_15,
 } video_interface_protocol_code_t;
 
-/* A.5 */
+/* A.5 Class-Specific VideoControl Interface Descriptor Subtypes */
 typedef enum {
-  VIDEO_CS_VC_INTERFACE_VC_DESCRIPTOR_UNDEF = 0x00,
-  VIDEO_CS_VC_INTERFACE_HEADER,
-  VIDEO_CS_VC_INTERFACE_INPUT_TERMINAL,
-  VIDEO_CS_VC_INTERFACE_OUTPUT_TERMINAL,
-  VIDEO_CS_VC_INTERFACE_SELECTOR_UNIT,
-  VIDEO_CS_VC_INTERFACE_PROCESSING_UNIT,
-  VIDEO_CS_VC_INTERFACE_EXTENSION_UNIT,
-  VIDEO_CS_VC_INTERFACE_ENCODING_UNIT,
-  VIDEO_CS_VC_INTERFACE_MAX,
+  VIDEO_CS_ITF_VC_UNDEFINED = 0x00,
+  VIDEO_CS_ITF_VC_HEADER,
+  VIDEO_CS_ITF_VC_INPUT_TERMINAL,
+  VIDEO_CS_ITF_VC_OUTPUT_TERMINAL,
+  VIDEO_CS_ITF_VC_SELECTOR_UNIT,
+  VIDEO_CS_ITF_VC_PROCESSING_UNIT,
+  VIDEO_CS_ITF_VC_EXTENSION_UNIT,
+  VIDEO_CS_ITF_VC_ENCODING_UNIT,
+  VIDEO_CS_ITF_VC_MAX,
 } video_cs_vc_interface_subtype_t;
 
-/* A.6 */
+/* A.6 Class-Specific VideoStreaming Interface Descriptor Subtypes */
 typedef enum {
-  VIDEO_CS_VS_INTERFACE_VS_DESCRIPTOR_UNDEF = 0x00,
-  VIDEO_CS_VS_INTERFACE_INPUT_HEADER,
-  VIDEO_CS_VS_INTERFACE_OUTPUT_HEADER,
-  VIDEO_CS_VS_INTERFACE_STILL_IMAGE_FRAME,
-  VIDEO_CS_VS_INTERFACE_FORMAT_UNCOMPRESSED,
-  VIDEO_CS_VS_INTERFACE_FRAME_UNCOMPRESSED,
-  VIDEO_CS_VS_INTERFACE_FORMAT_MJPEG,
-  VIDEO_CS_VS_INTERFACE_FRAME_MJPEG,
-  VIDEO_CS_VS_INTERFACE_FORMAT_MPEG2TS      = 0x0A,
-  VIDEO_CS_VS_INTERFACE_FORMAT_DV           = 0x0c,
-  VIDEO_CS_VS_INTERFACE_COLORFORMAT,
-  VIDEO_CS_VS_INTERFACE_FORMAT_FRAME_BASED  = 0x10,
-  VIDEO_CS_VS_INTERFACE_FRAME_FRAME_BASED,
-  VIDEO_CS_VS_INTERFACE_FORMAT_STREAM_BASED,
-  VIDEO_CS_VS_INTERFACE_FORMAT_H264,
-  VIDEO_CS_VS_INTERFACE_FRAME_H264,
-  VIDEO_CS_VS_INTERFACE_FORMAT_H264_SIMULCAST,
-  VIDEO_CS_VS_INTERFACE_FORMAT_VP8,
-  VIDEO_CS_VS_INTERFACE_FRAME_VP8,
-  VIDEO_CS_VS_INTERFACE_FORMAT_VP8_SIMULCAST,
+  VIDEO_CS_ITF_VS_UNDEFINED             = 0x00,
+  VIDEO_CS_ITF_VS_INPUT_HEADER          = 0x01,
+  VIDEO_CS_ITF_VS_OUTPUT_HEADER         = 0x02,
+  VIDEO_CS_ITF_VS_STILL_IMAGE_FRAME     = 0x03,
+  VIDEO_CS_ITF_VS_FORMAT_UNCOMPRESSED   = 0x04,
+  VIDEO_CS_ITF_VS_FRAME_UNCOMPRESSED    = 0x05,
+  VIDEO_CS_ITF_VS_FORMAT_MJPEG          = 0x06,
+  VIDEO_CS_ITF_VS_FRAME_MJPEG           = 0x07,
+  VIDEO_CS_ITF_VS_FORMAT_MPEG2TS        = 0x0A,
+  VIDEO_CS_ITF_VS_FORMAT_DV             = 0x0C,
+  VIDEO_CS_ITF_VS_COLORFORMAT           = 0x0D,
+  VIDEO_CS_ITF_VS_FORMAT_FRAME_BASED    = 0x10,
+  VIDEO_CS_ITF_VS_FRAME_FRAME_BASED     = 0x11,
+  VIDEO_CS_ITF_VS_FORMAT_STREAM_BASED   = 0x12,
+  VIDEO_CS_ITF_VS_FORMAT_H264           = 0x13,
+  VIDEO_CS_ITF_VS_FRAME_H264            = 0x14,
+  VIDEO_CS_ITF_VS_FORMAT_H264_SIMULCAST = 0x15,
+  VIDEO_CS_ITF_VS_FORMAT_VP8            = 0x16,
+  VIDEO_CS_ITF_VS_FRAME_VP8             = 0x17,
+  VIDEO_CS_ITF_VS_FORMAT_VP8_SIMULCAST  = 0x18,
 } video_cs_vs_interface_subtype_t;
 
-/* A.8 */
+/* A.7. Class-Specific Endpoint Descriptor Subtypes */
 typedef enum {
-  VIDEO_REQUEST_UNDEF = 0x00,
-  VIDEO_REQUEST_SET_CUR,
+  VIDEO_CS_EP_UNDEFINED = 0x00,
+  VIDEO_CS_EP_GENERAL,
+  VIDEO_CS_EP_ENDPOINT,
+  VIDEO_CS_EP_INTERRUPT
+} video_cs_ep_subtype_t;
+
+/* A.8 Class-Specific Request Codes */
+typedef enum {
+  VIDEO_REQUEST_UNDEFINED   = 0x00,
+  VIDEO_REQUEST_SET_CUR     = 0x01,
   VIDEO_REQUEST_SET_CUR_ALL = 0x11,
-  VIDEO_REQUEST_GET = 0x80,
-  VIDEO_REQUEST_GET_CUR,
-  VIDEO_REQUEST_GET_MIN,
-  VIDEO_REQUEST_GET_MAX,
-  VIDEO_REQUEST_GET_RES,
-  VIDEO_REQUEST_GET_LEN,
-  VIDEO_REQUEST_GET_INFO,
-  VIDEO_REQUEST_GET_DEF,
+  VIDEO_REQUEST_GET_CUR     = 0x81,
+  VIDEO_REQUEST_GET_MIN     = 0x82,
+  VIDEO_REQUEST_GET_MAX     = 0x83,
+  VIDEO_REQUEST_GET_RES     = 0x84,
+  VIDEO_REQUEST_GET_LEN     = 0x85,
+  VIDEO_REQUEST_GET_INFO    = 0x86,
+  VIDEO_REQUEST_GET_DEF     = 0x87,
   VIDEO_REQUEST_GET_CUR_ALL = 0x91,
-  VIDEO_REQUEST_GET_MIN_ALL,
-  VIDEO_REQUEST_GET_MAX_ALL,
-  VIDEO_REQUEST_GET_RES_ALL,
+  VIDEO_REQUEST_GET_MIN_ALL = 0x92,
+  VIDEO_REQUEST_GET_MAX_ALL = 0x93,
+  VIDEO_REQUEST_GET_RES_ALL = 0x94,
   VIDEO_REQUEST_GET_DEF_ALL = 0x97
 } video_control_request_t;
 
-/* A.9.1 */
+/* A.9.1 VideoControl Interface Control Selectors */
 typedef enum {
-  VIDEO_VC_CTL_UNDEF = 0x00,
+  VIDEO_VC_CTL_UNDEFINED = 0x00,
   VIDEO_VC_CTL_VIDEO_POWER_MODE,
   VIDEO_VC_CTL_REQUEST_ERROR_CODE,
 } video_interface_control_selector_t;
 
-/* A.9.8 */
+/* A.9.8 VideoStreaming Interface Control Selectors */
 typedef enum {
-  VIDEO_VS_CTL_UNDEF = 0x00,
+  VIDEO_VS_CTL_UNDEFINED = 0x00,
   VIDEO_VS_CTL_PROBE,
   VIDEO_VS_CTL_COMMIT,
   VIDEO_VS_CTL_STILL_PROBE,
@@ -166,20 +176,31 @@ typedef enum {
 
 /* B. Terminal Types */
 typedef enum {
+  // Terminal
   VIDEO_TT_VENDOR_SPECIFIC         = 0x0100,
-  VIDEO_TT_STREAMING,
+  VIDEO_TT_STREAMING               = 0x0101,
+
+  // Input
   VIDEO_ITT_VENDOR_SPECIFIC        = 0x0200,
-  VIDEO_ITT_CAMERA,
-  VIDEO_ITT_MEDIA_TRANSPORT_INPUT,
+  VIDEO_ITT_CAMERA                 = 0x0201,
+  VIDEO_ITT_MEDIA_TRANSPORT_INPUT  = 0x0202,
+
+  // Output
   VIDEO_OTT_VENDOR_SPECIFIC        = 0x0300,
-  VIDEO_OTT_DISPLAY,
-  VIDEO_OTT_MEDIA_TRANSPORT_OUTPUT,
-  VIDEO_TT_EXTERNAL_VENDOR_SPEIFIC = 0x0400,
-  VIDEO_TT_COMPOSITE_CONNECTOR,
-  VIDEO_TT_SVIDEO_CONNECTOR,
-  VIDEO_TT_COMPONENT_CONNECTOR,
+  VIDEO_OTT_DISPLAY                = 0x0301,
+  VIDEO_OTT_MEDIA_TRANSPORT_OUTPUT = 0x0302,
+
+  // External
+  VIDEO_ETT_VENDOR_SPEIFIC         = 0x0400,
+  VIDEO_ETT_COMPOSITE_CONNECTOR    = 0x0401,
+  VIDEO_ETT_SVIDEO_CONNECTOR       = 0x0402,
+  VIDEO_ETT_COMPONENT_CONNECTOR    = 0x0403,
 } video_terminal_type_t;
 
+//--------------------------------------------------------------------+
+// Descriptors
+//--------------------------------------------------------------------+
+
 /* 2.3.4.2 */
 typedef struct TU_ATTR_PACKED {
   uint8_t  bLength;
@@ -369,44 +390,44 @@ TU_VERIFY_STATIC( sizeof(video_probe_and_commit_control_t) == 48, "size is not c
 #define TUD_VIDEO_DESC_IAD(_firstitfs, _nitfs, _stridx) \
   TUD_VIDEO_DESC_IAD_LEN, TUSB_DESC_INTERFACE_ASSOCIATION, \
   _firstitfs, _nitfs, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_INTERFACE_COLLECTION, \
-  VIDEO_INT_PROTOCOL_CODE_UNDEF, _stridx
+  VIDEO_ITF_PROTOCOL_UNDEFINED, _stridx
 
 #define TUD_VIDEO_DESC_STD_VC(_itfnum, _nEPs, _stridx) \
   TUD_VIDEO_DESC_STD_VC_LEN, TUSB_DESC_INTERFACE, _itfnum, /* fixed to zero */ 0x00, \
-  _nEPs, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_CONTROL, VIDEO_INT_PROTOCOL_CODE_15, _stridx
+  _nEPs, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_CONTROL, VIDEO_ITF_PROTOCOL_15, _stridx
 
 /* 3.7.2 */
 #define TUD_VIDEO_DESC_CS_VC(_bcdUVC, _totallen, _clkfreq, ...)	\
-  TUD_VIDEO_DESC_CS_VC_LEN + (TU_ARGS_NUM(__VA_ARGS__)), TUSB_DESC_CS_INTERFACE, VIDEO_CS_VC_INTERFACE_HEADER, \
+  TUD_VIDEO_DESC_CS_VC_LEN + (TU_ARGS_NUM(__VA_ARGS__)), TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VC_HEADER, \
   U16_TO_U8S_LE(_bcdUVC), U16_TO_U8S_LE((_totallen) + TUD_VIDEO_DESC_CS_VC_LEN + (TU_ARGS_NUM(__VA_ARGS__))), \
   U32_TO_U8S_LE(_clkfreq), TU_ARGS_NUM(__VA_ARGS__), __VA_ARGS__
 
 /* 3.7.2.1 */
 #define TUD_VIDEO_DESC_INPUT_TERM(_tid, _tt, _at, _stridx) \
-  TUD_VIDEO_DESC_INPUT_TERM_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_VC_INTERFACE_INPUT_TERMINAL, \
+  TUD_VIDEO_DESC_INPUT_TERM_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VC_INPUT_TERMINAL, \
     _tid, U16_TO_U8S_LE(_tt), _at, _stridx
 
 /* 3.7.2.2 */
 #define TUD_VIDEO_DESC_OUTPUT_TERM(_tid, _tt, _at, _srcid, _stridx) \
-  TUD_VIDEO_DESC_OUTPUT_TERM_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_VC_INTERFACE_OUTPUT_TERMINAL, \
+  TUD_VIDEO_DESC_OUTPUT_TERM_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VC_OUTPUT_TERMINAL, \
     _tid, U16_TO_U8S_LE(_tt), _at, _srcid, _stridx
 
 /* 3.9.1 */
 #define TUD_VIDEO_DESC_STD_VS(_itfnum, _alt, _epn, _stridx) \
   TUD_VIDEO_DESC_STD_VS_LEN, TUSB_DESC_INTERFACE, _itfnum, _alt, \
-  _epn, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_STREAMING, VIDEO_INT_PROTOCOL_CODE_15, _stridx
+  _epn, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_STREAMING, VIDEO_ITF_PROTOCOL_15, _stridx
 
 /* 3.9.2.1 */
 #define TUD_VIDEO_DESC_CS_VS_INPUT(_numfmt, _totallen, _ep, _inf, _termlnk, _sticaptmeth, _trgspt, _trgusg, ...) \
   TUD_VIDEO_DESC_CS_VS_IN_LEN + (_numfmt) * (TU_ARGS_NUM(__VA_ARGS__)), TUSB_DESC_CS_INTERFACE, \
-  VIDEO_CS_VS_INTERFACE_INPUT_HEADER, _numfmt, \
+  VIDEO_CS_ITF_VS_INPUT_HEADER, _numfmt, \
   U16_TO_U8S_LE((_totallen) + TUD_VIDEO_DESC_CS_VS_IN_LEN + (_numfmt) * (TU_ARGS_NUM(__VA_ARGS__))), \
   _ep, _inf, _termlnk, _sticaptmeth, _trgspt, _trgusg, (TU_ARGS_NUM(__VA_ARGS__)), __VA_ARGS__
 
 /* 3.9.2.2 */
 #define TUD_VIDEO_DESC_CS_VS_OUTPUT(_numfmt, _totallen, _ep, _inf, _termlnk, ...) \
   TUD_VIDEO_DESC_CS_VS_OUT_LEN + (_numfmt) * (TU_ARGS_NUM(__VA_ARGS__)), TUSB_DESC_CS_INTERFACE, \
-  VIDEO_CS_VS_INTERFACE_OUTPUT_HEADER, _numfmt, \
+  VIDEO_CS_ITF_VS_OUTPUT_HEADER, _numfmt, \
   U16_TO_U8S_LE((_totallen) + TUD_VIDEO_DESC_CS_VS_OUT_LEN + (_numfmt) * (TU_ARGS_NUM(__VA_ARGS__))), \
   _ep, _inf, _termlnk, (TU_ARGS_NUM(__VA_ARGS__)), __VA_ARGS__
 
@@ -415,13 +436,13 @@ TU_VERIFY_STATIC( sizeof(video_probe_and_commit_control_t) == 48, "size is not c
 
 #define TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR(_fmtidx, _numfrmdesc, \
   _guid, _bitsperpix, _frmidx, _asrx, _asry, _interlace, _cp) \
-  TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_VS_INTERFACE_FORMAT_UNCOMPRESSED, \
+  TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_FORMAT_UNCOMPRESSED, \
   _fmtidx, _numfrmdesc, TUD_VIDEO_GUID(_guid), \
   _bitsperpix, _frmidx, _asrx,  _asry, _interlace, _cp
 
 /* Uncompressed 3.1.2 Table 3-3 */
 #define TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT(_frmidx, _cap, _width, _height, _minbr, _maxbr, _maxfrmbufsz, _frminterval, _minfrminterval, _maxfrminterval, _frmintervalstep) \
-  TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_VS_INTERFACE_FRAME_UNCOMPRESSED, \
+  TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_FRAME_UNCOMPRESSED, \
   _frmidx, _cap, U16_TO_U8S_LE(_width), U16_TO_U8S_LE(_height), U32_TO_U8S_LE(_minbr), U32_TO_U8S_LE(_maxbr), \
   U32_TO_U8S_LE(_maxfrmbufsz), U32_TO_U8S_LE(_frminterval), 0, \
   U32_TO_U8S_LE(_minfrminterval), U32_TO_U8S_LE(_maxfrminterval), U32_TO_U8S_LE(_frmintervalstep)
@@ -429,14 +450,14 @@ TU_VERIFY_STATIC( sizeof(video_probe_and_commit_control_t) == 48, "size is not c
 /* Uncompressed 3.1.2 Table 3-4 */
 #define TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_DISC(_frmidx, _cap, _width, _height, _minbr, _maxbr, _maxfrmbufsz, _frminterval, ...) \
   TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_DISC_LEN + (TU_ARGS_NUM(__VA_ARGS__)) * 4, \
-  TUSB_DESC_CS_INTERFACE, VIDEO_CS_VS_INTERFACE_FRAME_UNCOMPRESSED, \
+  TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_FRAME_UNCOMPRESSED, \
   _frmidx, _cap, U16_TO_U8S_LE(_width), U16_TO_U8S_LE(_height), U32_TO_U8S_LE(_minbr), U32_TO_U8S_LE(_maxbr), \
   U32_TO_U8S_LE(_maxfrmbufsz), U32_TO_U8S_LE(_frminterval), (TU_ARGS_NUM(__VA_ARGS__)), __VA_ARGS__
 
 /* 3.9.2.6 */
 #define TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING(_color, _trns, _mat) \
   TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING_LEN, \
-  TUSB_DESC_CS_INTERFACE, VIDEO_CS_VS_INTERFACE_COLORFORMAT, \
+  TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_COLORFORMAT, \
   _color, _trns, _mat
 
 /* 3.10.1.1 */
diff --git a/src/class/video/video_device.c b/src/class/video/video_device.c
index 12ccbd165..d34fe7b92 100644
--- a/src/class/video/video_device.c
+++ b/src/class/video/video_device.c
@@ -1,9 +1,8 @@
 /* 
  * The MIT License (MIT)
  *
- * Copyright (c) 2019 Ha Thach (tinyusb.org)
- * Copyright (c) 2020 Reinhard Panhuber, Jerzy Kasenberg
  * Copyright (c) 2021 Koji KITAYAMA
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -259,8 +258,8 @@ static void const* _find_desc_entity(void const *desc, uint_fast8_t entityid)
   void const *end = beg + vc->std.bLength + vc->ctl.wTotalLength;
   for (void const *cur = beg; cur < end; cur = _find_desc(cur, end, TUSB_DESC_CS_INTERFACE)) {
     tusb_desc_cs_video_entity_itf_t const *itf = (tusb_desc_cs_video_entity_itf_t const *)cur;
-    if ((VIDEO_CS_VC_INTERFACE_INPUT_TERMINAL  <= itf->bDescriptorSubtype
-         && itf->bDescriptorSubtype < VIDEO_CS_VC_INTERFACE_MAX)
+    if ((VIDEO_CS_ITF_VC_INPUT_TERMINAL  <= itf->bDescriptorSubtype
+         && itf->bDescriptorSubtype < VIDEO_CS_ITF_VC_MAX)
         && itf->bEntityId == entityid) {
       return itf;
     }
@@ -280,14 +279,14 @@ static inline void const* _end_of_streaming_descriptor(void const *desc)
 static inline tusb_desc_cs_video_fmt_uncompressed_t const *_find_desc_format(void const *beg, void const *end, uint_fast8_t fmtnum)
 {
   return (tusb_desc_cs_video_fmt_uncompressed_t const*)
-    _find_desc_3(beg, end, TUSB_DESC_CS_INTERFACE, VIDEO_CS_VS_INTERFACE_FORMAT_UNCOMPRESSED, fmtnum);
+    _find_desc_3(beg, end, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_FORMAT_UNCOMPRESSED, fmtnum);
 }
 
 /** Find the first frame descriptor with the specified format number. */
 static inline tusb_desc_cs_video_frm_uncompressed_t const *_find_desc_frame(void const *beg, void const *end, uint_fast8_t frmnum)
 {
   return (tusb_desc_cs_video_frm_uncompressed_t const*)
-    _find_desc_3(beg, end, TUSB_DESC_CS_INTERFACE, VIDEO_CS_VS_INTERFACE_FRAME_UNCOMPRESSED, frmnum);
+    _find_desc_3(beg, end, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_FRAME_UNCOMPRESSED, frmnum);
 }
 
 /** Set uniquely determined values to variables that have not been set
@@ -300,8 +299,7 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
   uint_fast8_t fmtnum = param->bFormatIndex;
   TU_ASSERT(fmtnum <= vs->stm.bNumFormats);
   if (!fmtnum) {
-    if (1 < vs->stm.bNumFormats)
-      return true; /* Need to negotiate all variables. */
+    if (1 < vs->stm.bNumFormats) return true; /* Need to negotiate all variables. */
     fmtnum = 1;
     param->bFormatIndex = 1;
   }
@@ -326,8 +324,7 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
   uint_fast8_t frmnum = param->bFrameIndex;
   TU_ASSERT(frmnum <= fmt->bNumFrameDescriptors);
   if (!frmnum) {
-    if (1 < fmt->bNumFrameDescriptors)
-      return true;
+    if (1 < fmt->bNumFrameDescriptors) return true;
     frmnum = 1;
     param->bFrameIndex = 1;
   }
@@ -344,8 +341,9 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
   uint_fast32_t interval = param->dwFrameInterval;
   if (!interval) {
     if ((1 < frm->bFrameIntervalType) ||
-        ((0 == frm->bFrameIntervalType) && (frm->dwFrameInterval[1] != frm->dwFrameInterval[0])))
+        ((0 == frm->bFrameIntervalType) && (frm->dwFrameInterval[1] != frm->dwFrameInterval[0]))) {
       return true;
+    }
     interval = frm->dwFrameInterval[0];
     param->dwFrameInterval = interval;
   }
@@ -457,7 +455,7 @@ static bool _open_vc_itf(uint8_t rhport, videod_interface_t *self, uint_fast8_t
   void const *end = beg + self->len;
   /* The first descriptor is a video control interface descriptor. */
   void const *cur = _find_desc_itf(beg, end, _desc_itfnum(beg), altnum);
-  TU_LOG2("    cur %ld\n", cur - beg);
+  TU_LOG2("    cur %d\n", cur - beg);
   TU_VERIFY(cur < end);
 
   tusb_desc_vc_itf_t const *vc = (tusb_desc_vc_itf_t const *)cur;
@@ -580,28 +578,31 @@ static int handle_video_ctl_std_req(uint8_t rhport, uint8_t stage,
                                     uint_fast8_t ctl_idx)
 {
   switch (request->bRequest) {
-  case TUSB_REQ_GET_INTERFACE:
-    if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-    TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN);
-    tusb_desc_vc_itf_t const *vc = _get_desc_vc(&_videod_itf[ctl_idx]);
-    if (!vc) return VIDEO_UNKNOWN;
-    if (tud_control_xfer(rhport, request,
-                         (void*)&vc->std.bAlternateSetting,
-                         sizeof(vc->std.bAlternateSetting)))
-      return VIDEO_NO_ERROR;
-    return VIDEO_UNKNOWN;
-  case TUSB_REQ_SET_INTERFACE:
-    if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-    TU_VERIFY(0 == request->wLength, VIDEO_UNKNOWN);
-    if (!_close_vc_itf(rhport, &_videod_itf[ctl_idx]))
-      return VIDEO_UNKNOWN;
-    if (!_open_vc_itf(rhport, &_videod_itf[ctl_idx], request->wValue))
-      return VIDEO_UNKNOWN;
-    tud_control_status(rhport, request);
-    return VIDEO_NO_ERROR;
-  default: /* Unknown/Unsupported request */
-    TU_BREAKPOINT();
-    return VIDEO_INVALID_REQUEST;
+    case TUSB_REQ_GET_INTERFACE:
+      if (stage == CONTROL_STAGE_SETUP)
+      {
+        TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
+        tusb_desc_vc_itf_t const *vc = _get_desc_vc(&_videod_itf[ctl_idx]);
+        TU_VERIFY(vc, VIDEO_ERROR_UNKNOWN);
+
+        TU_VERIFY(tud_control_xfer(rhport, request, (void*)&vc->std.bAlternateSetting, sizeof(vc->std.bAlternateSetting)),
+                  VIDEO_ERROR_UNKNOWN);
+      }
+      return VIDEO_ERROR_NONE;
+
+    case TUSB_REQ_SET_INTERFACE:
+      if (stage == CONTROL_STAGE_SETUP)
+      {
+        TU_VERIFY(0 == request->wLength, VIDEO_ERROR_UNKNOWN);
+        TU_VERIFY(_close_vc_itf(rhport, &_videod_itf[ctl_idx]), VIDEO_ERROR_UNKNOWN);
+        TU_VERIFY(_open_vc_itf(rhport, &_videod_itf[ctl_idx], request->wValue), VIDEO_ERROR_UNKNOWN);
+        tud_control_status(rhport, request);
+      }
+      return VIDEO_ERROR_NONE;
+
+    default: /* Unknown/Unsupported request */
+      TU_BREAKPOINT();
+      return VIDEO_ERROR_INVALID_REQUEST;
   }
 }
 
@@ -610,55 +611,66 @@ static int handle_video_ctl_cs_req(uint8_t rhport, uint8_t stage,
                                    uint_fast8_t ctl_idx)
 {
   videod_interface_t *self = &_videod_itf[ctl_idx];
+
   /* 4.2.1 Interface Control Request */
   switch (TU_U16_HIGH(request->wValue)) {
-  case VIDEO_VC_CTL_VIDEO_POWER_MODE:
-    switch (request->bRequest) {
-    case VIDEO_REQUEST_SET_CUR:
-      if (stage == CONTROL_STAGE_SETUP) {
-        TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN);
-        if (!tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode)))
-          return VIDEO_UNKNOWN;
-      } else if (stage == CONTROL_STAGE_ACK) {
-        if (tud_video_power_mode_cb)
-          return tud_video_power_mode_cb(ctl_idx, self->power_mode);
+    case VIDEO_VC_CTL_VIDEO_POWER_MODE:
+      switch (request->bRequest) {
+        case VIDEO_REQUEST_SET_CUR:
+          if (stage == CONTROL_STAGE_SETUP) {
+            TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode)), VIDEO_ERROR_UNKNOWN);
+          } else if (stage == CONTROL_STAGE_ACK) {
+            if (tud_video_power_mode_cb) return tud_video_power_mode_cb(ctl_idx, self->power_mode);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_CUR:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_INFO:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)&_cap_get_set, sizeof(_cap_get_set)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        default: break;
       }
-      return VIDEO_NO_ERROR;
-    case VIDEO_REQUEST_GET_CUR:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN);
-      if (!tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode)))
-        return VIDEO_UNKNOWN;
-      return VIDEO_NO_ERROR;
-    case VIDEO_REQUEST_GET_INFO:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN);
-      if (!tud_control_xfer(rhport, request, (uint8_t*)&_cap_get_set, sizeof(_cap_get_set)))
-        return VIDEO_UNKNOWN;
-      return VIDEO_NO_ERROR;
-    default: break;
-    }
-    break;
-  case VIDEO_VC_CTL_REQUEST_ERROR_CODE:
-    switch (request->bRequest) {
-    case VIDEO_REQUEST_GET_CUR:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      if (!tud_control_xfer(rhport, request, &self->error_code, sizeof(uint8_t)))
-        return VIDEO_UNKNOWN;
-      return VIDEO_NO_ERROR;
-    case VIDEO_REQUEST_GET_INFO:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      if (tud_control_xfer(rhport, request, (uint8_t*)&_cap_get, sizeof(_cap_get)))
-        return VIDEO_UNKNOWN;
-      return VIDEO_NO_ERROR;
+      break;
+
+    case VIDEO_VC_CTL_REQUEST_ERROR_CODE:
+      switch (request->bRequest) {
+        case VIDEO_REQUEST_GET_CUR:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(tud_control_xfer(rhport, request, &self->error_code, sizeof(uint8_t)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_INFO:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)&_cap_get, sizeof(_cap_get)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        default: break;
+      }
+      break;
+
     default: break;
-    }
-    break;
-  default: break;
   }
+
   /* Unknown/Unsupported request */
   TU_BREAKPOINT();
-  return VIDEO_INVALID_REQUEST;
+  return VIDEO_ERROR_INVALID_REQUEST;
 }
 
 static int handle_video_ctl_req(uint8_t rhport, uint8_t stage,
@@ -667,19 +679,20 @@ static int handle_video_ctl_req(uint8_t rhport, uint8_t stage,
 {
   uint_fast8_t entity_id;
   switch (request->bmRequestType_bit.type) {
-  case TUSB_REQ_TYPE_STANDARD:
-    return handle_video_ctl_std_req(rhport, stage, request, ctl_idx);
-  case TUSB_REQ_TYPE_CLASS:
-    entity_id = TU_U16_HIGH(request->wIndex);
-    if (!entity_id) {
-      return handle_video_ctl_cs_req(rhport, stage, request, ctl_idx);
-    } else {
-      if (!_find_desc_entity(_get_desc_vc(&_videod_itf[ctl_idx]), entity_id))
-        return VIDEO_INVALID_REQUEST;
-      return VIDEO_INVALID_REQUEST;
-    }
-  default:
-    return VIDEO_INVALID_REQUEST;
+    case TUSB_REQ_TYPE_STANDARD:
+      return handle_video_ctl_std_req(rhport, stage, request, ctl_idx);
+
+    case TUSB_REQ_TYPE_CLASS:
+      entity_id = TU_U16_HIGH(request->wIndex);
+      if (!entity_id) {
+        return handle_video_ctl_cs_req(rhport, stage, request, ctl_idx);
+      } else {
+        TU_VERIFY(_find_desc_entity(_get_desc_vc(&_videod_itf[ctl_idx]), entity_id), VIDEO_ERROR_INVALID_REQUEST);
+        return VIDEO_ERROR_NONE;
+      }
+
+    default:
+      return VIDEO_ERROR_INVALID_REQUEST;
   }
 }
 
@@ -689,25 +702,27 @@ static int handle_video_stm_std_req(uint8_t rhport, uint8_t stage,
 {
   videod_streaming_interface_t *self = &_videod_streaming_itf[stm_idx];
   switch (request->bRequest) {
-  case TUSB_REQ_GET_INTERFACE:
-    if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-    TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN);
-    tusb_desc_vs_itf_t const *vs = _get_desc_vs(self);
-    if (!vs) return VIDEO_UNKNOWN;
-    if (tud_control_xfer(rhport, request,
-                         (void*)&vs->std.bAlternateSetting,
-                         sizeof(vs->std.bAlternateSetting)))
-      return VIDEO_NO_ERROR;
-    return VIDEO_UNKNOWN;
-  case TUSB_REQ_SET_INTERFACE:
-    if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-    if (!_open_vs_itf(rhport, self, request->wValue))
-      return VIDEO_UNKNOWN;
-    tud_control_status(rhport, request);
-    return VIDEO_NO_ERROR;
-  default: /* Unknown/Unsupported request */
-    TU_BREAKPOINT();
-    return VIDEO_INVALID_REQUEST;
+    case TUSB_REQ_GET_INTERFACE:
+      if (stage == CONTROL_STAGE_SETUP)
+      {
+        TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
+        tusb_desc_vs_itf_t const *vs = _get_desc_vs(self);
+        TU_VERIFY(vs, VIDEO_ERROR_UNKNOWN);
+        TU_VERIFY(tud_control_xfer(rhport, request, (void*)&vs->std.bAlternateSetting, sizeof(vs->std.bAlternateSetting)), VIDEO_ERROR_UNKNOWN);
+      }
+      return VIDEO_ERROR_NONE;
+
+    case TUSB_REQ_SET_INTERFACE:
+      if (stage == CONTROL_STAGE_SETUP)
+      {
+        TU_VERIFY(_open_vs_itf(rhport, self, request->wValue), VIDEO_ERROR_UNKNOWN);
+        tud_control_status(rhport, request);
+      }
+      return VIDEO_ERROR_NONE;
+
+    default: /* Unknown/Unsupported request */
+      TU_BREAKPOINT();
+      return VIDEO_ERROR_INVALID_REQUEST;
   }
 }
 
@@ -717,124 +732,139 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
 {
   (void)rhport;
   videod_streaming_interface_t *self = &_videod_streaming_itf[stm_idx];
+
   /* 4.2.1 Interface Control Request */
   switch (TU_U16_HIGH(request->wValue)) {
-  case VIDEO_VS_CTL_STREAM_ERROR_CODE:
-    switch (request->bRequest) {
-    case VIDEO_REQUEST_GET_CUR:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      /* TODO */
-      if (!tud_control_xfer(rhport, request, &self->error_code, sizeof(uint8_t)))
-        return VIDEO_UNKNOWN;
-      return VIDEO_NO_ERROR;
-    case VIDEO_REQUEST_GET_INFO:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      if (tud_control_xfer(rhport, request, (uint8_t*)&_cap_get, sizeof(_cap_get)))
-        return VIDEO_UNKNOWN;
-      return VIDEO_NO_ERROR;
-    default: break;
-    }
-    break;
-  case VIDEO_VS_CTL_PROBE:
-    switch (request->bRequest) {
-    case VIDEO_REQUEST_SET_CUR:
-      if (stage == CONTROL_STAGE_SETUP) {
-        TU_VERIFY(sizeof(video_probe_and_commit_control_t) == request->wLength, VIDEO_UNKNOWN);
-        if (!tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)))
-          return VIDEO_UNKNOWN;
-      } else if (stage == CONTROL_STAGE_ACK) {
-        if (!_update_streaming_parameters(self, (video_probe_and_commit_control_t*)self->ep_buf))
-          return VIDEO_INVALID_VALUE_WITHIN_RANGE;
+    case VIDEO_VS_CTL_STREAM_ERROR_CODE:
+      switch (request->bRequest) {
+        case VIDEO_REQUEST_GET_CUR:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            /* TODO */
+            TU_VERIFY(tud_control_xfer(rhport, request, &self->error_code, sizeof(uint8_t)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_INFO:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)&_cap_get, sizeof(_cap_get)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        default: break;
       }
-      return VIDEO_NO_ERROR;
-    case VIDEO_REQUEST_GET_CUR:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      TU_VERIFY(request->wLength, VIDEO_UNKNOWN);
-      if (tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)))
-        return VIDEO_NO_ERROR;
-      return VIDEO_UNKNOWN;
-    case VIDEO_REQUEST_GET_MIN: {
-      video_probe_and_commit_control_t tmp;
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      TU_VERIFY(request->wLength, VIDEO_UNKNOWN);
-      tmp = *(video_probe_and_commit_control_t*)&self->ep_buf;
-      if (!_negotiate_streaming_parameters(self, false, &tmp))
-        return VIDEO_INVALID_VALUE_WITHIN_RANGE;
-      if (tud_control_xfer(rhport, request, &tmp,
-                           sizeof(video_probe_and_commit_control_t)))
-        return VIDEO_NO_ERROR;
-      return VIDEO_UNKNOWN;
-    }
-    case VIDEO_REQUEST_GET_MAX: {
-      video_probe_and_commit_control_t tmp;
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      TU_VERIFY(request->wLength, VIDEO_UNKNOWN);
-      tmp = *(video_probe_and_commit_control_t*)&self->ep_buf;
-      if (!_negotiate_streaming_parameters(self, true, &tmp))
-        return VIDEO_INVALID_VALUE_WITHIN_RANGE;
-      if (tud_control_xfer(rhport, request, self->ep_buf,
-                           sizeof(video_probe_and_commit_control_t)))
-        return VIDEO_NO_ERROR;
-      return VIDEO_UNKNOWN;
-    }
-    case VIDEO_REQUEST_GET_RES:
-      return VIDEO_UNKNOWN;
-    case VIDEO_REQUEST_GET_DEF:
-      return VIDEO_UNKNOWN;
-    case VIDEO_REQUEST_GET_LEN:
-      return VIDEO_UNKNOWN;
-    case VIDEO_REQUEST_GET_INFO:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN);
-      if (tud_control_xfer(rhport, request, (uint8_t*)&_cap_get_set, sizeof(_cap_get_set)))
-        return VIDEO_NO_ERROR;
-      return VIDEO_UNKNOWN;
-    default: break;
-    }
-    break;
-  case VIDEO_VS_CTL_COMMIT:
-    switch (request->bRequest) {
-    case VIDEO_REQUEST_SET_CUR:
-      if (stage == CONTROL_STAGE_SETUP) {
-        TU_VERIFY(sizeof(video_probe_and_commit_control_t) == request->wLength, VIDEO_UNKNOWN);
-        if (!tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)))
-          return VIDEO_UNKNOWN;
-      } else if (stage == CONTROL_STAGE_ACK) {
-        if (!_update_streaming_parameters(self, (video_probe_and_commit_control_t*)self->ep_buf))
-          return VIDEO_INVALID_VALUE_WITHIN_RANGE;
-        if (tud_video_commit_cb)
-          return tud_video_commit_cb(self->index_vc, self->index_vs,
-                                     (video_probe_and_commit_control_t*)self->ep_buf);
+      break;
+
+    case VIDEO_VS_CTL_PROBE:
+      switch (request->bRequest) {
+        case VIDEO_REQUEST_SET_CUR:
+          if (stage == CONTROL_STAGE_SETUP) {
+            TU_VERIFY(sizeof(video_probe_and_commit_control_t) == request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)),
+                      VIDEO_ERROR_UNKNOWN);
+          } else if (stage == CONTROL_STAGE_ACK) {
+            TU_VERIFY(_update_streaming_parameters(self, (video_probe_and_commit_control_t*)self->ep_buf),
+                      VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_CUR:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_MIN:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+
+            video_probe_and_commit_control_t tmp;
+            tmp = *(video_probe_and_commit_control_t*)&self->ep_buf;
+            TU_VERIFY(_negotiate_streaming_parameters(self, false, &tmp), VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
+            TU_VERIFY(tud_control_xfer(rhport, request, &tmp, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_MAX:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            video_probe_and_commit_control_t tmp;
+            tmp = *(video_probe_and_commit_control_t*)&self->ep_buf;
+            TU_VERIFY(_negotiate_streaming_parameters(self, true, &tmp), VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
+            TU_VERIFY(tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_RES: return VIDEO_ERROR_UNKNOWN;
+        case VIDEO_REQUEST_GET_DEF: return VIDEO_ERROR_UNKNOWN;
+        case VIDEO_REQUEST_GET_LEN: return VIDEO_ERROR_UNKNOWN;
+
+        case VIDEO_REQUEST_GET_INFO:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)&_cap_get_set, sizeof(_cap_get_set)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        default: break;
+      }
+      break;
+
+    case VIDEO_VS_CTL_COMMIT:
+      switch (request->bRequest) {
+        case VIDEO_REQUEST_SET_CUR:
+          if (stage == CONTROL_STAGE_SETUP) {
+            TU_VERIFY(sizeof(video_probe_and_commit_control_t) == request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
+          } else if (stage == CONTROL_STAGE_ACK) {
+            TU_VERIFY(_update_streaming_parameters(self, (video_probe_and_commit_control_t*)self->ep_buf), VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
+            if (tud_video_commit_cb) {
+              return tud_video_commit_cb(self->index_vc, self->index_vs, (video_probe_and_commit_control_t*)self->ep_buf);
+            }
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_CUR:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        case VIDEO_REQUEST_GET_INFO:
+          if (stage == CONTROL_STAGE_SETUP)
+          {
+            TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)&_cap_get_set, sizeof(_cap_get_set)), VIDEO_ERROR_UNKNOWN);
+          }
+          return VIDEO_ERROR_NONE;
+
+        default: break;
       }
-      return VIDEO_NO_ERROR;
-    case VIDEO_REQUEST_GET_CUR:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      TU_VERIFY(request->wLength, VIDEO_UNKNOWN);
-      if (tud_control_xfer(rhport, request, self->ep_buf, sizeof(video_probe_and_commit_control_t)))
-        return VIDEO_NO_ERROR;
-      return VIDEO_UNKNOWN;
-    case VIDEO_REQUEST_GET_INFO:
-      if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
-      TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN);
-      if (tud_control_xfer(rhport, request, (uint8_t*)&_cap_get_set, sizeof(_cap_get_set)))
-        return VIDEO_NO_ERROR;
-      return VIDEO_UNKNOWN;
+      break;
+
+    case VIDEO_VS_CTL_STILL_PROBE:
+    case VIDEO_VS_CTL_STILL_COMMIT:
+    case VIDEO_VS_CTL_STILL_IMAGE_TRIGGER:
+    case VIDEO_VS_CTL_GENERATE_KEY_FRAME:
+    case VIDEO_VS_CTL_UPDATE_FRAME_SEGMENT:
+    case VIDEO_VS_CTL_SYNCH_DELAY_CONTROL:
+      /* TODO */
+      break;
+
     default: break;
-    }
-    break;
-  case VIDEO_VS_CTL_STILL_PROBE:
-  case VIDEO_VS_CTL_STILL_COMMIT:
-  case VIDEO_VS_CTL_STILL_IMAGE_TRIGGER:
-  case VIDEO_VS_CTL_GENERATE_KEY_FRAME:
-  case VIDEO_VS_CTL_UPDATE_FRAME_SEGMENT:
-  case VIDEO_VS_CTL_SYNCH_DELAY_CONTROL:
-    /* TODO */
-    break;
-  default: break;
   }
+
   /* Unknown/Unsupported request */
   TU_BREAKPOINT();
-  return VIDEO_INVALID_REQUEST;
+  return VIDEO_ERROR_INVALID_REQUEST;
 }
 
 static int handle_video_stm_req(uint8_t rhport, uint8_t stage,
@@ -842,16 +872,16 @@ static int handle_video_stm_req(uint8_t rhport, uint8_t stage,
                                 uint_fast8_t stm_idx)
 {
   switch (request->bmRequestType_bit.type) {
-  case TUSB_REQ_TYPE_STANDARD:
-    return handle_video_stm_std_req(rhport, stage, request, stm_idx);
-  case TUSB_REQ_TYPE_CLASS:
-    if (TU_U16_HIGH(request->wIndex))
-      return VIDEO_INVALID_REQUEST;
-    return handle_video_stm_cs_req(rhport, stage, request, stm_idx);
-  default:
-    return VIDEO_INVALID_REQUEST;
+    case TUSB_REQ_TYPE_STANDARD:
+      return handle_video_stm_std_req(rhport, stage, request, stm_idx);
+
+    case TUSB_REQ_TYPE_CLASS:
+      if (TU_U16_HIGH(request->wIndex)) return VIDEO_ERROR_INVALID_REQUEST;
+      return handle_video_stm_cs_req(rhport, stage, request, stm_idx);
+
+    default: return VIDEO_ERROR_INVALID_REQUEST;
   }
-  return VIDEO_UNKNOWN;
+  return VIDEO_ERROR_UNKNOWN;
 }
 
 //--------------------------------------------------------------------+
@@ -862,8 +892,7 @@ bool tud_video_n_connected(uint_fast8_t ctl_idx)
 {
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, 0);
-  if (stm)
-    return true;
+  if (stm) return true;
   return false;
 }
 
@@ -872,8 +901,7 @@ bool tud_video_n_streaming(uint_fast8_t ctl_idx, uint_fast8_t stm_idx)
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING);
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx);
-  if (!stm || !stm->desc.ep[0])
-    return false;
+  if (!stm || !stm->desc.ep[0]) return false;
   return true;
 }
 
@@ -881,11 +909,9 @@ bool tud_video_n_frame_xfer(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, void *bu
 {
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING);
-  if (!buffer || !buffer)
-    return false;
+  if (!buffer || !buffer) return false;
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx);
-  if (!stm || !stm->desc.ep[0] || stm->buffer)
-    return false;
+  if (!stm || !stm->desc.ep[0] || stm->buffer) return false;
 
   /* Find EP address */
   void const *desc = _videod_itf[stm->index_vc].beg;
@@ -896,8 +922,7 @@ bool tud_video_n_frame_xfer(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, void *bu
     ep_addr = _desc_ep_addr(desc + ofs_ep);
     break;
   }
-  if (!ep_addr)
-    return false;
+  if (!ep_addr) return false;
 
   TU_VERIFY( usbd_edpt_claim(0, ep_addr));
   /* update the packet header */
@@ -942,16 +967,15 @@ void videod_reset(uint8_t rhport)
 
 uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len)
 {
-  TU_VERIFY((TUSB_CLASS_VIDEO           == itf_desc->bInterfaceClass) &&
-            (VIDEO_SUBCLASS_CONTROL     == itf_desc->bInterfaceSubClass) &&
-            (VIDEO_INT_PROTOCOL_CODE_15 == itf_desc->bInterfaceProtocol), 0);
+  TU_VERIFY((TUSB_CLASS_VIDEO       == itf_desc->bInterfaceClass) &&
+            (VIDEO_SUBCLASS_CONTROL == itf_desc->bInterfaceSubClass) &&
+            (VIDEO_ITF_PROTOCOL_15  == itf_desc->bInterfaceProtocol), 0);
 
   /* Find available interface */
   videod_interface_t *self = NULL;
   uint_fast8_t ctl_idx;
   for (ctl_idx = 0; ctl_idx < CFG_TUD_VIDEO; ++ctl_idx) {
-    if (_videod_itf[ctl_idx].beg)
-      continue;
+    if (_videod_itf[ctl_idx].beg) continue;
     self = &_videod_itf[ctl_idx];
     break;
   }
@@ -961,8 +985,7 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
   self->beg = itf_desc;
   self->len = max_len;
   /*------------- Video Control Interface -------------*/
-  if (!_open_vc_itf(rhport, self, 0))
-    return 0;
+  TU_VERIFY(_open_vc_itf(rhport, self, 0), 0);
   tusb_desc_vc_itf_t const *vc = _get_desc_vc(self);
   uint_fast8_t bInCollection   = vc->ctl.bInCollection;
   /* Find the end of the video interface descriptor */
@@ -971,8 +994,7 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
     videod_streaming_interface_t *stm = NULL;
     /* find free streaming interface handle */
     for (uint_fast8_t i = 0; i < CFG_TUD_VIDEO_STREAMING; ++i) {
-      if (_videod_streaming_itf[i].desc.beg)
-        continue;
+      if (_videod_streaming_itf[i].desc.beg) continue;
       stm = &_videod_streaming_itf[i];
       self->stm[stm_idx] = i;
       break;
@@ -994,9 +1016,7 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
 bool videod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
 {
   int err;
-  if (request->bmRequestType_bit.recipient != TUSB_REQ_RCPT_INTERFACE) {
-    return false;
-  }
+  TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
   uint_fast8_t itfnum = tu_u16_low(request->wIndex);
 
   /* Identify which control interface to use */
@@ -1004,9 +1024,9 @@ bool videod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_
   for (itf = 0; itf < CFG_TUD_VIDEO; ++itf) {
     void const *desc = _videod_itf[itf].beg;
     if (!desc) continue;
-    if (itfnum == _desc_itfnum(desc))
-      break;
+    if (itfnum == _desc_itfnum(desc)) break;
   }
+
   if (itf < CFG_TUD_VIDEO) {
     err = handle_video_ctl_req(rhport, stage, request, itf);
     _videod_itf[itf].error_code = (uint8_t)err;
@@ -1019,9 +1039,9 @@ bool videod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_
     videod_streaming_interface_t *stm = &_videod_streaming_itf[itf];
     if (!stm->desc.beg) continue;
     void const *desc = _videod_itf[stm->index_vc].beg;
-    if (itfnum == _desc_itfnum(desc + stm->desc.beg))
-      break;
+    if (itfnum == _desc_itfnum(desc + stm->desc.beg)) break;
   }
+
   if (itf < CFG_TUD_VIDEO_STREAMING) {
     err = handle_video_stm_req(rhport, stage, request, itf);
     _videod_streaming_itf[itf].error_code = (uint8_t)err;
@@ -1045,9 +1065,9 @@ bool videod_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint3
     if (!ep_ofs) continue;
     ctl = &_videod_itf[stm->index_vc];
     void const *desc = ctl->beg;
-    if (ep_addr == _desc_ep_addr(desc + ep_ofs))
-      break;
+    if (ep_addr == _desc_ep_addr(desc + ep_ofs)) break;
   }
+
   TU_ASSERT(itf < CFG_TUD_VIDEO_STREAMING);
   if (stm->offset < stm->bufsize) {
     /* Claim the endpoint */
@@ -1058,8 +1078,9 @@ bool videod_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint3
     stm->buffer  = NULL;
     stm->bufsize = 0;
     stm->offset  = 0;
-    if (tud_video_frame_xfer_complete_cb)
+    if (tud_video_frame_xfer_complete_cb) {
       tud_video_frame_xfer_complete_cb(stm->index_vc, stm->index_vs);
+    }
   }
   return true;
 }