X-Git-Url: http://47.100.26.94:8080/?a=blobdiff_plain;f=app%2Fsrc%2Fmain%2Fjni%2Flibuvc-0.0.6%2Finclude%2Flibuvc%2Flibuvc.h;fp=app%2Fsrc%2Fmain%2Fjni%2Flibuvc-0.0.6%2Finclude%2Flibuvc%2Flibuvc.h;h=fa0aea0be7dea29faf4085b049bbed9cf1c6b67e;hb=577426ccc66649228285c4a0b6ba8752836059c6;hp=0000000000000000000000000000000000000000;hpb=b7202442677d0cf41e6e59870cd6c34e5619b8b9;p=rtmpclient.git diff --git a/app/src/main/jni/libuvc-0.0.6/include/libuvc/libuvc.h b/app/src/main/jni/libuvc-0.0.6/include/libuvc/libuvc.h new file mode 100644 index 0000000..fa0aea0 --- /dev/null +++ b/app/src/main/jni/libuvc-0.0.6/include/libuvc/libuvc.h @@ -0,0 +1,741 @@ +#ifndef LIBUVC_H +#define LIBUVC_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include // FILE +#include +#include +#include + +struct libusb_context; +struct libusb_device_handle; + +/** UVC error types, based on libusb errors + * @ingroup diag + */ +typedef enum uvc_error { + /** Success (no error) */ + UVC_SUCCESS = 0, + /** Input/output error */ + UVC_ERROR_IO = -1, + /** Invalid parameter */ + UVC_ERROR_INVALID_PARAM = -2, + /** Access denied */ + UVC_ERROR_ACCESS = -3, + /** No such device */ + UVC_ERROR_NO_DEVICE = -4, + /** Entity not found */ + UVC_ERROR_NOT_FOUND = -5, + /** Resource busy */ + UVC_ERROR_BUSY = -6, + /** Operation timed out */ + UVC_ERROR_TIMEOUT = -7, + /** Overflow */ + UVC_ERROR_OVERFLOW = -8, + /** Pipe error */ + UVC_ERROR_PIPE = -9, + /** System call interrupted */ + UVC_ERROR_INTERRUPTED = -10, + /** Insufficient memory */ + UVC_ERROR_NO_MEM = -11, + /** Operation not supported */ + UVC_ERROR_NOT_SUPPORTED = -12, + /** Device is not UVC-compliant */ + UVC_ERROR_INVALID_DEVICE = -50, + /** Mode not supported */ + UVC_ERROR_INVALID_MODE = -51, + /** Resource has a callback (can't use polling and async) */ + UVC_ERROR_CALLBACK_EXISTS = -52, + /** Undefined error */ + UVC_ERROR_OTHER = -99 +} uvc_error_t; + +/** Color coding of stream, transport-independent + * @ingroup streaming + */ +enum uvc_frame_format { + UVC_FRAME_FORMAT_UNKNOWN = 0, + /** Any supported format */ + UVC_FRAME_FORMAT_ANY = 0, + UVC_FRAME_FORMAT_UNCOMPRESSED, + UVC_FRAME_FORMAT_COMPRESSED, + /** YUYV/YUV2/YUV422: YUV encoding with one luminance value per pixel and + * one UV (chrominance) pair for every two pixels. + */ + UVC_FRAME_FORMAT_YUYV, + UVC_FRAME_FORMAT_UYVY, + /** 24-bit RGB */ + UVC_FRAME_FORMAT_RGB, + UVC_FRAME_FORMAT_BGR, + /** Motion-JPEG (or JPEG) encoded images */ + UVC_FRAME_FORMAT_MJPEG, + /** Greyscale images */ + UVC_FRAME_FORMAT_GRAY8, + UVC_FRAME_FORMAT_GRAY16, + /* Raw colour mosaic images */ + UVC_FRAME_FORMAT_BY8, + UVC_FRAME_FORMAT_BA81, + UVC_FRAME_FORMAT_SGRBG8, + UVC_FRAME_FORMAT_SGBRG8, + UVC_FRAME_FORMAT_SRGGB8, + UVC_FRAME_FORMAT_SBGGR8, + /** Number of formats understood */ + UVC_FRAME_FORMAT_COUNT, +}; + +/* UVC_COLOR_FORMAT_* have been replaced with UVC_FRAME_FORMAT_*. Please use + * UVC_FRAME_FORMAT_* instead of using these. */ +#define UVC_COLOR_FORMAT_UNKNOWN UVC_FRAME_FORMAT_UNKNOWN +#define UVC_COLOR_FORMAT_UNCOMPRESSED UVC_FRAME_FORMAT_UNCOMPRESSED +#define UVC_COLOR_FORMAT_COMPRESSED UVC_FRAME_FORMAT_COMPRESSED +#define UVC_COLOR_FORMAT_YUYV UVC_FRAME_FORMAT_YUYV +#define UVC_COLOR_FORMAT_UYVY UVC_FRAME_FORMAT_UYVY +#define UVC_COLOR_FORMAT_RGB UVC_FRAME_FORMAT_RGB +#define UVC_COLOR_FORMAT_BGR UVC_FRAME_FORMAT_BGR +#define UVC_COLOR_FORMAT_MJPEG UVC_FRAME_FORMAT_MJPEG +#define UVC_COLOR_FORMAT_GRAY8 UVC_FRAME_FORMAT_GRAY8 +#define UVC_COLOR_FORMAT_GRAY16 UVC_FRAME_FORMAT_GRAY16 + +/** VideoStreaming interface descriptor subtype (A.6) */ +enum uvc_vs_desc_subtype { + UVC_VS_UNDEFINED = 0x00, + UVC_VS_INPUT_HEADER = 0x01, + UVC_VS_OUTPUT_HEADER = 0x02, + UVC_VS_STILL_IMAGE_FRAME = 0x03, + UVC_VS_FORMAT_UNCOMPRESSED = 0x04, + UVC_VS_FRAME_UNCOMPRESSED = 0x05, + UVC_VS_FORMAT_MJPEG = 0x06, + UVC_VS_FRAME_MJPEG = 0x07, + UVC_VS_FORMAT_MPEG2TS = 0x0a, + UVC_VS_FORMAT_DV = 0x0c, + UVC_VS_COLORFORMAT = 0x0d, + UVC_VS_FORMAT_FRAME_BASED = 0x10, + UVC_VS_FRAME_FRAME_BASED = 0x11, + UVC_VS_FORMAT_STREAM_BASED = 0x12 +}; + +struct uvc_format_desc; +struct uvc_frame_desc; + +/** Frame descriptor + * + * A "frame" is a configuration of a streaming format + * for a particular image size at one of possibly several + * available frame rates. + */ +typedef struct uvc_frame_desc { + struct uvc_format_desc *parent; + struct uvc_frame_desc *prev, *next; + /** Type of frame, such as JPEG frame or uncompressed frme */ + enum uvc_vs_desc_subtype bDescriptorSubtype; + /** Index of the frame within the list of specs available for this format */ + uint8_t bFrameIndex; + uint8_t bmCapabilities; + /** Image width */ + uint16_t wWidth; + /** Image height */ + uint16_t wHeight; + /** Bitrate of corresponding stream at minimal frame rate */ + uint32_t dwMinBitRate; + /** Bitrate of corresponding stream at maximal frame rate */ + uint32_t dwMaxBitRate; + /** Maximum number of bytes for a video frame */ + uint32_t dwMaxVideoFrameBufferSize; + /** Default frame interval (in 100ns units) */ + uint32_t dwDefaultFrameInterval; + /** Minimum frame interval for continuous mode (100ns units) */ + uint32_t dwMinFrameInterval; + /** Maximum frame interval for continuous mode (100ns units) */ + uint32_t dwMaxFrameInterval; + /** Granularity of frame interval range for continuous mode (100ns) */ + uint32_t dwFrameIntervalStep; + /** Frame intervals */ + uint8_t bFrameIntervalType; + /** number of bytes per line */ + uint32_t dwBytesPerLine; + /** Available frame rates, zero-terminated (in 100ns units) */ + uint32_t *intervals; +} uvc_frame_desc_t; + +/** Format descriptor + * + * A "format" determines a stream's image type (e.g., raw YUYV or JPEG) + * and includes many "frame" configurations. + */ +typedef struct uvc_format_desc { + struct uvc_streaming_interface *parent; + struct uvc_format_desc *prev, *next; + /** Type of image stream, such as JPEG or uncompressed. */ + enum uvc_vs_desc_subtype bDescriptorSubtype; + /** Identifier of this format within the VS interface's format list */ + uint8_t bFormatIndex; + uint8_t bNumFrameDescriptors; + /** Format specifier */ + union { + uint8_t guidFormat[16]; + uint8_t fourccFormat[4]; + }; + /** Format-specific data */ + union { + /** BPP for uncompressed stream */ + uint8_t bBitsPerPixel; + /** Flags for JPEG stream */ + uint8_t bmFlags; + }; + /** Default {uvc_frame_desc} to choose given this format */ + uint8_t bDefaultFrameIndex; + uint8_t bAspectRatioX; + uint8_t bAspectRatioY; + uint8_t bmInterlaceFlags; + uint8_t bCopyProtect; + uint8_t bVariableSize; + /** Available frame specifications for this format */ + struct uvc_frame_desc *frame_descs; +} uvc_format_desc_t; + +/** UVC request code (A.8) */ +enum uvc_req_code { + UVC_RC_UNDEFINED = 0x00, + UVC_SET_CUR = 0x01, + UVC_GET_CUR = 0x81, + UVC_GET_MIN = 0x82, + UVC_GET_MAX = 0x83, + UVC_GET_RES = 0x84, + UVC_GET_LEN = 0x85, + UVC_GET_INFO = 0x86, + UVC_GET_DEF = 0x87 +}; + +enum uvc_device_power_mode { + UVC_VC_VIDEO_POWER_MODE_FULL = 0x000b, + UVC_VC_VIDEO_POWER_MODE_DEVICE_DEPENDENT = 0x001b, +}; + +/** Camera terminal control selector (A.9.4) */ +enum uvc_ct_ctrl_selector { + UVC_CT_CONTROL_UNDEFINED = 0x00, + UVC_CT_SCANNING_MODE_CONTROL = 0x01, + UVC_CT_AE_MODE_CONTROL = 0x02, + UVC_CT_AE_PRIORITY_CONTROL = 0x03, + UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL = 0x04, + UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL = 0x05, + UVC_CT_FOCUS_ABSOLUTE_CONTROL = 0x06, + UVC_CT_FOCUS_RELATIVE_CONTROL = 0x07, + UVC_CT_FOCUS_AUTO_CONTROL = 0x08, + UVC_CT_IRIS_ABSOLUTE_CONTROL = 0x09, + UVC_CT_IRIS_RELATIVE_CONTROL = 0x0a, + UVC_CT_ZOOM_ABSOLUTE_CONTROL = 0x0b, + UVC_CT_ZOOM_RELATIVE_CONTROL = 0x0c, + UVC_CT_PANTILT_ABSOLUTE_CONTROL = 0x0d, + UVC_CT_PANTILT_RELATIVE_CONTROL = 0x0e, + UVC_CT_ROLL_ABSOLUTE_CONTROL = 0x0f, + UVC_CT_ROLL_RELATIVE_CONTROL = 0x10, + UVC_CT_PRIVACY_CONTROL = 0x11, + UVC_CT_FOCUS_SIMPLE_CONTROL = 0x12, + UVC_CT_DIGITAL_WINDOW_CONTROL = 0x13, + UVC_CT_REGION_OF_INTEREST_CONTROL = 0x14 +}; + +/** Processing unit control selector (A.9.5) */ +enum uvc_pu_ctrl_selector { + UVC_PU_CONTROL_UNDEFINED = 0x00, + UVC_PU_BACKLIGHT_COMPENSATION_CONTROL = 0x01, + UVC_PU_BRIGHTNESS_CONTROL = 0x02, + UVC_PU_CONTRAST_CONTROL = 0x03, + UVC_PU_GAIN_CONTROL = 0x04, + UVC_PU_POWER_LINE_FREQUENCY_CONTROL = 0x05, + UVC_PU_HUE_CONTROL = 0x06, + UVC_PU_SATURATION_CONTROL = 0x07, + UVC_PU_SHARPNESS_CONTROL = 0x08, + UVC_PU_GAMMA_CONTROL = 0x09, + UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL = 0x0a, + UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL = 0x0b, + UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL = 0x0c, + UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL = 0x0d, + UVC_PU_DIGITAL_MULTIPLIER_CONTROL = 0x0e, + UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL = 0x0f, + UVC_PU_HUE_AUTO_CONTROL = 0x10, + UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL = 0x11, + UVC_PU_ANALOG_LOCK_STATUS_CONTROL = 0x12, + UVC_PU_CONTRAST_AUTO_CONTROL = 0x13 +}; + +/** USB terminal type (B.1) */ +enum uvc_term_type { + UVC_TT_VENDOR_SPECIFIC = 0x0100, + UVC_TT_STREAMING = 0x0101 +}; + +/** Input terminal type (B.2) */ +enum uvc_it_type { + UVC_ITT_VENDOR_SPECIFIC = 0x0200, + UVC_ITT_CAMERA = 0x0201, + UVC_ITT_MEDIA_TRANSPORT_INPUT = 0x0202 +}; + +/** Output terminal type (B.3) */ +enum uvc_ot_type { + UVC_OTT_VENDOR_SPECIFIC = 0x0300, + UVC_OTT_DISPLAY = 0x0301, + UVC_OTT_MEDIA_TRANSPORT_OUTPUT = 0x0302 +}; + +/** External terminal type (B.4) */ +enum uvc_et_type { + UVC_EXTERNAL_VENDOR_SPECIFIC = 0x0400, + UVC_COMPOSITE_CONNECTOR = 0x0401, + UVC_SVIDEO_CONNECTOR = 0x0402, + UVC_COMPONENT_CONNECTOR = 0x0403 +}; + +/** Context, equivalent to libusb's contexts. + * + * May either own a libusb context or use one that's already made. + * + * Always create these with uvc_get_context. + */ +struct uvc_context; +typedef struct uvc_context uvc_context_t; + +/** UVC device. + * + * Get this from uvc_get_device_list() or uvc_find_device(). + */ +struct uvc_device; +typedef struct uvc_device uvc_device_t; + +/** Handle on an open UVC device. + * + * Get one of these from uvc_open(). Once you uvc_close() + * it, it's no longer valid. + */ +struct uvc_device_handle; +typedef struct uvc_device_handle uvc_device_handle_t; + +/** Handle on an open UVC stream. + * + * Get one of these from uvc_stream_open*(). + * Once you uvc_stream_close() it, it will no longer be valid. + */ +struct uvc_stream_handle; +typedef struct uvc_stream_handle uvc_stream_handle_t; + +/** Representation of the interface that brings data into the UVC device */ +typedef struct uvc_input_terminal { + struct uvc_input_terminal *prev, *next; + /** Index of the terminal within the device */ + uint8_t bTerminalID; + /** Type of terminal (e.g., camera) */ + enum uvc_it_type wTerminalType; + uint16_t wObjectiveFocalLengthMin; + uint16_t wObjectiveFocalLengthMax; + uint16_t wOcularFocalLength; + /** Camera controls (meaning of bits given in {uvc_ct_ctrl_selector}) */ + uint64_t bmControls; +} uvc_input_terminal_t; + +typedef struct uvc_output_terminal { + struct uvc_output_terminal *prev, *next; + /** @todo */ +} uvc_output_terminal_t; + +/** Represents post-capture processing functions */ +typedef struct uvc_processing_unit { + struct uvc_processing_unit *prev, *next; + /** Index of the processing unit within the device */ + uint8_t bUnitID; + /** Index of the terminal from which the device accepts images */ + uint8_t bSourceID; + /** Processing controls (meaning of bits given in {uvc_pu_ctrl_selector}) */ + uint64_t bmControls; +} uvc_processing_unit_t; + +/** Represents selector unit to connect other units */ +typedef struct uvc_selector_unit { + struct uvc_selector_unit *prev, *next; + /** Index of the selector unit within the device */ + uint8_t bUnitID; +} uvc_selector_unit_t; + +/** Custom processing or camera-control functions */ +typedef struct uvc_extension_unit { + struct uvc_extension_unit *prev, *next; + /** Index of the extension unit within the device */ + uint8_t bUnitID; + /** GUID identifying the extension unit */ + uint8_t guidExtensionCode[16]; + /** Bitmap of available controls (manufacturer-dependent) */ + uint64_t bmControls; +} uvc_extension_unit_t; + +enum uvc_status_class { + UVC_STATUS_CLASS_CONTROL = 0x10, + UVC_STATUS_CLASS_CONTROL_CAMERA = 0x11, + UVC_STATUS_CLASS_CONTROL_PROCESSING = 0x12, +}; + +enum uvc_status_attribute { + UVC_STATUS_ATTRIBUTE_VALUE_CHANGE = 0x00, + UVC_STATUS_ATTRIBUTE_INFO_CHANGE = 0x01, + UVC_STATUS_ATTRIBUTE_FAILURE_CHANGE = 0x02, + UVC_STATUS_ATTRIBUTE_UNKNOWN = 0xff +}; + +/** A callback function to accept status updates + * @ingroup device + */ +typedef void(uvc_status_callback_t)(enum uvc_status_class status_class, + int event, + int selector, + enum uvc_status_attribute status_attribute, + void *data, size_t data_len, + void *user_ptr); + +/** A callback function to accept button events + * @ingroup device + */ +typedef void(uvc_button_callback_t)(int button, + int state, + void *user_ptr); + +/** Structure representing a UVC device descriptor. + * + * (This isn't a standard structure.) + */ +typedef struct uvc_device_descriptor { + /** Vendor ID */ + uint16_t idVendor; + /** Product ID */ + uint16_t idProduct; + /** UVC compliance level, e.g. 0x0100 (1.0), 0x0110 */ + uint16_t bcdUVC; + /** Serial number (null if unavailable) */ + const char *serialNumber; + /** Device-reported manufacturer name (or null) */ + const char *manufacturer; + /** Device-reporter product name (or null) */ + const char *product; +} uvc_device_descriptor_t; + +/** An image frame received from the UVC device + * @ingroup streaming + */ +typedef struct uvc_frame { + /** Image data for this frame */ + void *data; + /** Size of image data buffer */ + size_t data_bytes; + /** Width of image in pixels */ + uint32_t width; + /** Height of image in pixels */ + uint32_t height; + /** Pixel data format */ + enum uvc_frame_format frame_format; + /** Number of bytes per horizontal line (undefined for compressed format) */ + size_t step; + /** Frame number (may skip, but is strictly monotonically increasing) */ + uint32_t sequence; + /** Estimate of system time when the device started capturing the image */ + struct timeval capture_time; + /** Handle on the device that produced the image. + * @warning You must not call any uvc_* functions during a callback. */ + uvc_device_handle_t *source; + /** Is the data buffer owned by the library? + * If 1, the data buffer can be arbitrarily reallocated by frame conversion + * functions. + * If 0, the data buffer will not be reallocated or freed by the library. + * Set this field to zero if you are supplying the buffer. + */ + uint8_t library_owns_data; +} uvc_frame_t; + +/** A callback function to handle incoming assembled UVC frames + * @ingroup streaming + */ +typedef void(uvc_frame_callback_t)(struct uvc_frame *frame, void *user_ptr); + +/** Streaming mode, includes all information needed to select stream + * @ingroup streaming + */ +typedef struct uvc_stream_ctrl { + uint16_t bmHint; + uint8_t bFormatIndex; + uint8_t bFrameIndex; + uint32_t dwFrameInterval; + uint16_t wKeyFrameRate; + uint16_t wPFrameRate; + uint16_t wCompQuality; + uint16_t wCompWindowSize; + uint16_t wDelay; + uint32_t dwMaxVideoFrameSize; + uint32_t dwMaxPayloadTransferSize; + uint32_t dwClockFrequency; + uint8_t bmFramingInfo; + uint8_t bPreferredVersion; + uint8_t bMinVersion; + uint8_t bMaxVersion; + uint8_t bInterfaceNumber; +} uvc_stream_ctrl_t; + +uvc_error_t uvc_init(uvc_context_t **ctx, struct libusb_context *usb_ctx); +void uvc_exit(uvc_context_t *ctx); + +uvc_error_t uvc_get_device_list( + uvc_context_t *ctx, + uvc_device_t ***list); +void uvc_free_device_list(uvc_device_t **list, uint8_t unref_devices); + +uvc_error_t uvc_get_device_descriptor( + uvc_device_t *dev, + uvc_device_descriptor_t **desc); +void uvc_free_device_descriptor( + uvc_device_descriptor_t *desc); + +uint8_t uvc_get_bus_number(uvc_device_t *dev); +uint8_t uvc_get_device_address(uvc_device_t *dev); + +uvc_error_t uvc_find_device( + uvc_context_t *ctx, + uvc_device_t **dev, + int vid, int pid, const char *sn); + +uvc_error_t uvc_find_devices( + uvc_context_t *ctx, + uvc_device_t ***devs, + int vid, int pid, const char *sn); + +uvc_error_t uvc_open( + uvc_device_t *dev, + uvc_device_handle_t **devh); +void uvc_close(uvc_device_handle_t *devh); + +uvc_device_t *uvc_get_device(uvc_device_handle_t *devh); +struct libusb_device_handle *uvc_get_libusb_handle(uvc_device_handle_t *devh); + +void uvc_ref_device(uvc_device_t *dev); +void uvc_unref_device(uvc_device_t *dev); + +void uvc_set_status_callback(uvc_device_handle_t *devh, + uvc_status_callback_t cb, + void *user_ptr); + +void uvc_set_button_callback(uvc_device_handle_t *devh, + uvc_button_callback_t cb, + void *user_ptr); + +const uvc_input_terminal_t *uvc_get_camera_terminal(uvc_device_handle_t *devh); +const uvc_input_terminal_t *uvc_get_input_terminals(uvc_device_handle_t *devh); +const uvc_output_terminal_t *uvc_get_output_terminals(uvc_device_handle_t *devh); +const uvc_selector_unit_t *uvc_get_selector_units(uvc_device_handle_t *devh); +const uvc_processing_unit_t *uvc_get_processing_units(uvc_device_handle_t *devh); +const uvc_extension_unit_t *uvc_get_extension_units(uvc_device_handle_t *devh); + +uvc_error_t uvc_get_stream_ctrl_format_size( + uvc_device_handle_t *devh, + uvc_stream_ctrl_t *ctrl, + enum uvc_frame_format format, + int width, int height, + int fps + ); + +const uvc_format_desc_t *uvc_get_format_descs(uvc_device_handle_t* ); + +uvc_error_t uvc_probe_stream_ctrl( + uvc_device_handle_t *devh, + uvc_stream_ctrl_t *ctrl); + +uvc_error_t uvc_start_streaming( + uvc_device_handle_t *devh, + uvc_stream_ctrl_t *ctrl, + uvc_frame_callback_t *cb, + void *user_ptr, + uint8_t flags); + +uvc_error_t uvc_start_iso_streaming( + uvc_device_handle_t *devh, + uvc_stream_ctrl_t *ctrl, + uvc_frame_callback_t *cb, + void *user_ptr); + +void uvc_stop_streaming(uvc_device_handle_t *devh); + +uvc_error_t uvc_stream_open_ctrl(uvc_device_handle_t *devh, uvc_stream_handle_t **strmh, uvc_stream_ctrl_t *ctrl); +uvc_error_t uvc_stream_ctrl(uvc_stream_handle_t *strmh, uvc_stream_ctrl_t *ctrl); +uvc_error_t uvc_stream_start(uvc_stream_handle_t *strmh, + uvc_frame_callback_t *cb, + void *user_ptr, + uint8_t flags); +uvc_error_t uvc_stream_start_iso(uvc_stream_handle_t *strmh, + uvc_frame_callback_t *cb, + void *user_ptr); +uvc_error_t uvc_stream_get_frame( + uvc_stream_handle_t *strmh, + uvc_frame_t **frame, + int32_t timeout_us +); +uvc_error_t uvc_stream_stop(uvc_stream_handle_t *strmh); +void uvc_stream_close(uvc_stream_handle_t *strmh); + +int uvc_get_ctrl_len(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl); +int uvc_get_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len, enum uvc_req_code req_code); +int uvc_set_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len); + +uvc_error_t uvc_get_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode *mode, enum uvc_req_code req_code); +uvc_error_t uvc_set_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode mode); + +/* AUTO-GENERATED control accessors! Update them with the output of `ctrl-gen.py decl`. */ +uvc_error_t uvc_get_scanning_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code); +uvc_error_t uvc_set_scanning_mode(uvc_device_handle_t *devh, uint8_t mode); + +uvc_error_t uvc_get_ae_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code); +uvc_error_t uvc_set_ae_mode(uvc_device_handle_t *devh, uint8_t mode); + +uvc_error_t uvc_get_ae_priority(uvc_device_handle_t *devh, uint8_t* priority, enum uvc_req_code req_code); +uvc_error_t uvc_set_ae_priority(uvc_device_handle_t *devh, uint8_t priority); + +uvc_error_t uvc_get_exposure_abs(uvc_device_handle_t *devh, uint32_t* time, enum uvc_req_code req_code); +uvc_error_t uvc_set_exposure_abs(uvc_device_handle_t *devh, uint32_t time); + +uvc_error_t uvc_get_exposure_rel(uvc_device_handle_t *devh, int8_t* step, enum uvc_req_code req_code); +uvc_error_t uvc_set_exposure_rel(uvc_device_handle_t *devh, int8_t step); + +uvc_error_t uvc_get_focus_abs(uvc_device_handle_t *devh, uint16_t* focus, enum uvc_req_code req_code); +uvc_error_t uvc_set_focus_abs(uvc_device_handle_t *devh, uint16_t focus); + +uvc_error_t uvc_get_focus_rel(uvc_device_handle_t *devh, int8_t* focus_rel, uint8_t* speed, enum uvc_req_code req_code); +uvc_error_t uvc_set_focus_rel(uvc_device_handle_t *devh, int8_t focus_rel, uint8_t speed); + +uvc_error_t uvc_get_focus_simple_range(uvc_device_handle_t *devh, uint8_t* focus, enum uvc_req_code req_code); +uvc_error_t uvc_set_focus_simple_range(uvc_device_handle_t *devh, uint8_t focus); + +uvc_error_t uvc_get_focus_auto(uvc_device_handle_t *devh, uint8_t* state, enum uvc_req_code req_code); +uvc_error_t uvc_set_focus_auto(uvc_device_handle_t *devh, uint8_t state); + +uvc_error_t uvc_get_iris_abs(uvc_device_handle_t *devh, uint16_t* iris, enum uvc_req_code req_code); +uvc_error_t uvc_set_iris_abs(uvc_device_handle_t *devh, uint16_t iris); + +uvc_error_t uvc_get_iris_rel(uvc_device_handle_t *devh, uint8_t* iris_rel, enum uvc_req_code req_code); +uvc_error_t uvc_set_iris_rel(uvc_device_handle_t *devh, uint8_t iris_rel); + +uvc_error_t uvc_get_zoom_abs(uvc_device_handle_t *devh, uint16_t* focal_length, enum uvc_req_code req_code); +uvc_error_t uvc_set_zoom_abs(uvc_device_handle_t *devh, uint16_t focal_length); + +uvc_error_t uvc_get_zoom_rel(uvc_device_handle_t *devh, int8_t* zoom_rel, uint8_t* digital_zoom, uint8_t* speed, enum uvc_req_code req_code); +uvc_error_t uvc_set_zoom_rel(uvc_device_handle_t *devh, int8_t zoom_rel, uint8_t digital_zoom, uint8_t speed); + +uvc_error_t uvc_get_pantilt_abs(uvc_device_handle_t *devh, int32_t* pan, int32_t* tilt, enum uvc_req_code req_code); +uvc_error_t uvc_set_pantilt_abs(uvc_device_handle_t *devh, int32_t pan, int32_t tilt); + +uvc_error_t uvc_get_pantilt_rel(uvc_device_handle_t *devh, int8_t* pan_rel, uint8_t* pan_speed, int8_t* tilt_rel, uint8_t* tilt_speed, enum uvc_req_code req_code); +uvc_error_t uvc_set_pantilt_rel(uvc_device_handle_t *devh, int8_t pan_rel, uint8_t pan_speed, int8_t tilt_rel, uint8_t tilt_speed); + +uvc_error_t uvc_get_roll_abs(uvc_device_handle_t *devh, int16_t* roll, enum uvc_req_code req_code); +uvc_error_t uvc_set_roll_abs(uvc_device_handle_t *devh, int16_t roll); + +uvc_error_t uvc_get_roll_rel(uvc_device_handle_t *devh, int8_t* roll_rel, uint8_t* speed, enum uvc_req_code req_code); +uvc_error_t uvc_set_roll_rel(uvc_device_handle_t *devh, int8_t roll_rel, uint8_t speed); + +uvc_error_t uvc_get_privacy(uvc_device_handle_t *devh, uint8_t* privacy, enum uvc_req_code req_code); +uvc_error_t uvc_set_privacy(uvc_device_handle_t *devh, uint8_t privacy); + +uvc_error_t uvc_get_digital_window(uvc_device_handle_t *devh, uint16_t* window_top, uint16_t* window_left, uint16_t* window_bottom, uint16_t* window_right, uint16_t* num_steps, uint16_t* num_steps_units, enum uvc_req_code req_code); +uvc_error_t uvc_set_digital_window(uvc_device_handle_t *devh, uint16_t window_top, uint16_t window_left, uint16_t window_bottom, uint16_t window_right, uint16_t num_steps, uint16_t num_steps_units); + +uvc_error_t uvc_get_digital_roi(uvc_device_handle_t *devh, uint16_t* roi_top, uint16_t* roi_left, uint16_t* roi_bottom, uint16_t* roi_right, uint16_t* auto_controls, enum uvc_req_code req_code); +uvc_error_t uvc_set_digital_roi(uvc_device_handle_t *devh, uint16_t roi_top, uint16_t roi_left, uint16_t roi_bottom, uint16_t roi_right, uint16_t auto_controls); + +uvc_error_t uvc_get_backlight_compensation(uvc_device_handle_t *devh, uint16_t* backlight_compensation, enum uvc_req_code req_code); +uvc_error_t uvc_set_backlight_compensation(uvc_device_handle_t *devh, uint16_t backlight_compensation); + +uvc_error_t uvc_get_brightness(uvc_device_handle_t *devh, int16_t* brightness, enum uvc_req_code req_code); +uvc_error_t uvc_set_brightness(uvc_device_handle_t *devh, int16_t brightness); + +uvc_error_t uvc_get_contrast(uvc_device_handle_t *devh, uint16_t* contrast, enum uvc_req_code req_code); +uvc_error_t uvc_set_contrast(uvc_device_handle_t *devh, uint16_t contrast); + +uvc_error_t uvc_get_contrast_auto(uvc_device_handle_t *devh, uint8_t* contrast_auto, enum uvc_req_code req_code); +uvc_error_t uvc_set_contrast_auto(uvc_device_handle_t *devh, uint8_t contrast_auto); + +uvc_error_t uvc_get_gain(uvc_device_handle_t *devh, uint16_t* gain, enum uvc_req_code req_code); +uvc_error_t uvc_set_gain(uvc_device_handle_t *devh, uint16_t gain); + +uvc_error_t uvc_get_power_line_frequency(uvc_device_handle_t *devh, uint8_t* power_line_frequency, enum uvc_req_code req_code); +uvc_error_t uvc_set_power_line_frequency(uvc_device_handle_t *devh, uint8_t power_line_frequency); + +uvc_error_t uvc_get_hue(uvc_device_handle_t *devh, int16_t* hue, enum uvc_req_code req_code); +uvc_error_t uvc_set_hue(uvc_device_handle_t *devh, int16_t hue); + +uvc_error_t uvc_get_hue_auto(uvc_device_handle_t *devh, uint8_t* hue_auto, enum uvc_req_code req_code); +uvc_error_t uvc_set_hue_auto(uvc_device_handle_t *devh, uint8_t hue_auto); + +uvc_error_t uvc_get_saturation(uvc_device_handle_t *devh, uint16_t* saturation, enum uvc_req_code req_code); +uvc_error_t uvc_set_saturation(uvc_device_handle_t *devh, uint16_t saturation); + +uvc_error_t uvc_get_sharpness(uvc_device_handle_t *devh, uint16_t* sharpness, enum uvc_req_code req_code); +uvc_error_t uvc_set_sharpness(uvc_device_handle_t *devh, uint16_t sharpness); + +uvc_error_t uvc_get_gamma(uvc_device_handle_t *devh, uint16_t* gamma, enum uvc_req_code req_code); +uvc_error_t uvc_set_gamma(uvc_device_handle_t *devh, uint16_t gamma); + +uvc_error_t uvc_get_white_balance_temperature(uvc_device_handle_t *devh, uint16_t* temperature, enum uvc_req_code req_code); +uvc_error_t uvc_set_white_balance_temperature(uvc_device_handle_t *devh, uint16_t temperature); + +uvc_error_t uvc_get_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t* temperature_auto, enum uvc_req_code req_code); +uvc_error_t uvc_set_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t temperature_auto); + +uvc_error_t uvc_get_white_balance_component(uvc_device_handle_t *devh, uint16_t* blue, uint16_t* red, enum uvc_req_code req_code); +uvc_error_t uvc_set_white_balance_component(uvc_device_handle_t *devh, uint16_t blue, uint16_t red); + +uvc_error_t uvc_get_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t* white_balance_component_auto, enum uvc_req_code req_code); +uvc_error_t uvc_set_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t white_balance_component_auto); + +uvc_error_t uvc_get_digital_multiplier(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code); +uvc_error_t uvc_set_digital_multiplier(uvc_device_handle_t *devh, uint16_t multiplier_step); + +uvc_error_t uvc_get_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code); +uvc_error_t uvc_set_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t multiplier_step); + +uvc_error_t uvc_get_analog_video_standard(uvc_device_handle_t *devh, uint8_t* video_standard, enum uvc_req_code req_code); +uvc_error_t uvc_set_analog_video_standard(uvc_device_handle_t *devh, uint8_t video_standard); + +uvc_error_t uvc_get_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t* status, enum uvc_req_code req_code); +uvc_error_t uvc_set_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t status); + +uvc_error_t uvc_get_input_select(uvc_device_handle_t *devh, uint8_t* selector, enum uvc_req_code req_code); +uvc_error_t uvc_set_input_select(uvc_device_handle_t *devh, uint8_t selector); +/* end AUTO-GENERATED control accessors */ + +void uvc_perror(uvc_error_t err, const char *msg); +const char* uvc_strerror(uvc_error_t err); +void uvc_print_diag(uvc_device_handle_t *devh, FILE *stream); +void uvc_print_stream_ctrl(uvc_stream_ctrl_t *ctrl, FILE *stream); + +uvc_frame_t *uvc_allocate_frame(size_t data_bytes); +void uvc_free_frame(uvc_frame_t *frame); + +uvc_error_t uvc_duplicate_frame(uvc_frame_t *in, uvc_frame_t *out); + +uvc_error_t uvc_yuyv2rgb(uvc_frame_t *in, uvc_frame_t *out); +uvc_error_t uvc_uyvy2rgb(uvc_frame_t *in, uvc_frame_t *out); +uvc_error_t uvc_any2rgb(uvc_frame_t *in, uvc_frame_t *out); + +uvc_error_t uvc_yuyv2bgr(uvc_frame_t *in, uvc_frame_t *out); +uvc_error_t uvc_uyvy2bgr(uvc_frame_t *in, uvc_frame_t *out); +uvc_error_t uvc_any2bgr(uvc_frame_t *in, uvc_frame_t *out); + +uvc_error_t uvc_yuyv2y(uvc_frame_t *in, uvc_frame_t *out); +uvc_error_t uvc_yuyv2uv(uvc_frame_t *in, uvc_frame_t *out); + +#ifdef LIBUVC_HAS_JPEG +uvc_error_t uvc_mjpeg2rgb(uvc_frame_t *in, uvc_frame_t *out); +#endif + +#ifdef __cplusplus +} +#endif + +#endif // !def(LIBUVC_H) +