mirror/tinyusb
1
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2025-04-17 08:45:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1 from hathach/kkitayam-add_uvc

Browse Source 
minor code clean up without functional changes
This commit is contained in:
Koji KITAYAMA 2021-10-12 23:20:55 +09:00 committed by GitHub
commit ef04dee52a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 425 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/device/video_capture/src/main.c
View File

@ -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; (void)ctl_idx; (void)stm_idx;
/* convert unit to ms from 100 ns */ /* convert unit to ms from 100 ns */
interval_ms = parameters->dwFrameInterval / 10000; interval_ms = parameters->dwFrameInterval / 10000;
return VIDEO_NO_ERROR; return VIDEO_ERROR_NONE;
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+

7
examples/device/video_capture/src/tusb_config.h
View File

@ -91,16 +91,11 @@
#endif #endif
//------------- CLASS -------------// //------------- 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 // The number of video control interfaces
#define CFG_TUD_VIDEO 1 #define CFG_TUD_VIDEO 1
// The number of video streaming interfaces // The number of video streaming interfaces
#define CFG_TUD_VIDEO_STREAMING 1 #define CFG_TUD_VIDEO_STREAMING 1
#define CFG_TUD_VENDOR 0
// video streaming endpoint size // video streaming endpoint size
#define CFG_TUD_VIDEO_STREAMING_EP_BUFSIZE 256 #define CFG_TUD_VIDEO_STREAMING_EP_BUFSIZE 256

16
examples/device/video_capture/src/usb_descriptors.c
View File

@ -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) #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 // 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 ... // 0 control, 1 In, 2 Bulk, 3 Iso, 4 In, 5 Bulk etc ...
#define EPNUM_VIDEO_IN 0x83 #define EPNUM_VIDEO_IN 0x83
#elif CFG_TUSB_MCU == OPT_MCU_SAMG || CFG_TUSB_MCU == OPT_MCU_CXD56 #elif TU_CHECK_MCU(NRF5X)
// SAMG doesn't support a same endpoint number with different direction IN and OUT // nRF5x ISO can only be endpoint 8
// e.g EP1 OUT & EP1 IN cannot exist together #define EPNUM_VIDEO_IN 0x88
#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
#else #else
#define EPNUM_VIDEO_IN 0x81 #define EPNUM_VIDEO_IN 0x81

66
examples/device/video_capture/src/usb_descriptors.h
View File

