1 /* This is an AUTO-GENERATED file! Update it with the output of `ctrl-gen.py def`. */
2 #include "libuvc/libuvc.h"
3 #include "libuvc/libuvc_internal.h"
5 static const int REQ_TYPE_SET = 0x21;
6 static const int REQ_TYPE_GET = 0xa1;
9 * @brief Reads the SCANNING_MODE control.
10 * @param devh UVC device handle
11 * @param[out] mode 0: interlaced, 1: progressive
12 * @param req_code UVC_GET_* request to execute
14 uvc_error_t uvc_get_scanning_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code) {
18 ret = libusb_control_transfer(
20 REQ_TYPE_GET, req_code,
21 UVC_CT_SCANNING_MODE_CONTROL << 8,
22 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
27 if (ret == sizeof(data)) {
37 * @brief Sets the SCANNING_MODE control.
38 * @param devh UVC device handle
39 * @param mode 0: interlaced, 1: progressive
41 uvc_error_t uvc_set_scanning_mode(uvc_device_handle_t *devh, uint8_t mode) {
47 ret = libusb_control_transfer(
49 REQ_TYPE_SET, UVC_SET_CUR,
50 UVC_CT_SCANNING_MODE_CONTROL << 8,
51 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
56 if (ret == sizeof(data))
63 * @brief Reads camera's auto-exposure mode.
65 * See uvc_set_ae_mode() for a description of the available modes.
66 * @param devh UVC device handle
67 * @param[out] mode 1: manual mode; 2: auto mode; 4: shutter priority mode; 8: aperture priority mode
68 * @param req_code UVC_GET_* request to execute
70 uvc_error_t uvc_get_ae_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code) {
74 ret = libusb_control_transfer(
76 REQ_TYPE_GET, req_code,
77 UVC_CT_AE_MODE_CONTROL << 8,
78 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
83 if (ret == sizeof(data)) {
93 * @brief Sets camera's auto-exposure mode.
95 * Cameras may support any of the following AE modes:
96 * * UVC_AUTO_EXPOSURE_MODE_MANUAL (1) - manual exposure time, manual iris
97 * * UVC_AUTO_EXPOSURE_MODE_AUTO (2) - auto exposure time, auto iris
98 * * UVC_AUTO_EXPOSURE_MODE_SHUTTER_PRIORITY (4) - manual exposure time, auto iris
99 * * UVC_AUTO_EXPOSURE_MODE_APERTURE_PRIORITY (8) - auto exposure time, manual iris
101 * Most cameras provide manual mode and aperture priority mode.
102 * @param devh UVC device handle
103 * @param mode 1: manual mode; 2: auto mode; 4: shutter priority mode; 8: aperture priority mode
105 uvc_error_t uvc_set_ae_mode(uvc_device_handle_t *devh, uint8_t mode) {
111 ret = libusb_control_transfer(
113 REQ_TYPE_SET, UVC_SET_CUR,
114 UVC_CT_AE_MODE_CONTROL << 8,
115 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
120 if (ret == sizeof(data))
127 * @brief Checks whether the camera may vary the frame rate for exposure control reasons.
128 * See uvc_set_ae_priority() for a description of the `priority` field.
129 * @param devh UVC device handle
130 * @param[out] priority 0: frame rate must remain constant; 1: frame rate may be varied for AE purposes
131 * @param req_code UVC_GET_* request to execute
133 uvc_error_t uvc_get_ae_priority(uvc_device_handle_t *devh, uint8_t* priority, enum uvc_req_code req_code) {
137 ret = libusb_control_transfer(
139 REQ_TYPE_GET, req_code,
140 UVC_CT_AE_PRIORITY_CONTROL << 8,
141 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
146 if (ret == sizeof(data)) {
156 * @brief Chooses whether the camera may vary the frame rate for exposure control reasons.
157 * A `priority` value of zero means the camera may not vary its frame rate. A value of 1
158 * means the frame rate is variable. This setting has no effect outside of the `auto` and
159 * `shutter_priority` auto-exposure modes.
160 * @param devh UVC device handle
161 * @param priority 0: frame rate must remain constant; 1: frame rate may be varied for AE purposes
163 uvc_error_t uvc_set_ae_priority(uvc_device_handle_t *devh, uint8_t priority) {
169 ret = libusb_control_transfer(
171 REQ_TYPE_SET, UVC_SET_CUR,
172 UVC_CT_AE_PRIORITY_CONTROL << 8,
173 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
178 if (ret == sizeof(data))
185 * @brief Gets the absolute exposure time.
187 * See uvc_set_exposure_abs() for a description of the `time` field.
188 * @param devh UVC device handle
190 * @param req_code UVC_GET_* request to execute
192 uvc_error_t uvc_get_exposure_abs(uvc_device_handle_t *devh, uint32_t* time, enum uvc_req_code req_code) {
196 ret = libusb_control_transfer(
198 REQ_TYPE_GET, req_code,
199 UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL << 8,
200 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
205 if (ret == sizeof(data)) {
206 *time = DW_TO_INT(data + 0);
215 * @brief Sets the absolute exposure time.
217 * The `time` parameter should be provided in units of 0.0001 seconds (e.g., use the value 100
218 * for a 10ms exposure period). Auto exposure should be set to `manual` or `shutter_priority`
219 * before attempting to change this setting.
220 * @param devh UVC device handle
223 uvc_error_t uvc_set_exposure_abs(uvc_device_handle_t *devh, uint32_t time) {
227 INT_TO_DW(time, data + 0);
229 ret = libusb_control_transfer(
231 REQ_TYPE_SET, UVC_SET_CUR,
232 UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL << 8,
233 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
238 if (ret == sizeof(data))
245 * @brief Reads the exposure time relative to the current setting.
246 * @param devh UVC device handle
247 * @param[out] step number of steps by which to change the exposure time, or zero to set the default exposure time
248 * @param req_code UVC_GET_* request to execute
250 uvc_error_t uvc_get_exposure_rel(uvc_device_handle_t *devh, int8_t* step, enum uvc_req_code req_code) {
254 ret = libusb_control_transfer(
256 REQ_TYPE_GET, req_code,
257 UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL << 8,
258 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
263 if (ret == sizeof(data)) {
273 * @brief Sets the exposure time relative to the current setting.
274 * @param devh UVC device handle
275 * @param step number of steps by which to change the exposure time, or zero to set the default exposure time
277 uvc_error_t uvc_set_exposure_rel(uvc_device_handle_t *devh, int8_t step) {
283 ret = libusb_control_transfer(
285 REQ_TYPE_SET, UVC_SET_CUR,
286 UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL << 8,
287 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
292 if (ret == sizeof(data))
299 * @brief Reads the distance at which an object is optimally focused.
300 * @param devh UVC device handle
301 * @param[out] focus focal target distance in millimeters
302 * @param req_code UVC_GET_* request to execute
304 uvc_error_t uvc_get_focus_abs(uvc_device_handle_t *devh, uint16_t* focus, enum uvc_req_code req_code) {
308 ret = libusb_control_transfer(
310 REQ_TYPE_GET, req_code,
311 UVC_CT_FOCUS_ABSOLUTE_CONTROL << 8,
312 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
317 if (ret == sizeof(data)) {
318 *focus = SW_TO_SHORT(data + 0);
327 * @brief Sets the distance at which an object is optimally focused.
328 * @param devh UVC device handle
329 * @param focus focal target distance in millimeters
331 uvc_error_t uvc_set_focus_abs(uvc_device_handle_t *devh, uint16_t focus) {
335 SHORT_TO_SW(focus, data + 0);
337 ret = libusb_control_transfer(
339 REQ_TYPE_SET, UVC_SET_CUR,
340 UVC_CT_FOCUS_ABSOLUTE_CONTROL << 8,
341 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
346 if (ret == sizeof(data))
353 * @brief Reads the FOCUS_RELATIVE control.
354 * @param devh UVC device handle
355 * @param[out] focus_rel TODO
356 * @param[out] speed TODO
357 * @param req_code UVC_GET_* request to execute
359 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) {
363 ret = libusb_control_transfer(
365 REQ_TYPE_GET, req_code,
366 UVC_CT_FOCUS_RELATIVE_CONTROL << 8,
367 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
372 if (ret == sizeof(data)) {
373 *focus_rel = data[0];
383 * @brief Sets the FOCUS_RELATIVE control.
384 * @param devh UVC device handle
385 * @param focus_rel TODO
388 uvc_error_t uvc_set_focus_rel(uvc_device_handle_t *devh, int8_t focus_rel, uint8_t speed) {
395 ret = libusb_control_transfer(
397 REQ_TYPE_SET, UVC_SET_CUR,
398 UVC_CT_FOCUS_RELATIVE_CONTROL << 8,
399 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
404 if (ret == sizeof(data))
411 * @brief Reads the FOCUS_SIMPLE control.
412 * @param devh UVC device handle
413 * @param[out] focus TODO
414 * @param req_code UVC_GET_* request to execute
416 uvc_error_t uvc_get_focus_simple_range(uvc_device_handle_t *devh, uint8_t* focus, enum uvc_req_code req_code) {
420 ret = libusb_control_transfer(
422 REQ_TYPE_GET, req_code,
423 UVC_CT_FOCUS_SIMPLE_CONTROL << 8,
424 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
429 if (ret == sizeof(data)) {
439 * @brief Sets the FOCUS_SIMPLE control.
440 * @param devh UVC device handle
443 uvc_error_t uvc_set_focus_simple_range(uvc_device_handle_t *devh, uint8_t focus) {
449 ret = libusb_control_transfer(
451 REQ_TYPE_SET, UVC_SET_CUR,
452 UVC_CT_FOCUS_SIMPLE_CONTROL << 8,
453 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
458 if (ret == sizeof(data))
465 * @brief Reads the FOCUS_AUTO control.
466 * @param devh UVC device handle
467 * @param[out] state TODO
468 * @param req_code UVC_GET_* request to execute
470 uvc_error_t uvc_get_focus_auto(uvc_device_handle_t *devh, uint8_t* state, enum uvc_req_code req_code) {
474 ret = libusb_control_transfer(
476 REQ_TYPE_GET, req_code,
477 UVC_CT_FOCUS_AUTO_CONTROL << 8,
478 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
483 if (ret == sizeof(data)) {
493 * @brief Sets the FOCUS_AUTO control.
494 * @param devh UVC device handle
497 uvc_error_t uvc_set_focus_auto(uvc_device_handle_t *devh, uint8_t state) {
503 ret = libusb_control_transfer(
505 REQ_TYPE_SET, UVC_SET_CUR,
506 UVC_CT_FOCUS_AUTO_CONTROL << 8,
507 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
512 if (ret == sizeof(data))
519 * @brief Reads the IRIS_ABSOLUTE control.
520 * @param devh UVC device handle
521 * @param[out] iris TODO
522 * @param req_code UVC_GET_* request to execute
524 uvc_error_t uvc_get_iris_abs(uvc_device_handle_t *devh, uint16_t* iris, enum uvc_req_code req_code) {
528 ret = libusb_control_transfer(
530 REQ_TYPE_GET, req_code,
531 UVC_CT_IRIS_ABSOLUTE_CONTROL << 8,
532 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
537 if (ret == sizeof(data)) {
538 *iris = SW_TO_SHORT(data + 0);
547 * @brief Sets the IRIS_ABSOLUTE control.
548 * @param devh UVC device handle
551 uvc_error_t uvc_set_iris_abs(uvc_device_handle_t *devh, uint16_t iris) {
555 SHORT_TO_SW(iris, data + 0);
557 ret = libusb_control_transfer(
559 REQ_TYPE_SET, UVC_SET_CUR,
560 UVC_CT_IRIS_ABSOLUTE_CONTROL << 8,
561 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
566 if (ret == sizeof(data))
573 * @brief Reads the IRIS_RELATIVE control.
574 * @param devh UVC device handle
575 * @param[out] iris_rel TODO
576 * @param req_code UVC_GET_* request to execute
578 uvc_error_t uvc_get_iris_rel(uvc_device_handle_t *devh, uint8_t* iris_rel, enum uvc_req_code req_code) {
582 ret = libusb_control_transfer(
584 REQ_TYPE_GET, req_code,
585 UVC_CT_IRIS_RELATIVE_CONTROL << 8,
586 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
591 if (ret == sizeof(data)) {
601 * @brief Sets the IRIS_RELATIVE control.
602 * @param devh UVC device handle
603 * @param iris_rel TODO
605 uvc_error_t uvc_set_iris_rel(uvc_device_handle_t *devh, uint8_t iris_rel) {
611 ret = libusb_control_transfer(
613 REQ_TYPE_SET, UVC_SET_CUR,
614 UVC_CT_IRIS_RELATIVE_CONTROL << 8,
615 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
620 if (ret == sizeof(data))
627 * @brief Reads the ZOOM_ABSOLUTE control.
628 * @param devh UVC device handle
629 * @param[out] focal_length TODO
630 * @param req_code UVC_GET_* request to execute
632 uvc_error_t uvc_get_zoom_abs(uvc_device_handle_t *devh, uint16_t* focal_length, enum uvc_req_code req_code) {
636 ret = libusb_control_transfer(
638 REQ_TYPE_GET, req_code,
639 UVC_CT_ZOOM_ABSOLUTE_CONTROL << 8,
640 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
645 if (ret == sizeof(data)) {
646 *focal_length = SW_TO_SHORT(data + 0);
655 * @brief Sets the ZOOM_ABSOLUTE control.
656 * @param devh UVC device handle
657 * @param focal_length TODO
659 uvc_error_t uvc_set_zoom_abs(uvc_device_handle_t *devh, uint16_t focal_length) {
663 SHORT_TO_SW(focal_length, data + 0);
665 ret = libusb_control_transfer(
667 REQ_TYPE_SET, UVC_SET_CUR,
668 UVC_CT_ZOOM_ABSOLUTE_CONTROL << 8,
669 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
674 if (ret == sizeof(data))
681 * @brief Reads the ZOOM_RELATIVE control.
682 * @param devh UVC device handle
683 * @param[out] zoom_rel TODO
684 * @param[out] digital_zoom TODO
685 * @param[out] speed TODO
686 * @param req_code UVC_GET_* request to execute
688 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) {
692 ret = libusb_control_transfer(
694 REQ_TYPE_GET, req_code,
695 UVC_CT_ZOOM_RELATIVE_CONTROL << 8,
696 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
701 if (ret == sizeof(data)) {
703 *digital_zoom = data[1];
713 * @brief Sets the ZOOM_RELATIVE control.
714 * @param devh UVC device handle
715 * @param zoom_rel TODO
716 * @param digital_zoom TODO
719 uvc_error_t uvc_set_zoom_rel(uvc_device_handle_t *devh, int8_t zoom_rel, uint8_t digital_zoom, uint8_t speed) {
724 data[1] = digital_zoom;
727 ret = libusb_control_transfer(
729 REQ_TYPE_SET, UVC_SET_CUR,
730 UVC_CT_ZOOM_RELATIVE_CONTROL << 8,
731 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
736 if (ret == sizeof(data))
743 * @brief Reads the PANTILT_ABSOLUTE control.
744 * @param devh UVC device handle
745 * @param[out] pan TODO
746 * @param[out] tilt TODO
747 * @param req_code UVC_GET_* request to execute
749 uvc_error_t uvc_get_pantilt_abs(uvc_device_handle_t *devh, int32_t* pan, int32_t* tilt, enum uvc_req_code req_code) {
753 ret = libusb_control_transfer(
755 REQ_TYPE_GET, req_code,
756 UVC_CT_PANTILT_ABSOLUTE_CONTROL << 8,
757 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
762 if (ret == sizeof(data)) {
763 *pan = DW_TO_INT(data + 0);
764 *tilt = DW_TO_INT(data + 4);
773 * @brief Sets the PANTILT_ABSOLUTE control.
774 * @param devh UVC device handle
778 uvc_error_t uvc_set_pantilt_abs(uvc_device_handle_t *devh, int32_t pan, int32_t tilt) {
782 INT_TO_DW(pan, data + 0);
783 INT_TO_DW(tilt, data + 4);
785 ret = libusb_control_transfer(
787 REQ_TYPE_SET, UVC_SET_CUR,
788 UVC_CT_PANTILT_ABSOLUTE_CONTROL << 8,
789 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
794 if (ret == sizeof(data))
801 * @brief Reads the PANTILT_RELATIVE control.
802 * @param devh UVC device handle
803 * @param[out] pan_rel TODO
804 * @param[out] pan_speed TODO
805 * @param[out] tilt_rel TODO
806 * @param[out] tilt_speed TODO
807 * @param req_code UVC_GET_* request to execute
809 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) {
813 ret = libusb_control_transfer(
815 REQ_TYPE_GET, req_code,
816 UVC_CT_PANTILT_RELATIVE_CONTROL << 8,
817 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
822 if (ret == sizeof(data)) {
824 *pan_speed = data[1];
826 *tilt_speed = data[3];
835 * @brief Sets the PANTILT_RELATIVE control.
836 * @param devh UVC device handle
837 * @param pan_rel TODO
838 * @param pan_speed TODO
839 * @param tilt_rel TODO
840 * @param tilt_speed TODO
842 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) {
849 data[3] = tilt_speed;
851 ret = libusb_control_transfer(
853 REQ_TYPE_SET, UVC_SET_CUR,
854 UVC_CT_PANTILT_RELATIVE_CONTROL << 8,
855 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
860 if (ret == sizeof(data))
867 * @brief Reads the ROLL_ABSOLUTE control.
868 * @param devh UVC device handle
869 * @param[out] roll TODO
870 * @param req_code UVC_GET_* request to execute
872 uvc_error_t uvc_get_roll_abs(uvc_device_handle_t *devh, int16_t* roll, enum uvc_req_code req_code) {
876 ret = libusb_control_transfer(
878 REQ_TYPE_GET, req_code,
879 UVC_CT_ROLL_ABSOLUTE_CONTROL << 8,
880 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
885 if (ret == sizeof(data)) {
886 *roll = SW_TO_SHORT(data + 0);
895 * @brief Sets the ROLL_ABSOLUTE control.
896 * @param devh UVC device handle
899 uvc_error_t uvc_set_roll_abs(uvc_device_handle_t *devh, int16_t roll) {
903 SHORT_TO_SW(roll, data + 0);
905 ret = libusb_control_transfer(
907 REQ_TYPE_SET, UVC_SET_CUR,
908 UVC_CT_ROLL_ABSOLUTE_CONTROL << 8,
909 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
914 if (ret == sizeof(data))
921 * @brief Reads the ROLL_RELATIVE control.
922 * @param devh UVC device handle
923 * @param[out] roll_rel TODO
924 * @param[out] speed TODO
925 * @param req_code UVC_GET_* request to execute
927 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) {
931 ret = libusb_control_transfer(
933 REQ_TYPE_GET, req_code,
934 UVC_CT_ROLL_RELATIVE_CONTROL << 8,
935 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
940 if (ret == sizeof(data)) {
951 * @brief Sets the ROLL_RELATIVE control.
952 * @param devh UVC device handle
953 * @param roll_rel TODO
956 uvc_error_t uvc_set_roll_rel(uvc_device_handle_t *devh, int8_t roll_rel, uint8_t speed) {
963 ret = libusb_control_transfer(
965 REQ_TYPE_SET, UVC_SET_CUR,
966 UVC_CT_ROLL_RELATIVE_CONTROL << 8,
967 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
972 if (ret == sizeof(data))
979 * @brief Reads the PRIVACY control.
980 * @param devh UVC device handle
981 * @param[out] privacy TODO
982 * @param req_code UVC_GET_* request to execute
984 uvc_error_t uvc_get_privacy(uvc_device_handle_t *devh, uint8_t* privacy, enum uvc_req_code req_code) {
988 ret = libusb_control_transfer(
990 REQ_TYPE_GET, req_code,
991 UVC_CT_PRIVACY_CONTROL << 8,
992 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
997 if (ret == sizeof(data)) {
1007 * @brief Sets the PRIVACY control.
1008 * @param devh UVC device handle
1009 * @param privacy TODO
1011 uvc_error_t uvc_set_privacy(uvc_device_handle_t *devh, uint8_t privacy) {
1017 ret = libusb_control_transfer(
1019 REQ_TYPE_SET, UVC_SET_CUR,
1020 UVC_CT_PRIVACY_CONTROL << 8,
1021 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1026 if (ret == sizeof(data))
1033 * @brief Reads the DIGITAL_WINDOW control.
1034 * @param devh UVC device handle
1035 * @param[out] window_top TODO
1036 * @param[out] window_left TODO
1037 * @param[out] window_bottom TODO
1038 * @param[out] window_right TODO
1039 * @param[out] num_steps TODO
1040 * @param[out] num_steps_units TODO
1041 * @param req_code UVC_GET_* request to execute
1043 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) {
1047 ret = libusb_control_transfer(
1049 REQ_TYPE_GET, req_code,
1050 UVC_CT_DIGITAL_WINDOW_CONTROL << 8,
1051 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1056 if (ret == sizeof(data)) {
1057 *window_top = SW_TO_SHORT(data + 0);
1058 *window_left = SW_TO_SHORT(data + 2);
1059 *window_bottom = SW_TO_SHORT(data + 4);
1060 *window_right = SW_TO_SHORT(data + 6);
1061 *num_steps = SW_TO_SHORT(data + 8);
1062 *num_steps_units = SW_TO_SHORT(data + 10);
1071 * @brief Sets the DIGITAL_WINDOW control.
1072 * @param devh UVC device handle
1073 * @param window_top TODO
1074 * @param window_left TODO
1075 * @param window_bottom TODO
1076 * @param window_right TODO
1077 * @param num_steps TODO
1078 * @param num_steps_units TODO
1080 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) {
1084 SHORT_TO_SW(window_top, data + 0);
1085 SHORT_TO_SW(window_left, data + 2);
1086 SHORT_TO_SW(window_bottom, data + 4);
1087 SHORT_TO_SW(window_right, data + 6);
1088 SHORT_TO_SW(num_steps, data + 8);
1089 SHORT_TO_SW(num_steps_units, data + 10);
1091 ret = libusb_control_transfer(
1093 REQ_TYPE_SET, UVC_SET_CUR,
1094 UVC_CT_DIGITAL_WINDOW_CONTROL << 8,
1095 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1100 if (ret == sizeof(data))
1107 * @brief Reads the REGION_OF_INTEREST control.
1108 * @param devh UVC device handle
1109 * @param[out] roi_top TODO
1110 * @param[out] roi_left TODO
1111 * @param[out] roi_bottom TODO
1112 * @param[out] roi_right TODO
1113 * @param[out] auto_controls TODO
1114 * @param req_code UVC_GET_* request to execute
1116 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) {
1120 ret = libusb_control_transfer(
1122 REQ_TYPE_GET, req_code,
1123 UVC_CT_REGION_OF_INTEREST_CONTROL << 8,
1124 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1129 if (ret == sizeof(data)) {
1130 *roi_top = SW_TO_SHORT(data + 0);
1131 *roi_left = SW_TO_SHORT(data + 2);
1132 *roi_bottom = SW_TO_SHORT(data + 4);
1133 *roi_right = SW_TO_SHORT(data + 6);
1134 *auto_controls = SW_TO_SHORT(data + 8);
1143 * @brief Sets the REGION_OF_INTEREST control.
1144 * @param devh UVC device handle
1145 * @param roi_top TODO
1146 * @param roi_left TODO
1147 * @param roi_bottom TODO
1148 * @param roi_right TODO
1149 * @param auto_controls TODO
1151 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) {
1155 SHORT_TO_SW(roi_top, data + 0);
1156 SHORT_TO_SW(roi_left, data + 2);
1157 SHORT_TO_SW(roi_bottom, data + 4);
1158 SHORT_TO_SW(roi_right, data + 6);
1159 SHORT_TO_SW(auto_controls, data + 8);
1161 ret = libusb_control_transfer(
1163 REQ_TYPE_SET, UVC_SET_CUR,
1164 UVC_CT_REGION_OF_INTEREST_CONTROL << 8,
1165 uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1170 if (ret == sizeof(data))
1177 * @brief Reads the BACKLIGHT_COMPENSATION control.
1178 * @param devh UVC device handle
1179 * @param[out] backlight_compensation device-dependent backlight compensation mode; zero means backlight compensation is disabled
1180 * @param req_code UVC_GET_* request to execute
1182 uvc_error_t uvc_get_backlight_compensation(uvc_device_handle_t *devh, uint16_t* backlight_compensation, enum uvc_req_code req_code) {
1186 ret = libusb_control_transfer(
1188 REQ_TYPE_GET, req_code,
1189 UVC_PU_BACKLIGHT_COMPENSATION_CONTROL << 8,
1190 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1195 if (ret == sizeof(data)) {
1196 *backlight_compensation = SW_TO_SHORT(data + 0);
1205 * @brief Sets the BACKLIGHT_COMPENSATION control.
1206 * @param devh UVC device handle
1207 * @param backlight_compensation device-dependent backlight compensation mode; zero means backlight compensation is disabled
1209 uvc_error_t uvc_set_backlight_compensation(uvc_device_handle_t *devh, uint16_t backlight_compensation) {
1213 SHORT_TO_SW(backlight_compensation, data + 0);
1215 ret = libusb_control_transfer(
1217 REQ_TYPE_SET, UVC_SET_CUR,
1218 UVC_PU_BACKLIGHT_COMPENSATION_CONTROL << 8,
1219 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1224 if (ret == sizeof(data))
1231 * @brief Reads the BRIGHTNESS control.
1232 * @param devh UVC device handle
1233 * @param[out] brightness TODO
1234 * @param req_code UVC_GET_* request to execute
1236 uvc_error_t uvc_get_brightness(uvc_device_handle_t *devh, int16_t* brightness, enum uvc_req_code req_code) {
1240 ret = libusb_control_transfer(
1242 REQ_TYPE_GET, req_code,
1243 UVC_PU_BRIGHTNESS_CONTROL << 8,
1244 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1249 if (ret == sizeof(data)) {
1250 *brightness = SW_TO_SHORT(data + 0);
1259 * @brief Sets the BRIGHTNESS control.
1260 * @param devh UVC device handle
1261 * @param brightness TODO
1263 uvc_error_t uvc_set_brightness(uvc_device_handle_t *devh, int16_t brightness) {
1267 SHORT_TO_SW(brightness, data + 0);
1269 ret = libusb_control_transfer(
1271 REQ_TYPE_SET, UVC_SET_CUR,
1272 UVC_PU_BRIGHTNESS_CONTROL << 8,
1273 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1278 if (ret == sizeof(data))
1285 * @brief Reads the CONTRAST control.
1286 * @param devh UVC device handle
1287 * @param[out] contrast TODO
1288 * @param req_code UVC_GET_* request to execute
1290 uvc_error_t uvc_get_contrast(uvc_device_handle_t *devh, uint16_t* contrast, enum uvc_req_code req_code) {
1294 ret = libusb_control_transfer(
1296 REQ_TYPE_GET, req_code,
1297 UVC_PU_CONTRAST_CONTROL << 8,
1298 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1303 if (ret == sizeof(data)) {
1304 *contrast = SW_TO_SHORT(data + 0);
1313 * @brief Sets the CONTRAST control.
1314 * @param devh UVC device handle
1315 * @param contrast TODO
1317 uvc_error_t uvc_set_contrast(uvc_device_handle_t *devh, uint16_t contrast) {
1321 SHORT_TO_SW(contrast, data + 0);
1323 ret = libusb_control_transfer(
1325 REQ_TYPE_SET, UVC_SET_CUR,
1326 UVC_PU_CONTRAST_CONTROL << 8,
1327 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1332 if (ret == sizeof(data))
1339 * @brief Reads the CONTRAST_AUTO control.
1340 * @param devh UVC device handle
1341 * @param[out] contrast_auto TODO
1342 * @param req_code UVC_GET_* request to execute
1344 uvc_error_t uvc_get_contrast_auto(uvc_device_handle_t *devh, uint8_t* contrast_auto, enum uvc_req_code req_code) {
1348 ret = libusb_control_transfer(
1350 REQ_TYPE_GET, req_code,
1351 UVC_PU_CONTRAST_AUTO_CONTROL << 8,
1352 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1357 if (ret == sizeof(data)) {
1358 *contrast_auto = data[0];
1367 * @brief Sets the CONTRAST_AUTO control.
1368 * @param devh UVC device handle
1369 * @param contrast_auto TODO
1371 uvc_error_t uvc_set_contrast_auto(uvc_device_handle_t *devh, uint8_t contrast_auto) {
1375 data[0] = contrast_auto;
1377 ret = libusb_control_transfer(
1379 REQ_TYPE_SET, UVC_SET_CUR,
1380 UVC_PU_CONTRAST_AUTO_CONTROL << 8,
1381 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1386 if (ret == sizeof(data))
1393 * @brief Reads the GAIN control.
1394 * @param devh UVC device handle
1395 * @param[out] gain TODO
1396 * @param req_code UVC_GET_* request to execute
1398 uvc_error_t uvc_get_gain(uvc_device_handle_t *devh, uint16_t* gain, enum uvc_req_code req_code) {
1402 ret = libusb_control_transfer(
1404 REQ_TYPE_GET, req_code,
1405 UVC_PU_GAIN_CONTROL << 8,
1406 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1411 if (ret == sizeof(data)) {
1412 *gain = SW_TO_SHORT(data + 0);
1421 * @brief Sets the GAIN control.
1422 * @param devh UVC device handle
1425 uvc_error_t uvc_set_gain(uvc_device_handle_t *devh, uint16_t gain) {
1429 SHORT_TO_SW(gain, data + 0);
1431 ret = libusb_control_transfer(
1433 REQ_TYPE_SET, UVC_SET_CUR,
1434 UVC_PU_GAIN_CONTROL << 8,
1435 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1440 if (ret == sizeof(data))
1447 * @brief Reads the POWER_LINE_FREQUENCY control.
1448 * @param devh UVC device handle
1449 * @param[out] power_line_frequency TODO
1450 * @param req_code UVC_GET_* request to execute
1452 uvc_error_t uvc_get_power_line_frequency(uvc_device_handle_t *devh, uint8_t* power_line_frequency, enum uvc_req_code req_code) {
1456 ret = libusb_control_transfer(
1458 REQ_TYPE_GET, req_code,
1459 UVC_PU_POWER_LINE_FREQUENCY_CONTROL << 8,
1460 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1465 if (ret == sizeof(data)) {
1466 *power_line_frequency = data[0];
1475 * @brief Sets the POWER_LINE_FREQUENCY control.
1476 * @param devh UVC device handle
1477 * @param power_line_frequency TODO
1479 uvc_error_t uvc_set_power_line_frequency(uvc_device_handle_t *devh, uint8_t power_line_frequency) {
1483 data[0] = power_line_frequency;
1485 ret = libusb_control_transfer(
1487 REQ_TYPE_SET, UVC_SET_CUR,
1488 UVC_PU_POWER_LINE_FREQUENCY_CONTROL << 8,
1489 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1494 if (ret == sizeof(data))
1501 * @brief Reads the HUE control.
1502 * @param devh UVC device handle
1503 * @param[out] hue TODO
1504 * @param req_code UVC_GET_* request to execute
1506 uvc_error_t uvc_get_hue(uvc_device_handle_t *devh, int16_t* hue, enum uvc_req_code req_code) {
1510 ret = libusb_control_transfer(
1512 REQ_TYPE_GET, req_code,
1513 UVC_PU_HUE_CONTROL << 8,
1514 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1519 if (ret == sizeof(data)) {
1520 *hue = SW_TO_SHORT(data + 0);
1529 * @brief Sets the HUE control.
1530 * @param devh UVC device handle
1533 uvc_error_t uvc_set_hue(uvc_device_handle_t *devh, int16_t hue) {
1537 SHORT_TO_SW(hue, data + 0);
1539 ret = libusb_control_transfer(
1541 REQ_TYPE_SET, UVC_SET_CUR,
1542 UVC_PU_HUE_CONTROL << 8,
1543 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1548 if (ret == sizeof(data))
1555 * @brief Reads the HUE_AUTO control.
1556 * @param devh UVC device handle
1557 * @param[out] hue_auto TODO
1558 * @param req_code UVC_GET_* request to execute
1560 uvc_error_t uvc_get_hue_auto(uvc_device_handle_t *devh, uint8_t* hue_auto, enum uvc_req_code req_code) {
1564 ret = libusb_control_transfer(
1566 REQ_TYPE_GET, req_code,
1567 UVC_PU_HUE_AUTO_CONTROL << 8,
1568 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1573 if (ret == sizeof(data)) {
1574 *hue_auto = data[0];
1583 * @brief Sets the HUE_AUTO control.
1584 * @param devh UVC device handle
1585 * @param hue_auto TODO
1587 uvc_error_t uvc_set_hue_auto(uvc_device_handle_t *devh, uint8_t hue_auto) {
1593 ret = libusb_control_transfer(
1595 REQ_TYPE_SET, UVC_SET_CUR,
1596 UVC_PU_HUE_AUTO_CONTROL << 8,
1597 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1602 if (ret == sizeof(data))
1609 * @brief Reads the SATURATION control.
1610 * @param devh UVC device handle
1611 * @param[out] saturation TODO
1612 * @param req_code UVC_GET_* request to execute
1614 uvc_error_t uvc_get_saturation(uvc_device_handle_t *devh, uint16_t* saturation, enum uvc_req_code req_code) {
1618 ret = libusb_control_transfer(
1620 REQ_TYPE_GET, req_code,
1621 UVC_PU_SATURATION_CONTROL << 8,
1622 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1627 if (ret == sizeof(data)) {
1628 *saturation = SW_TO_SHORT(data + 0);
1637 * @brief Sets the SATURATION control.
1638 * @param devh UVC device handle
1639 * @param saturation TODO
1641 uvc_error_t uvc_set_saturation(uvc_device_handle_t *devh, uint16_t saturation) {
1645 SHORT_TO_SW(saturation, data + 0);
1647 ret = libusb_control_transfer(
1649 REQ_TYPE_SET, UVC_SET_CUR,
1650 UVC_PU_SATURATION_CONTROL << 8,
1651 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1656 if (ret == sizeof(data))
1663 * @brief Reads the SHARPNESS control.
1664 * @param devh UVC device handle
1665 * @param[out] sharpness TODO
1666 * @param req_code UVC_GET_* request to execute
1668 uvc_error_t uvc_get_sharpness(uvc_device_handle_t *devh, uint16_t* sharpness, enum uvc_req_code req_code) {
1672 ret = libusb_control_transfer(
1674 REQ_TYPE_GET, req_code,
1675 UVC_PU_SHARPNESS_CONTROL << 8,
1676 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1681 if (ret == sizeof(data)) {
1682 *sharpness = SW_TO_SHORT(data + 0);
1691 * @brief Sets the SHARPNESS control.
1692 * @param devh UVC device handle
1693 * @param sharpness TODO
1695 uvc_error_t uvc_set_sharpness(uvc_device_handle_t *devh, uint16_t sharpness) {
1699 SHORT_TO_SW(sharpness, data + 0);
1701 ret = libusb_control_transfer(
1703 REQ_TYPE_SET, UVC_SET_CUR,
1704 UVC_PU_SHARPNESS_CONTROL << 8,
1705 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1710 if (ret == sizeof(data))
1717 * @brief Reads the GAMMA control.
1718 * @param devh UVC device handle
1719 * @param[out] gamma TODO
1720 * @param req_code UVC_GET_* request to execute
1722 uvc_error_t uvc_get_gamma(uvc_device_handle_t *devh, uint16_t* gamma, enum uvc_req_code req_code) {
1726 ret = libusb_control_transfer(
1728 REQ_TYPE_GET, req_code,
1729 UVC_PU_GAMMA_CONTROL << 8,
1730 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1735 if (ret == sizeof(data)) {
1736 *gamma = SW_TO_SHORT(data + 0);
1745 * @brief Sets the GAMMA control.
1746 * @param devh UVC device handle
1749 uvc_error_t uvc_set_gamma(uvc_device_handle_t *devh, uint16_t gamma) {
1753 SHORT_TO_SW(gamma, data + 0);
1755 ret = libusb_control_transfer(
1757 REQ_TYPE_SET, UVC_SET_CUR,
1758 UVC_PU_GAMMA_CONTROL << 8,
1759 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1764 if (ret == sizeof(data))
1771 * @brief Reads the WHITE_BALANCE_TEMPERATURE control.
1772 * @param devh UVC device handle
1773 * @param[out] temperature TODO
1774 * @param req_code UVC_GET_* request to execute
1776 uvc_error_t uvc_get_white_balance_temperature(uvc_device_handle_t *devh, uint16_t* temperature, enum uvc_req_code req_code) {
1780 ret = libusb_control_transfer(
1782 REQ_TYPE_GET, req_code,
1783 UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL << 8,
1784 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1789 if (ret == sizeof(data)) {
1790 *temperature = SW_TO_SHORT(data + 0);
1799 * @brief Sets the WHITE_BALANCE_TEMPERATURE control.
1800 * @param devh UVC device handle
1801 * @param temperature TODO
1803 uvc_error_t uvc_set_white_balance_temperature(uvc_device_handle_t *devh, uint16_t temperature) {
1807 SHORT_TO_SW(temperature, data + 0);
1809 ret = libusb_control_transfer(
1811 REQ_TYPE_SET, UVC_SET_CUR,
1812 UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL << 8,
1813 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1818 if (ret == sizeof(data))
1825 * @brief Reads the WHITE_BALANCE_TEMPERATURE_AUTO control.
1826 * @param devh UVC device handle
1827 * @param[out] temperature_auto TODO
1828 * @param req_code UVC_GET_* request to execute
1830 uvc_error_t uvc_get_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t* temperature_auto, enum uvc_req_code req_code) {
1834 ret = libusb_control_transfer(
1836 REQ_TYPE_GET, req_code,
1837 UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL << 8,
1838 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1843 if (ret == sizeof(data)) {
1844 *temperature_auto = data[0];
1853 * @brief Sets the WHITE_BALANCE_TEMPERATURE_AUTO control.
1854 * @param devh UVC device handle
1855 * @param temperature_auto TODO
1857 uvc_error_t uvc_set_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t temperature_auto) {
1861 data[0] = temperature_auto;
1863 ret = libusb_control_transfer(
1865 REQ_TYPE_SET, UVC_SET_CUR,
1866 UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL << 8,
1867 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1872 if (ret == sizeof(data))
1879 * @brief Reads the WHITE_BALANCE_COMPONENT control.
1880 * @param devh UVC device handle
1881 * @param[out] blue TODO
1882 * @param[out] red TODO
1883 * @param req_code UVC_GET_* request to execute
1885 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) {
1889 ret = libusb_control_transfer(
1891 REQ_TYPE_GET, req_code,
1892 UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL << 8,
1893 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1898 if (ret == sizeof(data)) {
1899 *blue = SW_TO_SHORT(data + 0);
1900 *red = SW_TO_SHORT(data + 2);
1909 * @brief Sets the WHITE_BALANCE_COMPONENT control.
1910 * @param devh UVC device handle
1914 uvc_error_t uvc_set_white_balance_component(uvc_device_handle_t *devh, uint16_t blue, uint16_t red) {
1918 SHORT_TO_SW(blue, data + 0);
1919 SHORT_TO_SW(red, data + 2);
1921 ret = libusb_control_transfer(
1923 REQ_TYPE_SET, UVC_SET_CUR,
1924 UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL << 8,
1925 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1930 if (ret == sizeof(data))
1937 * @brief Reads the WHITE_BALANCE_COMPONENT_AUTO control.
1938 * @param devh UVC device handle
1939 * @param[out] white_balance_component_auto TODO
1940 * @param req_code UVC_GET_* request to execute
1942 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) {
1946 ret = libusb_control_transfer(
1948 REQ_TYPE_GET, req_code,
1949 UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL << 8,
1950 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1955 if (ret == sizeof(data)) {
1956 *white_balance_component_auto = data[0];
1965 * @brief Sets the WHITE_BALANCE_COMPONENT_AUTO control.
1966 * @param devh UVC device handle
1967 * @param white_balance_component_auto TODO
1969 uvc_error_t uvc_set_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t white_balance_component_auto) {
1973 data[0] = white_balance_component_auto;
1975 ret = libusb_control_transfer(
1977 REQ_TYPE_SET, UVC_SET_CUR,
1978 UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL << 8,
1979 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
1984 if (ret == sizeof(data))
1991 * @brief Reads the DIGITAL_MULTIPLIER control.
1992 * @param devh UVC device handle
1993 * @param[out] multiplier_step TODO
1994 * @param req_code UVC_GET_* request to execute
1996 uvc_error_t uvc_get_digital_multiplier(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code) {
2000 ret = libusb_control_transfer(
2002 REQ_TYPE_GET, req_code,
2003 UVC_PU_DIGITAL_MULTIPLIER_CONTROL << 8,
2004 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2009 if (ret == sizeof(data)) {
2010 *multiplier_step = SW_TO_SHORT(data + 0);
2019 * @brief Sets the DIGITAL_MULTIPLIER control.
2020 * @param devh UVC device handle
2021 * @param multiplier_step TODO
2023 uvc_error_t uvc_set_digital_multiplier(uvc_device_handle_t *devh, uint16_t multiplier_step) {
2027 SHORT_TO_SW(multiplier_step, data + 0);
2029 ret = libusb_control_transfer(
2031 REQ_TYPE_SET, UVC_SET_CUR,
2032 UVC_PU_DIGITAL_MULTIPLIER_CONTROL << 8,
2033 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2038 if (ret == sizeof(data))
2045 * @brief Reads the DIGITAL_MULTIPLIER_LIMIT control.
2046 * @param devh UVC device handle
2047 * @param[out] multiplier_step TODO
2048 * @param req_code UVC_GET_* request to execute
2050 uvc_error_t uvc_get_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code) {
2054 ret = libusb_control_transfer(
2056 REQ_TYPE_GET, req_code,
2057 UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL << 8,
2058 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2063 if (ret == sizeof(data)) {
2064 *multiplier_step = SW_TO_SHORT(data + 0);
2073 * @brief Sets the DIGITAL_MULTIPLIER_LIMIT control.
2074 * @param devh UVC device handle
2075 * @param multiplier_step TODO
2077 uvc_error_t uvc_set_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t multiplier_step) {
2081 SHORT_TO_SW(multiplier_step, data + 0);
2083 ret = libusb_control_transfer(
2085 REQ_TYPE_SET, UVC_SET_CUR,
2086 UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL << 8,
2087 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2092 if (ret == sizeof(data))
2099 * @brief Reads the ANALOG_VIDEO_STANDARD control.
2100 * @param devh UVC device handle
2101 * @param[out] video_standard TODO
2102 * @param req_code UVC_GET_* request to execute
2104 uvc_error_t uvc_get_analog_video_standard(uvc_device_handle_t *devh, uint8_t* video_standard, enum uvc_req_code req_code) {
2108 ret = libusb_control_transfer(
2110 REQ_TYPE_GET, req_code,
2111 UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL << 8,
2112 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2117 if (ret == sizeof(data)) {
2118 *video_standard = data[0];
2127 * @brief Sets the ANALOG_VIDEO_STANDARD control.
2128 * @param devh UVC device handle
2129 * @param video_standard TODO
2131 uvc_error_t uvc_set_analog_video_standard(uvc_device_handle_t *devh, uint8_t video_standard) {
2135 data[0] = video_standard;
2137 ret = libusb_control_transfer(
2139 REQ_TYPE_SET, UVC_SET_CUR,
2140 UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL << 8,
2141 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2146 if (ret == sizeof(data))
2153 * @brief Reads the ANALOG_LOCK_STATUS control.
2154 * @param devh UVC device handle
2155 * @param[out] status TODO
2156 * @param req_code UVC_GET_* request to execute
2158 uvc_error_t uvc_get_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t* status, enum uvc_req_code req_code) {
2162 ret = libusb_control_transfer(
2164 REQ_TYPE_GET, req_code,
2165 UVC_PU_ANALOG_LOCK_STATUS_CONTROL << 8,
2166 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2171 if (ret == sizeof(data)) {
2181 * @brief Sets the ANALOG_LOCK_STATUS control.
2182 * @param devh UVC device handle
2183 * @param status TODO
2185 uvc_error_t uvc_set_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t status) {
2191 ret = libusb_control_transfer(
2193 REQ_TYPE_SET, UVC_SET_CUR,
2194 UVC_PU_ANALOG_LOCK_STATUS_CONTROL << 8,
2195 uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2200 if (ret == sizeof(data))
2207 * @brief Reads the INPUT_SELECT control.
2208 * @param devh UVC device handle
2209 * @param[out] selector TODO
2210 * @param req_code UVC_GET_* request to execute
2212 uvc_error_t uvc_get_input_select(uvc_device_handle_t *devh, uint8_t* selector, enum uvc_req_code req_code) {
2216 ret = libusb_control_transfer(
2218 REQ_TYPE_GET, req_code,
2219 UVC_SU_INPUT_SELECT_CONTROL << 8,
2220 uvc_get_selector_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2225 if (ret == sizeof(data)) {
2226 *selector = data[0];
2235 * @brief Sets the INPUT_SELECT control.
2236 * @param devh UVC device handle
2237 * @param selector TODO
2239 uvc_error_t uvc_set_input_select(uvc_device_handle_t *devh, uint8_t selector) {
2245 ret = libusb_control_transfer(
2247 REQ_TYPE_SET, UVC_SET_CUR,
2248 UVC_SU_INPUT_SELECT_CONTROL << 8,
2249 uvc_get_selector_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
2254 if (ret == sizeof(data))