diff --git a/examples/device/video_capture/src/main.c b/examples/device/video_capture/src/main.c index f0f4df6eb..a2d95c8f9 100644 --- a/examples/device/video_capture/src/main.c +++ b/examples/device/video_capture/src/main.c @@ -202,7 +202,7 @@ int tud_video_commit_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, (void)ctl_idx; (void)stm_idx; /* convert unit to ms from 100 ns */ interval_ms = parameters->dwFrameInterval / 10000; - return VIDEO_NO_ERROR; + return VIDEO_ERROR_NONE; } //--------------------------------------------------------------------+ diff --git a/examples/device/video_capture/src/tusb_config.h b/examples/device/video_capture/src/tusb_config.h index 5d2d5470c..4feb6a48a 100644 --- a/examples/device/video_capture/src/tusb_config.h +++ b/examples/device/video_capture/src/tusb_config.h @@ -91,16 +91,11 @@ #endif //------------- CLASS -------------// -#define CFG_TUD_CDC 0 -#define CFG_TUD_MSC 0 -#define CFG_TUD_HID 0 -#define CFG_TUD_MIDI 0 -#define CFG_TUD_AUDIO 0 // The number of video control interfaces #define CFG_TUD_VIDEO 1 + // The number of video streaming interfaces #define CFG_TUD_VIDEO_STREAMING 1 -#define CFG_TUD_VENDOR 0 // video streaming endpoint size #define CFG_TUD_VIDEO_STREAMING_EP_BUFSIZE 256 diff --git a/examples/device/video_capture/src/usb_descriptors.c b/examples/device/video_capture/src/usb_descriptors.c index b0e41b97e..404ffe070 100644 --- a/examples/device/video_capture/src/usb_descriptors.c +++ b/examples/device/video_capture/src/usb_descriptors.c @@ -77,22 +77,14 @@ uint8_t const * tud_descriptor_device_cb(void) #define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_VIDEO_CAPTURE_DESC_LEN) -#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X || CFG_TUSB_MCU == OPT_MCU_LPC177X_8X || CFG_TUSB_MCU == OPT_MCU_LPC40XX +#if TU_CHECK_MCU(LPC175X_6X) || TU_CHECK_MCU(LPC177X_8X) || TU_CHECK_MCU(LPC40XX) // LPC 17xx and 40xx endpoint type (bulk/interrupt/iso) are fixed by its number // 0 control, 1 In, 2 Bulk, 3 Iso, 4 In, 5 Bulk etc ... #define EPNUM_VIDEO_IN 0x83 -#elif CFG_TUSB_MCU == OPT_MCU_SAMG || CFG_TUSB_MCU == OPT_MCU_CXD56 - // SAMG doesn't support a same endpoint number with different direction IN and OUT - // e.g EP1 OUT & EP1 IN cannot exist together - #define EPNUM_VIDEO_IN 0x81 - -#elif CFG_TUSB_MCU == OPT_MCU_CXD56 - // CXD56 doesn't support a same endpoint number with different direction IN and OUT - // e.g EP1 OUT & EP1 IN cannot exist together - // CXD56 USB driver has fixed endpoint type (bulk/interrupt/iso) and direction (IN/OUT) by its number - // 0 control (IN/OUT), 1 Bulk (IN), 2 Bulk (OUT), 3 In (IN), 4 Bulk (IN), 5 Bulk (OUT), 6 In (IN) - #define EPNUM_VIDEO_IN 0x81 +#elif TU_CHECK_MCU(NRF5X) + // nRF5x ISO can only be endpoint 8 + #define EPNUM_VIDEO_IN 0x88 #else #define EPNUM_VIDEO_IN 0x81 diff --git a/examples/device/video_capture/src/usb_descriptors.h b/examples/device/video_capture/src/usb_descriptors.h index 403dc56a1..340b3f799 100644 --- a/examples/device/video_capture/src/usb_descriptors.h +++ b/examples/device/video_capture/src/usb_descriptors.h @@ -75,40 +75,38 @@ enum { #define TUD_VIDEO_CAPTURE_DESCRIPTOR(_stridx, _epin, _width, _height, _fps, _epsize) \ TUD_VIDEO_DESC_IAD(ITF_NUM_VIDEO_CONTROL, ITF_NUM_TOTAL, _stridx), \ - /* Video control 0 */ \ - TUD_VIDEO_DESC_STD_VC(ITF_NUM_VIDEO_CONTROL, 0, _stridx), \ - TUD_VIDEO_DESC_CS_VC( /* UVC 1.5*/ 0x0150, \ - /* wTotalLength - bLength */ \ - TUD_VIDEO_DESC_INPUT_TERM_LEN + TUD_VIDEO_DESC_OUTPUT_TERM_LEN, \ - UVC_CLOCK_FREQUENCY, 1), \ - TUD_VIDEO_DESC_INPUT_TERM(UVC_ENTITY_CAP_INPUT_TERMINAL,\ - VIDEO_TT_COMPOSITE_CONNECTOR, 0, 0), \ - TUD_VIDEO_DESC_OUTPUT_TERM(UVC_ENTITY_CAP_OUTPUT_TERMINAL,\ - VIDEO_TT_STREAMING, 0, 1, 0), \ - /* Video stream alt. 0 */ \ - TUD_VIDEO_DESC_STD_VS( 1, 0, 0, 0), \ - /* Video stream header for without still image capture */ \ - TUD_VIDEO_DESC_CS_VS_INPUT( /*bNumFormats*/1, \ - /*wTotalLength - bLength */\ - TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR_LEN\ - + TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT_LEN\ - + TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING_LEN,\ - _epin, /*bmInfo*/0, /*bTerminalLink*/UVC_ENTITY_CAP_OUTPUT_TERMINAL, \ - /*bStillCaptureMethod*/0, /*bTriggerSupport*/0, /*bTriggerUsage*/0, \ - /*bmaControls(1)*/0), \ - /* Video stream format */ \ - TUD_VIDEO_DESC_CS_VS_FMT_YUY2(/*bFormatIndex*/1, /*bNumFrameDescriptors*/1, \ - /*bDefaultFrameIndex*/1, 0, 0, 0, /*bCopyProtect*/0), \ - /* Video stream frame format */ \ - TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT(/*bFrameIndex */1, 0, _width, _height, \ - _width * _height * 16, _width * _height * 16 * _fps, \ - _width * _height * 16, \ - (10000000/_fps), (10000000/_fps), 10000000, 100000), \ - TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING(VIDEO_COLOR_PRIMARIES_BT709, VIDEO_COLOR_XFER_CH_BT709, VIDEO_COLOR_COEF_SMPTE170M), \ - /* VS alt 1 */\ - TUD_VIDEO_DESC_STD_VS(1, 1, 1, 0), \ - /* EP */ \ - TUD_VIDEO_DESC_EP_ISO(_epin, _epsize, 1) + /* Video control 0 */ \ + TUD_VIDEO_DESC_STD_VC(ITF_NUM_VIDEO_CONTROL, 0, _stridx), \ + TUD_VIDEO_DESC_CS_VC( /* UVC 1.5*/ 0x0150, \ + /* wTotalLength - bLength */ \ + TUD_VIDEO_DESC_INPUT_TERM_LEN + TUD_VIDEO_DESC_OUTPUT_TERM_LEN, \ + UVC_CLOCK_FREQUENCY, 1), \ + TUD_VIDEO_DESC_INPUT_TERM(UVC_ENTITY_CAP_INPUT_TERMINAL, VIDEO_ETT_COMPOSITE_CONNECTOR, 0, 0), \ + TUD_VIDEO_DESC_OUTPUT_TERM(UVC_ENTITY_CAP_OUTPUT_TERMINAL, VIDEO_TT_STREAMING, 0, 1, 0), \ + /* Video stream alt. 0 */ \ + TUD_VIDEO_DESC_STD_VS( 1, 0, 0, 0), \ + /* Video stream header for without still image capture */ \ + TUD_VIDEO_DESC_CS_VS_INPUT( /*bNumFormats*/1, \ + /*wTotalLength - bLength */\ + TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR_LEN\ + + TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT_LEN\ + + TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING_LEN,\ + _epin, /*bmInfo*/0, /*bTerminalLink*/UVC_ENTITY_CAP_OUTPUT_TERMINAL, \ + /*bStillCaptureMethod*/0, /*bTriggerSupport*/0, /*bTriggerUsage*/0, \ + /*bmaControls(1)*/0), \ + /* Video stream format */ \ + TUD_VIDEO_DESC_CS_VS_FMT_YUY2(/*bFormatIndex*/1, /*bNumFrameDescriptors*/1, \ + /*bDefaultFrameIndex*/1, 0, 0, 0, /*bCopyProtect*/0), \ + /* Video stream frame format */ \ + TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT(/*bFrameIndex */1, 0, _width, _height, \ + _width * _height * 16, _width * _height * 16 * _fps, \ + _width * _height * 16, \ + (10000000/_fps), (10000000/_fps), 10000000, 100000), \ + TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING(VIDEO_COLOR_PRIMARIES_BT709, VIDEO_COLOR_XFER_CH_BT709, VIDEO_COLOR_COEF_SMPTE170M), \ + /* VS alt 1 */\ + TUD_VIDEO_DESC_STD_VS(1, 1, 1, 0), \ + /* EP */ \ + TUD_VIDEO_DESC_EP_ISO(_epin, _epsize, 1) #endif 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; + 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; - 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; - 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; + 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; + } + 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; + } + 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 */ - 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; + 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; - } - 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); - } - 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; - 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; }