1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 fn extract_bit(byte: u8, index: usize) -> bool {
20 let bit_index = if cfg!(target_endian = "big") {
21 7 - (index % 8)
22 } else {
23 index % 8
24 };
25 let mask = 1 << bit_index;
26 byte & mask == mask
27 }
28 #[inline]
29 pub fn get_bit(&self, index: usize) -> bool {
30 debug_assert!(index / 8 < self.storage.as_ref().len());
31 let byte_index = index / 8;
32 let byte = self.storage.as_ref()[byte_index];
33 Self::extract_bit(byte, index)
34 }
35 #[inline]
36 pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
37 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
38 let byte_index = index / 8;
39 let byte = unsafe {
40 *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
41 };
42 Self::extract_bit(byte, index)
43 }
44 #[inline]
45 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
46 let bit_index = if cfg!(target_endian = "big") {
47 7 - (index % 8)
48 } else {
49 index % 8
50 };
51 let mask = 1 << bit_index;
52 if val { byte | mask } else { byte & !mask }
53 }
54 #[inline]
55 pub fn set_bit(&mut self, index: usize, val: bool) {
56 debug_assert!(index / 8 < self.storage.as_ref().len());
57 let byte_index = index / 8;
58 let byte = &mut self.storage.as_mut()[byte_index];
59 *byte = Self::change_bit(*byte, index, val);
60 }
61 #[inline]
62 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
63 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
64 let byte_index = index / 8;
65 let byte = unsafe {
66 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
67 };
68 unsafe { *byte = Self::change_bit(*byte, index, val) };
69 }
70 #[inline]
71 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
72 debug_assert!(bit_width <= 64);
73 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
74 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
75 let mut val = 0;
76 for i in 0..(bit_width as usize) {
77 if self.get_bit(i + bit_offset) {
78 let index = if cfg!(target_endian = "big") {
79 bit_width as usize - 1 - i
80 } else {
81 i
82 };
83 val |= 1 << index;
84 }
85 }
86 val
87 }
88 #[inline]
89 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
90 debug_assert!(bit_width <= 64);
91 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
92 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
93 let mut val = 0;
94 for i in 0..(bit_width as usize) {
95 if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
96 let index = if cfg!(target_endian = "big") {
97 bit_width as usize - 1 - i
98 } else {
99 i
100 };
101 val |= 1 << index;
102 }
103 }
104 val
105 }
106 #[inline]
107 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
108 debug_assert!(bit_width <= 64);
109 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
110 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
111 for i in 0..(bit_width as usize) {
112 let mask = 1 << i;
113 let val_bit_is_set = val & mask == mask;
114 let index = if cfg!(target_endian = "big") {
115 bit_width as usize - 1 - i
116 } else {
117 i
118 };
119 self.set_bit(index + bit_offset, val_bit_is_set);
120 }
121 }
122 #[inline]
123 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
124 debug_assert!(bit_width <= 64);
125 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
126 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
127 for i in 0..(bit_width as usize) {
128 let mask = 1 << i;
129 let val_bit_is_set = val & mask == mask;
130 let index = if cfg!(target_endian = "big") {
131 bit_width as usize - 1 - i
132 } else {
133 i
134 };
135 unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
136 }
137 }
138}
139pub const _STDINT_H: u32 = 1;
140pub const _FEATURES_H: u32 = 1;
141pub const _DEFAULT_SOURCE: u32 = 1;
142pub const __GLIBC_USE_ISOC2Y: u32 = 0;
143pub const __GLIBC_USE_ISOC23: u32 = 0;
144pub const __USE_ISOC11: u32 = 1;
145pub const __USE_ISOC99: u32 = 1;
146pub const __USE_ISOC95: u32 = 1;
147pub const __USE_POSIX_IMPLICITLY: u32 = 1;
148pub const _POSIX_SOURCE: u32 = 1;
149pub const _POSIX_C_SOURCE: u32 = 200809;
150pub const __USE_POSIX: u32 = 1;
151pub const __USE_POSIX2: u32 = 1;
152pub const __USE_POSIX199309: u32 = 1;
153pub const __USE_POSIX199506: u32 = 1;
154pub const __USE_XOPEN2K: u32 = 1;
155pub const __USE_XOPEN2K8: u32 = 1;
156pub const _ATFILE_SOURCE: u32 = 1;
157pub const __WORDSIZE: u32 = 64;
158pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
159pub const __SYSCALL_WORDSIZE: u32 = 64;
160pub const __TIMESIZE: u32 = 64;
161pub const __USE_TIME_BITS64: u32 = 1;
162pub const __USE_MISC: u32 = 1;
163pub const __USE_ATFILE: u32 = 1;
164pub const __USE_FORTIFY_LEVEL: u32 = 0;
165pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
166pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
167pub const __GLIBC_USE_C23_STRTOL: u32 = 0;
168pub const _STDC_PREDEF_H: u32 = 1;
169pub const __STDC_IEC_559__: u32 = 1;
170pub const __STDC_IEC_60559_BFP__: u32 = 201404;
171pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
172pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
173pub const __STDC_ISO_10646__: u32 = 201706;
174pub const __GNU_LIBRARY__: u32 = 6;
175pub const __GLIBC__: u32 = 2;
176pub const __GLIBC_MINOR__: u32 = 41;
177pub const _SYS_CDEFS_H: u32 = 1;
178pub const __glibc_c99_flexarr_available: u32 = 1;
179pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
180pub const __HAVE_GENERIC_SELECTION: u32 = 1;
181pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
182pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
183pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23: u32 = 0;
184pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
185pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
186pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23: u32 = 0;
187pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
188pub const _BITS_TYPES_H: u32 = 1;
189pub const _BITS_TYPESIZES_H: u32 = 1;
190pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
191pub const __INO_T_MATCHES_INO64_T: u32 = 1;
192pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
193pub const __STATFS_MATCHES_STATFS64: u32 = 1;
194pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
195pub const __FD_SETSIZE: u32 = 1024;
196pub const _BITS_TIME64_H: u32 = 1;
197pub const _BITS_WCHAR_H: u32 = 1;
198pub const _BITS_STDINT_INTN_H: u32 = 1;
199pub const _BITS_STDINT_UINTN_H: u32 = 1;
200pub const _BITS_STDINT_LEAST_H: u32 = 1;
201pub const INT8_MIN: i32 = -128;
202pub const INT16_MIN: i32 = -32768;
203pub const INT32_MIN: i32 = -2147483648;
204pub const INT8_MAX: u32 = 127;
205pub const INT16_MAX: u32 = 32767;
206pub const INT32_MAX: u32 = 2147483647;
207pub const UINT8_MAX: u32 = 255;
208pub const UINT16_MAX: u32 = 65535;
209pub const UINT32_MAX: u32 = 4294967295;
210pub const INT_LEAST8_MIN: i32 = -128;
211pub const INT_LEAST16_MIN: i32 = -32768;
212pub const INT_LEAST32_MIN: i32 = -2147483648;
213pub const INT_LEAST8_MAX: u32 = 127;
214pub const INT_LEAST16_MAX: u32 = 32767;
215pub const INT_LEAST32_MAX: u32 = 2147483647;
216pub const UINT_LEAST8_MAX: u32 = 255;
217pub const UINT_LEAST16_MAX: u32 = 65535;
218pub const UINT_LEAST32_MAX: u32 = 4294967295;
219pub const INT_FAST8_MIN: i32 = -128;
220pub const INT_FAST16_MIN: i64 = -9223372036854775808;
221pub const INT_FAST32_MIN: i64 = -9223372036854775808;
222pub const INT_FAST8_MAX: u32 = 127;
223pub const INT_FAST16_MAX: u64 = 9223372036854775807;
224pub const INT_FAST32_MAX: u64 = 9223372036854775807;
225pub const UINT_FAST8_MAX: u32 = 255;
226pub const UINT_FAST16_MAX: i32 = -1;
227pub const UINT_FAST32_MAX: i32 = -1;
228pub const INTPTR_MIN: i64 = -9223372036854775808;
229pub const INTPTR_MAX: u64 = 9223372036854775807;
230pub const UINTPTR_MAX: i32 = -1;
231pub const PTRDIFF_MIN: i64 = -9223372036854775808;
232pub const PTRDIFF_MAX: u64 = 9223372036854775807;
233pub const SIG_ATOMIC_MIN: i32 = -2147483648;
234pub const SIG_ATOMIC_MAX: u32 = 2147483647;
235pub const SIZE_MAX: i32 = -1;
236pub const WINT_MIN: u32 = 0;
237pub const WINT_MAX: u32 = 4294967295;
238pub const PsDepthRange_PsUnknown: PsDepthRange = -1;
239pub const PsDepthRange_PsNearRange: PsDepthRange = 0;
240pub const PsDepthRange_PsMidRange: PsDepthRange = 1;
241pub const PsDepthRange_PsFarRange: PsDepthRange = 2;
242pub const PsDepthRange_PsXNearRange: PsDepthRange = 3;
243pub const PsDepthRange_PsXMidRange: PsDepthRange = 4;
244pub const PsDepthRange_PsXFarRange: PsDepthRange = 5;
245pub const PsDepthRange_PsXXNearRange: PsDepthRange = 6;
246pub const PsDepthRange_PsXXMidRange: PsDepthRange = 7;
247pub const PsDepthRange_PsXXFarRange: PsDepthRange = 8;
248#[doc = " @brief Depth range setting.\\n\n These set estimated ranges. Detection distances may be greater than what is listed for the given setting. \\n\n Precision and minimum distance for depth detection varies with longer ranges."]
249pub type PsDepthRange = ::std::os::raw::c_int;
250#[doc = "!< Output both depth and RGB frames at 30 fps. The resolution of a depth frame is 640*480.\\n\n!< The resolution of an RGB frame can be set using ::PsSetFrameMode(), which supports 1600*1200/800*600/640*480."]
251pub const PsDataMode_PsDepthAndRGB_30: PsDataMode = 0;
252#[doc = "!< Outputs both IR and RGB frames at 30 fps. The resolution of an IR frame is 640*480.\\n\n!< The resolution of and RGB frame can be set using ::PsSetFrameMode(), which supports 1600*1200/800*600/640*480."]
253pub const PsDataMode_PsIRAndRGB_30: PsDataMode = 1;
254#[doc = "!< Outputs both depth and IR frames and RGB frame at 30 fps. The resolution for both depth and IR frames is 640*480.\\n\n!< The resolution of and RGB frame can be set using ::PsSetFrameMode(), which supports 1600*1200/800*600/640*480."]
255pub const PsDataMode_PsDepthAndIRAndRGB_30: PsDataMode = 2;
256#[doc = "!< Reserved for internal use."]
257pub const PsDataMode_PsNoCCD_30: PsDataMode = 4;
258#[doc = "!< WDR (Wide Dynamic Range) depth mode. Supports alternating multi-range depth frame output (e.g. Near/Far/Near/Far/Near)."]
259pub const PsDataMode_PsWDR_Depth: PsDataMode = 11;
260#[doc = "!< WDR (Wide Dynamic Range) IR mode. Not currently implemented."]
261pub const PsDataMode_PsWDR_IR: PsDataMode = 12;
262#[doc = "!< WDR (Wide Dynamic Range) Depth and IR mode. Not currently implemented."]
263pub const PsDataMode_PsWDR_DepthAndIR: PsDataMode = 13;
264#[doc = " @brief The data modes that determine the frame output from the device and the frame rate (fps)."]
265pub type PsDataMode = ::std::os::raw::c_uint;
266#[doc = "!< Gets the data mode lists that the device support"]
267pub const PsPropertyType_PsPropertyDataModeList: PsPropertyType = 9;
268#[doc = "!< Gets the depth range lists that the device support"]
269pub const PsPropertyType_PsPropertyDepthRangeList: PsPropertyType = 10;
270#[doc = " @brief Camera device properties to get or set on a device."]
271pub type PsPropertyType = ::std::os::raw::c_uint;
272#[doc = "!< Depth frame with 16 bits per pixel in millimeters."]
273pub const PsFrameType_PsDepthFrame: PsFrameType = 0;
274#[doc = "!< IR frame with 16 bits per pixel."]
275pub const PsFrameType_PsIRFrame: PsFrameType = 1;
276#[doc = "!< RGB frame with 24 bits per pixel in RGB/BGR format."]
277pub const PsFrameType_PsRGBFrame: PsFrameType = 3;
278#[doc = "!< RGB frame with 24 bits per pixel in RGB/BGR format, that is mapped to depth camera space where the resolution is the same as the depth frame's resolution.\\n\n!< This frame type can be enabled using ::PsSetMapperEnabledDepthToRGB()."]
279pub const PsFrameType_PsMappedRGBFrame: PsFrameType = 4;
280#[doc = "!< Depth frame with 16 bits per pixel, in millimeters, that is mapped to RGB camera space where the resolution is same as the RGB frame's resolution.\\n\n!< This frame type can be enabled using ::PsSetMapperEnabledRGBToDepth()."]
281pub const PsFrameType_PsMappedDepthFrame: PsFrameType = 5;
282#[doc = "!< WDR depth frame with 16 bits per pixel in millimeters. This only takes effect when the data mode set to ::PsWDR_Depth."]
283pub const PsFrameType_PsWDRDepthFrame: PsFrameType = 9;
284#[doc = " @brief Specifies the type of image frame."]
285pub type PsFrameType = ::std::os::raw::c_uint;
286#[doc = "!< Depth camera."]
287pub const PsSensorType_PsDepthSensor: PsSensorType = 1;
288#[doc = "!< Color (RGB) camera."]
289pub const PsSensorType_PsRgbSensor: PsSensorType = 2;
290#[doc = " @brief Specifies the type of camera sensor."]
291pub type PsSensorType = ::std::os::raw::c_uint;
292#[doc = "!< Depth image pixel format, 16 bits per pixel in mm."]
293pub const PsPixelFormat_PsPixelFormatDepthMM16: PsPixelFormat = 0;
294#[doc = "!< IR image pixel format, 16 bits per pixel."]
295pub const PsPixelFormat_PsPixelFormatGray16: PsPixelFormat = 1;
296#[doc = "!< Gray image pixel format, 8 bits per pixel."]
297pub const PsPixelFormat_PsPixelFormatGray8: PsPixelFormat = 2;
298#[doc = "!< Color image pixel format, 24 bits per pixel RGB format."]
299pub const PsPixelFormat_PsPixelFormatRGB888: PsPixelFormat = 3;
300#[doc = "!< Color image pixel format, 24 bits per pixel BGR format."]
301pub const PsPixelFormat_PsPixelFormatBGR888: PsPixelFormat = 4;
302#[doc = " @brief Specifies the image pixel format."]
303pub type PsPixelFormat = ::std::os::raw::c_uint;
304#[doc = "!< The function completed successfully."]
305pub const PsReturnStatus_PsRetOK: PsReturnStatus = 0;
306#[doc = "!< There is no depth camera connected or the camera has not been connected correctly. Check the hardware connection or try unplugging and re-plugging the USB cable."]
307pub const PsReturnStatus_PsRetNoDeviceConnected: PsReturnStatus = -1;
308#[doc = "!< The input device index is invalid."]
309pub const PsReturnStatus_PsRetInvalidDeviceIndex: PsReturnStatus = -2;
310#[doc = "!< The device structure pointer is null."]
311pub const PsReturnStatus_PsRetDevicePointerIsNull: PsReturnStatus = -3;
312#[doc = "!< The input frame type is invalid."]
313pub const PsReturnStatus_PsRetInvalidFrameType: PsReturnStatus = -4;
314#[doc = "!< The output frame buffer is null."]
315pub const PsReturnStatus_PsRetFramePointerIsNull: PsReturnStatus = -5;
316#[doc = "!< Cannot get the value for the specified property."]
317pub const PsReturnStatus_PsRetNoPropertyValueGet: PsReturnStatus = -6;
318#[doc = "!< Cannot set the value for the specified property."]
319pub const PsReturnStatus_PsRetNoPropertyValueSet: PsReturnStatus = -7;
320#[doc = "!< The input property value buffer pointer is null."]
321pub const PsReturnStatus_PsRetPropertyPointerIsNull: PsReturnStatus = -8;
322#[doc = "!< The input property value buffer size is too small to store the specified property value."]
323pub const PsReturnStatus_PsRetPropertySizeNotEnough: PsReturnStatus = -9;
324#[doc = "!< The input depth range mode is invalid."]
325pub const PsReturnStatus_PsRetInvalidDepthRange: PsReturnStatus = -10;
326#[doc = "!< Capture the next image frame time out."]
327pub const PsReturnStatus_PsRetReadNextFrameTimeOut: PsReturnStatus = -11;
328#[doc = "!< An input pointer parameter is null."]
329pub const PsReturnStatus_PsRetInputPointerIsNull: PsReturnStatus = -12;
330#[doc = "!< The camera has not been opened."]
331pub const PsReturnStatus_PsRetCameraNotOpened: PsReturnStatus = -13;
332#[doc = "!< The specified type of camera is invalid."]
333pub const PsReturnStatus_PsRetInvalidCameraType: PsReturnStatus = -14;
334#[doc = "!< One or more of the parameter values provided are invalid."]
335pub const PsReturnStatus_PsRetInvalidParams: PsReturnStatus = -15;
336#[doc = "!< This feature is not supported in the current version."]
337pub const PsReturnStatus_PsRetCurrentVersionNotSupport: PsReturnStatus = -16;
338#[doc = "!< There is an error in the upgrade file."]
339pub const PsReturnStatus_PsRetUpgradeImgError: PsReturnStatus = -17;
340#[doc = "!< Upgrade file path length greater than 260."]
341pub const PsReturnStatus_PsRetUpgradeImgPathTooLong: PsReturnStatus = -18;
342#[doc = "!< Ps2_SetUpgradeStatusCallback is not called."]
343pub const PsReturnStatus_PsRetUpgradeCallbackNotSet: PsReturnStatus = -19;
344#[doc = "!< There is no adapter connected"]
345pub const PsReturnStatus_PsRetNoAdapterConnected: PsReturnStatus = -100;
346#[doc = "!< The SDK has been Initialized"]
347pub const PsReturnStatus_PsRetReInitialized: PsReturnStatus = -101;
348#[doc = "!< The SDK has bot been Initialized"]
349pub const PsReturnStatus_PsRetNoInitialized: PsReturnStatus = -102;
350#[doc = "!< The camera has been opened."]
351pub const PsReturnStatus_PsRetCameraOpened: PsReturnStatus = -103;
352#[doc = "!< Set/Get cmd control error"]
353pub const PsReturnStatus_PsRetCmdError: PsReturnStatus = -104;
354#[doc = "!< Set cmd ok.but time out for the sync return"]
355pub const PsReturnStatus_PsRetCmdSyncTimeOut: PsReturnStatus = -105;
356#[doc = "!< IP is not in the same network segment"]
357pub const PsReturnStatus_PsRetIPNotMatch: PsReturnStatus = -106;
358#[doc = "!< An unknown error occurred."]
359pub const PsReturnStatus_PsRetOthers: PsReturnStatus = -255;
360#[doc = " @brief Return status codes for all APIs.\\n\n \t\t <code>PsRetOK = 0</code> means the API successfully completed its operation.\\n\n \t\t All other codes indicate a device, parameter, or API usage error."]
361pub type PsReturnStatus = ::std::os::raw::c_int;
362#[doc = "!< Two depth ranges."]
363pub const PsWDRTotalRange_PsWDRTotalRange_Two: PsWDRTotalRange = 2;
364#[doc = "!< Three depth ranges."]
365pub const PsWDRTotalRange_PsWDRTotalRange_Three: PsWDRTotalRange = 3;
366#[doc = " @brief Specifies the number of depth ranges defined for WDR. Currently only two or three ranges are supported (e.g. Near/Far or Near/Mid/Far)."]
367pub type PsWDRTotalRange = ::std::os::raw::c_uint;
368#[doc = "!< WDR image output is fused from multiple ranges."]
369pub const PsWDRStyle_PsWDR_FUSION: PsWDRStyle = 0;
370#[doc = "!< WDR image output alternates between depths (e.g. Near/Far/Near/Far ... )."]
371pub const PsWDRStyle_PsWDR_ALTERNATION: PsWDRStyle = 1;
372#[doc = " @brief The WDR style setting used for ::PsSetWDRStyle(). This determines if the WDR image output is a fusion from multiple ranges (e.g. Near/Far fusion)\\n\n or an alternative output (e.g. Near/Far/Near/Far ... )."]
373pub type PsWDRStyle = ::std::os::raw::c_uint;
374#[doc = "!< Depth Stream"]
375pub const PsStreamType_PsStreamDepth: PsStreamType = 0;
376#[doc = "!< IR Stream"]
377pub const PsStreamType_PsStreamIR: PsStreamType = 1;
378#[doc = "!< RGB Stream"]
379pub const PsStreamType_PsStreamRGB: PsStreamType = 2;
380#[doc = " @brief Stream type"]
381pub type PsStreamType = ::std::os::raw::c_uint;
382pub const PsResolution_PsRGB_Resolution_640_480: PsResolution = 2;
383pub const PsResolution_PsRGB_Resolution_1600_1200: PsResolution = 4;
384pub const PsResolution_PsRGB_Resolution_800_600: PsResolution = 5;
385#[doc = "\t@brief\tResolution"]
386pub type PsResolution = ::std::os::raw::c_uint;
387pub const PsLinkType_LinkeUNKNOWN: PsLinkType = 0;
388pub const PsLinkType_LinkUSB: PsLinkType = 1;
389pub const PsLinkType_LinkSocket: PsLinkType = 2;
390pub const PsLinkType_LinkMIPI: PsLinkType = 3;
391pub type PsLinkType = ::std::os::raw::c_uint;
392pub const PsConnectStatus_ConnectUNKNOWN: PsConnectStatus = 0;
393pub const PsConnectStatus_Unconnected: PsConnectStatus = 1;
394pub const PsConnectStatus_Connected: PsConnectStatus = 2;
395pub const PsConnectStatus_Opened: PsConnectStatus = 3;
396pub type PsConnectStatus = ::std::os::raw::c_uint;
397pub const PsDeviceType_NONE: PsDeviceType = 0;
398pub const PsDeviceType_DCAM305: PsDeviceType = 305;
399pub const PsDeviceType_DCAM500: PsDeviceType = 500;
400pub const PsDeviceType_CSI100: PsDeviceType = 501;
401pub const PsDeviceType_DCAM510: PsDeviceType = 510;
402pub const PsDeviceType_DCAM550U: PsDeviceType = 550;
403pub const PsDeviceType_DCAM550P: PsDeviceType = 551;
404pub const PsDeviceType_DCAM550E: PsDeviceType = 552;
405pub const PsDeviceType_DCAM560: PsDeviceType = 560;
406pub const PsDeviceType_DCAM560CPRO: PsDeviceType = 561;
407pub const PsDeviceType_DCAM560CLITE: PsDeviceType = 562;
408pub const PsDeviceType_DCAM710: PsDeviceType = 710;
409pub const PsDeviceType_DCAM800: PsDeviceType = 800;
410pub const PsDeviceType_DCAM_MIPI: PsDeviceType = 801;
411pub const PsDeviceType_DCAM800LITE: PsDeviceType = 802;
412pub const PsDeviceType_DCAM800LITEUSB: PsDeviceType = 803;
413pub const PsDeviceType_DCAM101: PsDeviceType = 804;
414pub const PsDeviceType_MAX: PsDeviceType = 805;
415pub type PsDeviceType = ::std::os::raw::c_uint;
416pub type __u_char = ::std::os::raw::c_uchar;
417pub type __u_short = ::std::os::raw::c_ushort;
418pub type __u_int = ::std::os::raw::c_uint;
419pub type __u_long = ::std::os::raw::c_ulong;
420pub type __int8_t = ::std::os::raw::c_schar;
421pub type __uint8_t = ::std::os::raw::c_uchar;
422pub type __int16_t = ::std::os::raw::c_short;
423pub type __uint16_t = ::std::os::raw::c_ushort;
424pub type __int32_t = ::std::os::raw::c_int;
425pub type __uint32_t = ::std::os::raw::c_uint;
426pub type __int64_t = ::std::os::raw::c_long;
427pub type __uint64_t = ::std::os::raw::c_ulong;
428pub type __int_least8_t = __int8_t;
429pub type __uint_least8_t = __uint8_t;
430pub type __int_least16_t = __int16_t;
431pub type __uint_least16_t = __uint16_t;
432pub type __int_least32_t = __int32_t;
433pub type __uint_least32_t = __uint32_t;
434pub type __int_least64_t = __int64_t;
435pub type __uint_least64_t = __uint64_t;
436pub type __quad_t = ::std::os::raw::c_long;
437pub type __u_quad_t = ::std::os::raw::c_ulong;
438pub type __intmax_t = ::std::os::raw::c_long;
439pub type __uintmax_t = ::std::os::raw::c_ulong;
440pub type __dev_t = ::std::os::raw::c_ulong;
441pub type __uid_t = ::std::os::raw::c_uint;
442pub type __gid_t = ::std::os::raw::c_uint;
443pub type __ino_t = ::std::os::raw::c_ulong;
444pub type __ino64_t = ::std::os::raw::c_ulong;
445pub type __mode_t = ::std::os::raw::c_uint;
446pub type __nlink_t = ::std::os::raw::c_ulong;
447pub type __off_t = ::std::os::raw::c_long;
448pub type __off64_t = ::std::os::raw::c_long;
449pub type __pid_t = ::std::os::raw::c_int;
450#[repr(C)]
451#[derive(Debug, Default, Copy, Clone)]
452pub struct __fsid_t {
453 pub __val: [::std::os::raw::c_int; 2usize],
454}
455#[allow(clippy::unnecessary_operation, clippy::identity_op)]
456const _: () = {
457 ["Size of __fsid_t"][::std::mem::size_of::<__fsid_t>() - 8usize];
458 ["Alignment of __fsid_t"][::std::mem::align_of::<__fsid_t>() - 4usize];
459 ["Offset of field: __fsid_t::__val"][::std::mem::offset_of!(__fsid_t, __val) - 0usize];
460};
461pub type __clock_t = ::std::os::raw::c_long;
462pub type __rlim_t = ::std::os::raw::c_ulong;
463pub type __rlim64_t = ::std::os::raw::c_ulong;
464pub type __id_t = ::std::os::raw::c_uint;
465pub type __time_t = ::std::os::raw::c_long;
466pub type __useconds_t = ::std::os::raw::c_uint;
467pub type __suseconds_t = ::std::os::raw::c_long;
468pub type __suseconds64_t = ::std::os::raw::c_long;
469pub type __daddr_t = ::std::os::raw::c_int;
470pub type __key_t = ::std::os::raw::c_int;
471pub type __clockid_t = ::std::os::raw::c_int;
472pub type __timer_t = *mut ::std::os::raw::c_void;
473pub type __blksize_t = ::std::os::raw::c_long;
474pub type __blkcnt_t = ::std::os::raw::c_long;
475pub type __blkcnt64_t = ::std::os::raw::c_long;
476pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
477pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
478pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
479pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
480pub type __fsword_t = ::std::os::raw::c_long;
481pub type __ssize_t = ::std::os::raw::c_long;
482pub type __syscall_slong_t = ::std::os::raw::c_long;
483pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
484pub type __loff_t = __off64_t;
485pub type __caddr_t = *mut ::std::os::raw::c_char;
486pub type __intptr_t = ::std::os::raw::c_long;
487pub type __socklen_t = ::std::os::raw::c_uint;
488pub type __sig_atomic_t = ::std::os::raw::c_int;
489pub type int_least8_t = __int_least8_t;
490pub type int_least16_t = __int_least16_t;
491pub type int_least32_t = __int_least32_t;
492pub type int_least64_t = __int_least64_t;
493pub type uint_least8_t = __uint_least8_t;
494pub type uint_least16_t = __uint_least16_t;
495pub type uint_least32_t = __uint_least32_t;
496pub type uint_least64_t = __uint_least64_t;
497pub type int_fast8_t = ::std::os::raw::c_schar;
498pub type int_fast16_t = ::std::os::raw::c_long;
499pub type int_fast32_t = ::std::os::raw::c_long;
500pub type int_fast64_t = ::std::os::raw::c_long;
501pub type uint_fast8_t = ::std::os::raw::c_uchar;
502pub type uint_fast16_t = ::std::os::raw::c_ulong;
503pub type uint_fast32_t = ::std::os::raw::c_ulong;
504pub type uint_fast64_t = ::std::os::raw::c_ulong;
505pub type intmax_t = __intmax_t;
506pub type uintmax_t = __uintmax_t;
507pub type PsDepthPixel = u16;
508pub type PsGray16Pixel = u16;
509pub type PsGray8Pixel = u8;
510#[doc = " @brief Color image pixel type in 24-bit RGB format."]
511#[repr(C)]
512#[derive(Debug, Default, Copy, Clone)]
513pub struct PsRGB888Pixel {
514 #[doc = "!< Red"]
515 pub r: u8,
516 #[doc = "!< Green"]
517 pub g: u8,
518 #[doc = "!< Blue"]
519 pub b: u8,
520}
521#[allow(clippy::unnecessary_operation, clippy::identity_op)]
522const _: () = {
523 ["Size of PsRGB888Pixel"][::std::mem::size_of::<PsRGB888Pixel>() - 3usize];
524 ["Alignment of PsRGB888Pixel"][::std::mem::align_of::<PsRGB888Pixel>() - 1usize];
525 ["Offset of field: PsRGB888Pixel::r"][::std::mem::offset_of!(PsRGB888Pixel, r) - 0usize];
526 ["Offset of field: PsRGB888Pixel::g"][::std::mem::offset_of!(PsRGB888Pixel, g) - 1usize];
527 ["Offset of field: PsRGB888Pixel::b"][::std::mem::offset_of!(PsRGB888Pixel, b) - 2usize];
528};
529#[doc = " @brief Color image pixel type in 24-bit BGR format."]
530#[repr(C)]
531#[derive(Debug, Default, Copy, Clone)]
532pub struct PsBGR888Pixel {
533 #[doc = "!< Blue"]
534 pub b: u8,
535 #[doc = "!< Green"]
536 pub g: u8,
537 #[doc = "!< Red"]
538 pub r: u8,
539}
540#[allow(clippy::unnecessary_operation, clippy::identity_op)]
541const _: () = {
542 ["Size of PsBGR888Pixel"][::std::mem::size_of::<PsBGR888Pixel>() - 3usize];
543 ["Alignment of PsBGR888Pixel"][::std::mem::align_of::<PsBGR888Pixel>() - 1usize];
544 ["Offset of field: PsBGR888Pixel::b"][::std::mem::offset_of!(PsBGR888Pixel, b) - 0usize];
545 ["Offset of field: PsBGR888Pixel::g"][::std::mem::offset_of!(PsBGR888Pixel, g) - 1usize];
546 ["Offset of field: PsBGR888Pixel::r"][::std::mem::offset_of!(PsBGR888Pixel, r) - 2usize];
547};
548#[doc = " @brief Specifies the frame mode including the pixel format, resolution, and frame rate."]
549#[repr(C, packed)]
550#[derive(Debug, Copy, Clone)]
551pub struct PsFrameMode {
552 #[doc = "!< The pixel format used by a frame."]
553 pub pixelFormat: PsPixelFormat,
554 #[doc = "!< The width of the image, in pixels."]
555 pub resolutionWidth: i32,
556 #[doc = "!< The height of the image, in pixels."]
557 pub resolutionHeight: i32,
558 #[doc = "!< The image stream frame rate."]
559 pub fps: i32,
560}
561#[allow(clippy::unnecessary_operation, clippy::identity_op)]
562const _: () = {
563 ["Size of PsFrameMode"][::std::mem::size_of::<PsFrameMode>() - 16usize];
564 ["Alignment of PsFrameMode"][::std::mem::align_of::<PsFrameMode>() - 1usize];
565 ["Offset of field: PsFrameMode::pixelFormat"]
566 [::std::mem::offset_of!(PsFrameMode, pixelFormat) - 0usize];
567 ["Offset of field: PsFrameMode::resolutionWidth"]
568 [::std::mem::offset_of!(PsFrameMode, resolutionWidth) - 4usize];
569 ["Offset of field: PsFrameMode::resolutionHeight"]
570 [::std::mem::offset_of!(PsFrameMode, resolutionHeight) - 8usize];
571 ["Offset of field: PsFrameMode::fps"][::std::mem::offset_of!(PsFrameMode, fps) - 12usize];
572};
573impl Default for PsFrameMode {
574 fn default() -> Self {
575 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
576 unsafe {
577 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
578 s.assume_init()
579 }
580 }
581}
582#[doc = " @brief Stores the x, y, and z components of a 3D vector."]
583#[repr(C, packed)]
584#[derive(Debug, Default, Copy, Clone)]
585pub struct PsVector3f {
586 #[doc = "!< The x, y, and z components of the vector."]
587 pub x: f32,
588 #[doc = "!< The x, y, and z components of the vector."]
589 pub y: f32,
590 #[doc = "!< The x, y, and z components of the vector."]
591 pub z: f32,
592}
593#[allow(clippy::unnecessary_operation, clippy::identity_op)]
594const _: () = {
595 ["Size of PsVector3f"][::std::mem::size_of::<PsVector3f>() - 12usize];
596 ["Alignment of PsVector3f"][::std::mem::align_of::<PsVector3f>() - 1usize];
597 ["Offset of field: PsVector3f::x"][::std::mem::offset_of!(PsVector3f, x) - 0usize];
598 ["Offset of field: PsVector3f::y"][::std::mem::offset_of!(PsVector3f, y) - 4usize];
599 ["Offset of field: PsVector3f::z"][::std::mem::offset_of!(PsVector3f, z) - 8usize];
600};
601#[doc = " @brief Stores the x, y, and z components of a 2D vector."]
602#[repr(C, packed)]
603#[derive(Debug, Default, Copy, Clone)]
604pub struct PsVector2u16 {
605 pub x: u16,
606 pub y: u16,
607}
608#[allow(clippy::unnecessary_operation, clippy::identity_op)]
609const _: () = {
610 ["Size of PsVector2u16"][::std::mem::size_of::<PsVector2u16>() - 4usize];
611 ["Alignment of PsVector2u16"][::std::mem::align_of::<PsVector2u16>() - 1usize];
612 ["Offset of field: PsVector2u16::x"][::std::mem::offset_of!(PsVector2u16, x) - 0usize];
613 ["Offset of field: PsVector2u16::y"][::std::mem::offset_of!(PsVector2u16, y) - 2usize];
614};
615#[doc = " @brief Contains depth information for a given pixel."]
616#[repr(C, packed)]
617#[derive(Debug, Default, Copy, Clone)]
618pub struct PsDepthVector3 {
619 #[doc = "!< The x coordinate of the pixel."]
620 pub depthX: ::std::os::raw::c_int,
621 #[doc = "!< The y coordinate of the pixel."]
622 pub depthY: ::std::os::raw::c_int,
623 #[doc = "!< The depth of the pixel, in millimeters."]
624 pub depthZ: PsDepthPixel,
625}
626#[allow(clippy::unnecessary_operation, clippy::identity_op)]
627const _: () = {
628 ["Size of PsDepthVector3"][::std::mem::size_of::<PsDepthVector3>() - 10usize];
629 ["Alignment of PsDepthVector3"][::std::mem::align_of::<PsDepthVector3>() - 1usize];
630 ["Offset of field: PsDepthVector3::depthX"]
631 [::std::mem::offset_of!(PsDepthVector3, depthX) - 0usize];
632 ["Offset of field: PsDepthVector3::depthY"]
633 [::std::mem::offset_of!(PsDepthVector3, depthY) - 4usize];
634 ["Offset of field: PsDepthVector3::depthZ"]
635 [::std::mem::offset_of!(PsDepthVector3, depthZ) - 8usize];
636};
637#[doc = " @brief Camera intrinsic parameters and distortion coefficients."]
638#[repr(C, packed)]
639#[derive(Debug, Default, Copy, Clone)]
640pub struct PsCameraParameters {
641 #[doc = "!< Focal length x (pixel)"]
642 pub fx: f64,
643 #[doc = "!< Focal length y (pixel)"]
644 pub fy: f64,
645 #[doc = "!< Principal point x (pixel)"]
646 pub cx: f64,
647 #[doc = "!< Principal point y (pixel)"]
648 pub cy: f64,
649 #[doc = "!< Radial distortion coefficient, 1st-order"]
650 pub k1: f64,
651 #[doc = "!< Radial distortion coefficient, 2nd-order"]
652 pub k2: f64,
653 #[doc = "!< Tangential distortion coefficient"]
654 pub p1: f64,
655 #[doc = "!< Tangential distortion coefficient"]
656 pub p2: f64,
657 #[doc = "!< Radial distortion coefficient, 3rd-order"]
658 pub k3: f64,
659 #[doc = "!< Radial distortion coefficient, 4st-order"]
660 pub k4: f64,
661 #[doc = "!< Radial distortion coefficient, 5nd-order"]
662 pub k5: f64,
663 #[doc = "!< Radial distortion coefficient, 6rd-order"]
664 pub k6: f64,
665}
666#[allow(clippy::unnecessary_operation, clippy::identity_op)]
667const _: () = {
668 ["Size of PsCameraParameters"][::std::mem::size_of::<PsCameraParameters>() - 96usize];
669 ["Alignment of PsCameraParameters"][::std::mem::align_of::<PsCameraParameters>() - 1usize];
670 ["Offset of field: PsCameraParameters::fx"]
671 [::std::mem::offset_of!(PsCameraParameters, fx) - 0usize];
672 ["Offset of field: PsCameraParameters::fy"]
673 [::std::mem::offset_of!(PsCameraParameters, fy) - 8usize];
674 ["Offset of field: PsCameraParameters::cx"]
675 [::std::mem::offset_of!(PsCameraParameters, cx) - 16usize];
676 ["Offset of field: PsCameraParameters::cy"]
677 [::std::mem::offset_of!(PsCameraParameters, cy) - 24usize];
678 ["Offset of field: PsCameraParameters::k1"]
679 [::std::mem::offset_of!(PsCameraParameters, k1) - 32usize];
680 ["Offset of field: PsCameraParameters::k2"]
681 [::std::mem::offset_of!(PsCameraParameters, k2) - 40usize];
682 ["Offset of field: PsCameraParameters::p1"]
683 [::std::mem::offset_of!(PsCameraParameters, p1) - 48usize];
684 ["Offset of field: PsCameraParameters::p2"]
685 [::std::mem::offset_of!(PsCameraParameters, p2) - 56usize];
686 ["Offset of field: PsCameraParameters::k3"]
687 [::std::mem::offset_of!(PsCameraParameters, k3) - 64usize];
688 ["Offset of field: PsCameraParameters::k4"]
689 [::std::mem::offset_of!(PsCameraParameters, k4) - 72usize];
690 ["Offset of field: PsCameraParameters::k5"]
691 [::std::mem::offset_of!(PsCameraParameters, k5) - 80usize];
692 ["Offset of field: PsCameraParameters::k6"]
693 [::std::mem::offset_of!(PsCameraParameters, k6) - 88usize];
694};
695#[doc = " @brief Specifies the camera’s location and orientation extrinsic parameters."]
696#[repr(C, packed)]
697#[derive(Debug, Default, Copy, Clone)]
698pub struct PsCameraExtrinsicParameters {
699 #[doc = "!< Orientation stored as an array of 9 double representing a 3x3 rotation matrix."]
700 pub rotation: [f64; 9usize],
701 #[doc = "!< Location stored as an array of 3 double representing a 3-D translation vector."]
702 pub translation: [f64; 3usize],
703}
704#[allow(clippy::unnecessary_operation, clippy::identity_op)]
705const _: () = {
706 ["Size of PsCameraExtrinsicParameters"]
707 [::std::mem::size_of::<PsCameraExtrinsicParameters>() - 96usize];
708 ["Alignment of PsCameraExtrinsicParameters"]
709 [::std::mem::align_of::<PsCameraExtrinsicParameters>() - 1usize];
710 ["Offset of field: PsCameraExtrinsicParameters::rotation"]
711 [::std::mem::offset_of!(PsCameraExtrinsicParameters, rotation) - 0usize];
712 ["Offset of field: PsCameraExtrinsicParameters::translation"]
713 [::std::mem::offset_of!(PsCameraExtrinsicParameters, translation) - 72usize];
714};
715#[repr(C, packed)]
716#[derive(Debug, Default, Copy, Clone)]
717pub struct PsTimeStamp {
718 pub tm_sec: u16,
719 pub tm_min: u16,
720 pub tm_hour: u16,
721 pub tm_msec: u16,
722}
723#[allow(clippy::unnecessary_operation, clippy::identity_op)]
724const _: () = {
725 ["Size of PsTimeStamp"][::std::mem::size_of::<PsTimeStamp>() - 8usize];
726 ["Alignment of PsTimeStamp"][::std::mem::align_of::<PsTimeStamp>() - 1usize];
727 ["Offset of field: PsTimeStamp::tm_sec"][::std::mem::offset_of!(PsTimeStamp, tm_sec) - 0usize];
728 ["Offset of field: PsTimeStamp::tm_min"][::std::mem::offset_of!(PsTimeStamp, tm_min) - 2usize];
729 ["Offset of field: PsTimeStamp::tm_hour"]
730 [::std::mem::offset_of!(PsTimeStamp, tm_hour) - 4usize];
731 ["Offset of field: PsTimeStamp::tm_msec"]
732 [::std::mem::offset_of!(PsTimeStamp, tm_msec) - 6usize];
733};
734#[doc = " @brief Depth/IR/RGB image frame data."]
735#[repr(C, packed)]
736#[derive(Debug, Copy, Clone)]
737pub struct PsFrame {
738 #[doc = "!< The index of the frame."]
739 pub frameIndex: u32,
740 #[doc = "!< The type of frame. See ::PsFrameType for more information."]
741 pub frameType: PsFrameType,
742 #[doc = "!< The pixel format used by a frame. See ::PsPixelFormat for more information."]
743 pub pixelFormat: PsPixelFormat,
744 #[doc = "!< Used to synchronize with IMU, in the range of 0 to 255."]
745 pub imuFrameNo: u8,
746 #[doc = "!< A buffer containing the frame’s image data."]
747 pub pFrameData: *mut u8,
748 #[doc = "!< The length of pFrame, in bytes."]
749 pub dataLen: u32,
750 #[doc = "!< The exposure time, in milliseconds."]
751 pub exposureTime: f32,
752 #[doc = "!< The depth range mode of the current frame. Used only for depth frames."]
753 pub depthRange: PsDepthRange,
754 #[doc = "!< The width of the frame, in pixels."]
755 pub width: u16,
756 #[doc = "!< The height of the frame, in pixels."]
757 pub height: u16,
758 #[doc = "!< The timestamp of the frame that decoded."]
759 pub timestamp: PsTimeStamp,
760 #[doc = "!< The timestamp of the camera."]
761 pub hardwaretimestamp: u64,
762}
763#[allow(clippy::unnecessary_operation, clippy::identity_op)]
764const _: () = {
765 ["Size of PsFrame"][::std::mem::size_of::<PsFrame>() - 53usize];
766 ["Alignment of PsFrame"][::std::mem::align_of::<PsFrame>() - 1usize];
767 ["Offset of field: PsFrame::frameIndex"][::std::mem::offset_of!(PsFrame, frameIndex) - 0usize];
768 ["Offset of field: PsFrame::frameType"][::std::mem::offset_of!(PsFrame, frameType) - 4usize];
769 ["Offset of field: PsFrame::pixelFormat"]
770 [::std::mem::offset_of!(PsFrame, pixelFormat) - 8usize];
771 ["Offset of field: PsFrame::imuFrameNo"][::std::mem::offset_of!(PsFrame, imuFrameNo) - 12usize];
772 ["Offset of field: PsFrame::pFrameData"][::std::mem::offset_of!(PsFrame, pFrameData) - 13usize];
773 ["Offset of field: PsFrame::dataLen"][::std::mem::offset_of!(PsFrame, dataLen) - 21usize];
774 ["Offset of field: PsFrame::exposureTime"]
775 [::std::mem::offset_of!(PsFrame, exposureTime) - 25usize];
776 ["Offset of field: PsFrame::depthRange"][::std::mem::offset_of!(PsFrame, depthRange) - 29usize];
777 ["Offset of field: PsFrame::width"][::std::mem::offset_of!(PsFrame, width) - 33usize];
778 ["Offset of field: PsFrame::height"][::std::mem::offset_of!(PsFrame, height) - 35usize];
779 ["Offset of field: PsFrame::timestamp"][::std::mem::offset_of!(PsFrame, timestamp) - 37usize];
780 ["Offset of field: PsFrame::hardwaretimestamp"]
781 [::std::mem::offset_of!(PsFrame, hardwaretimestamp) - 45usize];
782};
783impl Default for PsFrame {
784 fn default() -> Self {
785 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
786 unsafe {
787 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
788 s.assume_init()
789 }
790 }
791}
792#[doc = " @brief WDR (Wide Dynamic Range) output mode settings (e.g. Near/Far range fusion)."]
793#[repr(C, packed)]
794#[derive(Debug, Copy, Clone)]
795pub struct PsWDROutputMode {
796 #[doc = "!< The number of ranges supported. Currently only two or three ranges are supported (e.g. Near/Far or Near/Mid/Far)."]
797 pub totalRange: PsWDRTotalRange,
798 #[doc = "!< The first range."]
799 pub range1: PsDepthRange,
800 #[doc = "!< The count of successive <code>range1</code> frames."]
801 pub range1Count: u8,
802 #[doc = "!< The second range."]
803 pub range2: PsDepthRange,
804 #[doc = "!< The count of successive <code>range2</code> frames."]
805 pub range2Count: u8,
806 #[doc = "!< Third range. This range only takes effect when <code>totalRange</code> is set to <code>3</code>."]
807 pub range3: PsDepthRange,
808 #[doc = "!< The count of successive <code>range3</code> frames. This only takes effect when <code>totalRange</code> is set to <code>3</code>."]
809 pub range3Count: u8,
810}
811#[allow(clippy::unnecessary_operation, clippy::identity_op)]
812const _: () = {
813 ["Size of PsWDROutputMode"][::std::mem::size_of::<PsWDROutputMode>() - 19usize];
814 ["Alignment of PsWDROutputMode"][::std::mem::align_of::<PsWDROutputMode>() - 1usize];
815 ["Offset of field: PsWDROutputMode::totalRange"]
816 [::std::mem::offset_of!(PsWDROutputMode, totalRange) - 0usize];
817 ["Offset of field: PsWDROutputMode::range1"]
818 [::std::mem::offset_of!(PsWDROutputMode, range1) - 4usize];
819 ["Offset of field: PsWDROutputMode::range1Count"]
820 [::std::mem::offset_of!(PsWDROutputMode, range1Count) - 8usize];
821 ["Offset of field: PsWDROutputMode::range2"]
822 [::std::mem::offset_of!(PsWDROutputMode, range2) - 9usize];
823 ["Offset of field: PsWDROutputMode::range2Count"]
824 [::std::mem::offset_of!(PsWDROutputMode, range2Count) - 13usize];
825 ["Offset of field: PsWDROutputMode::range3"]
826 [::std::mem::offset_of!(PsWDROutputMode, range3) - 14usize];
827 ["Offset of field: PsWDROutputMode::range3Count"]
828 [::std::mem::offset_of!(PsWDROutputMode, range3Count) - 18usize];
829};
830impl Default for PsWDROutputMode {
831 fn default() -> Self {
832 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
833 unsafe {
834 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
835 s.assume_init()
836 }
837 }
838}
839#[doc = " @brief Specifies the GMMGain including the gain value and option type."]
840#[repr(C, packed)]
841#[derive(Debug, Default, Copy, Clone)]
842pub struct PsGMMGain {
843 #[doc = "!< The GMM gain value of the device."]
844 pub gain: u16,
845 #[doc = "!< The option type of setting the GMM gain effective time. 0:Immediate effect, invalid after camera closure; 1:Permanent entry into force."]
846 pub option: u8,
847}
848#[allow(clippy::unnecessary_operation, clippy::identity_op)]
849const _: () = {
850 ["Size of PsGMMGain"][::std::mem::size_of::<PsGMMGain>() - 3usize];
851 ["Alignment of PsGMMGain"][::std::mem::align_of::<PsGMMGain>() - 1usize];
852 ["Offset of field: PsGMMGain::gain"][::std::mem::offset_of!(PsGMMGain, gain) - 0usize];
853 ["Offset of field: PsGMMGain::option"][::std::mem::offset_of!(PsGMMGain, option) - 2usize];
854};
855#[repr(C)]
856#[derive(Debug, Default, Copy, Clone)]
857pub struct PsFrameReady {
858 pub _bitfield_align_1: [u8; 0],
859 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
860}
861#[allow(clippy::unnecessary_operation, clippy::identity_op)]
862const _: () = {
863 ["Size of PsFrameReady"][::std::mem::size_of::<PsFrameReady>() - 4usize];
864 ["Alignment of PsFrameReady"][::std::mem::align_of::<PsFrameReady>() - 1usize];
865};
866impl PsFrameReady {
867 #[inline]
868 pub fn depth(&self) -> u32 {
869 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
870 }
871 #[inline]
872 pub fn set_depth(&mut self, val: u32) {
873 unsafe {
874 let val: u32 = ::std::mem::transmute(val);
875 self._bitfield_1.set(0usize, 1u8, val as u64)
876 }
877 }
878 #[inline]
879 pub unsafe fn depth_raw(this: *const Self) -> u32 {
880 unsafe {
881 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
882 ::std::ptr::addr_of!((*this)._bitfield_1),
883 0usize,
884 1u8,
885 ) as u32)
886 }
887 }
888 #[inline]
889 pub unsafe fn set_depth_raw(this: *mut Self, val: u32) {
890 unsafe {
891 let val: u32 = ::std::mem::transmute(val);
892 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
893 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
894 0usize,
895 1u8,
896 val as u64,
897 )
898 }
899 }
900 #[inline]
901 pub fn ir(&self) -> u32 {
902 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
903 }
904 #[inline]
905 pub fn set_ir(&mut self, val: u32) {
906 unsafe {
907 let val: u32 = ::std::mem::transmute(val);
908 self._bitfield_1.set(1usize, 1u8, val as u64)
909 }
910 }
911 #[inline]
912 pub unsafe fn ir_raw(this: *const Self) -> u32 {
913 unsafe {
914 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
915 ::std::ptr::addr_of!((*this)._bitfield_1),
916 1usize,
917 1u8,
918 ) as u32)
919 }
920 }
921 #[inline]
922 pub unsafe fn set_ir_raw(this: *mut Self, val: u32) {
923 unsafe {
924 let val: u32 = ::std::mem::transmute(val);
925 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
926 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
927 1usize,
928 1u8,
929 val as u64,
930 )
931 }
932 }
933 #[inline]
934 pub fn rgb(&self) -> u32 {
935 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
936 }
937 #[inline]
938 pub fn set_rgb(&mut self, val: u32) {
939 unsafe {
940 let val: u32 = ::std::mem::transmute(val);
941 self._bitfield_1.set(2usize, 1u8, val as u64)
942 }
943 }
944 #[inline]
945 pub unsafe fn rgb_raw(this: *const Self) -> u32 {
946 unsafe {
947 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
948 ::std::ptr::addr_of!((*this)._bitfield_1),
949 2usize,
950 1u8,
951 ) as u32)
952 }
953 }
954 #[inline]
955 pub unsafe fn set_rgb_raw(this: *mut Self, val: u32) {
956 unsafe {
957 let val: u32 = ::std::mem::transmute(val);
958 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
959 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
960 2usize,
961 1u8,
962 val as u64,
963 )
964 }
965 }
966 #[inline]
967 pub fn mappedRGB(&self) -> u32 {
968 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
969 }
970 #[inline]
971 pub fn set_mappedRGB(&mut self, val: u32) {
972 unsafe {
973 let val: u32 = ::std::mem::transmute(val);
974 self._bitfield_1.set(3usize, 1u8, val as u64)
975 }
976 }
977 #[inline]
978 pub unsafe fn mappedRGB_raw(this: *const Self) -> u32 {
979 unsafe {
980 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
981 ::std::ptr::addr_of!((*this)._bitfield_1),
982 3usize,
983 1u8,
984 ) as u32)
985 }
986 }
987 #[inline]
988 pub unsafe fn set_mappedRGB_raw(this: *mut Self, val: u32) {
989 unsafe {
990 let val: u32 = ::std::mem::transmute(val);
991 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
992 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
993 3usize,
994 1u8,
995 val as u64,
996 )
997 }
998 }
999 #[inline]
1000 pub fn mappedDepth(&self) -> u32 {
1001 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1002 }
1003 #[inline]
1004 pub fn set_mappedDepth(&mut self, val: u32) {
1005 unsafe {
1006 let val: u32 = ::std::mem::transmute(val);
1007 self._bitfield_1.set(4usize, 1u8, val as u64)
1008 }
1009 }
1010 #[inline]
1011 pub unsafe fn mappedDepth_raw(this: *const Self) -> u32 {
1012 unsafe {
1013 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1014 ::std::ptr::addr_of!((*this)._bitfield_1),
1015 4usize,
1016 1u8,
1017 ) as u32)
1018 }
1019 }
1020 #[inline]
1021 pub unsafe fn set_mappedDepth_raw(this: *mut Self, val: u32) {
1022 unsafe {
1023 let val: u32 = ::std::mem::transmute(val);
1024 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1025 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1026 4usize,
1027 1u8,
1028 val as u64,
1029 )
1030 }
1031 }
1032 #[inline]
1033 pub fn mappedIR(&self) -> u32 {
1034 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1035 }
1036 #[inline]
1037 pub fn set_mappedIR(&mut self, val: u32) {
1038 unsafe {
1039 let val: u32 = ::std::mem::transmute(val);
1040 self._bitfield_1.set(5usize, 1u8, val as u64)
1041 }
1042 }
1043 #[inline]
1044 pub unsafe fn mappedIR_raw(this: *const Self) -> u32 {
1045 unsafe {
1046 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1047 ::std::ptr::addr_of!((*this)._bitfield_1),
1048 5usize,
1049 1u8,
1050 ) as u32)
1051 }
1052 }
1053 #[inline]
1054 pub unsafe fn set_mappedIR_raw(this: *mut Self, val: u32) {
1055 unsafe {
1056 let val: u32 = ::std::mem::transmute(val);
1057 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1058 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1059 5usize,
1060 1u8,
1061 val as u64,
1062 )
1063 }
1064 }
1065 #[inline]
1066 pub fn confidence(&self) -> u32 {
1067 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1068 }
1069 #[inline]
1070 pub fn set_confidence(&mut self, val: u32) {
1071 unsafe {
1072 let val: u32 = ::std::mem::transmute(val);
1073 self._bitfield_1.set(6usize, 1u8, val as u64)
1074 }
1075 }
1076 #[inline]
1077 pub unsafe fn confidence_raw(this: *const Self) -> u32 {
1078 unsafe {
1079 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1080 ::std::ptr::addr_of!((*this)._bitfield_1),
1081 6usize,
1082 1u8,
1083 ) as u32)
1084 }
1085 }
1086 #[inline]
1087 pub unsafe fn set_confidence_raw(this: *mut Self, val: u32) {
1088 unsafe {
1089 let val: u32 = ::std::mem::transmute(val);
1090 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1091 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1092 6usize,
1093 1u8,
1094 val as u64,
1095 )
1096 }
1097 }
1098 #[inline]
1099 pub fn wdrDepth(&self) -> u32 {
1100 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1101 }
1102 #[inline]
1103 pub fn set_wdrDepth(&mut self, val: u32) {
1104 unsafe {
1105 let val: u32 = ::std::mem::transmute(val);
1106 self._bitfield_1.set(7usize, 1u8, val as u64)
1107 }
1108 }
1109 #[inline]
1110 pub unsafe fn wdrDepth_raw(this: *const Self) -> u32 {
1111 unsafe {
1112 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1113 ::std::ptr::addr_of!((*this)._bitfield_1),
1114 7usize,
1115 1u8,
1116 ) as u32)
1117 }
1118 }
1119 #[inline]
1120 pub unsafe fn set_wdrDepth_raw(this: *mut Self, val: u32) {
1121 unsafe {
1122 let val: u32 = ::std::mem::transmute(val);
1123 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1124 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1125 7usize,
1126 1u8,
1127 val as u64,
1128 )
1129 }
1130 }
1131 #[inline]
1132 pub fn reserved(&self) -> u32 {
1133 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
1134 }
1135 #[inline]
1136 pub fn set_reserved(&mut self, val: u32) {
1137 unsafe {
1138 let val: u32 = ::std::mem::transmute(val);
1139 self._bitfield_1.set(8usize, 24u8, val as u64)
1140 }
1141 }
1142 #[inline]
1143 pub unsafe fn reserved_raw(this: *const Self) -> u32 {
1144 unsafe {
1145 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1146 ::std::ptr::addr_of!((*this)._bitfield_1),
1147 8usize,
1148 24u8,
1149 ) as u32)
1150 }
1151 }
1152 #[inline]
1153 pub unsafe fn set_reserved_raw(this: *mut Self, val: u32) {
1154 unsafe {
1155 let val: u32 = ::std::mem::transmute(val);
1156 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1157 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1158 8usize,
1159 24u8,
1160 val as u64,
1161 )
1162 }
1163 }
1164 #[inline]
1165 pub fn new_bitfield_1(
1166 depth: u32,
1167 ir: u32,
1168 rgb: u32,
1169 mappedRGB: u32,
1170 mappedDepth: u32,
1171 mappedIR: u32,
1172 confidence: u32,
1173 wdrDepth: u32,
1174 reserved: u32,
1175 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1176 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1177 __bindgen_bitfield_unit.set(0usize, 1u8, {
1178 let depth: u32 = unsafe { ::std::mem::transmute(depth) };
1179 depth as u64
1180 });
1181 __bindgen_bitfield_unit.set(1usize, 1u8, {
1182 let ir: u32 = unsafe { ::std::mem::transmute(ir) };
1183 ir as u64
1184 });
1185 __bindgen_bitfield_unit.set(2usize, 1u8, {
1186 let rgb: u32 = unsafe { ::std::mem::transmute(rgb) };
1187 rgb as u64
1188 });
1189 __bindgen_bitfield_unit.set(3usize, 1u8, {
1190 let mappedRGB: u32 = unsafe { ::std::mem::transmute(mappedRGB) };
1191 mappedRGB as u64
1192 });
1193 __bindgen_bitfield_unit.set(4usize, 1u8, {
1194 let mappedDepth: u32 = unsafe { ::std::mem::transmute(mappedDepth) };
1195 mappedDepth as u64
1196 });
1197 __bindgen_bitfield_unit.set(5usize, 1u8, {
1198 let mappedIR: u32 = unsafe { ::std::mem::transmute(mappedIR) };
1199 mappedIR as u64
1200 });
1201 __bindgen_bitfield_unit.set(6usize, 1u8, {
1202 let confidence: u32 = unsafe { ::std::mem::transmute(confidence) };
1203 confidence as u64
1204 });
1205 __bindgen_bitfield_unit.set(7usize, 1u8, {
1206 let wdrDepth: u32 = unsafe { ::std::mem::transmute(wdrDepth) };
1207 wdrDepth as u64
1208 });
1209 __bindgen_bitfield_unit.set(8usize, 24u8, {
1210 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
1211 reserved as u64
1212 });
1213 __bindgen_bitfield_unit
1214 }
1215}
1216pub type PsDeviceHandle = *mut ::std::os::raw::c_void;
1217#[repr(C, packed)]
1218#[derive(Debug, Copy, Clone)]
1219pub struct PsDeviceInfo {
1220 pub SessionCount: ::std::os::raw::c_int,
1221 pub devicetype: PsDeviceType,
1222 pub uri: [::std::os::raw::c_char; 256usize],
1223 pub fw: [::std::os::raw::c_char; 50usize],
1224 pub alias: [::std::os::raw::c_char; 64usize],
1225 pub status: PsConnectStatus,
1226 pub ip: [::std::os::raw::c_char; 16usize],
1227}
1228#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1229const _: () = {
1230 ["Size of PsDeviceInfo"][::std::mem::size_of::<PsDeviceInfo>() - 398usize];
1231 ["Alignment of PsDeviceInfo"][::std::mem::align_of::<PsDeviceInfo>() - 1usize];
1232 ["Offset of field: PsDeviceInfo::SessionCount"]
1233 [::std::mem::offset_of!(PsDeviceInfo, SessionCount) - 0usize];
1234 ["Offset of field: PsDeviceInfo::devicetype"]
1235 [::std::mem::offset_of!(PsDeviceInfo, devicetype) - 4usize];
1236 ["Offset of field: PsDeviceInfo::uri"][::std::mem::offset_of!(PsDeviceInfo, uri) - 8usize];
1237 ["Offset of field: PsDeviceInfo::fw"][::std::mem::offset_of!(PsDeviceInfo, fw) - 264usize];
1238 ["Offset of field: PsDeviceInfo::alias"]
1239 [::std::mem::offset_of!(PsDeviceInfo, alias) - 314usize];
1240 ["Offset of field: PsDeviceInfo::status"]
1241 [::std::mem::offset_of!(PsDeviceInfo, status) - 378usize];
1242 ["Offset of field: PsDeviceInfo::ip"][::std::mem::offset_of!(PsDeviceInfo, ip) - 382usize];
1243};
1244impl Default for PsDeviceInfo {
1245 fn default() -> Self {
1246 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1247 unsafe {
1248 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1249 s.assume_init()
1250 }
1251 }
1252}
1253#[repr(C)]
1254#[derive(Debug, Default, Copy, Clone)]
1255pub struct PsDataModeList {
1256 pub count: u8,
1257 pub datamodelist: [u8; 32usize],
1258}
1259#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1260const _: () = {
1261 ["Size of PsDataModeList"][::std::mem::size_of::<PsDataModeList>() - 33usize];
1262 ["Alignment of PsDataModeList"][::std::mem::align_of::<PsDataModeList>() - 1usize];
1263 ["Offset of field: PsDataModeList::count"]
1264 [::std::mem::offset_of!(PsDataModeList, count) - 0usize];
1265 ["Offset of field: PsDataModeList::datamodelist"]
1266 [::std::mem::offset_of!(PsDataModeList, datamodelist) - 1usize];
1267};
1268#[repr(C)]
1269#[derive(Debug, Default, Copy, Clone)]
1270pub struct PsDepthRangeList {
1271 pub count: u8,
1272 pub depthrangelist: [u8; 9usize],
1273}
1274#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1275const _: () = {
1276 ["Size of PsDepthRangeList"][::std::mem::size_of::<PsDepthRangeList>() - 10usize];
1277 ["Alignment of PsDepthRangeList"][::std::mem::align_of::<PsDepthRangeList>() - 1usize];
1278 ["Offset of field: PsDepthRangeList::count"]
1279 [::std::mem::offset_of!(PsDepthRangeList, count) - 0usize];
1280 ["Offset of field: PsDepthRangeList::depthrangelist"]
1281 [::std::mem::offset_of!(PsDepthRangeList, depthrangelist) - 1usize];
1282};
1283#[repr(C, packed)]
1284#[derive(Debug, Default, Copy, Clone)]
1285pub struct PsMeasuringRange {
1286 pub depthMode: u8,
1287 pub depthMaxNear: u16,
1288 pub depthMaxMid: u16,
1289 pub depthMaxFar: u16,
1290 pub effectDepthMaxNear: u16,
1291 pub effectDepthMaxMid: u16,
1292 pub effectDepthMaxFar: u16,
1293 pub effectDepthMinNear: u16,
1294 pub effectDepthMinMid: u16,
1295 pub effectDepthMinFar: u16,
1296}
1297#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1298const _: () = {
1299 ["Size of PsMeasuringRange"][::std::mem::size_of::<PsMeasuringRange>() - 19usize];
1300 ["Alignment of PsMeasuringRange"][::std::mem::align_of::<PsMeasuringRange>() - 1usize];
1301 ["Offset of field: PsMeasuringRange::depthMode"]
1302 [::std::mem::offset_of!(PsMeasuringRange, depthMode) - 0usize];
1303 ["Offset of field: PsMeasuringRange::depthMaxNear"]
1304 [::std::mem::offset_of!(PsMeasuringRange, depthMaxNear) - 1usize];
1305 ["Offset of field: PsMeasuringRange::depthMaxMid"]
1306 [::std::mem::offset_of!(PsMeasuringRange, depthMaxMid) - 3usize];
1307 ["Offset of field: PsMeasuringRange::depthMaxFar"]
1308 [::std::mem::offset_of!(PsMeasuringRange, depthMaxFar) - 5usize];
1309 ["Offset of field: PsMeasuringRange::effectDepthMaxNear"]
1310 [::std::mem::offset_of!(PsMeasuringRange, effectDepthMaxNear) - 7usize];
1311 ["Offset of field: PsMeasuringRange::effectDepthMaxMid"]
1312 [::std::mem::offset_of!(PsMeasuringRange, effectDepthMaxMid) - 9usize];
1313 ["Offset of field: PsMeasuringRange::effectDepthMaxFar"]
1314 [::std::mem::offset_of!(PsMeasuringRange, effectDepthMaxFar) - 11usize];
1315 ["Offset of field: PsMeasuringRange::effectDepthMinNear"]
1316 [::std::mem::offset_of!(PsMeasuringRange, effectDepthMinNear) - 13usize];
1317 ["Offset of field: PsMeasuringRange::effectDepthMinMid"]
1318 [::std::mem::offset_of!(PsMeasuringRange, effectDepthMinMid) - 15usize];
1319 ["Offset of field: PsMeasuringRange::effectDepthMinFar"]
1320 [::std::mem::offset_of!(PsMeasuringRange, effectDepthMinFar) - 17usize];
1321};
1322#[repr(C, packed)]
1323#[derive(Debug, Default, Copy, Clone)]
1324pub struct PsTalDelay {
1325 pub range: u8,
1326 pub value0: u16,
1327 pub value1: u16,
1328 pub value2: u16,
1329 pub value3: u16,
1330 pub value4: u16,
1331}
1332#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1333const _: () = {
1334 ["Size of PsTalDelay"][::std::mem::size_of::<PsTalDelay>() - 11usize];
1335 ["Alignment of PsTalDelay"][::std::mem::align_of::<PsTalDelay>() - 1usize];
1336 ["Offset of field: PsTalDelay::range"][::std::mem::offset_of!(PsTalDelay, range) - 0usize];
1337 ["Offset of field: PsTalDelay::value0"][::std::mem::offset_of!(PsTalDelay, value0) - 1usize];
1338 ["Offset of field: PsTalDelay::value1"][::std::mem::offset_of!(PsTalDelay, value1) - 3usize];
1339 ["Offset of field: PsTalDelay::value2"][::std::mem::offset_of!(PsTalDelay, value2) - 5usize];
1340 ["Offset of field: PsTalDelay::value3"][::std::mem::offset_of!(PsTalDelay, value3) - 7usize];
1341 ["Offset of field: PsTalDelay::value4"][::std::mem::offset_of!(PsTalDelay, value4) - 9usize];
1342};
1343#[doc = " @brief WDR (Wide Dynamic Range) output mode settings (e.g. Near/Far range fusion)."]
1344#[repr(C, packed)]
1345#[derive(Debug, Default, Copy, Clone)]
1346pub struct PsWDRPulseCount {
1347 #[doc = "!< The pulseCount of the first range."]
1348 pub pulseCount1: u16,
1349 #[doc = "!< The pulseCount of the second range."]
1350 pub pulseCount2: u16,
1351 #[doc = "!< The pulseCount of the third range."]
1352 pub pulseCount3: u16,
1353 pub option: u8,
1354}
1355#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1356const _: () = {
1357 ["Size of PsWDRPulseCount"][::std::mem::size_of::<PsWDRPulseCount>() - 7usize];
1358 ["Alignment of PsWDRPulseCount"][::std::mem::align_of::<PsWDRPulseCount>() - 1usize];
1359 ["Offset of field: PsWDRPulseCount::pulseCount1"]
1360 [::std::mem::offset_of!(PsWDRPulseCount, pulseCount1) - 0usize];
1361 ["Offset of field: PsWDRPulseCount::pulseCount2"]
1362 [::std::mem::offset_of!(PsWDRPulseCount, pulseCount2) - 2usize];
1363 ["Offset of field: PsWDRPulseCount::pulseCount3"]
1364 [::std::mem::offset_of!(PsWDRPulseCount, pulseCount3) - 4usize];
1365 ["Offset of field: PsWDRPulseCount::option"]
1366 [::std::mem::offset_of!(PsWDRPulseCount, option) - 6usize];
1367};
1368#[doc = " @brief WDR (Wide Dynamic Range) output mode settings (e.g. Near/Far range fusion)."]
1369#[repr(C, packed)]
1370#[derive(Debug, Default, Copy, Clone)]
1371pub struct PsWDRConfidenceThreshold {
1372 #[doc = "!< The confidence threshold of the first range."]
1373 pub threshold1: u16,
1374 #[doc = "!< The confidence threshold of the second range."]
1375 pub threshold2: u16,
1376 #[doc = "!< The confidence threshold of the third range."]
1377 pub threshold3: u16,
1378}
1379#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1380const _: () = {
1381 ["Size of PsWDRConfidenceThreshold"]
1382 [::std::mem::size_of::<PsWDRConfidenceThreshold>() - 6usize];
1383 ["Alignment of PsWDRConfidenceThreshold"]
1384 [::std::mem::align_of::<PsWDRConfidenceThreshold>() - 1usize];
1385 ["Offset of field: PsWDRConfidenceThreshold::threshold1"]
1386 [::std::mem::offset_of!(PsWDRConfidenceThreshold, threshold1) - 0usize];
1387 ["Offset of field: PsWDRConfidenceThreshold::threshold2"]
1388 [::std::mem::offset_of!(PsWDRConfidenceThreshold, threshold2) - 2usize];
1389 ["Offset of field: PsWDRConfidenceThreshold::threshold3"]
1390 [::std::mem::offset_of!(PsWDRConfidenceThreshold, threshold3) - 4usize];
1391};
1392#[doc = " @brief hotplug status callback function\n pInfo return the info of the Device, See ::PsDeviceInfo\n state 0:device added , 1:device removed"]
1393pub type PtrHotPlugStatusCallback = ::std::option::Option<
1394 unsafe extern "C" fn(pInfo: *const PsDeviceInfo, state: ::std::os::raw::c_int),
1395>;
1396#[doc = " @brief hotplug status callback function for c plus plus\n pInfo return the info of the Device, See ::PsDeviceInfo\n state 0:device added , 1:device removed\n contex pointer to the object of C++ class"]
1397pub type PtrHotPlugStatusCallback_ = ::std::option::Option<
1398 unsafe extern "C" fn(
1399 pInfo: *const PsDeviceInfo,
1400 state: ::std::os::raw::c_int,
1401 contex: *mut ::std::os::raw::c_void,
1402 ),
1403>;
1404unsafe extern "C" {
1405 #[doc = " @brief \t\tInitializes the API on the device. This function must be invoked before any other Vzense APIs.\n @return\t\t::PsRetOK if the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1406 pub fn Ps2_Initialize() -> PsReturnStatus;
1407}
1408unsafe extern "C" {
1409 #[doc = " @brief \t\tShuts down the API on the device and clears all resources allocated by the API. After invoking this function, no other Vzense APIs can be invoked.\n @return\t\t::PsRetOK\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1410 pub fn Ps2_Shutdown() -> PsReturnStatus;
1411}
1412unsafe extern "C" {
1413 #[doc = " @brief \t\tReturns the number of camera devices currently connected.\n @param[out]\tpDeviceCount\tPointer to a 32-bit integer variable in which to return the device count.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1414 pub fn Ps2_GetDeviceCount(pDeviceCount: *mut u32) -> PsReturnStatus;
1415}
1416unsafe extern "C" {
1417 #[doc = " @brief \t\tReturns the info lists of the deviceCount camera devices.\n @param[in] \tdeviceCount\t\tthe number of camera devices.\n @param[out]\tpDevicesList\tPointer to a buffer in which to store the deviceCount devices infos.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1418 pub fn Ps2_GetDeviceListInfo(
1419 pDevicesList: *mut PsDeviceInfo,
1420 deviceCount: u32,
1421 ) -> PsReturnStatus;
1422}
1423unsafe extern "C" {
1424 #[doc = " @brief \t\tReturns the info of the deviceIndex camera device.\n @param[in] \tdeviceIndex\tThe index of the device to open. Device indices range from 0 to device count - 1.\n @param[out]\tpDevices\tPointer to a buffer in which to store the device info.\n @return \t\t::PsRetOK\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1425 pub fn Ps2_GetDeviceInfo(pDevices: *mut PsDeviceInfo, deviceIndex: u32) -> PsReturnStatus;
1426}
1427unsafe extern "C" {
1428 #[doc = " @brief \t\tOpens the device specified by <code>uri</code>. The device must be subsequently closed using PsCloseDevice().\n @param[in] \turi\t\t\tthe uri of the device. See ::PsDeviceInfo for more information.\n @param[out]\tpDevices\tthe handle of the device on which to open.\n @return: \t\t::PsRetOK\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1429 pub fn Ps2_OpenDevice(
1430 uri: *const ::std::os::raw::c_char,
1431 pDevice: *mut PsDeviceHandle,
1432 ) -> PsReturnStatus;
1433}
1434unsafe extern "C" {
1435 #[doc = " @brief \t\tCloses the device specified by <code>device</code> that was opened using PsOpenDevice.\n @param[in] \tdevice\t\tThe handle of the device to close.\n @return: \t\t::PsRetOK\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1436 pub fn Ps2_CloseDevice(device: *mut PsDeviceHandle) -> PsReturnStatus;
1437}
1438unsafe extern "C" {
1439 #[doc = " @brief \t\tStarts capturing the image stream indicated by <code>device</code>. \\n\nInvoke Ps2_StopStream() to stop capturing the image stream.\n @param[in] \tdevice\t\t\tThe handle of the device on which to start capturing the image stream.\n @param[in] \tsessionIndex\tThe index of the session that include N Tof sensors and maximum N RGB sensors. \\n\nrange from 0 to ::SessionCount - 1. See ::PsDeviceInfo for more information. \\n\nFor example, the camera <code>device</code> has 2 Tof sensor and 1 rgb sensor, the ::SessionCount is 2.\\n\nIf the <code>sessionIndex</code> is 0 mean that start 1 tof stream and the rgb stream, \\n\nand if the <code>sessionIndex</code> is 1 mean that start only 1 tof stream.\n @return \t ::PsRetOK if\tthe function succeeded, or one of the error values defined by ::PsReturnStatus."]
1440 pub fn Ps2_StartStream(device: PsDeviceHandle, sessionIndex: u32) -> PsReturnStatus;
1441}
1442unsafe extern "C" {
1443 #[doc = " @brief \t\tStops capturing the image stream on the device specified by <code>device</code>. that was started using Ps2_StartStream.\n @param[in] \tdevice\t\t\tThe handle of the device on which to stop capturing the image stream.\n @param[in] \tsessionIndex\tThe index of the session that include N Tof sensors and maximum N RGB sensors. \\n\nrange from 0 to ::SessionCount - 1. See ::PsDeviceInfo for more information. \\n\nFor example, the camera <code>device</code> has 2 Tof sensor and 1 rgb sensor, the ::SessionCount is 2.\\n\nIf the <code>sessionIndex</code> is 0 mean that stop 1 tof stream and the rgb stream, \\n\nand if the <code>sessionIndex</code> is 1 mean that stop only 1 tof stream.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1444 pub fn Ps2_StopStream(device: PsDeviceHandle, sessionIndex: u32) -> PsReturnStatus;
1445}
1446unsafe extern "C" {
1447 #[doc = " @brief \t\tCaptures the next image frame from the device specified by <code>device</code>. This API must be invoked before capturing frame data using PsGetFrame().\n @param[in] \tdevice\t\t\tThe handle of the device on which to read the next frame.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tpFrameReady\t\tPointer to a buffer in which to store the signal on which image is ready to be get.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1448 pub fn Ps2_ReadNextFrame(
1449 device: PsDeviceHandle,
1450 sessionIndex: u32,
1451 pFrameReady: *mut PsFrameReady,
1452 ) -> PsReturnStatus;
1453}
1454unsafe extern "C" {
1455 #[doc = " @brief \t\tReturns the image data for the current frame from the device specified by <code>device</code>.\\n\nBefore invoking this API, invoke PsReadNextFrame() to capture one image frame from the device.\n @param[in] \tdevice\t\t\tThe handle of the device to capture an image frame from.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tframeType\t\tThe image frame type.\n @param[out]\tpPsFrame\t\tPointer to a buffer in which to store the returned image data.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1456 pub fn Ps2_GetFrame(
1457 device: PsDeviceHandle,
1458 sessionIndex: u32,
1459 frameType: PsFrameType,
1460 pPsFrame: *mut PsFrame,
1461 ) -> PsReturnStatus;
1462}
1463unsafe extern "C" {
1464 #[doc = " @brief \t\tSets the output data mode for the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device for which to set the data mode.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tdataMode\t\tThe output data mode. See ::PsDataMode for more information.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1465 pub fn Ps2_SetDataMode(
1466 device: PsDeviceHandle,
1467 sessionIndex: u32,
1468 dataMode: PsDataMode,
1469 ) -> PsReturnStatus;
1470}
1471unsafe extern "C" {
1472 #[doc = " @brief \t\tReturns the output data mode from the device specified by <code>device</code>.\n @param[in]\tdevice\t\t\tThe handle of the device for which to set the data mode.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[Out]\tdataMode\t\tThe output data mode. See ::PsDataMode for more information.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1473 pub fn Ps2_GetDataMode(
1474 device: PsDeviceHandle,
1475 sessionIndex: u32,
1476 dataMode: *mut PsDataMode,
1477 ) -> PsReturnStatus;
1478}
1479unsafe extern "C" {
1480 #[doc = " @brief \t\tReturns the depth range mode from the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device from which to get the depth range.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tpDepthRange\t\tPointer to a ::PsDepthRange variable in which to store the returned depth range mode.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1481 pub fn Ps2_GetDepthRange(
1482 device: PsDeviceHandle,
1483 sessionIndex: u32,
1484 pDepthRange: *mut PsDepthRange,
1485 ) -> PsReturnStatus;
1486}
1487unsafe extern "C" {
1488 #[doc = " @brief \t\tSets the depth range mode for the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the depth range.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tdepthRange \t\tSpecifies the depth range mode.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1489 pub fn Ps2_SetDepthRange(
1490 device: PsDeviceHandle,
1491 sessionIndex: u32,
1492 depthRange: PsDepthRange,
1493 ) -> PsReturnStatus;
1494}
1495unsafe extern "C" {
1496 #[doc = " @brief \t\tReturns the threshold value for the background filter from the device specified by <code>device</code>. \\n\nThe value represents the cut-off point for distant data that the filter should ignore. \\n\nFor example, if 20.0 is specified, data with 20% or less confidence will be dropped.\n @param[in] \tdevice\t\t\tThe handle of the device from which to get the threshold.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out] \tpThreshold \t\tPointer to a 16-bit unsigned integer variable in which to return the threshold value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1497 pub fn Ps2_GetThreshold(
1498 device: PsDeviceHandle,
1499 sessionIndex: u32,
1500 pThreshold: *mut u16,
1501 ) -> PsReturnStatus;
1502}
1503unsafe extern "C" {
1504 #[doc = " @brief \t\tSets the threshold value for the background filter for the device specified by <code>device</code>. \\n\nThe value represents the cut-off point for distant data that the filter should ignore. \\n\nFor example, if 20.0 is specified, data with 20% or less confidence will be dropped.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the threshold.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tthreshold\t\tThe threshold value to set. 0 will attempt to keep all point data but may not be accurate further away; 100 or higher will reject almost all point data leaving only the closest points.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1505 pub fn Ps2_SetThreshold(
1506 device: PsDeviceHandle,
1507 sessionIndex: u32,
1508 threshold: u16,
1509 ) -> PsReturnStatus;
1510}
1511unsafe extern "C" {
1512 #[doc = " @brief \t\tReturns the pulse count from the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the pulse count.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out] \tpPulseCount\t\tPointer to a 16-bit unsigned integer variable in which to store the pulse count value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1513 pub fn Ps2_GetPulseCount(
1514 device: PsDeviceHandle,
1515 sessionIndex: u32,
1516 pPulseCount: *mut u16,
1517 ) -> PsReturnStatus;
1518}
1519unsafe extern "C" {
1520 #[doc = " @brief \t\tSets the pulse count for the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the pulse count.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tpulseCount \t\tThe pulse count value to set.For the range 3 and 4,the value is in the range [0,260],for the other range,the value is in the range [0,600].\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1521 pub fn Ps2_SetPulseCount(
1522 device: PsDeviceHandle,
1523 sessionIndex: u32,
1524 pulseCount: u16,
1525 ) -> PsReturnStatus;
1526}
1527unsafe extern "C" {
1528 #[doc = " @brief \t\tReturns the the device's GMM gain.\n @param[in]\tdevice\t\t\tThe handle of the device from which to get the GMM gain.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out] \tgmmgain \t\tPointer to a variable in which to store the returned GMM gain.\n @return\t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1529 pub fn Ps2_GetGMMGain(
1530 device: PsDeviceHandle,
1531 sessionIndex: u32,
1532 gmmgain: *mut u16,
1533 ) -> PsReturnStatus;
1534}
1535unsafe extern "C" {
1536 #[doc = " @brief \t\tSets the device GMM gain on a device.\n @param[in]\tdevice\t\t\tThe handle of the device on which to set the GMM gain.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tgmmgain\t\t\tThe GMM gain value to set. See ::PsGMMGain for more information.The GMM gain value is in the range [0,4095].\n @return\t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1537 pub fn Ps2_SetGMMGain(
1538 device: PsDeviceHandle,
1539 sessionIndex: u32,
1540 gmmgain: PsGMMGain,
1541 ) -> PsReturnStatus;
1542}
1543unsafe extern "C" {
1544 #[doc = " @brief \t\tReturns a specific property value from the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device from which to get the property value.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tpropertyType\tThe type of property to get from the device. See ::PsPropertyType for more information.\n @param[out]\tpData\t\t\tPointer to a buffer to store the returned property value.\n @param[out]\tpDataSize\t\tThe size, in bytes, of the property value returned in <code>pData</code>.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1545 pub fn Ps2_GetProperty(
1546 device: PsDeviceHandle,
1547 sessionIndex: u32,
1548 propertyType: i32,
1549 pData: *mut ::std::os::raw::c_void,
1550 pDataSize: *mut i32,
1551 ) -> PsReturnStatus;
1552}
1553unsafe extern "C" {
1554 #[doc = " @brief \t\tSet the corresponding property value for the device specified by <code>device</code>.\n @param[in]\tdevice\t\t\tThe handle of the device from which to set the property value.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tpropertyType\tThe type of property to set on the device.\n @param[in]\tpData\t\t\tPointer to a buffer containing the property value.\n @param[in]\tdataSize\t\tThe size, in bytes, of the property value contained in <code>pData</code>.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1555 pub fn Ps2_SetProperty(
1556 device: PsDeviceHandle,
1557 sessionIndex: u32,
1558 propertyType: i32,
1559 pData: *const ::std::os::raw::c_void,
1560 dataSize: i32,
1561 ) -> PsReturnStatus;
1562}
1563unsafe extern "C" {
1564 #[doc = " @brief \t\tReturns the internal intrinsic and distortion coefficient parameters from the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\t\tThe handle of the device from which to get the internal parameters.\n @param[in] \tsessionIndex\t\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tsensorType\t\t\tThe type of sensor (depth or RGB) from which to get parameter information. Pass in the applicable value defined by ::PsSensorType.\n @param[out] \tpCameraParameters\tPointer to a PsCameraParameters variable in which to store the parameter values.\n @return \t\t::PsRetOK\t\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1565 pub fn Ps2_GetCameraParameters(
1566 device: PsDeviceHandle,
1567 sessionIndex: u32,
1568 sensorType: PsSensorType,
1569 pCameraParameters: *mut PsCameraParameters,
1570 ) -> PsReturnStatus;
1571}
1572unsafe extern "C" {
1573 #[doc = " @brief \t\tReturns the camera rotation and translation coefficient parameters from the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\t\t\t\tThe handle of the device from which to get the extrinsic parameters.\n @param[in] \tsessionIndex\t\t\t\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out] \tpCameraExtrinsicParameters \tPointer to a ::PsGetCameraExtrinsicParameters variable in which to store the parameters.\n @return \t\t::PsRetOK\t\t\t\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1574 pub fn Ps2_GetCameraExtrinsicParameters(
1575 device: PsDeviceHandle,
1576 sessionIndex: u32,
1577 pCameraExtrinsicParameters: *mut PsCameraExtrinsicParameters,
1578 ) -> PsReturnStatus;
1579}
1580unsafe extern "C" {
1581 #[doc = " @brief \t\tSets the color image pixel format on the device specified by <code>device</code>. Currently only RGB and BGR formats are supported.\n @param[in] \tdevice\t\t\tThe handle of the device to set the pixel format.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tpixelFormat\t\tThe color pixel format to use. Pass in one of the values defined by ::PsPixelFormat. Currently only <code>PsPixelFormatRGB888</code> and <code>PsPixelFormatBGR888</code> are supported.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1582 pub fn Ps2_SetColorPixelFormat(
1583 device: PsDeviceHandle,
1584 sessionIndex: u32,
1585 pixelFormat: PsPixelFormat,
1586 ) -> PsReturnStatus;
1587}
1588unsafe extern "C" {
1589 #[doc = " @brief \t\tSets the RGB frame Resolution.\n @param[in]\tdevice\t\t\tThe handle of the device on which to set the GMM gain.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tresolution\t\tThe resolution value to set. See ::PsResolution for more information.\n @return\t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1590 pub fn Ps2_SetRGBResolution(
1591 device: PsDeviceHandle,
1592 sessionIndex: u32,
1593 resolution: PsResolution,
1594 ) -> PsReturnStatus;
1595}
1596unsafe extern "C" {
1597 #[doc = " @brief \t\tReturns the the RGB frame Resolution.\n @param[in]\tdevice\t\t\tThe handle of the device from which to get the GMM gain.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out] \tresolution \t\tPointer to a variable in which to store the returned resolution.\n @return\t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1598 pub fn Ps2_GetRGBResolution(
1599 device: PsDeviceHandle,
1600 sessionIndex: u32,
1601 resolution: *mut u16,
1602 ) -> PsReturnStatus;
1603}
1604unsafe extern "C" {
1605 #[doc = " @brief \t\tSets the WDR output mode.\n @param[in]\tdevice\t\t\tThe handle of the device on which to set the mode.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tpWDRMode \t\tThe WDR output mode to set. See ::PsWDROutputMode for more information.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1606 pub fn Ps2_SetWDROutputMode(
1607 device: PsDeviceHandle,
1608 sessionIndex: u32,
1609 pWDRMode: *mut PsWDROutputMode,
1610 ) -> PsReturnStatus;
1611}
1612unsafe extern "C" {
1613 #[doc = " @brief\t\tGets the current WDR output mode.\n @param[in]\tdevice\t\t\tThe handle of the device on which to get the mode from.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tpWDRMode \t\tA pointer to a ::PsWDROutputMode variable in which to store the current WDR output mode.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1614 pub fn Ps2_GetWDROutputMode(
1615 device: PsDeviceHandle,
1616 sessionIndex: u32,
1617 pWDRMode: *mut PsWDROutputMode,
1618 ) -> PsReturnStatus;
1619}
1620unsafe extern "C" {
1621 #[doc = " @brief \t\tSets the WDR style on the device.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the WDR style.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \twdrStyle \t\tThe wide dynamic range merge style to use. See ::PsWDRStyle for more information.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1622 pub fn Ps2_SetWDRStyle(
1623 device: PsDeviceHandle,
1624 sessionIndex: u32,
1625 wdrStyle: PsWDRStyle,
1626 ) -> PsReturnStatus;
1627}
1628unsafe extern "C" {
1629 #[doc = " @brief \t\tGets the MeasuringRange in depthRange.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the WDR style.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tdepthRange\t \tSpecifies the depth range mode.\n @param[out]\tpMeasuringRange A pointer to a ::PsMeasuringRange variable in which to store the MeasuringRange in depthRange.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1630 pub fn Ps2_GetMeasuringRange(
1631 device: PsDeviceHandle,
1632 sessionIndex: u32,
1633 depthRange: PsDepthRange,
1634 pMeasuringRange: *mut PsMeasuringRange,
1635 ) -> PsReturnStatus;
1636}
1637unsafe extern "C" {
1638 #[doc = " @brief \t\tConverts the input points from world coordinate space to depth coordinate space.\n @param[in]\tdevice\t\t\tThe handle of the device on which to perform the operation.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tpWorldVector \tPointer to a buffer containing the x, y, and z values of the input world coordinates to be converted, measured in millimeters.\n @param[out]\tpDepthVector \tPointer to a buffer in which to output the converted x, y, and z values of the depth coordinates. \\n\n\t\t\t\t\t\t\t\tx and y are measured in pixels, where 0, 0 is located at the top left corner of the image. \\n\n\t\t\t\t\t\t\t\tz is measured in millimeters, based on the ::PsPixelFormat depth frame.\n @param[in]\tpointCount \t\tThe number of coordinates to convert.\n @param[in]\tpCameraParam\tThe intrinsic camera parameters for the depth camera. See ::PsGetCameraParameters.\n @return\t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1639 pub fn Ps2_ConvertWorldToDepth(
1640 device: PsDeviceHandle,
1641 sessionIndex: u32,
1642 pWorldVector: *mut PsVector3f,
1643 pDepthVector: *mut PsDepthVector3,
1644 pointCount: i32,
1645 pCameraParam: *mut PsCameraParameters,
1646 ) -> PsReturnStatus;
1647}
1648unsafe extern "C" {
1649 #[doc = " @brief \t\tConverts the input points from depth coordinate space to world coordinate space.\n @param[in] \tdevice\t\t\tThe handle of the device on which to perform the operation.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tpDepthVector \tPointer to a buffer containing the x, y, and z values of the depth coordinates to be converted. \\n\n \t\t\t\t\t\t\t x and y are measured in pixels, where 0, 0 is located at the top left corner of the image. \\n\n\t z is measured in millimeters, based on the ::PsPixelFormat depth frame.\n @param[out] \tpWorldVector \tPointer to a buffer in which to output the converted x, y, and z values of the world coordinates, measured in millimeters.\n @param[in] \tpointCount \t\tThe number of points to convert.\n @param[in]\tpCameraParam\tThe intrinsic camera parameters for the depth camera. See ::PsGetCameraParameters.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1650 pub fn Ps2_ConvertDepthToWorld(
1651 device: PsDeviceHandle,
1652 sessionIndex: u32,
1653 pDepthVector: *mut PsDepthVector3,
1654 pWorldVector: *mut PsVector3f,
1655 pointCount: i32,
1656 pCameraParam: *mut PsCameraParameters,
1657 ) -> PsReturnStatus;
1658}
1659unsafe extern "C" {
1660 #[doc = " @brief \t\tConverts the input Depth frame from depth coordinate space to world coordinate space on the device.\n @param[in] \tdevice\t\t\tThe handle of the device on which to perform the operation.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tdepthFrame\t\tThe depth frame.\n @param[out] \tpWorldVector \tPointer to a buffer in which to output the converted x, y, and z values of the world coordinates, measured in millimeters.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1661 pub fn Ps2_ConvertDepthFrameToWorldVector(
1662 device: PsDeviceHandle,
1663 sessionIndex: u32,
1664 depthFrame: PsFrame,
1665 pWorldVector: *mut PsVector3f,
1666 ) -> PsReturnStatus;
1667}
1668unsafe extern "C" {
1669 #[doc = " @brief\t\tEnables or disables the syncronize feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1670 pub fn Ps2_SetSynchronizeEnabled(
1671 device: PsDeviceHandle,
1672 sessionIndex: u32,
1673 bEnabled: u8,
1674 ) -> PsReturnStatus;
1675}
1676unsafe extern "C" {
1677 #[doc = " @brief \t\tReturns the Boolean value of whether the syncronize feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1678 pub fn Ps2_GetSynchronizeEnabled(
1679 device: PsDeviceHandle,
1680 sessionIndex: u32,
1681 bEnabled: *mut u8,
1682 ) -> PsReturnStatus;
1683}
1684unsafe extern "C" {
1685 #[doc = " @brief \t\tEnables or disables the depth and ir distortion correction feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1686 pub fn Ps2_SetDepthDistortionCorrectionEnabled(
1687 device: PsDeviceHandle,
1688 sessionIndex: u32,
1689 bEnabled: u8,
1690 ) -> PsReturnStatus;
1691}
1692unsafe extern "C" {
1693 #[doc = " @brief \t\tReturns the Boolean value of whether the depth and ir distortion correction feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1694 pub fn Ps2_GetDepthDistortionCorrectionEnabled(
1695 device: PsDeviceHandle,
1696 sessionIndex: u32,
1697 bEnabled: *mut u8,
1698 ) -> PsReturnStatus;
1699}
1700unsafe extern "C" {
1701 #[doc = " @brief \t\tEnables or disables the RGB distortion correction feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1702 pub fn Ps2_SetRGBDistortionCorrectionEnabled(
1703 device: PsDeviceHandle,
1704 sessionIndex: u32,
1705 bEnabled: u8,
1706 ) -> PsReturnStatus;
1707}
1708unsafe extern "C" {
1709 #[doc = " @brief \t\tReturns the Boolean value of whether the RGB distortion correction feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1710 pub fn Ps2_GetRGBDistortionCorrectionEnabled(
1711 device: PsDeviceHandle,
1712 sessionIndex: u32,
1713 bEnabled: *mut u8,
1714 ) -> PsReturnStatus;
1715}
1716unsafe extern "C" {
1717 #[doc = " @brief\t\tEnables or disables the ComputeRealDepth feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1718 pub fn Ps2_SetComputeRealDepthCorrectionEnabled(
1719 device: PsDeviceHandle,
1720 sessionIndex: u32,
1721 bEnabled: u8,
1722 ) -> PsReturnStatus;
1723}
1724unsafe extern "C" {
1725 #[doc = " @brief \t\tReturns the Boolean value of whether the ComputeRealDepth feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1726 pub fn Ps2_GetComputeRealDepthCorrectionEnabled(
1727 device: PsDeviceHandle,
1728 sessionIndex: u32,
1729 bEnabled: *mut u8,
1730 ) -> PsReturnStatus;
1731}
1732unsafe extern "C" {
1733 #[doc = " @brief\t\tEnables or disables the SpatialFilter feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1734 pub fn Ps2_SetSpatialFilterEnabled(
1735 device: PsDeviceHandle,
1736 sessionIndex: u32,
1737 bEnabled: u8,
1738 ) -> PsReturnStatus;
1739}
1740unsafe extern "C" {
1741 #[doc = " @brief \t\tReturns the Boolean value of whether the SpatialFilter feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1742 pub fn Ps2_GetSpatialFilterEnabled(
1743 device: PsDeviceHandle,
1744 sessionIndex: u32,
1745 bEnabled: *mut u8,
1746 ) -> PsReturnStatus;
1747}
1748unsafe extern "C" {
1749 #[doc = " @brief\t\tEnables or disables the TimeFilter feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1750 pub fn Ps2_SetTimeFilterEnabled(
1751 device: PsDeviceHandle,
1752 sessionIndex: u32,
1753 bEnabled: u8,
1754 ) -> PsReturnStatus;
1755}
1756unsafe extern "C" {
1757 #[doc = " @brief \t\tReturns the Boolean value of whether the TimeFilter feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1758 pub fn Ps2_GetTimeFilterEnabled(
1759 device: PsDeviceHandle,
1760 sessionIndex: u32,
1761 bEnabled: *mut u8,
1762 ) -> PsReturnStatus;
1763}
1764unsafe extern "C" {
1765 #[doc = " @brief\t\tEnables or disables the Depth Stream feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1766 pub fn Ps2_SetDepthFrameEnabled(
1767 device: PsDeviceHandle,
1768 sessionIndex: u32,
1769 bEnabled: u8,
1770 ) -> PsReturnStatus;
1771}
1772unsafe extern "C" {
1773 #[doc = " @brief\t\tEnables or disables the IR Stream feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1774 pub fn Ps2_SetIrFrameEnabled(
1775 device: PsDeviceHandle,
1776 sessionIndex: u32,
1777 bEnabled: u8,
1778 ) -> PsReturnStatus;
1779}
1780unsafe extern "C" {
1781 #[doc = " @brief\t\tEnables or disables the RGB Stream feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1782 pub fn Ps2_SetRgbFrameEnabled(
1783 device: PsDeviceHandle,
1784 sessionIndex: u32,
1785 bEnabled: u8,
1786 ) -> PsReturnStatus;
1787}
1788unsafe extern "C" {
1789 #[doc = " @brief\t\tSets the ImageMirror feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\ttype\t\t\t1 left-right mirror; 2 up-down mirror;3 both mirror (rotation 180)\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1790 pub fn Ps2_SetImageMirror(
1791 device: PsDeviceHandle,
1792 sessionIndex: u32,
1793 type_: i32,
1794 ) -> PsReturnStatus;
1795}
1796unsafe extern "C" {
1797 #[doc = " @brief\t\tSets the ImageRotation feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\ttype\t\t\t0 counterclock 906у; 1 counterclock 1806у;2 counterclock 2706у\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1798 pub fn Ps2_SetImageRotation(
1799 device: PsDeviceHandle,
1800 sessionIndex: u32,
1801 type_: i32,
1802 ) -> PsReturnStatus;
1803}
1804unsafe extern "C" {
1805 #[doc = " @brief \t\tEnables or disables mapping of the depth image to RGB space on the device. When enabled, PsGetFrame() can\\n\n \t\tbe invoked passing ::PsMappedRGBFrame as the frame type, to get the depth frame that is mapped to RGB space. The resolution of\\n\n \t\tthe mapped rgb frame is the same as that of the depth image.\n @param[in] \tdevice\t\t\tThe handle of the device on which to enable or disable mapping.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tbEnabled \t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1806 pub fn Ps2_SetMapperEnabledDepthToRGB(
1807 device: PsDeviceHandle,
1808 sessionIndex: u32,
1809 bEnabled: u8,
1810 ) -> PsReturnStatus;
1811}
1812unsafe extern "C" {
1813 #[doc = " @brief \t\tReturns the Boolean value of whether the mapping of the depth image to RGB space feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1814 pub fn Ps2_GetMapperEnabledDepthToRGB(
1815 device: PsDeviceHandle,
1816 sessionIndex: u32,
1817 bEnabled: *mut u8,
1818 ) -> PsReturnStatus;
1819}
1820unsafe extern "C" {
1821 #[doc = " @brief \t\tEnables or disables mapping of the RGB image to depth space on the device. When enabled, PsGetFrame()\\n\ncan be invoked passing ::PsMappedDepthFrame as the frame type, to get the RGB frame that is mapped to depth space. The resolution\\n\nof the mapped depth frame is the same as that of the RGB image.\n @param[in] \tdevice\t\t\tThe handle of the device on which to enable or disable mapping.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tbEnabled \t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1822 pub fn Ps2_SetMapperEnabledRGBToDepth(
1823 device: PsDeviceHandle,
1824 sessionIndex: u32,
1825 bEnabled: u8,
1826 ) -> PsReturnStatus;
1827}
1828unsafe extern "C" {
1829 #[doc = " @brief \t\tReturns the Boolean value of whether the mapping of the RGB image to depth space feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1830 pub fn Ps2_GetMapperEnabledRGBToDepth(
1831 device: PsDeviceHandle,
1832 sessionIndex: u32,
1833 bEnabled: *mut u8,
1834 ) -> PsReturnStatus;
1835}
1836unsafe extern "C" {
1837 #[doc = " @brief \t\tSets hotplug status callback function\n @param[in]\tpCallback\t\tPointer to the callback function. See ::PtrHotPlugStatusCallback\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1838 pub fn Ps2_SetHotPlugStatusCallback(pCallback: PtrHotPlugStatusCallback) -> PsReturnStatus;
1839}
1840unsafe extern "C" {
1841 #[doc = " @brief \t\tSets hotplug status callback function for c plus plus\n @param[in]\tpCallback\t\tPointer to the callback function. See ::PtrHotPlugStatusCallback\n @param[in]\tcontex\t\t Pointer to the object of C++ class\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1842 pub fn Ps2_SetHotPlugStatusCallback_(
1843 pCallback: PtrHotPlugStatusCallback_,
1844 contex: *mut ::std::os::raw::c_void,
1845 ) -> PsReturnStatus;
1846}
1847unsafe extern "C" {
1848 #[doc = " @brief \t\tReturns the pulse count from the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the pulse count.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out] \tpwdrPulseCount\tA pointer to a ::PsWDRPulseCount variable in which to store the PulseCount in WDR mode.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1849 pub fn Ps2_GetWDRPulseCount(
1850 device: PsDeviceHandle,
1851 sessionIndex: u32,
1852 pwdrPulseCount: *mut PsWDRPulseCount,
1853 ) -> PsReturnStatus;
1854}
1855unsafe extern "C" {
1856 #[doc = " @brief \t\tSets the pulse count for the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the pulse count.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tpwdrPulseCount \tThe PulseCount value in WDR mode to set.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1857 pub fn Ps2_SetWDRPulseCount(
1858 device: PsDeviceHandle,
1859 sessionIndex: u32,
1860 wdrpulseCount: PsWDRPulseCount,
1861 ) -> PsReturnStatus;
1862}
1863unsafe extern "C" {
1864 #[doc = " @brief \t\tGets the serial number.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the pulse count.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tsn \t\t\t\tPointer to a variable in which to store the returned sn value.\n @param[in] \tlength \t\t\tThe maximum length is 63 bytes.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1865 pub fn Ps2_GetSerialNumber(
1866 device: PsDeviceHandle,
1867 sessionIndex: u32,
1868 sn: *mut ::std::os::raw::c_char,
1869 length: ::std::os::raw::c_int,
1870 ) -> PsReturnStatus;
1871}
1872unsafe extern "C" {
1873 #[doc = " @brief \t\tGets the firmware version number.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the pulse count.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tfw \t\t\t\tPointer to a variable in which to store the returned fw value.\n @param[in] \tlength \t\t\tThe maximum length is 63 bytes.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1874 pub fn Ps2_GetFirmwareVersionNumber(
1875 device: PsDeviceHandle,
1876 sessionIndex: u32,
1877 fw: *mut ::std::os::raw::c_char,
1878 length: ::std::os::raw::c_int,
1879 ) -> PsReturnStatus;
1880}
1881unsafe extern "C" {
1882 #[doc = " @brief\t\tEnables or disables the DSP feature for tof frame.\n\t\t\t\tThe DSP feature only support ComputeRealDepthCorrection and SpatialFilter.\n\t The default filter has ComputeRealDepthCorrection, SpatialFilter,TimeFilter, DepthDistortionCorrection and IrDistortionCorrection.\n\t\t\t\tEnable the DSP feature can reduce SDK loading, but disable it has a better effect.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1883 pub fn Ps2_SetDSPEnabled(
1884 device: PsDeviceHandle,
1885 sessionIndex: u32,
1886 bEnabled: u8,
1887 ) -> PsReturnStatus;
1888}
1889unsafe extern "C" {
1890 #[doc = " @brief\t\tReturns the Boolean value of whether the DSP feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1891 pub fn Ps2_GetDSPEnabled(
1892 device: PsDeviceHandle,
1893 sessionIndex: u32,
1894 bEnabled: *mut u8,
1895 ) -> PsReturnStatus;
1896}
1897unsafe extern "C" {
1898 pub fn Ps2_SetSlaveModeEnabled(
1899 device: PsDeviceHandle,
1900 sessionIndex: u32,
1901 bEnabled: u8,
1902 ) -> PsReturnStatus;
1903}
1904unsafe extern "C" {
1905 #[doc = " @brief \t\tSets the tof frame rate.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the pulse count.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tvalue \t\t The value of rate,in 3,5,6,10,15,30.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1906 pub fn Ps2_SetTofFrameRate(
1907 device: PsDeviceHandle,
1908 sessionIndex: u32,
1909 value: u8,
1910 ) -> PsReturnStatus;
1911}
1912unsafe extern "C" {
1913 #[doc = " @brief \t\tGets the tof frame rate.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the pulse count.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tvalue \t\t The rate value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1914 pub fn Ps2_GetTofFrameRate(
1915 device: PsDeviceHandle,
1916 sessionIndex: u32,
1917 value: *mut u8,
1918 ) -> PsReturnStatus;
1919}
1920unsafe extern "C" {
1921 #[doc = " @brief\t\tEnables or disables the StandBy feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1922 pub fn Ps2_SetStandByEnabled(
1923 device: PsDeviceHandle,
1924 sessionIndex: u32,
1925 bEnabled: u8,
1926 ) -> PsReturnStatus;
1927}
1928unsafe extern "C" {
1929 #[doc = " @brief \t\tOpens the device specified by <code>alias</code>. The device must be subsequently closed using PsCloseDevice().\n @param[in] \talias\t\tthe alias of the device. See ::PsDeviceInfo for more information.\n @param[out]\tpDevices\tthe handle of the device on which to open.\n @return: \t\t::PsRetOK\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1930 pub fn Ps2_OpenDeviceByAlias(
1931 alias: *const ::std::os::raw::c_char,
1932 pDevice: *mut PsDeviceHandle,
1933 ) -> PsReturnStatus;
1934}
1935unsafe extern "C" {
1936 #[doc = " @brief \t\tSet the waittime of read next frame.\n @param[in] \tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \ttime \t\t\tThe unit is millisecond, the value is in the range (0,65535) and the default value is 350 millisecond.\n You can change the value according to the frame rate. For example,the frame rate is 30, so the theoretical waittime interval is 33ms, but if set the time value is 20ms,\n it means the max wait time is 20 ms when capturing next frame, so when call the Ps2_ReadNextFrame, it may return PsRetReadNextFrameTimeOut(-11).\n so the value range that recommended is [50.350].\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1937 pub fn Ps2_SetWaitTimeOfReadNextFrame(
1938 device: PsDeviceHandle,
1939 sessionIndex: u32,
1940 time: u16,
1941 ) -> PsReturnStatus;
1942}
1943unsafe extern "C" {
1944 #[doc = " @brief \t\tGets the version of SDK.\n @param[in] \tversion \t\tPointer to a variable in which to store the returned version value.\n @param[in] \tlength \t\t\tThe maximum length is 63 bytes.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1945 pub fn Ps2_GetSDKVersion(
1946 version: *mut ::std::os::raw::c_char,
1947 length: ::std::os::raw::c_int,
1948 ) -> PsReturnStatus;
1949}
1950unsafe extern "C" {
1951 #[doc = " @brief \t\tReturns the point value of the frame that the mapping of the depth image to RGB space.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tpointInDepth\tThe point in depth frame.\n @param[in]\trgbSize\t\t\tThe size(x = w,y = h) of rgb frame.\n\n @param[out]\tpPointInRGB\t\tThe point in the rgb frame.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1952 pub fn Ps2_GetMappedPointDepthToRGB(
1953 device: PsDeviceHandle,
1954 sessionIndex: u32,
1955 depthPoint: PsDepthVector3,
1956 rgbSize: PsVector2u16,
1957 pPosInRGB: *mut PsVector2u16,
1958 ) -> PsReturnStatus;
1959}
1960unsafe extern "C" {
1961 #[doc = " @brief\t\tTrigger frame data once in slave mode.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1962 pub fn Ps2_SetSlaveTrigger(device: PsDeviceHandle, sessionIndex: u32) -> PsReturnStatus;
1963}
1964unsafe extern "C" {
1965 #[doc = " @brief \t\tGets IP from the device specified by <code>uri</code>.\n @param[in] \turi\t\t\tthe uri of the device. See ::PsDeviceInfo for more information.\n @param[out]\tip\t\t\tPointer to a buffer in which to store the device IP. the buffer default size is 17, and the last buffer set '\\0'.\n @return: \t\t::PsRetOK\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1966 pub fn Ps2_GetDeviceIP(
1967 uri: *const ::std::os::raw::c_char,
1968 ip: *mut ::std::os::raw::c_char,
1969 ) -> PsReturnStatus;
1970}
1971unsafe extern "C" {
1972 #[doc = " @brief \t\tGets the MAC from the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[out]\tmac\t\t\t\tPointer to a buffer in which to store the device MAC. the buffer default size is 18, and the last buffer set '\\0'.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1973 pub fn Ps2_GetDeviceMAC(
1974 device: PsDeviceHandle,
1975 sessionIndex: u32,
1976 mac: *mut ::std::os::raw::c_char,
1977 ) -> PsReturnStatus;
1978}
1979unsafe extern "C" {
1980 #[doc = " @brief \t\tSets the RGB brightness.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[in]\tvalue\t\t\tThe value of brightness,in [-64,64].\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1981 pub fn Ps2_SetRGBBrightness(
1982 device: PsDeviceHandle,
1983 sessionIndex: u32,
1984 value: ::std::os::raw::c_char,
1985 ) -> PsReturnStatus;
1986}
1987unsafe extern "C" {
1988 #[doc = " @brief \t\tGets the RGB brightness.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[out]\tvalue\t\t\tThe value of brightness,in [-64,64].\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1989 pub fn Ps2_GetRGBBrightness(
1990 device: PsDeviceHandle,
1991 sessionIndex: u32,
1992 value: *mut ::std::os::raw::c_char,
1993 ) -> PsReturnStatus;
1994}
1995unsafe extern "C" {
1996 #[doc = " @brief \t\tSets the maximum exposure time of RGB in AEC.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[in]\tvalue\t\t\tThe value of brightness,in [1,30] and the unit is 1ms.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
1997 pub fn Ps2_SetRGBMaximumExposureTime(
1998 device: PsDeviceHandle,
1999 sessionIndex: u32,
2000 value: u8,
2001 ) -> PsReturnStatus;
2002}
2003unsafe extern "C" {
2004 #[doc = " @brief \t\tGets the maximum exposure time of RGB in AEC.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[out]\tvalue\t\t\tThe value of brightness,in [1,30] and the unit is 1ms.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2005 pub fn Ps2_GetRGBMaximumExposureTime(
2006 device: PsDeviceHandle,
2007 sessionIndex: u32,
2008 value: *mut u8,
2009 ) -> PsReturnStatus;
2010}
2011unsafe extern "C" {
2012 #[doc = " @brief \t\tSets the RGB frequency of power line.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[in]\tvalue\t\t\tThe frequency value of power line, 1:50HZ 2:60HZ\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2013 pub fn Ps2_SetRGBFrequencyOfPowerLine(
2014 device: PsDeviceHandle,
2015 sessionIndex: u32,
2016 value: u8,
2017 ) -> PsReturnStatus;
2018}
2019unsafe extern "C" {
2020 #[doc = " @brief \t\tGets the RGB frequency of power line.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[out]\tvalue\t\t\tThe frequency value of power line, 1:50HZ 2:60HZ\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2021 pub fn Ps2_GetRGBFrequencyOfPowerLine(
2022 device: PsDeviceHandle,
2023 sessionIndex: u32,
2024 value: *mut u8,
2025 ) -> PsReturnStatus;
2026}
2027unsafe extern "C" {
2028 #[doc = " @brief\t\tReboot the camera.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2029 pub fn Ps2_RebootCamera(device: PsDeviceHandle, sessionIndex: u32) -> PsReturnStatus;
2030}
2031unsafe extern "C" {
2032 #[doc = " @brief\t\tEnables or disables the legacy algorithmic,and default value is disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2033 pub fn Ps2_SetLegacyAlgorithmicEnabled(
2034 device: PsDeviceHandle,
2035 sessionIndex: u32,
2036 enabled: u8,
2037 ) -> PsReturnStatus;
2038}
2039unsafe extern "C" {
2040 #[doc = " @brief\t\tEnables or disables the ConfidenceFilter feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2041 pub fn Ps2_SetConfidenceFilterEnabled(
2042 device: PsDeviceHandle,
2043 sessionIndex: u32,
2044 enabled: u8,
2045 ) -> PsReturnStatus;
2046}
2047unsafe extern "C" {
2048 #[doc = " @brief \t\tReturns the Boolean value of whether the ConfidenceFilter feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2049 pub fn Ps2_GetConfidenceFilterEnabled(
2050 device: PsDeviceHandle,
2051 sessionIndex: u32,
2052 enabled: *mut u8,
2053 ) -> PsReturnStatus;
2054}
2055unsafe extern "C" {
2056 #[doc = " @brief \t\tSets the ConfidenceFilter threshold value for the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the threshold.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tthreshold\t\tThe threshold value to set. 0 will attempt to keep all point data but may not be accurate further away; 1000 is the max value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2057 pub fn Ps2_SetConfidenceFilterThreshold(
2058 device: PsDeviceHandle,
2059 sessionIndex: u32,
2060 threshold: u16,
2061 ) -> PsReturnStatus;
2062}
2063unsafe extern "C" {
2064 #[doc = " @brief \t\tGets the ConfidenceFilter threshold value for the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the threshold.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tthreshold\t\tThe threshold value to set. 0 will attempt to keep all point data but may not be accurate further away; 1000 is the max value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2065 pub fn Ps2_GetConfidenceFilterThreshold(
2066 device: PsDeviceHandle,
2067 sessionIndex: u32,
2068 threshold: *mut u16,
2069 ) -> PsReturnStatus;
2070}
2071unsafe extern "C" {
2072 #[doc = " @brief \t\tSets the WDR ConfidenceFilter threshold value for the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the threshold.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tthreshold\t\tThe threshold value to set. 0 will attempt to keep all point data but may not be accurate further away; 1000 is the max value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2073 pub fn Ps2_SetWDRConfidenceFilterThreshold(
2074 device: PsDeviceHandle,
2075 sessionIndex: u32,
2076 wdrconfidencethreshold: PsWDRConfidenceThreshold,
2077 ) -> PsReturnStatus;
2078}
2079unsafe extern "C" {
2080 #[doc = " @brief \t\tGets the WDR ConfidenceFilter threshold value for the device specified by <code>device</code>.\n @param[in] \tdevice\t\t\tThe handle of the device on which to set the threshold.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in] \tthreshold\t\tThe threshold value to set. 0 will attempt to keep all point data but may not be accurate further away; 1000 is the max value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2081 pub fn Ps2_GetWDRConfidenceFilterThreshold(
2082 device: PsDeviceHandle,
2083 sessionIndex: u32,
2084 wdrconfidencethreshold: *mut PsWDRConfidenceThreshold,
2085 ) -> PsReturnStatus;
2086}
2087unsafe extern "C" {
2088 #[doc = " @brief \t\tOpens the device specified by <code>ip</code>. The device must be subsequently closed using PsCloseDevice().\n @param[in] \tip\t\t\tthe ip of the device. See ::PsDeviceInfo for more information.\n @param[out]\tpDevices\tthe handle of the device on which to open.\n @return: \t\t::PsRetOK\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2089 pub fn Ps2_OpenDeviceByIP(
2090 ip: *const ::std::os::raw::c_char,
2091 pDevice: *mut PsDeviceHandle,
2092 ) -> PsReturnStatus;
2093}
2094unsafe extern "C" {
2095 #[doc = " @brief\t\tEnables or disables the RGB manual exposure feature.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[in]\tbEnabled\t\tSet to <code>true</code> to enable the feature or <code>false</code> to disable the feature.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2096 pub fn Ps2_SetRGBManualExposureEnabled(
2097 device: PsDeviceHandle,
2098 sessionIndex: u32,
2099 enabled: u8,
2100 ) -> PsReturnStatus;
2101}
2102unsafe extern "C" {
2103 #[doc = " @brief \t\tReturns the Boolean value of whether the RGB manual exposure feature is enabled or disabled.\n @param[in]\tdevice\t\t\tThe handle of the device on which to enable or disable the feature.\n @param[in] \tsessionIndex\tThe index of the session. See ::Ps2_StartStream() & ::Ps2_StopStream() api for more information.\n @param[out]\tbEnabled\t\tPointer to a variable in which to store the returned Boolean value.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2104 pub fn Ps2_GetRGBManualExposureEnabled(
2105 device: PsDeviceHandle,
2106 sessionIndex: u32,
2107 enabled: *mut u8,
2108 ) -> PsReturnStatus;
2109}
2110unsafe extern "C" {
2111 #[doc = " @brief \t\tSets the RGB absolute exposure in manual.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[in]\tvalue\t\t\tThe value of brightness,in [1,4000] and the unit is 100us.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2112 pub fn Ps2_SetRGBAbsoluteExposure(
2113 device: PsDeviceHandle,
2114 sessionIndex: u32,
2115 value: u16,
2116 ) -> PsReturnStatus;
2117}
2118unsafe extern "C" {
2119 #[doc = " @brief \t\tGets the RGB absolute exposure in manual.\n @param[in] \tdevice\t\t\tThe handle of the device.\n @param[in] \tsessionIndex\tThe index of the session.\n @param[out]\tvalue\t\t\tThe value of brightness,in [1,4000] and the unit is 100us.\n @return \t\t::PsRetOK\t\tif the function succeeded, or one of the error values defined by ::PsReturnStatus."]
2120 pub fn Ps2_GetRGBAbsoluteExposure(
2121 device: PsDeviceHandle,
2122 sessionIndex: u32,
2123 value: *mut u16,
2124 ) -> PsReturnStatus;
2125}