@ -75,40 +75,38 @@ enum {
#define TUD_VIDEO_CAPTURE_DESCRIPTOR(_stridx, _epin, _width, _height, _fps, _epsize) \ #define TUD_VIDEO_CAPTURE_DESCRIPTOR(_stridx, _epin, _width, _height, _fps, _epsize) \
TUD_VIDEO_DESC_IAD(ITF_NUM_VIDEO_CONTROL, ITF_NUM_TOTAL, _stridx), \ TUD_VIDEO_DESC_IAD(ITF_NUM_VIDEO_CONTROL, ITF_NUM_TOTAL, _stridx), \
/* Video control 0 */ \ /* Video control 0 */ \
TUD_VIDEO_DESC_STD_VC(ITF_NUM_VIDEO_CONTROL, 0, _stridx), \ TUD_VIDEO_DESC_STD_VC(ITF_NUM_VIDEO_CONTROL, 0, _stridx), \
TUD_VIDEO_DESC_CS_VC( /* UVC 1.5*/ 0x0150, \ TUD_VIDEO_DESC_CS_VC( /* UVC 1.5*/ 0x0150, \
/* wTotalLength - bLength */ \ /* wTotalLength - bLength */ \
TUD_VIDEO_DESC_INPUT_TERM_LEN + TUD_VIDEO_DESC_OUTPUT_TERM_LEN, \ TUD_VIDEO_DESC_INPUT_TERM_LEN + TUD_VIDEO_DESC_OUTPUT_TERM_LEN, \
UVC_CLOCK_FREQUENCY, 1), \ UVC_CLOCK_FREQUENCY, 1), \
TUD_VIDEO_DESC_INPUT_TERM(UVC_ENTITY_CAP_INPUT_TERMINAL,\ TUD_VIDEO_DESC_INPUT_TERM(UVC_ENTITY_CAP_INPUT_TERMINAL, VIDEO_ETT_COMPOSITE_CONNECTOR, 0, 0), \
VIDEO_TT_COMPOSITE_CONNECTOR, 0, 0), \ TUD_VIDEO_DESC_OUTPUT_TERM(UVC_ENTITY_CAP_OUTPUT_TERMINAL, VIDEO_TT_STREAMING, 0, 1, 0), \
TUD_VIDEO_DESC_OUTPUT_TERM(UVC_ENTITY_CAP_OUTPUT_TERMINAL,\ /* Video stream alt. 0 */ \
VIDEO_TT_STREAMING, 0, 1, 0), \ TUD_VIDEO_DESC_STD_VS( 1, 0, 0, 0), \
/* Video stream alt. 0 */ \ /* Video stream header for without still image capture */ \
TUD_VIDEO_DESC_STD_VS( 1, 0, 0, 0), \ TUD_VIDEO_DESC_CS_VS_INPUT( /*bNumFormats*/1, \
/* Video stream header for without still image capture */ \ /*wTotalLength - bLength */\
TUD_VIDEO_DESC_CS_VS_INPUT( /*bNumFormats*/1, \ TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR_LEN\
/*wTotalLength - bLength */\ + TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT_LEN\
TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR_LEN\ + TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING_LEN,\
+ TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT_LEN\ _epin, /*bmInfo*/0, /*bTerminalLink*/UVC_ENTITY_CAP_OUTPUT_TERMINAL, \
+ TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING_LEN,\ /*bStillCaptureMethod*/0, /*bTriggerSupport*/0, /*bTriggerUsage*/0, \
_epin, /*bmInfo*/0, /*bTerminalLink*/UVC_ENTITY_CAP_OUTPUT_TERMINAL, \ /*bmaControls(1)*/0), \
/*bStillCaptureMethod*/0, /*bTriggerSupport*/0, /*bTriggerUsage*/0, \ /* Video stream format */ \
/*bmaControls(1)*/0), \ TUD_VIDEO_DESC_CS_VS_FMT_YUY2(/*bFormatIndex*/1, /*bNumFrameDescriptors*/1, \
/* Video stream format */ \ /*bDefaultFrameIndex*/1, 0, 0, 0, /*bCopyProtect*/0), \
TUD_VIDEO_DESC_CS_VS_FMT_YUY2(/*bFormatIndex*/1, /*bNumFrameDescriptors*/1, \ /* Video stream frame format */ \
/*bDefaultFrameIndex*/1, 0, 0, 0, /*bCopyProtect*/0), \ TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT(/*bFrameIndex */1, 0, _width, _height, \
/* Video stream frame format */ \ _width * _height * 16, _width * _height * 16 * _fps, \
TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT(/*bFrameIndex */1, 0, _width, _height, \ _width * _height * 16, \
_width * _height * 16, _width * _height * 16 * _fps, \ (10000000/_fps), (10000000/_fps), 10000000, 100000), \
_width * _height * 16, \ TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING(VIDEO_COLOR_PRIMARIES_BT709, VIDEO_COLOR_XFER_CH_BT709, VIDEO_COLOR_COEF_SMPTE170M), \
(10000000/_fps), (10000000/_fps), 10000000, 100000), \ /* VS alt 1 */\
TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING(VIDEO_COLOR_PRIMARIES_BT709, VIDEO_COLOR_XFER_CH_BT709, VIDEO_COLOR_COEF_SMPTE170M), \ TUD_VIDEO_DESC_STD_VS(1, 1, 1, 0), \
/* VS alt 1 */\ /* EP */ \
TUD_VIDEO_DESC_STD_VS(1, 1, 1, 0), \ TUD_VIDEO_DESC_EP_ISO(_epin, _epsize, 1)
/* EP */ \
TUD_VIDEO_DESC_EP_ISO(_epin, _epsize, 1)
#endif #endif

197
src/class/video/video.h
View File

@ -29,18 +29,20 @@
#include "common/tusb_common.h" #include "common/tusb_common.h"
// Table 3-19 Color Matching Descriptor
typedef enum { typedef enum {
VIDEO_COLOR_PRIMARIES_UNDEFINED = 0x00, VIDEO_COLOR_PRIMARIES_UNDEFINED = 0x00,
VIDEO_COLOR_PRIMARIES_BT709, VIDEO_COLOR_PRIMARIES_BT709, // sRGB (default)
VIDEO_COLOR_PRIMARIES_BT470_2M, VIDEO_COLOR_PRIMARIES_BT470_2M,
VIDEO_COLOR_PRIMARIES_BT470_2BG, VIDEO_COLOR_PRIMARIES_BT470_2BG,
VIDEO_COLOR_PRIMARIES_SMPTE170M, VIDEO_COLOR_PRIMARIES_SMPTE170M,
VIDEO_COLOR_PRIMARIES_SMPTE240M, VIDEO_COLOR_PRIMARIES_SMPTE240M,
} video_color_primaries_t; } video_color_primaries_t;
// Table 3-19 Color Matching Descriptor
typedef enum { typedef enum {
VIDEO_COLOR_XFER_CH_UNDEFINED = 0x00, 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_2M,
VIDEO_COLOR_XFER_CH_BT470_2BG, VIDEO_COLOR_XFER_CH_BT470_2BG,
VIDEO_COLOR_XFER_CH_SMPTE170M, VIDEO_COLOR_XFER_CH_SMPTE170M,
@ -49,30 +51,31 @@ typedef enum {
VIDEO_COLOR_XFER_CH_SRGB, VIDEO_COLOR_XFER_CH_SRGB,
} video_color_transfer_characteristics_t; } video_color_transfer_characteristics_t;
// Table 3-19 Color Matching Descriptor
typedef enum { typedef enum {
VIDEO_COLOR_COEF_UNDEFINED = 0x00, VIDEO_COLOR_COEF_UNDEFINED = 0x00,
VIDEO_COLOR_COEF_BT709, VIDEO_COLOR_COEF_BT709,
VIDEO_COLOR_COEF_FCC, VIDEO_COLOR_COEF_FCC,
VIDEO_COLOR_COEF_BT470_2BG, VIDEO_COLOR_COEF_BT470_2BG,
VIDEO_COLOR_COEF_SMPTE170M, VIDEO_COLOR_COEF_SMPTE170M, // BT.601 default
VIDEO_COLOR_COEF_SMPTE240M, VIDEO_COLOR_COEF_SMPTE240M,
} video_color_matrix_coefficients_t; } video_color_matrix_coefficients_t;
/* 4.2.1.2 */ /* 4.2.1.2 Request Error Code Control */
typedef enum { typedef enum {
VIDEO_NO_ERROR = 0, /* The request succeeded. */ VIDEO_ERROR_NONE = 0, /* The request succeeded. */
VIDEO_NOT_READY, VIDEO_ERROR_NOT_READY,
VIDEO_WRONG_STATE, VIDEO_ERROR_WRONG_STATE,
VIDEO_POWER, VIDEO_ERROR_POWER,
VIDEO_OUT_OF_RANGE, VIDEO_ERROR_OUT_OF_RANGE,
VIDEO_INVALID_UNIT, VIDEO_ERROR_INVALID_UNIT,
VIDEO_INVALID_CONTROL, VIDEO_ERROR_INVALID_CONTROL,
VIDEO_INVALID_REQUEST, VIDEO_ERROR_INVALID_REQUEST,
VIDEO_INVALID_VALUE_WITHIN_RANGE, VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE,
VIDEO_UNKNOWN = 0xFF, VIDEO_ERROR_UNKNOWN = 0xFF,
} video_error_code_t; } video_error_code_t;
/* A.2 */ /* A.2 Interface Subclass */
typedef enum { typedef enum {
VIDEO_SUBCLASS_UNDEFINED = 0x00, VIDEO_SUBCLASS_UNDEFINED = 0x00,
VIDEO_SUBCLASS_CONTROL, VIDEO_SUBCLASS_CONTROL,
@ -80,79 +83,86 @@ typedef enum {
VIDEO_SUBCLASS_INTERFACE_COLLECTION, VIDEO_SUBCLASS_INTERFACE_COLLECTION,
} video_subclass_type_t; } video_subclass_type_t;
/* A.3 */ /* A.3 Interface Protocol */
typedef enum { typedef enum {
VIDEO_INT_PROTOCOL_CODE_UNDEF = 0x00, VIDEO_ITF_PROTOCOL_UNDEFINED = 0x00,
VIDEO_INT_PROTOCOL_CODE_15, VIDEO_ITF_PROTOCOL_15,
} video_interface_protocol_code_t; } video_interface_protocol_code_t;
/* A.5 */ /* A.5 Class-Specific VideoControl Interface Descriptor Subtypes */
typedef enum { typedef enum {
VIDEO_CS_VC_INTERFACE_VC_DESCRIPTOR_UNDEF = 0x00, VIDEO_CS_ITF_VC_UNDEFINED = 0x00,
VIDEO_CS_VC_INTERFACE_HEADER, VIDEO_CS_ITF_VC_HEADER,
VIDEO_CS_VC_INTERFACE_INPUT_TERMINAL, VIDEO_CS_ITF_VC_INPUT_TERMINAL,
VIDEO_CS_VC_INTERFACE_OUTPUT_TERMINAL, VIDEO_CS_ITF_VC_OUTPUT_TERMINAL,
VIDEO_CS_VC_INTERFACE_SELECTOR_UNIT, VIDEO_CS_ITF_VC_SELECTOR_UNIT,
VIDEO_CS_VC_INTERFACE_PROCESSING_UNIT, VIDEO_CS_ITF_VC_PROCESSING_UNIT,
VIDEO_CS_VC_INTERFACE_EXTENSION_UNIT, VIDEO_CS_ITF_VC_EXTENSION_UNIT,
VIDEO_CS_VC_INTERFACE_ENCODING_UNIT, VIDEO_CS_ITF_VC_ENCODING_UNIT,
VIDEO_CS_VC_INTERFACE_MAX, VIDEO_CS_ITF_VC_MAX,
} video_cs_vc_interface_subtype_t; } video_cs_vc_interface_subtype_t;
/* A.6 */ /* A.6 Class-Specific VideoStreaming Interface Descriptor Subtypes */
typedef enum { typedef enum {
VIDEO_CS_VS_INTERFACE_VS_DESCRIPTOR_UNDEF = 0x00, VIDEO_CS_ITF_VS_UNDEFINED = 0x00,
VIDEO_CS_VS_INTERFACE_INPUT_HEADER, VIDEO_CS_ITF_VS_INPUT_HEADER = 0x01,
VIDEO_CS_VS_INTERFACE_OUTPUT_HEADER, VIDEO_CS_ITF_VS_OUTPUT_HEADER = 0x02,
VIDEO_CS_VS_INTERFACE_STILL_IMAGE_FRAME, VIDEO_CS_ITF_VS_STILL_IMAGE_FRAME = 0x03,
VIDEO_CS_VS_INTERFACE_FORMAT_UNCOMPRESSED, VIDEO_CS_ITF_VS_FORMAT_UNCOMPRESSED = 0x04,
VIDEO_CS_VS_INTERFACE_FRAME_UNCOMPRESSED, VIDEO_CS_ITF_VS_FRAME_UNCOMPRESSED = 0x05,
VIDEO_CS_VS_INTERFACE_FORMAT_MJPEG, VIDEO_CS_ITF_VS_FORMAT_MJPEG = 0x06,
VIDEO_CS_VS_INTERFACE_FRAME_MJPEG, VIDEO_CS_ITF_VS_FRAME_MJPEG = 0x07,
VIDEO_CS_VS_INTERFACE_FORMAT_MPEG2TS = 0x0A, VIDEO_CS_ITF_VS_FORMAT_MPEG2TS = 0x0A,
VIDEO_CS_VS_INTERFACE_FORMAT_DV = 0x0c, VIDEO_CS_ITF_VS_FORMAT_DV = 0x0C,
VIDEO_CS_VS_INTERFACE_COLORFORMAT, VIDEO_CS_ITF_VS_COLORFORMAT = 0x0D,
VIDEO_CS_VS_INTERFACE_FORMAT_FRAME_BASED = 0x10, VIDEO_CS_ITF_VS_FORMAT_FRAME_BASED = 0x10,
VIDEO_CS_VS_INTERFACE_FRAME_FRAME_BASED, VIDEO_CS_ITF_VS_FRAME_FRAME_BASED = 0x11,
VIDEO_CS_VS_INTERFACE_FORMAT_STREAM_BASED, VIDEO_CS_ITF_VS_FORMAT_STREAM_BASED = 0x12,
VIDEO_CS_VS_INTERFACE_FORMAT_H264, VIDEO_CS_ITF_VS_FORMAT_H264 = 0x13,
VIDEO_CS_VS_INTERFACE_FRAME_H264, VIDEO_CS_ITF_VS_FRAME_H264 = 0x14,
VIDEO_CS_VS_INTERFACE_FORMAT_H264_SIMULCAST, VIDEO_CS_ITF_VS_FORMAT_H264_SIMULCAST = 0x15,
VIDEO_CS_VS_INTERFACE_FORMAT_VP8, VIDEO_CS_ITF_VS_FORMAT_VP8 = 0x16,
VIDEO_CS_VS_INTERFACE_FRAME_VP8, VIDEO_CS_ITF_VS_FRAME_VP8 = 0x17,
VIDEO_CS_VS_INTERFACE_FORMAT_VP8_SIMULCAST, VIDEO_CS_ITF_VS_FORMAT_VP8_SIMULCAST = 0x18,
} video_cs_vs_interface_subtype_t; } video_cs_vs_interface_subtype_t;
/* A.8 */ /* A.7. Class-Specific Endpoint Descriptor Subtypes */
typedef enum { typedef enum {
VIDEO_REQUEST_UNDEF = 0x00, VIDEO_CS_EP_UNDEFINED = 0x00,
VIDEO_REQUEST_SET_CUR, 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_SET_CUR_ALL = 0x11,
VIDEO_REQUEST_GET = 0x80, VIDEO_REQUEST_GET_CUR = 0x81,
VIDEO_REQUEST_GET_CUR, VIDEO_REQUEST_GET_MIN = 0x82,
VIDEO_REQUEST_GET_MIN, VIDEO_REQUEST_GET_MAX = 0x83,
VIDEO_REQUEST_GET_MAX, VIDEO_REQUEST_GET_RES = 0x84,
VIDEO_REQUEST_GET_RES, VIDEO_REQUEST_GET_LEN = 0x85,
VIDEO_REQUEST_GET_LEN, VIDEO_REQUEST_GET_INFO = 0x86,
VIDEO_REQUEST_GET_INFO, VIDEO_REQUEST_GET_DEF = 0x87,
VIDEO_REQUEST_GET_DEF,
VIDEO_REQUEST_GET_CUR_ALL = 0x91, VIDEO_REQUEST_GET_CUR_ALL = 0x91,
VIDEO_REQUEST_GET_MIN_ALL, VIDEO_REQUEST_GET_MIN_ALL = 0x92,
VIDEO_REQUEST_GET_MAX_ALL, VIDEO_REQUEST_GET_MAX_ALL = 0x93,
VIDEO_REQUEST_GET_RES_ALL, VIDEO_REQUEST_GET_RES_ALL = 0x94,
VIDEO_REQUEST_GET_DEF_ALL = 0x97 VIDEO_REQUEST_GET_DEF_ALL = 0x97
} video_control_request_t; } video_control_request_t;
/* A.9.1 */ /* A.9.1 VideoControl Interface Control Selectors */
typedef enum { typedef enum {
VIDEO_VC_CTL_UNDEF = 0x00, VIDEO_VC_CTL_UNDEFINED = 0x00,
VIDEO_VC_CTL_VIDEO_POWER_MODE, VIDEO_VC_CTL_VIDEO_POWER_MODE,
VIDEO_VC_CTL_REQUEST_ERROR_CODE, VIDEO_VC_CTL_REQUEST_ERROR_CODE,
} video_interface_control_selector_t; } video_interface_control_selector_t;
/* A.9.8 */ /* A.9.8 VideoStreaming Interface Control Selectors */
typedef enum { typedef enum {
VIDEO_VS_CTL_UNDEF = 0x00, VIDEO_VS_CTL_UNDEFINED = 0x00,
VIDEO_VS_CTL_PROBE, VIDEO_VS_CTL_PROBE,
VIDEO_VS_CTL_COMMIT, VIDEO_VS_CTL_COMMIT,
VIDEO_VS_CTL_STILL_PROBE, VIDEO_VS_CTL_STILL_PROBE,
@ -166,20 +176,31 @@ typedef enum {
/* B. Terminal Types */ /* B. Terminal Types */
typedef enum { typedef enum {
// Terminal
VIDEO_TT_VENDOR_SPECIFIC = 0x0100, VIDEO_TT_VENDOR_SPECIFIC = 0x0100,
VIDEO_TT_STREAMING, VIDEO_TT_STREAMING = 0x0101,
// Input
VIDEO_ITT_VENDOR_SPECIFIC = 0x0200, VIDEO_ITT_VENDOR_SPECIFIC = 0x0200,
VIDEO_ITT_CAMERA, VIDEO_ITT_CAMERA = 0x0201,
VIDEO_ITT_MEDIA_TRANSPORT_INPUT, VIDEO_ITT_MEDIA_TRANSPORT_INPUT = 0x0202,
// Output
VIDEO_OTT_VENDOR_SPECIFIC = 0x0300, VIDEO_OTT_VENDOR_SPECIFIC = 0x0300,
VIDEO_OTT_DISPLAY, VIDEO_OTT_DISPLAY = 0x0301,
VIDEO_OTT_MEDIA_TRANSPORT_OUTPUT, VIDEO_OTT_MEDIA_TRANSPORT_OUTPUT = 0x0302,
VIDEO_TT_EXTERNAL_VENDOR_SPEIFIC = 0x0400,
VIDEO_TT_COMPOSITE_CONNECTOR, // External
VIDEO_TT_SVIDEO_CONNECTOR, VIDEO_ETT_VENDOR_SPEIFIC = 0x0400,
VIDEO_TT_COMPONENT_CONNECTOR, VIDEO_ETT_COMPOSITE_CONNECTOR = 0x0401,
VIDEO_ETT_SVIDEO_CONNECTOR = 0x0402,
VIDEO_ETT_COMPONENT_CONNECTOR = 0x0403,
} video_terminal_type_t; } video_terminal_type_t;
//--------------------------------------------------------------------+
// Descriptors
//--------------------------------------------------------------------+
/* 2.3.4.2 */ /* 2.3.4.2 */
typedef struct TU_ATTR_PACKED { typedef struct TU_ATTR_PACKED {
uint8_t bLength; 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) \ #define TUD_VIDEO_DESC_IAD(_firstitfs, _nitfs, _stridx) \
TUD_VIDEO_DESC_IAD_LEN, TUSB_DESC_INTERFACE_ASSOCIATION, \ TUD_VIDEO_DESC_IAD_LEN, TUSB_DESC_INTERFACE_ASSOCIATION, \
_firstitfs, _nitfs, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_INTERFACE_COLLECTION, \ _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) \ #define TUD_VIDEO_DESC_STD_VC(_itfnum, _nEPs, _stridx) \
TUD_VIDEO_DESC_STD_VC_LEN, TUSB_DESC_INTERFACE, _itfnum, /* fixed to zero */ 0x00, \ 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 */ /* 3.7.2 */
#define TUD_VIDEO_DESC_CS_VC(_bcdUVC, _totallen, _clkfreq, ...) \ #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__))), \ 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__ U32_TO_U8S_LE(_clkfreq), TU_ARGS_NUM(__VA_ARGS__), __VA_ARGS__
/* 3.7.2.1 */ /* 3.7.2.1 */
#define TUD_VIDEO_DESC_INPUT_TERM(_tid, _tt, _at, _stridx) \ #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 _tid, U16_TO_U8S_LE(_tt), _at, _stridx
/* 3.7.2.2 */ /* 3.7.2.2 */
#define TUD_VIDEO_DESC_OUTPUT_TERM(_tid, _tt, _at, _srcid, _stridx) \ #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 _tid, U16_TO_U8S_LE(_tt), _at, _srcid, _stridx
/* 3.9.1 */ /* 3.9.1 */
#define TUD_VIDEO_DESC_STD_VS(_itfnum, _alt, _epn, _stridx) \ #define TUD_VIDEO_DESC_STD_VS(_itfnum, _alt, _epn, _stridx) \
TUD_VIDEO_DESC_STD_VS_LEN, TUSB_DESC_INTERFACE, _itfnum, _alt, \ 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 */ /* 3.9.2.1 */
#define TUD_VIDEO_DESC_CS_VS_INPUT(_numfmt, _totallen, _ep, _inf, _termlnk, _sticaptmeth, _trgspt, _trgusg, ...) \ #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, \ 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__))), \ 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__ _ep, _inf, _termlnk, _sticaptmeth, _trgspt, _trgusg, (TU_ARGS_NUM(__VA_ARGS__)), __VA_ARGS__
/* 3.9.2.2 */ /* 3.9.2.2 */
#define TUD_VIDEO_DESC_CS_VS_OUTPUT(_numfmt, _totallen, _ep, _inf, _termlnk, ...) \ #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, \ 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__))), \ 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__ _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, \ #define TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR(_fmtidx, _numfrmdesc, \
_guid, _bitsperpix, _frmidx, _asrx, _asry, _interlace, _cp) \ _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), \ _fmtidx, _numfrmdesc, TUD_VIDEO_GUID(_guid), \
_bitsperpix, _frmidx, _asrx, _asry, _interlace, _cp _bitsperpix, _frmidx, _asrx, _asry, _interlace, _cp
/* Uncompressed 3.1.2 Table 3-3 */ /* 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) \ #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), \ _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(_maxfrmbufsz), U32_TO_U8S_LE(_frminterval), 0, \
U32_TO_U8S_LE(_minfrminterval), U32_TO_U8S_LE(_maxfrminterval), U32_TO_U8S_LE(_frmintervalstep) 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 */ /* Uncompressed 3.1.2 Table 3-4 */
#define TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_DISC(_frmidx, _cap, _width, _height, _minbr, _maxbr, _maxfrmbufsz, _frminterval, ...) \ #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, \ 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), \ _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__ U32_TO_U8S_LE(_maxfrmbufsz), U32_TO_U8S_LE(_frminterval), (TU_ARGS_NUM(__VA_ARGS__)), __VA_ARGS__
/* 3.9.2.6 */ /* 3.9.2.6 */
#define TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING(_color, _trns, _mat) \ #define TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING(_color, _trns, _mat) \
TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING_LEN, \ 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 _color, _trns, _mat
/* 3.10.1.1 */ /* 3.10.1.1 */

535
src/class/video/video_device.c
View File

@ -1,9 +1,8 @@
/* /*
* The MIT License (MIT) * 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) 2021 Koji KITAYAMA
* Copyright (c) 2019 Ha Thach (tinyusb.org)
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * 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; 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)) { 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; 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 if ((VIDEO_CS_ITF_VC_INPUT_TERMINAL <= itf->bDescriptorSubtype
&& itf->bDescriptorSubtype < VIDEO_CS_VC_INTERFACE_MAX) && itf->bDescriptorSubtype < VIDEO_CS_ITF_VC_MAX)
&& itf->bEntityId == entityid) { && itf->bEntityId == entityid) {
return itf; 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) 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*) 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. */ /** 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) 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*) 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 /** 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; uint_fast8_t fmtnum = param->bFormatIndex;
TU_ASSERT(fmtnum <= vs->stm.bNumFormats); TU_ASSERT(fmtnum <= vs->stm.bNumFormats);
if (!fmtnum) { if (!fmtnum) {
if (1 < vs->stm.bNumFormats) if (1 < vs->stm.bNumFormats) return true; /* Need to negotiate all variables. */
return true; /* Need to negotiate all variables. */
fmtnum = 1; fmtnum = 1;
param->bFormatIndex = 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; uint_fast8_t frmnum = param->bFrameIndex;
TU_ASSERT(frmnum <= fmt->bNumFrameDescriptors); TU_ASSERT(frmnum <= fmt->bNumFrameDescriptors);
if (!frmnum) { if (!frmnum) {
if (1 < fmt->bNumFrameDescriptors) if (1 < fmt->bNumFrameDescriptors) return true;
return true;
frmnum = 1; frmnum = 1;
param->bFrameIndex = 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; uint_fast32_t interval = param->dwFrameInterval;
if (!interval) { if (!interval) {
if ((1 < frm->bFrameIntervalType) || if ((1 < frm->bFrameIntervalType) ||
((0 == frm->bFrameIntervalType) && (frm->dwFrameInterval[1] != frm->dwFrameInterval[0]))) ((0 == frm->bFrameIntervalType) && (frm->dwFrameInterval[1] != frm->dwFrameInterval[0]))) {
return true; return true;
}
interval = frm->dwFrameInterval[0]; interval = frm->dwFrameInterval[0];
param->dwFrameInterval = interval; 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; void const *end = beg + self->len;
/* The first descriptor is a video control interface descriptor. */ /* The first descriptor is a video control interface descriptor. */
void const *cur = _find_desc_itf(beg, end, _desc_itfnum(beg), altnum); 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); TU_VERIFY(cur < end);
tusb_desc_vc_itf_t const *vc = (tusb_desc_vc_itf_t const *)cur; 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) uint_fast8_t ctl_idx)
{ {
switch (request->bRequest) { switch (request->bRequest) {
case TUSB_REQ_GET_INTERFACE: case TUSB_REQ_GET_INTERFACE:
if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR; if (stage == CONTROL_STAGE_SETUP)
TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN); {
tusb_desc_vc_itf_t const *vc = _get_desc_vc(&_videod_itf[ctl_idx]); TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
if (!vc) return VIDEO_UNKNOWN; tusb_desc_vc_itf_t const *vc = _get_desc_vc(&_videod_itf[ctl_idx]);
if (tud_control_xfer(rhport, request, TU_VERIFY(vc, VIDEO_ERROR_UNKNOWN);
(void*)&vc->std.bAlternateSetting,
sizeof(vc->std.bAlternateSetting))) TU_VERIFY(tud_control_xfer(rhport, request, (void*)&vc->std.bAlternateSetting, sizeof(vc->std.bAlternateSetting)),
return VIDEO_NO_ERROR; VIDEO_ERROR_UNKNOWN);
return VIDEO_UNKNOWN; }
case TUSB_REQ_SET_INTERFACE: return VIDEO_ERROR_NONE;
if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR;
TU_VERIFY(0 == request->wLength, VIDEO_UNKNOWN); case TUSB_REQ_SET_INTERFACE:
if (!_close_vc_itf(rhport, &_videod_itf[ctl_idx])) if (stage == CONTROL_STAGE_SETUP)
return VIDEO_UNKNOWN; {
if (!_open_vc_itf(rhport, &_videod_itf[ctl_idx], request->wValue)) TU_VERIFY(0 == request->wLength, VIDEO_ERROR_UNKNOWN);
return VIDEO_UNKNOWN; TU_VERIFY(_close_vc_itf(rhport, &_videod_itf[ctl_idx]), VIDEO_ERROR_UNKNOWN);
tud_control_status(rhport, request); TU_VERIFY(_open_vc_itf(rhport, &_videod_itf[ctl_idx], request->wValue), VIDEO_ERROR_UNKNOWN);
return VIDEO_NO_ERROR; tud_control_status(rhport, request);
default: /* Unknown/Unsupported request */ }
TU_BREAKPOINT(); return VIDEO_ERROR_NONE;
return VIDEO_INVALID_REQUEST;
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) uint_fast8_t ctl_idx)
{ {
videod_interface_t *self = &_videod_itf[ctl_idx]; videod_interface_t *self = &_videod_itf[ctl_idx];
/* 4.2.1 Interface Control Request */ /* 4.2.1 Interface Control Request */
switch (TU_U16_HIGH(request->wValue)) { switch (TU_U16_HIGH(request->wValue)) {
case VIDEO_VC_CTL_VIDEO_POWER_MODE: case VIDEO_VC_CTL_VIDEO_POWER_MODE:
switch (request->bRequest) { switch (request->bRequest) {
case VIDEO_REQUEST_SET_CUR: case VIDEO_REQUEST_SET_CUR:
if (stage == CONTROL_STAGE_SETUP) { if (stage == CONTROL_STAGE_SETUP) {
TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN); TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
if (!tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode))) TU_VERIFY(tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode)), VIDEO_ERROR_UNKNOWN);
return VIDEO_UNKNOWN; } else if (stage == CONTROL_STAGE_ACK) {
} else if (stage == CONTROL_STAGE_ACK) { if (tud_video_power_mode_cb) return tud_video_power_mode_cb(ctl_idx, self->power_mode);
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; break;
case VIDEO_REQUEST_GET_CUR:
if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR; case VIDEO_VC_CTL_REQUEST_ERROR_CODE:
TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN); switch (request->bRequest) {
if (!tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode))) case VIDEO_REQUEST_GET_CUR:
return VIDEO_UNKNOWN; if (stage == CONTROL_STAGE_SETUP)
return VIDEO_NO_ERROR; {
case VIDEO_REQUEST_GET_INFO: TU_VERIFY(tud_control_xfer(rhport, request, &self->error_code, sizeof(uint8_t)), VIDEO_ERROR_UNKNOWN);
if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR; }
TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN); return VIDEO_ERROR_NONE;
if (!tud_control_xfer(rhport, request, (uint8_t*)&_cap_get_set, sizeof(_cap_get_set)))
return VIDEO_UNKNOWN; case VIDEO_REQUEST_GET_INFO:
return VIDEO_NO_ERROR; 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; 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 */ /* Unknown/Unsupported request */
TU_BREAKPOINT(); TU_BREAKPOINT();
return VIDEO_INVALID_REQUEST; return VIDEO_ERROR_INVALID_REQUEST;
} }
static int handle_video_ctl_req(uint8_t rhport, uint8_t stage, 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; uint_fast8_t entity_id;
switch (request->bmRequestType_bit.type) { switch (request->bmRequestType_bit.type) {
case TUSB_REQ_TYPE_STANDARD: case TUSB_REQ_TYPE_STANDARD:
return handle_video_ctl_std_req(rhport, stage, request, ctl_idx); return handle_video_ctl_std_req(rhport, stage, request, ctl_idx);
case TUSB_REQ_TYPE_CLASS:
entity_id = TU_U16_HIGH(request->wIndex); case TUSB_REQ_TYPE_CLASS:
if (!entity_id) { entity_id = TU_U16_HIGH(request->wIndex);
return handle_video_ctl_cs_req(rhport, stage, request, ctl_idx); if (!entity_id) {
} else { return handle_video_ctl_cs_req(rhport, stage, request, ctl_idx);
if (!_find_desc_entity(_get_desc_vc(&_videod_itf[ctl_idx]), entity_id)) } else {
return VIDEO_INVALID_REQUEST; TU_VERIFY(_find_desc_entity(_get_desc_vc(&_videod_itf[ctl_idx]), entity_id), VIDEO_ERROR_INVALID_REQUEST);
return VIDEO_INVALID_REQUEST; return VIDEO_ERROR_NONE;
} }
default:
return VIDEO_INVALID_REQUEST; 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]; videod_streaming_interface_t *self = &_videod_streaming_itf[stm_idx];
switch (request->bRequest) { switch (request->bRequest) {
case TUSB_REQ_GET_INTERFACE: case TUSB_REQ_GET_INTERFACE:
if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR; if (stage == CONTROL_STAGE_SETUP)
TU_VERIFY(1 == request->wLength, VIDEO_UNKNOWN); {
tusb_desc_vs_itf_t const *vs = _get_desc_vs(self); TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
if (!vs) return VIDEO_UNKNOWN; tusb_desc_vs_itf_t const *vs = _get_desc_vs(self);
if (tud_control_xfer(rhport, request, TU_VERIFY(vs, VIDEO_ERROR_UNKNOWN);
(void*)&vs->std.bAlternateSetting, TU_VERIFY(tud_control_xfer(rhport, request, (void*)&vs->std.bAlternateSetting, sizeof(vs->std.bAlternateSetting)), VIDEO_ERROR_UNKNOWN);
sizeof(vs->std.bAlternateSetting))) }
return VIDEO_NO_ERROR; return VIDEO_ERROR_NONE;
return VIDEO_UNKNOWN;
case TUSB_REQ_SET_INTERFACE: case TUSB_REQ_SET_INTERFACE:
if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR; if (stage == CONTROL_STAGE_SETUP)
if (!_open_vs_itf(rhport, self, request->wValue)) {
return VIDEO_UNKNOWN; TU_VERIFY(_open_vs_itf(rhport, self, request->wValue), VIDEO_ERROR_UNKNOWN);
tud_control_status(rhport, request); tud_control_status(rhport, request);
return VIDEO_NO_ERROR; }
default: /* Unknown/Unsupported request */ return VIDEO_ERROR_NONE;
TU_BREAKPOINT();
return VIDEO_INVALID_REQUEST; 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; (void)rhport;
videod_streaming_interface_t *self = &_videod_streaming_itf[stm_idx]; videod_streaming_interface_t *self = &_videod_streaming_itf[stm_idx];
/* 4.2.1 Interface Control Request */ /* 4.2.1 Interface Control Request */
switch (TU_U16_HIGH(request->wValue)) { switch (TU_U16_HIGH(request->wValue)) {
case VIDEO_VS_CTL_STREAM_ERROR_CODE: case VIDEO_VS_CTL_STREAM_ERROR_CODE:
switch (request->bRequest) { switch (request->bRequest) {
case VIDEO_REQUEST_GET_CUR: case VIDEO_REQUEST_GET_CUR:
if (stage != CONTROL_STAGE_SETUP) return VIDEO_NO_ERROR; 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 */ /* TODO */
if (!tud_control_xfer(rhport, request, &self->error_code, sizeof(uint8_t))) break;
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; 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 */ /* Unknown/Unsupported request */
TU_BREAKPOINT(); TU_BREAKPOINT();
return VIDEO_INVALID_REQUEST; return VIDEO_ERROR_INVALID_REQUEST;
} }
static int handle_video_stm_req(uint8_t rhport, uint8_t stage, 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) uint_fast8_t stm_idx)
{ {
switch (request->bmRequestType_bit.type) { switch (request->bmRequestType_bit.type) {
case TUSB_REQ_TYPE_STANDARD: case TUSB_REQ_TYPE_STANDARD:
return handle_video_stm_std_req(rhport, stage, request, stm_idx); return handle_video_stm_std_req(rhport, stage, request, stm_idx);
case TUSB_REQ_TYPE_CLASS:
if (TU_U16_HIGH(request->wIndex)) case TUSB_REQ_TYPE_CLASS:
return VIDEO_INVALID_REQUEST; if (TU_U16_HIGH(request->wIndex)) return VIDEO_ERROR_INVALID_REQUEST;
return handle_video_stm_cs_req(rhport, stage, request, stm_idx); return handle_video_stm_cs_req(rhport, stage, request, stm_idx);
default:
return VIDEO_INVALID_REQUEST; 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); TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, 0); videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, 0);
if (stm) if (stm) return true;
return true;
return false; 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(ctl_idx < CFG_TUD_VIDEO);
TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING); TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING);
videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx); videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx);
if (!stm || !stm->desc.ep[0]) if (!stm || !stm->desc.ep[0]) return false;
return false;
return true; 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(ctl_idx < CFG_TUD_VIDEO);
TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING); TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING);
if (!buffer || !buffer) if (!buffer || !buffer) return false;
return false;
videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx); videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx);
if (!stm || !stm->desc.ep[0] || stm->buffer) if (!stm || !stm->desc.ep[0] || stm->buffer) return false;
return false;
/* Find EP address */ /* Find EP address */
void const *desc = _videod_itf[stm->index_vc].beg; 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); ep_addr = _desc_ep_addr(desc + ofs_ep);
break; break;
} }
if (!ep_addr) if (!ep_addr) return false;
return false;
TU_VERIFY( usbd_edpt_claim(0, ep_addr)); TU_VERIFY( usbd_edpt_claim(0, ep_addr));
/* update the packet header */ /* 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) 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) && TU_VERIFY((TUSB_CLASS_VIDEO == itf_desc->bInterfaceClass) &&
(VIDEO_SUBCLASS_CONTROL == itf_desc->bInterfaceSubClass) && (VIDEO_SUBCLASS_CONTROL == itf_desc->bInterfaceSubClass) &&
(VIDEO_INT_PROTOCOL_CODE_15 == itf_desc->bInterfaceProtocol), 0); (VIDEO_ITF_PROTOCOL_15 == itf_desc->bInterfaceProtocol), 0);
/* Find available interface */ /* Find available interface */
videod_interface_t *self = NULL; videod_interface_t *self = NULL;
uint_fast8_t ctl_idx; uint_fast8_t ctl_idx;
for (ctl_idx = 0; ctl_idx < CFG_TUD_VIDEO; ++ctl_idx) { for (ctl_idx = 0; ctl_idx < CFG_TUD_VIDEO; ++ctl_idx) {
if (_videod_itf[ctl_idx].beg) if (_videod_itf[ctl_idx].beg) continue;
continue;
self = &_videod_itf[ctl_idx]; self = &_videod_itf[ctl_idx];
break; 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->beg = itf_desc;
self->len = max_len; self->len = max_len;
/*------------- Video Control Interface -------------*/ /*------------- Video Control Interface -------------*/
if (!_open_vc_itf(rhport, self, 0)) TU_VERIFY(_open_vc_itf(rhport, self, 0), 0);
return 0;
tusb_desc_vc_itf_t const *vc = _get_desc_vc(self); tusb_desc_vc_itf_t const *vc = _get_desc_vc(self);
uint_fast8_t bInCollection = vc->ctl.bInCollection; uint_fast8_t bInCollection = vc->ctl.bInCollection;
/* Find the end of the video interface descriptor */ /* 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; videod_streaming_interface_t *stm = NULL;
/* find free streaming interface handle */ /* find free streaming interface handle */
for (uint_fast8_t i = 0; i < CFG_TUD_VIDEO_STREAMING; ++i) { for (uint_fast8_t i = 0; i < CFG_TUD_VIDEO_STREAMING; ++i) {
if (_videod_streaming_itf[i].desc.beg) if (_videod_streaming_itf[i].desc.beg) continue;
continue;
stm = &_videod_streaming_itf[i]; stm = &_videod_streaming_itf[i];
self->stm[stm_idx] = i; self->stm[stm_idx] = i;
break; 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) bool videod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
{ {
int err; int err;
if (request->bmRequestType_bit.recipient != TUSB_REQ_RCPT_INTERFACE) { TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
return false;
}
uint_fast8_t itfnum = tu_u16_low(request->wIndex); uint_fast8_t itfnum = tu_u16_low(request->wIndex);
/* Identify which control interface to use */ /* 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) { for (itf = 0; itf < CFG_TUD_VIDEO; ++itf) {
void const *desc = _videod_itf[itf].beg; void const *desc = _videod_itf[itf].beg;
if (!desc) continue; if (!desc) continue;
if (itfnum == _desc_itfnum(desc)) if (itfnum == _desc_itfnum(desc)) break;
break;
} }
if (itf < CFG_TUD_VIDEO) { if (itf < CFG_TUD_VIDEO) {
err = handle_video_ctl_req(rhport, stage, request, itf); err = handle_video_ctl_req(rhport, stage, request, itf);
_videod_itf[itf].error_code = (uint8_t)err; _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]; videod_streaming_interface_t *stm = &_videod_streaming_itf[itf];
if (!stm->desc.beg) continue; if (!stm->desc.beg) continue;
void const *desc = _videod_itf[stm->index_vc].beg; void const *desc = _videod_itf[stm->index_vc].beg;
if (itfnum == _desc_itfnum(desc + stm->desc.beg)) if (itfnum == _desc_itfnum(desc + stm->desc.beg)) break;
break;
} }
if (itf < CFG_TUD_VIDEO_STREAMING) { if (itf < CFG_TUD_VIDEO_STREAMING) {
err = handle_video_stm_req(rhport, stage, request, itf); err = handle_video_stm_req(rhport, stage, request, itf);
_videod_streaming_itf[itf].error_code = (uint8_t)err; _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; if (!ep_ofs) continue;
ctl = &_videod_itf[stm->index_vc]; ctl = &_videod_itf[stm->index_vc];
void const *desc = ctl->beg; void const *desc = ctl->beg;
if (ep_addr == _desc_ep_addr(desc + ep_ofs)) if (ep_addr == _desc_ep_addr(desc + ep_ofs)) break;
break;
} }
TU_ASSERT(itf < CFG_TUD_VIDEO_STREAMING); TU_ASSERT(itf < CFG_TUD_VIDEO_STREAMING);
if (stm->offset < stm->bufsize) { if (stm->offset < stm->bufsize) {
/* Claim the endpoint */ /* 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->buffer = NULL;
stm->bufsize = 0; stm->bufsize = 0;
stm->offset = 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); tud_video_frame_xfer_complete_cb(stm->index_vc, stm->index_vs);
}
} }
return true; return true;
} }