1#![allow(
4 dead_code,
5 non_upper_case_globals,
6 non_camel_case_types,
7 non_snake_case
8)]
9
10pub const VMBINFINITE: u32 = 4294967295;
11pub type VmbInt8_t = ::std::os::raw::c_schar;
12pub type VmbUint8_t = ::std::os::raw::c_uchar;
13pub type VmbInt16_t = ::std::os::raw::c_short;
14pub type VmbUint16_t = ::std::os::raw::c_ushort;
15pub type VmbInt32_t = ::std::os::raw::c_int;
16pub type VmbUint32_t = ::std::os::raw::c_uint;
17pub type VmbInt64_t = ::std::os::raw::c_longlong;
18pub type VmbUint64_t = ::std::os::raw::c_ulonglong;
19pub type VmbHandle_t = *mut ::std::os::raw::c_void;
20pub type VmbBool_t = ::std::os::raw::c_char;
21pub mod VmbBoolVal {
22 pub type Type = ::std::os::raw::c_uint;
23 pub const VmbBoolTrue: Type = 1;
24 pub const VmbBoolFalse: Type = 0;
25}
26pub type VmbUchar_t = ::std::os::raw::c_uchar;
27pub mod VmbErrorType {
28 pub type Type = ::std::os::raw::c_int;
29 pub const VmbErrorSuccess: Type = 0;
30 pub const VmbErrorInternalFault: Type = -1;
31 pub const VmbErrorApiNotStarted: Type = -2;
32 pub const VmbErrorNotFound: Type = -3;
33 pub const VmbErrorBadHandle: Type = -4;
34 pub const VmbErrorDeviceNotOpen: Type = -5;
35 pub const VmbErrorInvalidAccess: Type = -6;
36 pub const VmbErrorBadParameter: Type = -7;
37 pub const VmbErrorStructSize: Type = -8;
38 pub const VmbErrorMoreData: Type = -9;
39 pub const VmbErrorWrongType: Type = -10;
40 pub const VmbErrorInvalidValue: Type = -11;
41 pub const VmbErrorTimeout: Type = -12;
42 pub const VmbErrorOther: Type = -13;
43 pub const VmbErrorResources: Type = -14;
44 pub const VmbErrorInvalidCall: Type = -15;
45 pub const VmbErrorNoTL: Type = -16;
46 pub const VmbErrorNotImplemented: Type = -17;
47 pub const VmbErrorNotSupported: Type = -18;
48 pub const VmbErrorIncomplete: Type = -19;
49 pub const VmbErrorIO: Type = -20;
50}
51pub type VmbError_t = VmbInt32_t;
52#[repr(C)]
53#[derive(Debug, Copy, Clone, PartialEq)]
54pub struct VmbVersionInfo_t {
55 pub major: VmbUint32_t,
56 pub minor: VmbUint32_t,
57 pub patch: VmbUint32_t,
58}
59#[test]
60fn bindgen_test_layout_VmbVersionInfo_t() {
61 assert_eq!(
62 ::std::mem::size_of::<VmbVersionInfo_t>(),
63 12usize,
64 concat!("Size of: ", stringify!(VmbVersionInfo_t))
65 );
66 assert_eq!(
67 ::std::mem::align_of::<VmbVersionInfo_t>(),
68 4usize,
69 concat!("Alignment of ", stringify!(VmbVersionInfo_t))
70 );
71 fn test_field_major() {
72 assert_eq!(
73 unsafe {
74 let uninit = ::std::mem::MaybeUninit::<VmbVersionInfo_t>::uninit();
75 let ptr = uninit.as_ptr();
76 ::std::ptr::addr_of!((*ptr).major) as usize - ptr as usize
77 },
78 0usize,
79 concat!(
80 "Offset of field: ",
81 stringify!(VmbVersionInfo_t),
82 "::",
83 stringify!(major)
84 )
85 );
86 }
87 test_field_major();
88 fn test_field_minor() {
89 assert_eq!(
90 unsafe {
91 let uninit = ::std::mem::MaybeUninit::<VmbVersionInfo_t>::uninit();
92 let ptr = uninit.as_ptr();
93 ::std::ptr::addr_of!((*ptr).minor) as usize - ptr as usize
94 },
95 4usize,
96 concat!(
97 "Offset of field: ",
98 stringify!(VmbVersionInfo_t),
99 "::",
100 stringify!(minor)
101 )
102 );
103 }
104 test_field_minor();
105 fn test_field_patch() {
106 assert_eq!(
107 unsafe {
108 let uninit = ::std::mem::MaybeUninit::<VmbVersionInfo_t>::uninit();
109 let ptr = uninit.as_ptr();
110 ::std::ptr::addr_of!((*ptr).patch) as usize - ptr as usize
111 },
112 8usize,
113 concat!(
114 "Offset of field: ",
115 stringify!(VmbVersionInfo_t),
116 "::",
117 stringify!(patch)
118 )
119 );
120 }
121 test_field_patch();
122}
123pub mod VmbPixelType {
124 pub type Type = ::std::os::raw::c_uint;
125 pub const VmbPixelMono: Type = 16777216;
126 pub const VmbPixelColor: Type = 33554432;
127}
128pub mod VmbPixelOccupyType {
129 pub type Type = ::std::os::raw::c_uint;
130 pub const VmbPixelOccupy8Bit: Type = 524288;
131 pub const VmbPixelOccupy10Bit: Type = 655360;
132 pub const VmbPixelOccupy12Bit: Type = 786432;
133 pub const VmbPixelOccupy14Bit: Type = 917504;
134 pub const VmbPixelOccupy16Bit: Type = 1048576;
135 pub const VmbPixelOccupy24Bit: Type = 1572864;
136 pub const VmbPixelOccupy32Bit: Type = 2097152;
137 pub const VmbPixelOccupy48Bit: Type = 3145728;
138 pub const VmbPixelOccupy64Bit: Type = 4194304;
139}
140pub mod VmbPixelFormatType {
141 pub type Type = ::std::os::raw::c_uint;
142 pub const VmbPixelFormatMono8: Type = 17301505;
143 pub const VmbPixelFormatMono10: Type = 17825795;
144 pub const VmbPixelFormatMono10p: Type = 17432646;
145 pub const VmbPixelFormatMono12: Type = 17825797;
146 pub const VmbPixelFormatMono12Packed: Type = 17563654;
147 pub const VmbPixelFormatMono12p: Type = 17563719;
148 pub const VmbPixelFormatMono14: Type = 17825829;
149 pub const VmbPixelFormatMono16: Type = 17825799;
150 pub const VmbPixelFormatBayerGR8: Type = 17301512;
151 pub const VmbPixelFormatBayerRG8: Type = 17301513;
152 pub const VmbPixelFormatBayerGB8: Type = 17301514;
153 pub const VmbPixelFormatBayerBG8: Type = 17301515;
154 pub const VmbPixelFormatBayerGR10: Type = 17825804;
155 pub const VmbPixelFormatBayerRG10: Type = 17825805;
156 pub const VmbPixelFormatBayerGB10: Type = 17825806;
157 pub const VmbPixelFormatBayerBG10: Type = 17825807;
158 pub const VmbPixelFormatBayerGR12: Type = 17825808;
159 pub const VmbPixelFormatBayerRG12: Type = 17825809;
160 pub const VmbPixelFormatBayerGB12: Type = 17825810;
161 pub const VmbPixelFormatBayerBG12: Type = 17825811;
162 pub const VmbPixelFormatBayerGR12Packed: Type = 17563690;
163 pub const VmbPixelFormatBayerRG12Packed: Type = 17563691;
164 pub const VmbPixelFormatBayerGB12Packed: Type = 17563692;
165 pub const VmbPixelFormatBayerBG12Packed: Type = 17563693;
166 pub const VmbPixelFormatBayerGR10p: Type = 17432662;
167 pub const VmbPixelFormatBayerRG10p: Type = 17432664;
168 pub const VmbPixelFormatBayerGB10p: Type = 17432660;
169 pub const VmbPixelFormatBayerBG10p: Type = 17432658;
170 pub const VmbPixelFormatBayerGR12p: Type = 17563735;
171 pub const VmbPixelFormatBayerRG12p: Type = 17563737;
172 pub const VmbPixelFormatBayerGB12p: Type = 17563733;
173 pub const VmbPixelFormatBayerBG12p: Type = 17563731;
174 pub const VmbPixelFormatBayerGR16: Type = 17825838;
175 pub const VmbPixelFormatBayerRG16: Type = 17825839;
176 pub const VmbPixelFormatBayerGB16: Type = 17825840;
177 pub const VmbPixelFormatBayerBG16: Type = 17825841;
178 pub const VmbPixelFormatRgb8: Type = 35127316;
179 pub const VmbPixelFormatBgr8: Type = 35127317;
180 pub const VmbPixelFormatRgb10: Type = 36700184;
181 pub const VmbPixelFormatBgr10: Type = 36700185;
182 pub const VmbPixelFormatRgb12: Type = 36700186;
183 pub const VmbPixelFormatBgr12: Type = 36700187;
184 pub const VmbPixelFormatRgb14: Type = 36700254;
185 pub const VmbPixelFormatBgr14: Type = 36700234;
186 pub const VmbPixelFormatRgb16: Type = 36700211;
187 pub const VmbPixelFormatBgr16: Type = 36700235;
188 pub const VmbPixelFormatArgb8: Type = 35651606;
189 pub const VmbPixelFormatRgba8: Type = 35651606;
190 pub const VmbPixelFormatBgra8: Type = 35651607;
191 pub const VmbPixelFormatRgba10: Type = 37748831;
192 pub const VmbPixelFormatBgra10: Type = 37748812;
193 pub const VmbPixelFormatRgba12: Type = 37748833;
194 pub const VmbPixelFormatBgra12: Type = 37748814;
195 pub const VmbPixelFormatRgba14: Type = 37748835;
196 pub const VmbPixelFormatBgra14: Type = 37748816;
197 pub const VmbPixelFormatRgba16: Type = 37748836;
198 pub const VmbPixelFormatBgra16: Type = 37748817;
199 pub const VmbPixelFormatYuv411: Type = 34340894;
200 pub const VmbPixelFormatYuv422: Type = 34603039;
201 pub const VmbPixelFormatYuv444: Type = 35127328;
202 pub const VmbPixelFormatYCbCr411_8_CbYYCrYY: Type = 34340924;
203 pub const VmbPixelFormatYCbCr422_8_CbYCrY: Type = 34603075;
204 pub const VmbPixelFormatYCbCr8_CbYCr: Type = 35127354;
205 pub const VmbPixelFormatLast: Type = 35127355;
206}
207pub type VmbPixelFormat_t = VmbUint32_t;
208extern "C" {
209 pub static gVimbaHandle: VmbHandle_t;
210}
211pub mod VmbInterfaceType {
212 pub type Type = ::std::os::raw::c_uint;
213 pub const VmbInterfaceUnknown: Type = 0;
214 pub const VmbInterfaceFirewire: Type = 1;
215 pub const VmbInterfaceEthernet: Type = 2;
216 pub const VmbInterfaceUsb: Type = 3;
217 pub const VmbInterfaceCL: Type = 4;
218 pub const VmbInterfaceCSI2: Type = 5;
219}
220pub type VmbInterface_t = VmbUint32_t;
221pub mod VmbAccessModeType {
222 pub type Type = ::std::os::raw::c_uint;
223 pub const VmbAccessModeNone: Type = 0;
224 pub const VmbAccessModeFull: Type = 1;
225 pub const VmbAccessModeRead: Type = 2;
226 pub const VmbAccessModeConfig: Type = 4;
227 pub const VmbAccessModeLite: Type = 8;
228}
229pub type VmbAccessMode_t = VmbUint32_t;
230#[repr(C)]
231#[derive(Debug, Copy, Clone, PartialEq)]
232pub struct VmbInterfaceInfo_t {
233 pub interfaceIdString: *const ::std::os::raw::c_char,
234 pub interfaceType: VmbInterface_t,
235 pub interfaceName: *const ::std::os::raw::c_char,
236 pub serialString: *const ::std::os::raw::c_char,
237 pub permittedAccess: VmbAccessMode_t,
238}
239#[test]
240fn bindgen_test_layout_VmbInterfaceInfo_t() {
241 assert_eq!(
242 ::std::mem::size_of::<VmbInterfaceInfo_t>(),
243 40usize,
244 concat!("Size of: ", stringify!(VmbInterfaceInfo_t))
245 );
246 assert_eq!(
247 ::std::mem::align_of::<VmbInterfaceInfo_t>(),
248 8usize,
249 concat!("Alignment of ", stringify!(VmbInterfaceInfo_t))
250 );
251 fn test_field_interfaceIdString() {
252 assert_eq!(
253 unsafe {
254 let uninit = ::std::mem::MaybeUninit::<VmbInterfaceInfo_t>::uninit();
255 let ptr = uninit.as_ptr();
256 ::std::ptr::addr_of!((*ptr).interfaceIdString) as usize - ptr as usize
257 },
258 0usize,
259 concat!(
260 "Offset of field: ",
261 stringify!(VmbInterfaceInfo_t),
262 "::",
263 stringify!(interfaceIdString)
264 )
265 );
266 }
267 test_field_interfaceIdString();
268 fn test_field_interfaceType() {
269 assert_eq!(
270 unsafe {
271 let uninit = ::std::mem::MaybeUninit::<VmbInterfaceInfo_t>::uninit();
272 let ptr = uninit.as_ptr();
273 ::std::ptr::addr_of!((*ptr).interfaceType) as usize - ptr as usize
274 },
275 8usize,
276 concat!(
277 "Offset of field: ",
278 stringify!(VmbInterfaceInfo_t),
279 "::",
280 stringify!(interfaceType)
281 )
282 );
283 }
284 test_field_interfaceType();
285 fn test_field_interfaceName() {
286 assert_eq!(
287 unsafe {
288 let uninit = ::std::mem::MaybeUninit::<VmbInterfaceInfo_t>::uninit();
289 let ptr = uninit.as_ptr();
290 ::std::ptr::addr_of!((*ptr).interfaceName) as usize - ptr as usize
291 },
292 16usize,
293 concat!(
294 "Offset of field: ",
295 stringify!(VmbInterfaceInfo_t),
296 "::",
297 stringify!(interfaceName)
298 )
299 );
300 }
301 test_field_interfaceName();
302 fn test_field_serialString() {
303 assert_eq!(
304 unsafe {
305 let uninit = ::std::mem::MaybeUninit::<VmbInterfaceInfo_t>::uninit();
306 let ptr = uninit.as_ptr();
307 ::std::ptr::addr_of!((*ptr).serialString) as usize - ptr as usize
308 },
309 24usize,
310 concat!(
311 "Offset of field: ",
312 stringify!(VmbInterfaceInfo_t),
313 "::",
314 stringify!(serialString)
315 )
316 );
317 }
318 test_field_serialString();
319 fn test_field_permittedAccess() {
320 assert_eq!(
321 unsafe {
322 let uninit = ::std::mem::MaybeUninit::<VmbInterfaceInfo_t>::uninit();
323 let ptr = uninit.as_ptr();
324 ::std::ptr::addr_of!((*ptr).permittedAccess) as usize - ptr as usize
325 },
326 32usize,
327 concat!(
328 "Offset of field: ",
329 stringify!(VmbInterfaceInfo_t),
330 "::",
331 stringify!(permittedAccess)
332 )
333 );
334 }
335 test_field_permittedAccess();
336}
337#[repr(C)]
338#[derive(Debug, Copy, Clone, PartialEq)]
339pub struct VmbCameraInfo_t {
340 pub cameraIdString: *const ::std::os::raw::c_char,
341 pub cameraName: *const ::std::os::raw::c_char,
342 pub modelName: *const ::std::os::raw::c_char,
343 pub serialString: *const ::std::os::raw::c_char,
344 pub permittedAccess: VmbAccessMode_t,
345 pub interfaceIdString: *const ::std::os::raw::c_char,
346}
347#[test]
348fn bindgen_test_layout_VmbCameraInfo_t() {
349 assert_eq!(
350 ::std::mem::size_of::<VmbCameraInfo_t>(),
351 48usize,
352 concat!("Size of: ", stringify!(VmbCameraInfo_t))
353 );
354 assert_eq!(
355 ::std::mem::align_of::<VmbCameraInfo_t>(),
356 8usize,
357 concat!("Alignment of ", stringify!(VmbCameraInfo_t))
358 );
359 fn test_field_cameraIdString() {
360 assert_eq!(
361 unsafe {
362 let uninit = ::std::mem::MaybeUninit::<VmbCameraInfo_t>::uninit();
363 let ptr = uninit.as_ptr();
364 ::std::ptr::addr_of!((*ptr).cameraIdString) as usize - ptr as usize
365 },
366 0usize,
367 concat!(
368 "Offset of field: ",
369 stringify!(VmbCameraInfo_t),
370 "::",
371 stringify!(cameraIdString)
372 )
373 );
374 }
375 test_field_cameraIdString();
376 fn test_field_cameraName() {
377 assert_eq!(
378 unsafe {
379 let uninit = ::std::mem::MaybeUninit::<VmbCameraInfo_t>::uninit();
380 let ptr = uninit.as_ptr();
381 ::std::ptr::addr_of!((*ptr).cameraName) as usize - ptr as usize
382 },
383 8usize,
384 concat!(
385 "Offset of field: ",
386 stringify!(VmbCameraInfo_t),
387 "::",
388 stringify!(cameraName)
389 )
390 );
391 }
392 test_field_cameraName();
393 fn test_field_modelName() {
394 assert_eq!(
395 unsafe {
396 let uninit = ::std::mem::MaybeUninit::<VmbCameraInfo_t>::uninit();
397 let ptr = uninit.as_ptr();
398 ::std::ptr::addr_of!((*ptr).modelName) as usize - ptr as usize
399 },
400 16usize,
401 concat!(
402 "Offset of field: ",
403 stringify!(VmbCameraInfo_t),
404 "::",
405 stringify!(modelName)
406 )
407 );
408 }
409 test_field_modelName();
410 fn test_field_serialString() {
411 assert_eq!(
412 unsafe {
413 let uninit = ::std::mem::MaybeUninit::<VmbCameraInfo_t>::uninit();
414 let ptr = uninit.as_ptr();
415 ::std::ptr::addr_of!((*ptr).serialString) as usize - ptr as usize
416 },
417 24usize,
418 concat!(
419 "Offset of field: ",
420 stringify!(VmbCameraInfo_t),
421 "::",
422 stringify!(serialString)
423 )
424 );
425 }
426 test_field_serialString();
427 fn test_field_permittedAccess() {
428 assert_eq!(
429 unsafe {
430 let uninit = ::std::mem::MaybeUninit::<VmbCameraInfo_t>::uninit();
431 let ptr = uninit.as_ptr();
432 ::std::ptr::addr_of!((*ptr).permittedAccess) as usize - ptr as usize
433 },
434 32usize,
435 concat!(
436 "Offset of field: ",
437 stringify!(VmbCameraInfo_t),
438 "::",
439 stringify!(permittedAccess)
440 )
441 );
442 }
443 test_field_permittedAccess();
444 fn test_field_interfaceIdString() {
445 assert_eq!(
446 unsafe {
447 let uninit = ::std::mem::MaybeUninit::<VmbCameraInfo_t>::uninit();
448 let ptr = uninit.as_ptr();
449 ::std::ptr::addr_of!((*ptr).interfaceIdString) as usize - ptr as usize
450 },
451 40usize,
452 concat!(
453 "Offset of field: ",
454 stringify!(VmbCameraInfo_t),
455 "::",
456 stringify!(interfaceIdString)
457 )
458 );
459 }
460 test_field_interfaceIdString();
461}
462pub mod VmbFeatureDataType {
463 pub type Type = ::std::os::raw::c_uint;
464 pub const VmbFeatureDataUnknown: Type = 0;
465 pub const VmbFeatureDataInt: Type = 1;
466 pub const VmbFeatureDataFloat: Type = 2;
467 pub const VmbFeatureDataEnum: Type = 3;
468 pub const VmbFeatureDataString: Type = 4;
469 pub const VmbFeatureDataBool: Type = 5;
470 pub const VmbFeatureDataCommand: Type = 6;
471 pub const VmbFeatureDataRaw: Type = 7;
472 pub const VmbFeatureDataNone: Type = 8;
473}
474pub type VmbFeatureData_t = VmbUint32_t;
475pub mod VmbFeatureVisibilityType {
476 pub type Type = ::std::os::raw::c_uint;
477 pub const VmbFeatureVisibilityUnknown: Type = 0;
478 pub const VmbFeatureVisibilityBeginner: Type = 1;
479 pub const VmbFeatureVisibilityExpert: Type = 2;
480 pub const VmbFeatureVisibilityGuru: Type = 3;
481 pub const VmbFeatureVisibilityInvisible: Type = 4;
482}
483pub type VmbFeatureVisibility_t = VmbUint32_t;
484impl VmbFeatureFlagsType {
485 pub const VmbFeatureFlagsNone: VmbFeatureFlagsType = VmbFeatureFlagsType(0);
486}
487impl VmbFeatureFlagsType {
488 pub const VmbFeatureFlagsRead: VmbFeatureFlagsType = VmbFeatureFlagsType(1);
489}
490impl VmbFeatureFlagsType {
491 pub const VmbFeatureFlagsWrite: VmbFeatureFlagsType = VmbFeatureFlagsType(2);
492}
493impl VmbFeatureFlagsType {
494 pub const VmbFeatureFlagsVolatile: VmbFeatureFlagsType = VmbFeatureFlagsType(8);
495}
496impl VmbFeatureFlagsType {
497 pub const VmbFeatureFlagsModifyWrite: VmbFeatureFlagsType = VmbFeatureFlagsType(16);
498}
499impl ::std::ops::BitOr<VmbFeatureFlagsType> for VmbFeatureFlagsType {
500 type Output = Self;
501 #[inline]
502 fn bitor(self, other: Self) -> Self {
503 VmbFeatureFlagsType(self.0 | other.0)
504 }
505}
506impl ::std::ops::BitOrAssign for VmbFeatureFlagsType {
507 #[inline]
508 fn bitor_assign(&mut self, rhs: VmbFeatureFlagsType) {
509 self.0 |= rhs.0;
510 }
511}
512impl ::std::ops::BitAnd<VmbFeatureFlagsType> for VmbFeatureFlagsType {
513 type Output = Self;
514 #[inline]
515 fn bitand(self, other: Self) -> Self {
516 VmbFeatureFlagsType(self.0 & other.0)
517 }
518}
519impl ::std::ops::BitAndAssign for VmbFeatureFlagsType {
520 #[inline]
521 fn bitand_assign(&mut self, rhs: VmbFeatureFlagsType) {
522 self.0 &= rhs.0;
523 }
524}
525#[repr(transparent)]
526#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
527pub struct VmbFeatureFlagsType(pub ::std::os::raw::c_uint);
528pub type VmbFeatureFlags_t = VmbUint32_t;
529#[repr(C)]
530#[derive(Debug, Copy, Clone, PartialEq)]
531pub struct VmbFeatureInfo {
532 pub name: *const ::std::os::raw::c_char,
533 pub featureDataType: VmbFeatureData_t,
534 pub featureFlags: VmbFeatureFlags_t,
535 pub category: *const ::std::os::raw::c_char,
536 pub displayName: *const ::std::os::raw::c_char,
537 pub pollingTime: VmbUint32_t,
538 pub unit: *const ::std::os::raw::c_char,
539 pub representation: *const ::std::os::raw::c_char,
540 pub visibility: VmbFeatureVisibility_t,
541 pub tooltip: *const ::std::os::raw::c_char,
542 pub description: *const ::std::os::raw::c_char,
543 pub sfncNamespace: *const ::std::os::raw::c_char,
544 pub isStreamable: VmbBool_t,
545 pub hasAffectedFeatures: VmbBool_t,
546 pub hasSelectedFeatures: VmbBool_t,
547}
548#[test]
549fn bindgen_test_layout_VmbFeatureInfo() {
550 assert_eq!(
551 ::std::mem::size_of::<VmbFeatureInfo>(),
552 96usize,
553 concat!("Size of: ", stringify!(VmbFeatureInfo))
554 );
555 assert_eq!(
556 ::std::mem::align_of::<VmbFeatureInfo>(),
557 8usize,
558 concat!("Alignment of ", stringify!(VmbFeatureInfo))
559 );
560 fn test_field_name() {
561 assert_eq!(
562 unsafe {
563 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
564 let ptr = uninit.as_ptr();
565 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
566 },
567 0usize,
568 concat!(
569 "Offset of field: ",
570 stringify!(VmbFeatureInfo),
571 "::",
572 stringify!(name)
573 )
574 );
575 }
576 test_field_name();
577 fn test_field_featureDataType() {
578 assert_eq!(
579 unsafe {
580 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
581 let ptr = uninit.as_ptr();
582 ::std::ptr::addr_of!((*ptr).featureDataType) as usize - ptr as usize
583 },
584 8usize,
585 concat!(
586 "Offset of field: ",
587 stringify!(VmbFeatureInfo),
588 "::",
589 stringify!(featureDataType)
590 )
591 );
592 }
593 test_field_featureDataType();
594 fn test_field_featureFlags() {
595 assert_eq!(
596 unsafe {
597 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
598 let ptr = uninit.as_ptr();
599 ::std::ptr::addr_of!((*ptr).featureFlags) as usize - ptr as usize
600 },
601 12usize,
602 concat!(
603 "Offset of field: ",
604 stringify!(VmbFeatureInfo),
605 "::",
606 stringify!(featureFlags)
607 )
608 );
609 }
610 test_field_featureFlags();
611 fn test_field_category() {
612 assert_eq!(
613 unsafe {
614 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
615 let ptr = uninit.as_ptr();
616 ::std::ptr::addr_of!((*ptr).category) as usize - ptr as usize
617 },
618 16usize,
619 concat!(
620 "Offset of field: ",
621 stringify!(VmbFeatureInfo),
622 "::",
623 stringify!(category)
624 )
625 );
626 }
627 test_field_category();
628 fn test_field_displayName() {
629 assert_eq!(
630 unsafe {
631 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
632 let ptr = uninit.as_ptr();
633 ::std::ptr::addr_of!((*ptr).displayName) as usize - ptr as usize
634 },
635 24usize,
636 concat!(
637 "Offset of field: ",
638 stringify!(VmbFeatureInfo),
639 "::",
640 stringify!(displayName)
641 )
642 );
643 }
644 test_field_displayName();
645 fn test_field_pollingTime() {
646 assert_eq!(
647 unsafe {
648 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
649 let ptr = uninit.as_ptr();
650 ::std::ptr::addr_of!((*ptr).pollingTime) as usize - ptr as usize
651 },
652 32usize,
653 concat!(
654 "Offset of field: ",
655 stringify!(VmbFeatureInfo),
656 "::",
657 stringify!(pollingTime)
658 )
659 );
660 }
661 test_field_pollingTime();
662 fn test_field_unit() {
663 assert_eq!(
664 unsafe {
665 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
666 let ptr = uninit.as_ptr();
667 ::std::ptr::addr_of!((*ptr).unit) as usize - ptr as usize
668 },
669 40usize,
670 concat!(
671 "Offset of field: ",
672 stringify!(VmbFeatureInfo),
673 "::",
674 stringify!(unit)
675 )
676 );
677 }
678 test_field_unit();
679 fn test_field_representation() {
680 assert_eq!(
681 unsafe {
682 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
683 let ptr = uninit.as_ptr();
684 ::std::ptr::addr_of!((*ptr).representation) as usize - ptr as usize
685 },
686 48usize,
687 concat!(
688 "Offset of field: ",
689 stringify!(VmbFeatureInfo),
690 "::",
691 stringify!(representation)
692 )
693 );
694 }
695 test_field_representation();
696 fn test_field_visibility() {
697 assert_eq!(
698 unsafe {
699 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
700 let ptr = uninit.as_ptr();
701 ::std::ptr::addr_of!((*ptr).visibility) as usize - ptr as usize
702 },
703 56usize,
704 concat!(
705 "Offset of field: ",
706 stringify!(VmbFeatureInfo),
707 "::",
708 stringify!(visibility)
709 )
710 );
711 }
712 test_field_visibility();
713 fn test_field_tooltip() {
714 assert_eq!(
715 unsafe {
716 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
717 let ptr = uninit.as_ptr();
718 ::std::ptr::addr_of!((*ptr).tooltip) as usize - ptr as usize
719 },
720 64usize,
721 concat!(
722 "Offset of field: ",
723 stringify!(VmbFeatureInfo),
724 "::",
725 stringify!(tooltip)
726 )
727 );
728 }
729 test_field_tooltip();
730 fn test_field_description() {
731 assert_eq!(
732 unsafe {
733 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
734 let ptr = uninit.as_ptr();
735 ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize
736 },
737 72usize,
738 concat!(
739 "Offset of field: ",
740 stringify!(VmbFeatureInfo),
741 "::",
742 stringify!(description)
743 )
744 );
745 }
746 test_field_description();
747 fn test_field_sfncNamespace() {
748 assert_eq!(
749 unsafe {
750 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
751 let ptr = uninit.as_ptr();
752 ::std::ptr::addr_of!((*ptr).sfncNamespace) as usize - ptr as usize
753 },
754 80usize,
755 concat!(
756 "Offset of field: ",
757 stringify!(VmbFeatureInfo),
758 "::",
759 stringify!(sfncNamespace)
760 )
761 );
762 }
763 test_field_sfncNamespace();
764 fn test_field_isStreamable() {
765 assert_eq!(
766 unsafe {
767 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
768 let ptr = uninit.as_ptr();
769 ::std::ptr::addr_of!((*ptr).isStreamable) as usize - ptr as usize
770 },
771 88usize,
772 concat!(
773 "Offset of field: ",
774 stringify!(VmbFeatureInfo),
775 "::",
776 stringify!(isStreamable)
777 )
778 );
779 }
780 test_field_isStreamable();
781 fn test_field_hasAffectedFeatures() {
782 assert_eq!(
783 unsafe {
784 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
785 let ptr = uninit.as_ptr();
786 ::std::ptr::addr_of!((*ptr).hasAffectedFeatures) as usize - ptr as usize
787 },
788 89usize,
789 concat!(
790 "Offset of field: ",
791 stringify!(VmbFeatureInfo),
792 "::",
793 stringify!(hasAffectedFeatures)
794 )
795 );
796 }
797 test_field_hasAffectedFeatures();
798 fn test_field_hasSelectedFeatures() {
799 assert_eq!(
800 unsafe {
801 let uninit = ::std::mem::MaybeUninit::<VmbFeatureInfo>::uninit();
802 let ptr = uninit.as_ptr();
803 ::std::ptr::addr_of!((*ptr).hasSelectedFeatures) as usize - ptr as usize
804 },
805 90usize,
806 concat!(
807 "Offset of field: ",
808 stringify!(VmbFeatureInfo),
809 "::",
810 stringify!(hasSelectedFeatures)
811 )
812 );
813 }
814 test_field_hasSelectedFeatures();
815}
816pub type VmbFeatureInfo_t = VmbFeatureInfo;
817#[repr(C)]
818#[derive(Debug, Copy, Clone, PartialEq)]
819pub struct VmbFeatureEnumEntry {
820 pub name: *const ::std::os::raw::c_char,
821 pub displayName: *const ::std::os::raw::c_char,
822 pub visibility: VmbFeatureVisibility_t,
823 pub tooltip: *const ::std::os::raw::c_char,
824 pub description: *const ::std::os::raw::c_char,
825 pub sfncNamespace: *const ::std::os::raw::c_char,
826 pub intValue: VmbInt64_t,
827}
828#[test]
829fn bindgen_test_layout_VmbFeatureEnumEntry() {
830 assert_eq!(
831 ::std::mem::size_of::<VmbFeatureEnumEntry>(),
832 56usize,
833 concat!("Size of: ", stringify!(VmbFeatureEnumEntry))
834 );
835 assert_eq!(
836 ::std::mem::align_of::<VmbFeatureEnumEntry>(),
837 8usize,
838 concat!("Alignment of ", stringify!(VmbFeatureEnumEntry))
839 );
840 fn test_field_name() {
841 assert_eq!(
842 unsafe {
843 let uninit = ::std::mem::MaybeUninit::<VmbFeatureEnumEntry>::uninit();
844 let ptr = uninit.as_ptr();
845 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
846 },
847 0usize,
848 concat!(
849 "Offset of field: ",
850 stringify!(VmbFeatureEnumEntry),
851 "::",
852 stringify!(name)
853 )
854 );
855 }
856 test_field_name();
857 fn test_field_displayName() {
858 assert_eq!(
859 unsafe {
860 let uninit = ::std::mem::MaybeUninit::<VmbFeatureEnumEntry>::uninit();
861 let ptr = uninit.as_ptr();
862 ::std::ptr::addr_of!((*ptr).displayName) as usize - ptr as usize
863 },
864 8usize,
865 concat!(
866 "Offset of field: ",
867 stringify!(VmbFeatureEnumEntry),
868 "::",
869 stringify!(displayName)
870 )
871 );
872 }
873 test_field_displayName();
874 fn test_field_visibility() {
875 assert_eq!(
876 unsafe {
877 let uninit = ::std::mem::MaybeUninit::<VmbFeatureEnumEntry>::uninit();
878 let ptr = uninit.as_ptr();
879 ::std::ptr::addr_of!((*ptr).visibility) as usize - ptr as usize
880 },
881 16usize,
882 concat!(
883 "Offset of field: ",
884 stringify!(VmbFeatureEnumEntry),
885 "::",
886 stringify!(visibility)
887 )
888 );
889 }
890 test_field_visibility();
891 fn test_field_tooltip() {
892 assert_eq!(
893 unsafe {
894 let uninit = ::std::mem::MaybeUninit::<VmbFeatureEnumEntry>::uninit();
895 let ptr = uninit.as_ptr();
896 ::std::ptr::addr_of!((*ptr).tooltip) as usize - ptr as usize
897 },
898 24usize,
899 concat!(
900 "Offset of field: ",
901 stringify!(VmbFeatureEnumEntry),
902 "::",
903 stringify!(tooltip)
904 )
905 );
906 }
907 test_field_tooltip();
908 fn test_field_description() {
909 assert_eq!(
910 unsafe {
911 let uninit = ::std::mem::MaybeUninit::<VmbFeatureEnumEntry>::uninit();
912 let ptr = uninit.as_ptr();
913 ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize
914 },
915 32usize,
916 concat!(
917 "Offset of field: ",
918 stringify!(VmbFeatureEnumEntry),
919 "::",
920 stringify!(description)
921 )
922 );
923 }
924 test_field_description();
925 fn test_field_sfncNamespace() {
926 assert_eq!(
927 unsafe {
928 let uninit = ::std::mem::MaybeUninit::<VmbFeatureEnumEntry>::uninit();
929 let ptr = uninit.as_ptr();
930 ::std::ptr::addr_of!((*ptr).sfncNamespace) as usize - ptr as usize
931 },
932 40usize,
933 concat!(
934 "Offset of field: ",
935 stringify!(VmbFeatureEnumEntry),
936 "::",
937 stringify!(sfncNamespace)
938 )
939 );
940 }
941 test_field_sfncNamespace();
942 fn test_field_intValue() {
943 assert_eq!(
944 unsafe {
945 let uninit = ::std::mem::MaybeUninit::<VmbFeatureEnumEntry>::uninit();
946 let ptr = uninit.as_ptr();
947 ::std::ptr::addr_of!((*ptr).intValue) as usize - ptr as usize
948 },
949 48usize,
950 concat!(
951 "Offset of field: ",
952 stringify!(VmbFeatureEnumEntry),
953 "::",
954 stringify!(intValue)
955 )
956 );
957 }
958 test_field_intValue();
959}
960pub type VmbFeatureEnumEntry_t = VmbFeatureEnumEntry;
961pub mod VmbFrameStatusType {
962 pub type Type = ::std::os::raw::c_int;
963 pub const VmbFrameStatusComplete: Type = 0;
964 pub const VmbFrameStatusIncomplete: Type = -1;
965 pub const VmbFrameStatusTooSmall: Type = -2;
966 pub const VmbFrameStatusInvalid: Type = -3;
967}
968pub type VmbFrameStatus_t = VmbInt32_t;
969impl VmbFrameFlagsType {
970 pub const VmbFrameFlagsNone: VmbFrameFlagsType = VmbFrameFlagsType(0);
971}
972impl VmbFrameFlagsType {
973 pub const VmbFrameFlagsDimension: VmbFrameFlagsType = VmbFrameFlagsType(1);
974}
975impl VmbFrameFlagsType {
976 pub const VmbFrameFlagsOffset: VmbFrameFlagsType = VmbFrameFlagsType(2);
977}
978impl VmbFrameFlagsType {
979 pub const VmbFrameFlagsFrameID: VmbFrameFlagsType = VmbFrameFlagsType(4);
980}
981impl VmbFrameFlagsType {
982 pub const VmbFrameFlagsTimestamp: VmbFrameFlagsType = VmbFrameFlagsType(8);
983}
984impl ::std::ops::BitOr<VmbFrameFlagsType> for VmbFrameFlagsType {
985 type Output = Self;
986 #[inline]
987 fn bitor(self, other: Self) -> Self {
988 VmbFrameFlagsType(self.0 | other.0)
989 }
990}
991impl ::std::ops::BitOrAssign for VmbFrameFlagsType {
992 #[inline]
993 fn bitor_assign(&mut self, rhs: VmbFrameFlagsType) {
994 self.0 |= rhs.0;
995 }
996}
997impl ::std::ops::BitAnd<VmbFrameFlagsType> for VmbFrameFlagsType {
998 type Output = Self;
999 #[inline]
1000 fn bitand(self, other: Self) -> Self {
1001 VmbFrameFlagsType(self.0 & other.0)
1002 }
1003}
1004impl ::std::ops::BitAndAssign for VmbFrameFlagsType {
1005 #[inline]
1006 fn bitand_assign(&mut self, rhs: VmbFrameFlagsType) {
1007 self.0 &= rhs.0;
1008 }
1009}
1010#[repr(transparent)]
1011#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1012pub struct VmbFrameFlagsType(pub ::std::os::raw::c_uint);
1013pub type VmbFrameFlags_t = VmbUint32_t;
1014#[repr(C)]
1015#[derive(Debug, Copy, Clone, PartialEq)]
1016pub struct VmbFrame_t {
1017 pub buffer: *mut ::std::os::raw::c_void,
1018 pub bufferSize: VmbUint32_t,
1019 pub context: [*mut ::std::os::raw::c_void; 4usize],
1020 pub receiveStatus: VmbFrameStatus_t,
1021 pub receiveFlags: VmbFrameFlags_t,
1022 pub imageSize: VmbUint32_t,
1023 pub ancillarySize: VmbUint32_t,
1024 pub pixelFormat: VmbPixelFormat_t,
1025 pub width: VmbUint32_t,
1026 pub height: VmbUint32_t,
1027 pub offsetX: VmbUint32_t,
1028 pub offsetY: VmbUint32_t,
1029 pub frameID: VmbUint64_t,
1030 pub timestamp: VmbUint64_t,
1031}
1032#[test]
1033fn bindgen_test_layout_VmbFrame_t() {
1034 assert_eq!(
1035 ::std::mem::size_of::<VmbFrame_t>(),
1036 104usize,
1037 concat!("Size of: ", stringify!(VmbFrame_t))
1038 );
1039 assert_eq!(
1040 ::std::mem::align_of::<VmbFrame_t>(),
1041 8usize,
1042 concat!("Alignment of ", stringify!(VmbFrame_t))
1043 );
1044 fn test_field_buffer() {
1045 assert_eq!(
1046 unsafe {
1047 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1048 let ptr = uninit.as_ptr();
1049 ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize
1050 },
1051 0usize,
1052 concat!(
1053 "Offset of field: ",
1054 stringify!(VmbFrame_t),
1055 "::",
1056 stringify!(buffer)
1057 )
1058 );
1059 }
1060 test_field_buffer();
1061 fn test_field_bufferSize() {
1062 assert_eq!(
1063 unsafe {
1064 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1065 let ptr = uninit.as_ptr();
1066 ::std::ptr::addr_of!((*ptr).bufferSize) as usize - ptr as usize
1067 },
1068 8usize,
1069 concat!(
1070 "Offset of field: ",
1071 stringify!(VmbFrame_t),
1072 "::",
1073 stringify!(bufferSize)
1074 )
1075 );
1076 }
1077 test_field_bufferSize();
1078 fn test_field_context() {
1079 assert_eq!(
1080 unsafe {
1081 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1082 let ptr = uninit.as_ptr();
1083 ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize
1084 },
1085 16usize,
1086 concat!(
1087 "Offset of field: ",
1088 stringify!(VmbFrame_t),
1089 "::",
1090 stringify!(context)
1091 )
1092 );
1093 }
1094 test_field_context();
1095 fn test_field_receiveStatus() {
1096 assert_eq!(
1097 unsafe {
1098 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1099 let ptr = uninit.as_ptr();
1100 ::std::ptr::addr_of!((*ptr).receiveStatus) as usize - ptr as usize
1101 },
1102 48usize,
1103 concat!(
1104 "Offset of field: ",
1105 stringify!(VmbFrame_t),
1106 "::",
1107 stringify!(receiveStatus)
1108 )
1109 );
1110 }
1111 test_field_receiveStatus();
1112 fn test_field_receiveFlags() {
1113 assert_eq!(
1114 unsafe {
1115 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1116 let ptr = uninit.as_ptr();
1117 ::std::ptr::addr_of!((*ptr).receiveFlags) as usize - ptr as usize
1118 },
1119 52usize,
1120 concat!(
1121 "Offset of field: ",
1122 stringify!(VmbFrame_t),
1123 "::",
1124 stringify!(receiveFlags)
1125 )
1126 );
1127 }
1128 test_field_receiveFlags();
1129 fn test_field_imageSize() {
1130 assert_eq!(
1131 unsafe {
1132 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1133 let ptr = uninit.as_ptr();
1134 ::std::ptr::addr_of!((*ptr).imageSize) as usize - ptr as usize
1135 },
1136 56usize,
1137 concat!(
1138 "Offset of field: ",
1139 stringify!(VmbFrame_t),
1140 "::",
1141 stringify!(imageSize)
1142 )
1143 );
1144 }
1145 test_field_imageSize();
1146 fn test_field_ancillarySize() {
1147 assert_eq!(
1148 unsafe {
1149 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1150 let ptr = uninit.as_ptr();
1151 ::std::ptr::addr_of!((*ptr).ancillarySize) as usize - ptr as usize
1152 },
1153 60usize,
1154 concat!(
1155 "Offset of field: ",
1156 stringify!(VmbFrame_t),
1157 "::",
1158 stringify!(ancillarySize)
1159 )
1160 );
1161 }
1162 test_field_ancillarySize();
1163 fn test_field_pixelFormat() {
1164 assert_eq!(
1165 unsafe {
1166 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1167 let ptr = uninit.as_ptr();
1168 ::std::ptr::addr_of!((*ptr).pixelFormat) as usize - ptr as usize
1169 },
1170 64usize,
1171 concat!(
1172 "Offset of field: ",
1173 stringify!(VmbFrame_t),
1174 "::",
1175 stringify!(pixelFormat)
1176 )
1177 );
1178 }
1179 test_field_pixelFormat();
1180 fn test_field_width() {
1181 assert_eq!(
1182 unsafe {
1183 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1184 let ptr = uninit.as_ptr();
1185 ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize
1186 },
1187 68usize,
1188 concat!(
1189 "Offset of field: ",
1190 stringify!(VmbFrame_t),
1191 "::",
1192 stringify!(width)
1193 )
1194 );
1195 }
1196 test_field_width();
1197 fn test_field_height() {
1198 assert_eq!(
1199 unsafe {
1200 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1201 let ptr = uninit.as_ptr();
1202 ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize
1203 },
1204 72usize,
1205 concat!(
1206 "Offset of field: ",
1207 stringify!(VmbFrame_t),
1208 "::",
1209 stringify!(height)
1210 )
1211 );
1212 }
1213 test_field_height();
1214 fn test_field_offsetX() {
1215 assert_eq!(
1216 unsafe {
1217 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1218 let ptr = uninit.as_ptr();
1219 ::std::ptr::addr_of!((*ptr).offsetX) as usize - ptr as usize
1220 },
1221 76usize,
1222 concat!(
1223 "Offset of field: ",
1224 stringify!(VmbFrame_t),
1225 "::",
1226 stringify!(offsetX)
1227 )
1228 );
1229 }
1230 test_field_offsetX();
1231 fn test_field_offsetY() {
1232 assert_eq!(
1233 unsafe {
1234 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1235 let ptr = uninit.as_ptr();
1236 ::std::ptr::addr_of!((*ptr).offsetY) as usize - ptr as usize
1237 },
1238 80usize,
1239 concat!(
1240 "Offset of field: ",
1241 stringify!(VmbFrame_t),
1242 "::",
1243 stringify!(offsetY)
1244 )
1245 );
1246 }
1247 test_field_offsetY();
1248 fn test_field_frameID() {
1249 assert_eq!(
1250 unsafe {
1251 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1252 let ptr = uninit.as_ptr();
1253 ::std::ptr::addr_of!((*ptr).frameID) as usize - ptr as usize
1254 },
1255 88usize,
1256 concat!(
1257 "Offset of field: ",
1258 stringify!(VmbFrame_t),
1259 "::",
1260 stringify!(frameID)
1261 )
1262 );
1263 }
1264 test_field_frameID();
1265 fn test_field_timestamp() {
1266 assert_eq!(
1267 unsafe {
1268 let uninit = ::std::mem::MaybeUninit::<VmbFrame_t>::uninit();
1269 let ptr = uninit.as_ptr();
1270 ::std::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize
1271 },
1272 96usize,
1273 concat!(
1274 "Offset of field: ",
1275 stringify!(VmbFrame_t),
1276 "::",
1277 stringify!(timestamp)
1278 )
1279 );
1280 }
1281 test_field_timestamp();
1282}
1283pub mod VmbFeaturePersistType {
1284 pub type Type = ::std::os::raw::c_uint;
1285 pub const VmbFeaturePersistAll: Type = 0;
1286 pub const VmbFeaturePersistStreamable: Type = 1;
1287 pub const VmbFeaturePersistNoLUT: Type = 2;
1288}
1289pub type VmbFeaturePersist_t = VmbUint32_t;
1290#[repr(C)]
1291#[derive(Debug, Copy, Clone, PartialEq)]
1292pub struct VmbFeaturePersistSettings_t {
1293 pub persistType: VmbFeaturePersist_t,
1294 pub maxIterations: VmbUint32_t,
1295 pub loggingLevel: VmbUint32_t,
1296}
1297#[test]
1298fn bindgen_test_layout_VmbFeaturePersistSettings_t() {
1299 assert_eq!(
1300 ::std::mem::size_of::<VmbFeaturePersistSettings_t>(),
1301 12usize,
1302 concat!("Size of: ", stringify!(VmbFeaturePersistSettings_t))
1303 );
1304 assert_eq!(
1305 ::std::mem::align_of::<VmbFeaturePersistSettings_t>(),
1306 4usize,
1307 concat!("Alignment of ", stringify!(VmbFeaturePersistSettings_t))
1308 );
1309 fn test_field_persistType() {
1310 assert_eq!(
1311 unsafe {
1312 let uninit = ::std::mem::MaybeUninit::<VmbFeaturePersistSettings_t>::uninit();
1313 let ptr = uninit.as_ptr();
1314 ::std::ptr::addr_of!((*ptr).persistType) as usize - ptr as usize
1315 },
1316 0usize,
1317 concat!(
1318 "Offset of field: ",
1319 stringify!(VmbFeaturePersistSettings_t),
1320 "::",
1321 stringify!(persistType)
1322 )
1323 );
1324 }
1325 test_field_persistType();
1326 fn test_field_maxIterations() {
1327 assert_eq!(
1328 unsafe {
1329 let uninit = ::std::mem::MaybeUninit::<VmbFeaturePersistSettings_t>::uninit();
1330 let ptr = uninit.as_ptr();
1331 ::std::ptr::addr_of!((*ptr).maxIterations) as usize - ptr as usize
1332 },
1333 4usize,
1334 concat!(
1335 "Offset of field: ",
1336 stringify!(VmbFeaturePersistSettings_t),
1337 "::",
1338 stringify!(maxIterations)
1339 )
1340 );
1341 }
1342 test_field_maxIterations();
1343 fn test_field_loggingLevel() {
1344 assert_eq!(
1345 unsafe {
1346 let uninit = ::std::mem::MaybeUninit::<VmbFeaturePersistSettings_t>::uninit();
1347 let ptr = uninit.as_ptr();
1348 ::std::ptr::addr_of!((*ptr).loggingLevel) as usize - ptr as usize
1349 },
1350 8usize,
1351 concat!(
1352 "Offset of field: ",
1353 stringify!(VmbFeaturePersistSettings_t),
1354 "::",
1355 stringify!(loggingLevel)
1356 )
1357 );
1358 }
1359 test_field_loggingLevel();
1360}
1361pub type VmbInvalidationCallback = ::std::option::Option<
1362 unsafe extern "C" fn(
1363 handle: VmbHandle_t,
1364 name: *const ::std::os::raw::c_char,
1365 pUserContext: *mut ::std::os::raw::c_void,
1366 ),
1367>;
1368pub type VmbFrameCallback =
1369 ::std::option::Option<unsafe extern "C" fn(cameraHandle: VmbHandle_t, pFrame: *mut VmbFrame_t)>;
1370extern crate libloading;
1371pub struct VimbaC {
1372 __library: ::libloading::Library,
1373 pub VmbVersionQuery: Result<
1374 unsafe extern "C" fn(
1375 pVersionInfo: *mut VmbVersionInfo_t,
1376 sizeofVersionInfo: VmbUint32_t,
1377 ) -> VmbError_t,
1378 ::libloading::Error,
1379 >,
1380 pub VmbStartup: Result<unsafe extern "C" fn() -> VmbError_t, ::libloading::Error>,
1381 pub VmbShutdown: Result<unsafe extern "C" fn(), ::libloading::Error>,
1382 pub VmbCamerasList: Result<
1383 unsafe extern "C" fn(
1384 pCameraInfo: *mut VmbCameraInfo_t,
1385 listLength: VmbUint32_t,
1386 pNumFound: *mut VmbUint32_t,
1387 sizeofCameraInfo: VmbUint32_t,
1388 ) -> VmbError_t,
1389 ::libloading::Error,
1390 >,
1391 pub VmbCameraInfoQuery: Result<
1392 unsafe extern "C" fn(
1393 idString: *const ::std::os::raw::c_char,
1394 pInfo: *mut VmbCameraInfo_t,
1395 sizeofCameraInfo: VmbUint32_t,
1396 ) -> VmbError_t,
1397 ::libloading::Error,
1398 >,
1399 pub VmbCameraOpen: Result<
1400 unsafe extern "C" fn(
1401 idString: *const ::std::os::raw::c_char,
1402 accessMode: VmbAccessMode_t,
1403 pCameraHandle: *mut VmbHandle_t,
1404 ) -> VmbError_t,
1405 ::libloading::Error,
1406 >,
1407 pub VmbCameraClose:
1408 Result<unsafe extern "C" fn(cameraHandle: VmbHandle_t) -> VmbError_t, ::libloading::Error>,
1409 pub VmbFeaturesList: Result<
1410 unsafe extern "C" fn(
1411 handle: VmbHandle_t,
1412 pFeatureInfoList: *mut VmbFeatureInfo_t,
1413 listLength: VmbUint32_t,
1414 pNumFound: *mut VmbUint32_t,
1415 sizeofFeatureInfo: VmbUint32_t,
1416 ) -> VmbError_t,
1417 ::libloading::Error,
1418 >,
1419 pub VmbFeatureInfoQuery: Result<
1420 unsafe extern "C" fn(
1421 handle: VmbHandle_t,
1422 name: *const ::std::os::raw::c_char,
1423 pFeatureInfo: *mut VmbFeatureInfo_t,
1424 sizeofFeatureInfo: VmbUint32_t,
1425 ) -> VmbError_t,
1426 ::libloading::Error,
1427 >,
1428 pub VmbFeatureListAffected: Result<
1429 unsafe extern "C" fn(
1430 handle: VmbHandle_t,
1431 name: *const ::std::os::raw::c_char,
1432 pFeatureInfoList: *mut VmbFeatureInfo_t,
1433 listLength: VmbUint32_t,
1434 pNumFound: *mut VmbUint32_t,
1435 sizeofFeatureInfo: VmbUint32_t,
1436 ) -> VmbError_t,
1437 ::libloading::Error,
1438 >,
1439 pub VmbFeatureListSelected: Result<
1440 unsafe extern "C" fn(
1441 handle: VmbHandle_t,
1442 name: *const ::std::os::raw::c_char,
1443 pFeatureInfoList: *mut VmbFeatureInfo_t,
1444 listLength: VmbUint32_t,
1445 pNumFound: *mut VmbUint32_t,
1446 sizeofFeatureInfo: VmbUint32_t,
1447 ) -> VmbError_t,
1448 ::libloading::Error,
1449 >,
1450 pub VmbFeatureAccessQuery: Result<
1451 unsafe extern "C" fn(
1452 handle: VmbHandle_t,
1453 name: *const ::std::os::raw::c_char,
1454 pIsReadable: *mut VmbBool_t,
1455 pIsWriteable: *mut VmbBool_t,
1456 ) -> VmbError_t,
1457 ::libloading::Error,
1458 >,
1459 pub VmbFeatureIntGet: Result<
1460 unsafe extern "C" fn(
1461 handle: VmbHandle_t,
1462 name: *const ::std::os::raw::c_char,
1463 pValue: *mut VmbInt64_t,
1464 ) -> VmbError_t,
1465 ::libloading::Error,
1466 >,
1467 pub VmbFeatureIntSet: Result<
1468 unsafe extern "C" fn(
1469 handle: VmbHandle_t,
1470 name: *const ::std::os::raw::c_char,
1471 value: VmbInt64_t,
1472 ) -> VmbError_t,
1473 ::libloading::Error,
1474 >,
1475 pub VmbFeatureIntRangeQuery: Result<
1476 unsafe extern "C" fn(
1477 handle: VmbHandle_t,
1478 name: *const ::std::os::raw::c_char,
1479 pMin: *mut VmbInt64_t,
1480 pMax: *mut VmbInt64_t,
1481 ) -> VmbError_t,
1482 ::libloading::Error,
1483 >,
1484 pub VmbFeatureIntIncrementQuery: Result<
1485 unsafe extern "C" fn(
1486 handle: VmbHandle_t,
1487 name: *const ::std::os::raw::c_char,
1488 pValue: *mut VmbInt64_t,
1489 ) -> VmbError_t,
1490 ::libloading::Error,
1491 >,
1492 pub VmbFeatureFloatGet: Result<
1493 unsafe extern "C" fn(
1494 handle: VmbHandle_t,
1495 name: *const ::std::os::raw::c_char,
1496 pValue: *mut f64,
1497 ) -> VmbError_t,
1498 ::libloading::Error,
1499 >,
1500 pub VmbFeatureFloatSet: Result<
1501 unsafe extern "C" fn(
1502 handle: VmbHandle_t,
1503 name: *const ::std::os::raw::c_char,
1504 value: f64,
1505 ) -> VmbError_t,
1506 ::libloading::Error,
1507 >,
1508 pub VmbFeatureFloatRangeQuery: Result<
1509 unsafe extern "C" fn(
1510 handle: VmbHandle_t,
1511 name: *const ::std::os::raw::c_char,
1512 pMin: *mut f64,
1513 pMax: *mut f64,
1514 ) -> VmbError_t,
1515 ::libloading::Error,
1516 >,
1517 pub VmbFeatureFloatIncrementQuery: Result<
1518 unsafe extern "C" fn(
1519 handle: VmbHandle_t,
1520 name: *const ::std::os::raw::c_char,
1521 pHasIncrement: *mut VmbBool_t,
1522 pValue: *mut f64,
1523 ) -> VmbError_t,
1524 ::libloading::Error,
1525 >,
1526 pub VmbFeatureEnumGet: Result<
1527 unsafe extern "C" fn(
1528 handle: VmbHandle_t,
1529 name: *const ::std::os::raw::c_char,
1530 pValue: *mut *const ::std::os::raw::c_char,
1531 ) -> VmbError_t,
1532 ::libloading::Error,
1533 >,
1534 pub VmbFeatureEnumSet: Result<
1535 unsafe extern "C" fn(
1536 handle: VmbHandle_t,
1537 name: *const ::std::os::raw::c_char,
1538 value: *const ::std::os::raw::c_char,
1539 ) -> VmbError_t,
1540 ::libloading::Error,
1541 >,
1542 pub VmbFeatureEnumRangeQuery: Result<
1543 unsafe extern "C" fn(
1544 handle: VmbHandle_t,
1545 name: *const ::std::os::raw::c_char,
1546 pNameArray: *mut *const ::std::os::raw::c_char,
1547 arrayLength: VmbUint32_t,
1548 pNumFilled: *mut VmbUint32_t,
1549 ) -> VmbError_t,
1550 ::libloading::Error,
1551 >,
1552 pub VmbFeatureEnumIsAvailable: Result<
1553 unsafe extern "C" fn(
1554 handle: VmbHandle_t,
1555 name: *const ::std::os::raw::c_char,
1556 value: *const ::std::os::raw::c_char,
1557 pIsAvailable: *mut VmbBool_t,
1558 ) -> VmbError_t,
1559 ::libloading::Error,
1560 >,
1561 pub VmbFeatureEnumAsInt: Result<
1562 unsafe extern "C" fn(
1563 handle: VmbHandle_t,
1564 name: *const ::std::os::raw::c_char,
1565 value: *const ::std::os::raw::c_char,
1566 pIntVal: *mut VmbInt64_t,
1567 ) -> VmbError_t,
1568 ::libloading::Error,
1569 >,
1570 pub VmbFeatureEnumAsString: Result<
1571 unsafe extern "C" fn(
1572 handle: VmbHandle_t,
1573 name: *const ::std::os::raw::c_char,
1574 intValue: VmbInt64_t,
1575 pStringValue: *mut *const ::std::os::raw::c_char,
1576 ) -> VmbError_t,
1577 ::libloading::Error,
1578 >,
1579 pub VmbFeatureEnumEntryGet: Result<
1580 unsafe extern "C" fn(
1581 handle: VmbHandle_t,
1582 featureName: *const ::std::os::raw::c_char,
1583 entryName: *const ::std::os::raw::c_char,
1584 pFeatureEnumEntry: *mut VmbFeatureEnumEntry_t,
1585 sizeofFeatureEnumEntry: VmbUint32_t,
1586 ) -> VmbError_t,
1587 ::libloading::Error,
1588 >,
1589 pub VmbFeatureStringGet: Result<
1590 unsafe extern "C" fn(
1591 handle: VmbHandle_t,
1592 name: *const ::std::os::raw::c_char,
1593 buffer: *mut ::std::os::raw::c_char,
1594 bufferSize: VmbUint32_t,
1595 pSizeFilled: *mut VmbUint32_t,
1596 ) -> VmbError_t,
1597 ::libloading::Error,
1598 >,
1599 pub VmbFeatureStringSet: Result<
1600 unsafe extern "C" fn(
1601 handle: VmbHandle_t,
1602 name: *const ::std::os::raw::c_char,
1603 value: *const ::std::os::raw::c_char,
1604 ) -> VmbError_t,
1605 ::libloading::Error,
1606 >,
1607 pub VmbFeatureStringMaxlengthQuery: Result<
1608 unsafe extern "C" fn(
1609 handle: VmbHandle_t,
1610 name: *const ::std::os::raw::c_char,
1611 pMaxLength: *mut VmbUint32_t,
1612 ) -> VmbError_t,
1613 ::libloading::Error,
1614 >,
1615 pub VmbFeatureBoolGet: Result<
1616 unsafe extern "C" fn(
1617 handle: VmbHandle_t,
1618 name: *const ::std::os::raw::c_char,
1619 pValue: *mut VmbBool_t,
1620 ) -> VmbError_t,
1621 ::libloading::Error,
1622 >,
1623 pub VmbFeatureBoolSet: Result<
1624 unsafe extern "C" fn(
1625 handle: VmbHandle_t,
1626 name: *const ::std::os::raw::c_char,
1627 value: VmbBool_t,
1628 ) -> VmbError_t,
1629 ::libloading::Error,
1630 >,
1631 pub VmbFeatureCommandRun: Result<
1632 unsafe extern "C" fn(
1633 handle: VmbHandle_t,
1634 name: *const ::std::os::raw::c_char,
1635 ) -> VmbError_t,
1636 ::libloading::Error,
1637 >,
1638 pub VmbFeatureCommandIsDone: Result<
1639 unsafe extern "C" fn(
1640 handle: VmbHandle_t,
1641 name: *const ::std::os::raw::c_char,
1642 pIsDone: *mut VmbBool_t,
1643 ) -> VmbError_t,
1644 ::libloading::Error,
1645 >,
1646 pub VmbFeatureRawGet: Result<
1647 unsafe extern "C" fn(
1648 handle: VmbHandle_t,
1649 name: *const ::std::os::raw::c_char,
1650 pBuffer: *mut ::std::os::raw::c_char,
1651 bufferSize: VmbUint32_t,
1652 pSizeFilled: *mut VmbUint32_t,
1653 ) -> VmbError_t,
1654 ::libloading::Error,
1655 >,
1656 pub VmbFeatureRawSet: Result<
1657 unsafe extern "C" fn(
1658 handle: VmbHandle_t,
1659 name: *const ::std::os::raw::c_char,
1660 pBuffer: *const ::std::os::raw::c_char,
1661 bufferSize: VmbUint32_t,
1662 ) -> VmbError_t,
1663 ::libloading::Error,
1664 >,
1665 pub VmbFeatureRawLengthQuery: Result<
1666 unsafe extern "C" fn(
1667 handle: VmbHandle_t,
1668 name: *const ::std::os::raw::c_char,
1669 pLength: *mut VmbUint32_t,
1670 ) -> VmbError_t,
1671 ::libloading::Error,
1672 >,
1673 pub VmbFeatureInvalidationRegister: Result<
1674 unsafe extern "C" fn(
1675 handle: VmbHandle_t,
1676 name: *const ::std::os::raw::c_char,
1677 callback: VmbInvalidationCallback,
1678 pUserContext: *mut ::std::os::raw::c_void,
1679 ) -> VmbError_t,
1680 ::libloading::Error,
1681 >,
1682 pub VmbFeatureInvalidationUnregister: Result<
1683 unsafe extern "C" fn(
1684 handle: VmbHandle_t,
1685 name: *const ::std::os::raw::c_char,
1686 callback: VmbInvalidationCallback,
1687 ) -> VmbError_t,
1688 ::libloading::Error,
1689 >,
1690 pub VmbFrameAnnounce: Result<
1691 unsafe extern "C" fn(
1692 cameraHandle: VmbHandle_t,
1693 pFrame: *const VmbFrame_t,
1694 sizeofFrame: VmbUint32_t,
1695 ) -> VmbError_t,
1696 ::libloading::Error,
1697 >,
1698 pub VmbFrameRevoke: Result<
1699 unsafe extern "C" fn(cameraHandle: VmbHandle_t, pFrame: *const VmbFrame_t) -> VmbError_t,
1700 ::libloading::Error,
1701 >,
1702 pub VmbFrameRevokeAll:
1703 Result<unsafe extern "C" fn(cameraHandle: VmbHandle_t) -> VmbError_t, ::libloading::Error>,
1704 pub VmbCaptureStart:
1705 Result<unsafe extern "C" fn(cameraHandle: VmbHandle_t) -> VmbError_t, ::libloading::Error>,
1706 pub VmbCaptureEnd:
1707 Result<unsafe extern "C" fn(cameraHandle: VmbHandle_t) -> VmbError_t, ::libloading::Error>,
1708 pub VmbCaptureFrameQueue: Result<
1709 unsafe extern "C" fn(
1710 cameraHandle: VmbHandle_t,
1711 pFrame: *const VmbFrame_t,
1712 callback: VmbFrameCallback,
1713 ) -> VmbError_t,
1714 ::libloading::Error,
1715 >,
1716 pub VmbCaptureFrameWait: Result<
1717 unsafe extern "C" fn(
1718 cameraHandle: VmbHandle_t,
1719 pFrame: *const VmbFrame_t,
1720 timeout: VmbUint32_t,
1721 ) -> VmbError_t,
1722 ::libloading::Error,
1723 >,
1724 pub VmbCaptureQueueFlush:
1725 Result<unsafe extern "C" fn(cameraHandle: VmbHandle_t) -> VmbError_t, ::libloading::Error>,
1726 pub VmbInterfacesList: Result<
1727 unsafe extern "C" fn(
1728 pInterfaceInfo: *mut VmbInterfaceInfo_t,
1729 listLength: VmbUint32_t,
1730 pNumFound: *mut VmbUint32_t,
1731 sizeofInterfaceInfo: VmbUint32_t,
1732 ) -> VmbError_t,
1733 ::libloading::Error,
1734 >,
1735 pub VmbInterfaceOpen: Result<
1736 unsafe extern "C" fn(
1737 idString: *const ::std::os::raw::c_char,
1738 pInterfaceHandle: *mut VmbHandle_t,
1739 ) -> VmbError_t,
1740 ::libloading::Error,
1741 >,
1742 pub VmbInterfaceClose: Result<
1743 unsafe extern "C" fn(interfaceHandle: VmbHandle_t) -> VmbError_t,
1744 ::libloading::Error,
1745 >,
1746 pub VmbAncillaryDataOpen: Result<
1747 unsafe extern "C" fn(
1748 pFrame: *mut VmbFrame_t,
1749 pAncillaryDataHandle: *mut VmbHandle_t,
1750 ) -> VmbError_t,
1751 ::libloading::Error,
1752 >,
1753 pub VmbAncillaryDataClose: Result<
1754 unsafe extern "C" fn(ancillaryDataHandle: VmbHandle_t) -> VmbError_t,
1755 ::libloading::Error,
1756 >,
1757 pub VmbMemoryRead: Result<
1758 unsafe extern "C" fn(
1759 handle: VmbHandle_t,
1760 address: VmbUint64_t,
1761 bufferSize: VmbUint32_t,
1762 dataBuffer: *mut ::std::os::raw::c_char,
1763 pSizeComplete: *mut VmbUint32_t,
1764 ) -> VmbError_t,
1765 ::libloading::Error,
1766 >,
1767 pub VmbMemoryWrite: Result<
1768 unsafe extern "C" fn(
1769 handle: VmbHandle_t,
1770 address: VmbUint64_t,
1771 bufferSize: VmbUint32_t,
1772 dataBuffer: *const ::std::os::raw::c_char,
1773 pSizeComplete: *mut VmbUint32_t,
1774 ) -> VmbError_t,
1775 ::libloading::Error,
1776 >,
1777 pub VmbRegistersRead: Result<
1778 unsafe extern "C" fn(
1779 handle: VmbHandle_t,
1780 readCount: VmbUint32_t,
1781 pAddressArray: *const VmbUint64_t,
1782 pDataArray: *mut VmbUint64_t,
1783 pNumCompleteReads: *mut VmbUint32_t,
1784 ) -> VmbError_t,
1785 ::libloading::Error,
1786 >,
1787 pub VmbRegistersWrite: Result<
1788 unsafe extern "C" fn(
1789 handle: VmbHandle_t,
1790 writeCount: VmbUint32_t,
1791 pAddressArray: *const VmbUint64_t,
1792 pDataArray: *const VmbUint64_t,
1793 pNumCompleteWrites: *mut VmbUint32_t,
1794 ) -> VmbError_t,
1795 ::libloading::Error,
1796 >,
1797 pub VmbCameraSettingsSave: Result<
1798 unsafe extern "C" fn(
1799 handle: VmbHandle_t,
1800 fileName: *const ::std::os::raw::c_char,
1801 pSettings: *mut VmbFeaturePersistSettings_t,
1802 sizeofSettings: VmbUint32_t,
1803 ) -> VmbError_t,
1804 ::libloading::Error,
1805 >,
1806 pub VmbCameraSettingsLoad: Result<
1807 unsafe extern "C" fn(
1808 handle: VmbHandle_t,
1809 fileName: *const ::std::os::raw::c_char,
1810 pSettings: *mut VmbFeaturePersistSettings_t,
1811 sizeofSettings: VmbUint32_t,
1812 ) -> VmbError_t,
1813 ::libloading::Error,
1814 >,
1815}
1816impl VimbaC {
1817 pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
1818 where
1819 P: AsRef<::std::ffi::OsStr>,
1820 {
1821 let library = ::libloading::Library::new(path)?;
1822 Self::from_library(library)
1823 }
1824 pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
1825 where
1826 L: Into<::libloading::Library>,
1827 {
1828 let __library = library.into();
1829 let VmbVersionQuery = __library.get(b"VmbVersionQuery\0").map(|sym| *sym);
1830 let VmbStartup = __library.get(b"VmbStartup\0").map(|sym| *sym);
1831 let VmbShutdown = __library.get(b"VmbShutdown\0").map(|sym| *sym);
1832 let VmbCamerasList = __library.get(b"VmbCamerasList\0").map(|sym| *sym);
1833 let VmbCameraInfoQuery = __library.get(b"VmbCameraInfoQuery\0").map(|sym| *sym);
1834 let VmbCameraOpen = __library.get(b"VmbCameraOpen\0").map(|sym| *sym);
1835 let VmbCameraClose = __library.get(b"VmbCameraClose\0").map(|sym| *sym);
1836 let VmbFeaturesList = __library.get(b"VmbFeaturesList\0").map(|sym| *sym);
1837 let VmbFeatureInfoQuery = __library.get(b"VmbFeatureInfoQuery\0").map(|sym| *sym);
1838 let VmbFeatureListAffected = __library.get(b"VmbFeatureListAffected\0").map(|sym| *sym);
1839 let VmbFeatureListSelected = __library.get(b"VmbFeatureListSelected\0").map(|sym| *sym);
1840 let VmbFeatureAccessQuery = __library.get(b"VmbFeatureAccessQuery\0").map(|sym| *sym);
1841 let VmbFeatureIntGet = __library.get(b"VmbFeatureIntGet\0").map(|sym| *sym);
1842 let VmbFeatureIntSet = __library.get(b"VmbFeatureIntSet\0").map(|sym| *sym);
1843 let VmbFeatureIntRangeQuery = __library.get(b"VmbFeatureIntRangeQuery\0").map(|sym| *sym);
1844 let VmbFeatureIntIncrementQuery = __library
1845 .get(b"VmbFeatureIntIncrementQuery\0")
1846 .map(|sym| *sym);
1847 let VmbFeatureFloatGet = __library.get(b"VmbFeatureFloatGet\0").map(|sym| *sym);
1848 let VmbFeatureFloatSet = __library.get(b"VmbFeatureFloatSet\0").map(|sym| *sym);
1849 let VmbFeatureFloatRangeQuery = __library
1850 .get(b"VmbFeatureFloatRangeQuery\0")
1851 .map(|sym| *sym);
1852 let VmbFeatureFloatIncrementQuery = __library
1853 .get(b"VmbFeatureFloatIncrementQuery\0")
1854 .map(|sym| *sym);
1855 let VmbFeatureEnumGet = __library.get(b"VmbFeatureEnumGet\0").map(|sym| *sym);
1856 let VmbFeatureEnumSet = __library.get(b"VmbFeatureEnumSet\0").map(|sym| *sym);
1857 let VmbFeatureEnumRangeQuery = __library.get(b"VmbFeatureEnumRangeQuery\0").map(|sym| *sym);
1858 let VmbFeatureEnumIsAvailable = __library
1859 .get(b"VmbFeatureEnumIsAvailable\0")
1860 .map(|sym| *sym);
1861 let VmbFeatureEnumAsInt = __library.get(b"VmbFeatureEnumAsInt\0").map(|sym| *sym);
1862 let VmbFeatureEnumAsString = __library.get(b"VmbFeatureEnumAsString\0").map(|sym| *sym);
1863 let VmbFeatureEnumEntryGet = __library.get(b"VmbFeatureEnumEntryGet\0").map(|sym| *sym);
1864 let VmbFeatureStringGet = __library.get(b"VmbFeatureStringGet\0").map(|sym| *sym);
1865 let VmbFeatureStringSet = __library.get(b"VmbFeatureStringSet\0").map(|sym| *sym);
1866 let VmbFeatureStringMaxlengthQuery = __library
1867 .get(b"VmbFeatureStringMaxlengthQuery\0")
1868 .map(|sym| *sym);
1869 let VmbFeatureBoolGet = __library.get(b"VmbFeatureBoolGet\0").map(|sym| *sym);
1870 let VmbFeatureBoolSet = __library.get(b"VmbFeatureBoolSet\0").map(|sym| *sym);
1871 let VmbFeatureCommandRun = __library.get(b"VmbFeatureCommandRun\0").map(|sym| *sym);
1872 let VmbFeatureCommandIsDone = __library.get(b"VmbFeatureCommandIsDone\0").map(|sym| *sym);
1873 let VmbFeatureRawGet = __library.get(b"VmbFeatureRawGet\0").map(|sym| *sym);
1874 let VmbFeatureRawSet = __library.get(b"VmbFeatureRawSet\0").map(|sym| *sym);
1875 let VmbFeatureRawLengthQuery = __library.get(b"VmbFeatureRawLengthQuery\0").map(|sym| *sym);
1876 let VmbFeatureInvalidationRegister = __library
1877 .get(b"VmbFeatureInvalidationRegister\0")
1878 .map(|sym| *sym);
1879 let VmbFeatureInvalidationUnregister = __library
1880 .get(b"VmbFeatureInvalidationUnregister\0")
1881 .map(|sym| *sym);
1882 let VmbFrameAnnounce = __library.get(b"VmbFrameAnnounce\0").map(|sym| *sym);
1883 let VmbFrameRevoke = __library.get(b"VmbFrameRevoke\0").map(|sym| *sym);
1884 let VmbFrameRevokeAll = __library.get(b"VmbFrameRevokeAll\0").map(|sym| *sym);
1885 let VmbCaptureStart = __library.get(b"VmbCaptureStart\0").map(|sym| *sym);
1886 let VmbCaptureEnd = __library.get(b"VmbCaptureEnd\0").map(|sym| *sym);
1887 let VmbCaptureFrameQueue = __library.get(b"VmbCaptureFrameQueue\0").map(|sym| *sym);
1888 let VmbCaptureFrameWait = __library.get(b"VmbCaptureFrameWait\0").map(|sym| *sym);
1889 let VmbCaptureQueueFlush = __library.get(b"VmbCaptureQueueFlush\0").map(|sym| *sym);
1890 let VmbInterfacesList = __library.get(b"VmbInterfacesList\0").map(|sym| *sym);
1891 let VmbInterfaceOpen = __library.get(b"VmbInterfaceOpen\0").map(|sym| *sym);
1892 let VmbInterfaceClose = __library.get(b"VmbInterfaceClose\0").map(|sym| *sym);
1893 let VmbAncillaryDataOpen = __library.get(b"VmbAncillaryDataOpen\0").map(|sym| *sym);
1894 let VmbAncillaryDataClose = __library.get(b"VmbAncillaryDataClose\0").map(|sym| *sym);
1895 let VmbMemoryRead = __library.get(b"VmbMemoryRead\0").map(|sym| *sym);
1896 let VmbMemoryWrite = __library.get(b"VmbMemoryWrite\0").map(|sym| *sym);
1897 let VmbRegistersRead = __library.get(b"VmbRegistersRead\0").map(|sym| *sym);
1898 let VmbRegistersWrite = __library.get(b"VmbRegistersWrite\0").map(|sym| *sym);
1899 let VmbCameraSettingsSave = __library.get(b"VmbCameraSettingsSave\0").map(|sym| *sym);
1900 let VmbCameraSettingsLoad = __library.get(b"VmbCameraSettingsLoad\0").map(|sym| *sym);
1901 Ok(VimbaC {
1902 __library,
1903 VmbVersionQuery,
1904 VmbStartup,
1905 VmbShutdown,
1906 VmbCamerasList,
1907 VmbCameraInfoQuery,
1908 VmbCameraOpen,
1909 VmbCameraClose,
1910 VmbFeaturesList,
1911 VmbFeatureInfoQuery,
1912 VmbFeatureListAffected,
1913 VmbFeatureListSelected,
1914 VmbFeatureAccessQuery,
1915 VmbFeatureIntGet,
1916 VmbFeatureIntSet,
1917 VmbFeatureIntRangeQuery,
1918 VmbFeatureIntIncrementQuery,
1919 VmbFeatureFloatGet,
1920 VmbFeatureFloatSet,
1921 VmbFeatureFloatRangeQuery,
1922 VmbFeatureFloatIncrementQuery,
1923 VmbFeatureEnumGet,
1924 VmbFeatureEnumSet,
1925 VmbFeatureEnumRangeQuery,
1926 VmbFeatureEnumIsAvailable,
1927 VmbFeatureEnumAsInt,
1928 VmbFeatureEnumAsString,
1929 VmbFeatureEnumEntryGet,
1930 VmbFeatureStringGet,
1931 VmbFeatureStringSet,
1932 VmbFeatureStringMaxlengthQuery,
1933 VmbFeatureBoolGet,
1934 VmbFeatureBoolSet,
1935 VmbFeatureCommandRun,
1936 VmbFeatureCommandIsDone,
1937 VmbFeatureRawGet,
1938 VmbFeatureRawSet,
1939 VmbFeatureRawLengthQuery,
1940 VmbFeatureInvalidationRegister,
1941 VmbFeatureInvalidationUnregister,
1942 VmbFrameAnnounce,
1943 VmbFrameRevoke,
1944 VmbFrameRevokeAll,
1945 VmbCaptureStart,
1946 VmbCaptureEnd,
1947 VmbCaptureFrameQueue,
1948 VmbCaptureFrameWait,
1949 VmbCaptureQueueFlush,
1950 VmbInterfacesList,
1951 VmbInterfaceOpen,
1952 VmbInterfaceClose,
1953 VmbAncillaryDataOpen,
1954 VmbAncillaryDataClose,
1955 VmbMemoryRead,
1956 VmbMemoryWrite,
1957 VmbRegistersRead,
1958 VmbRegistersWrite,
1959 VmbCameraSettingsSave,
1960 VmbCameraSettingsLoad,
1961 })
1962 }
1963 pub unsafe fn VmbVersionQuery(
1964 &self,
1965 pVersionInfo: *mut VmbVersionInfo_t,
1966 sizeofVersionInfo: VmbUint32_t,
1967 ) -> VmbError_t {
1968 (self
1969 .VmbVersionQuery
1970 .as_ref()
1971 .expect("Expected function, got error."))(pVersionInfo, sizeofVersionInfo)
1972 }
1973 pub unsafe fn VmbStartup(&self) -> VmbError_t {
1974 (self
1975 .VmbStartup
1976 .as_ref()
1977 .expect("Expected function, got error."))()
1978 }
1979 pub unsafe fn VmbShutdown(&self) -> () {
1980 (self
1981 .VmbShutdown
1982 .as_ref()
1983 .expect("Expected function, got error."))()
1984 }
1985 pub unsafe fn VmbCamerasList(
1986 &self,
1987 pCameraInfo: *mut VmbCameraInfo_t,
1988 listLength: VmbUint32_t,
1989 pNumFound: *mut VmbUint32_t,
1990 sizeofCameraInfo: VmbUint32_t,
1991 ) -> VmbError_t {
1992 (self
1993 .VmbCamerasList
1994 .as_ref()
1995 .expect("Expected function, got error."))(
1996 pCameraInfo,
1997 listLength,
1998 pNumFound,
1999 sizeofCameraInfo,
2000 )
2001 }
2002 pub unsafe fn VmbCameraInfoQuery(
2003 &self,
2004 idString: *const ::std::os::raw::c_char,
2005 pInfo: *mut VmbCameraInfo_t,
2006 sizeofCameraInfo: VmbUint32_t,
2007 ) -> VmbError_t {
2008 (self
2009 .VmbCameraInfoQuery
2010 .as_ref()
2011 .expect("Expected function, got error."))(idString, pInfo, sizeofCameraInfo)
2012 }
2013 pub unsafe fn VmbCameraOpen(
2014 &self,
2015 idString: *const ::std::os::raw::c_char,
2016 accessMode: VmbAccessMode_t,
2017 pCameraHandle: *mut VmbHandle_t,
2018 ) -> VmbError_t {
2019 (self
2020 .VmbCameraOpen
2021 .as_ref()
2022 .expect("Expected function, got error."))(idString, accessMode, pCameraHandle)
2023 }
2024 pub unsafe fn VmbCameraClose(&self, cameraHandle: VmbHandle_t) -> VmbError_t {
2025 (self
2026 .VmbCameraClose
2027 .as_ref()
2028 .expect("Expected function, got error."))(cameraHandle)
2029 }
2030 pub unsafe fn VmbFeaturesList(
2031 &self,
2032 handle: VmbHandle_t,
2033 pFeatureInfoList: *mut VmbFeatureInfo_t,
2034 listLength: VmbUint32_t,
2035 pNumFound: *mut VmbUint32_t,
2036 sizeofFeatureInfo: VmbUint32_t,
2037 ) -> VmbError_t {
2038 (self
2039 .VmbFeaturesList
2040 .as_ref()
2041 .expect("Expected function, got error."))(
2042 handle,
2043 pFeatureInfoList,
2044 listLength,
2045 pNumFound,
2046 sizeofFeatureInfo,
2047 )
2048 }
2049 pub unsafe fn VmbFeatureInfoQuery(
2050 &self,
2051 handle: VmbHandle_t,
2052 name: *const ::std::os::raw::c_char,
2053 pFeatureInfo: *mut VmbFeatureInfo_t,
2054 sizeofFeatureInfo: VmbUint32_t,
2055 ) -> VmbError_t {
2056 (self
2057 .VmbFeatureInfoQuery
2058 .as_ref()
2059 .expect("Expected function, got error."))(
2060 handle, name, pFeatureInfo, sizeofFeatureInfo
2061 )
2062 }
2063 pub unsafe fn VmbFeatureListAffected(
2064 &self,
2065 handle: VmbHandle_t,
2066 name: *const ::std::os::raw::c_char,
2067 pFeatureInfoList: *mut VmbFeatureInfo_t,
2068 listLength: VmbUint32_t,
2069 pNumFound: *mut VmbUint32_t,
2070 sizeofFeatureInfo: VmbUint32_t,
2071 ) -> VmbError_t {
2072 (self
2073 .VmbFeatureListAffected
2074 .as_ref()
2075 .expect("Expected function, got error."))(
2076 handle,
2077 name,
2078 pFeatureInfoList,
2079 listLength,
2080 pNumFound,
2081 sizeofFeatureInfo,
2082 )
2083 }
2084 pub unsafe fn VmbFeatureListSelected(
2085 &self,
2086 handle: VmbHandle_t,
2087 name: *const ::std::os::raw::c_char,
2088 pFeatureInfoList: *mut VmbFeatureInfo_t,
2089 listLength: VmbUint32_t,
2090 pNumFound: *mut VmbUint32_t,
2091 sizeofFeatureInfo: VmbUint32_t,
2092 ) -> VmbError_t {
2093 (self
2094 .VmbFeatureListSelected
2095 .as_ref()
2096 .expect("Expected function, got error."))(
2097 handle,
2098 name,
2099 pFeatureInfoList,
2100 listLength,
2101 pNumFound,
2102 sizeofFeatureInfo,
2103 )
2104 }
2105 pub unsafe fn VmbFeatureAccessQuery(
2106 &self,
2107 handle: VmbHandle_t,
2108 name: *const ::std::os::raw::c_char,
2109 pIsReadable: *mut VmbBool_t,
2110 pIsWriteable: *mut VmbBool_t,
2111 ) -> VmbError_t {
2112 (self
2113 .VmbFeatureAccessQuery
2114 .as_ref()
2115 .expect("Expected function, got error."))(
2116 handle, name, pIsReadable, pIsWriteable
2117 )
2118 }
2119 pub unsafe fn VmbFeatureIntGet(
2120 &self,
2121 handle: VmbHandle_t,
2122 name: *const ::std::os::raw::c_char,
2123 pValue: *mut VmbInt64_t,
2124 ) -> VmbError_t {
2125 (self
2126 .VmbFeatureIntGet
2127 .as_ref()
2128 .expect("Expected function, got error."))(handle, name, pValue)
2129 }
2130 pub unsafe fn VmbFeatureIntSet(
2131 &self,
2132 handle: VmbHandle_t,
2133 name: *const ::std::os::raw::c_char,
2134 value: VmbInt64_t,
2135 ) -> VmbError_t {
2136 (self
2137 .VmbFeatureIntSet
2138 .as_ref()
2139 .expect("Expected function, got error."))(handle, name, value)
2140 }
2141 pub unsafe fn VmbFeatureIntRangeQuery(
2142 &self,
2143 handle: VmbHandle_t,
2144 name: *const ::std::os::raw::c_char,
2145 pMin: *mut VmbInt64_t,
2146 pMax: *mut VmbInt64_t,
2147 ) -> VmbError_t {
2148 (self
2149 .VmbFeatureIntRangeQuery
2150 .as_ref()
2151 .expect("Expected function, got error."))(handle, name, pMin, pMax)
2152 }
2153 pub unsafe fn VmbFeatureIntIncrementQuery(
2154 &self,
2155 handle: VmbHandle_t,
2156 name: *const ::std::os::raw::c_char,
2157 pValue: *mut VmbInt64_t,
2158 ) -> VmbError_t {
2159 (self
2160 .VmbFeatureIntIncrementQuery
2161 .as_ref()
2162 .expect("Expected function, got error."))(handle, name, pValue)
2163 }
2164 pub unsafe fn VmbFeatureFloatGet(
2165 &self,
2166 handle: VmbHandle_t,
2167 name: *const ::std::os::raw::c_char,
2168 pValue: *mut f64,
2169 ) -> VmbError_t {
2170 (self
2171 .VmbFeatureFloatGet
2172 .as_ref()
2173 .expect("Expected function, got error."))(handle, name, pValue)
2174 }
2175 pub unsafe fn VmbFeatureFloatSet(
2176 &self,
2177 handle: VmbHandle_t,
2178 name: *const ::std::os::raw::c_char,
2179 value: f64,
2180 ) -> VmbError_t {
2181 (self
2182 .VmbFeatureFloatSet
2183 .as_ref()
2184 .expect("Expected function, got error."))(handle, name, value)
2185 }
2186 pub unsafe fn VmbFeatureFloatRangeQuery(
2187 &self,
2188 handle: VmbHandle_t,
2189 name: *const ::std::os::raw::c_char,
2190 pMin: *mut f64,
2191 pMax: *mut f64,
2192 ) -> VmbError_t {
2193 (self
2194 .VmbFeatureFloatRangeQuery
2195 .as_ref()
2196 .expect("Expected function, got error."))(handle, name, pMin, pMax)
2197 }
2198 pub unsafe fn VmbFeatureFloatIncrementQuery(
2199 &self,
2200 handle: VmbHandle_t,
2201 name: *const ::std::os::raw::c_char,
2202 pHasIncrement: *mut VmbBool_t,
2203 pValue: *mut f64,
2204 ) -> VmbError_t {
2205 (self
2206 .VmbFeatureFloatIncrementQuery
2207 .as_ref()
2208 .expect("Expected function, got error."))(handle, name, pHasIncrement, pValue)
2209 }
2210 pub unsafe fn VmbFeatureEnumGet(
2211 &self,
2212 handle: VmbHandle_t,
2213 name: *const ::std::os::raw::c_char,
2214 pValue: *mut *const ::std::os::raw::c_char,
2215 ) -> VmbError_t {
2216 (self
2217 .VmbFeatureEnumGet
2218 .as_ref()
2219 .expect("Expected function, got error."))(handle, name, pValue)
2220 }
2221 pub unsafe fn VmbFeatureEnumSet(
2222 &self,
2223 handle: VmbHandle_t,
2224 name: *const ::std::os::raw::c_char,
2225 value: *const ::std::os::raw::c_char,
2226 ) -> VmbError_t {
2227 (self
2228 .VmbFeatureEnumSet
2229 .as_ref()
2230 .expect("Expected function, got error."))(handle, name, value)
2231 }
2232 pub unsafe fn VmbFeatureEnumRangeQuery(
2233 &self,
2234 handle: VmbHandle_t,
2235 name: *const ::std::os::raw::c_char,
2236 pNameArray: *mut *const ::std::os::raw::c_char,
2237 arrayLength: VmbUint32_t,
2238 pNumFilled: *mut VmbUint32_t,
2239 ) -> VmbError_t {
2240 (self
2241 .VmbFeatureEnumRangeQuery
2242 .as_ref()
2243 .expect("Expected function, got error."))(
2244 handle,
2245 name,
2246 pNameArray,
2247 arrayLength,
2248 pNumFilled,
2249 )
2250 }
2251 pub unsafe fn VmbFeatureEnumIsAvailable(
2252 &self,
2253 handle: VmbHandle_t,
2254 name: *const ::std::os::raw::c_char,
2255 value: *const ::std::os::raw::c_char,
2256 pIsAvailable: *mut VmbBool_t,
2257 ) -> VmbError_t {
2258 (self
2259 .VmbFeatureEnumIsAvailable
2260 .as_ref()
2261 .expect("Expected function, got error."))(handle, name, value, pIsAvailable)
2262 }
2263 pub unsafe fn VmbFeatureEnumAsInt(
2264 &self,
2265 handle: VmbHandle_t,
2266 name: *const ::std::os::raw::c_char,
2267 value: *const ::std::os::raw::c_char,
2268 pIntVal: *mut VmbInt64_t,
2269 ) -> VmbError_t {
2270 (self
2271 .VmbFeatureEnumAsInt
2272 .as_ref()
2273 .expect("Expected function, got error."))(handle, name, value, pIntVal)
2274 }
2275 pub unsafe fn VmbFeatureEnumAsString(
2276 &self,
2277 handle: VmbHandle_t,
2278 name: *const ::std::os::raw::c_char,
2279 intValue: VmbInt64_t,
2280 pStringValue: *mut *const ::std::os::raw::c_char,
2281 ) -> VmbError_t {
2282 (self
2283 .VmbFeatureEnumAsString
2284 .as_ref()
2285 .expect("Expected function, got error."))(handle, name, intValue, pStringValue)
2286 }
2287 pub unsafe fn VmbFeatureEnumEntryGet(
2288 &self,
2289 handle: VmbHandle_t,
2290 featureName: *const ::std::os::raw::c_char,
2291 entryName: *const ::std::os::raw::c_char,
2292 pFeatureEnumEntry: *mut VmbFeatureEnumEntry_t,
2293 sizeofFeatureEnumEntry: VmbUint32_t,
2294 ) -> VmbError_t {
2295 (self
2296 .VmbFeatureEnumEntryGet
2297 .as_ref()
2298 .expect("Expected function, got error."))(
2299 handle,
2300 featureName,
2301 entryName,
2302 pFeatureEnumEntry,
2303 sizeofFeatureEnumEntry,
2304 )
2305 }
2306 pub unsafe fn VmbFeatureStringGet(
2307 &self,
2308 handle: VmbHandle_t,
2309 name: *const ::std::os::raw::c_char,
2310 buffer: *mut ::std::os::raw::c_char,
2311 bufferSize: VmbUint32_t,
2312 pSizeFilled: *mut VmbUint32_t,
2313 ) -> VmbError_t {
2314 (self
2315 .VmbFeatureStringGet
2316 .as_ref()
2317 .expect("Expected function, got error."))(
2318 handle, name, buffer, bufferSize, pSizeFilled
2319 )
2320 }
2321 pub unsafe fn VmbFeatureStringSet(
2322 &self,
2323 handle: VmbHandle_t,
2324 name: *const ::std::os::raw::c_char,
2325 value: *const ::std::os::raw::c_char,
2326 ) -> VmbError_t {
2327 (self
2328 .VmbFeatureStringSet
2329 .as_ref()
2330 .expect("Expected function, got error."))(handle, name, value)
2331 }
2332 pub unsafe fn VmbFeatureStringMaxlengthQuery(
2333 &self,
2334 handle: VmbHandle_t,
2335 name: *const ::std::os::raw::c_char,
2336 pMaxLength: *mut VmbUint32_t,
2337 ) -> VmbError_t {
2338 (self
2339 .VmbFeatureStringMaxlengthQuery
2340 .as_ref()
2341 .expect("Expected function, got error."))(handle, name, pMaxLength)
2342 }
2343 pub unsafe fn VmbFeatureBoolGet(
2344 &self,
2345 handle: VmbHandle_t,
2346 name: *const ::std::os::raw::c_char,
2347 pValue: *mut VmbBool_t,
2348 ) -> VmbError_t {
2349 (self
2350 .VmbFeatureBoolGet
2351 .as_ref()
2352 .expect("Expected function, got error."))(handle, name, pValue)
2353 }
2354 pub unsafe fn VmbFeatureBoolSet(
2355 &self,
2356 handle: VmbHandle_t,
2357 name: *const ::std::os::raw::c_char,
2358 value: VmbBool_t,
2359 ) -> VmbError_t {
2360 (self
2361 .VmbFeatureBoolSet
2362 .as_ref()
2363 .expect("Expected function, got error."))(handle, name, value)
2364 }
2365 pub unsafe fn VmbFeatureCommandRun(
2366 &self,
2367 handle: VmbHandle_t,
2368 name: *const ::std::os::raw::c_char,
2369 ) -> VmbError_t {
2370 (self
2371 .VmbFeatureCommandRun
2372 .as_ref()
2373 .expect("Expected function, got error."))(handle, name)
2374 }
2375 pub unsafe fn VmbFeatureCommandIsDone(
2376 &self,
2377 handle: VmbHandle_t,
2378 name: *const ::std::os::raw::c_char,
2379 pIsDone: *mut VmbBool_t,
2380 ) -> VmbError_t {
2381 (self
2382 .VmbFeatureCommandIsDone
2383 .as_ref()
2384 .expect("Expected function, got error."))(handle, name, pIsDone)
2385 }
2386 pub unsafe fn VmbFeatureRawGet(
2387 &self,
2388 handle: VmbHandle_t,
2389 name: *const ::std::os::raw::c_char,
2390 pBuffer: *mut ::std::os::raw::c_char,
2391 bufferSize: VmbUint32_t,
2392 pSizeFilled: *mut VmbUint32_t,
2393 ) -> VmbError_t {
2394 (self
2395 .VmbFeatureRawGet
2396 .as_ref()
2397 .expect("Expected function, got error."))(
2398 handle,
2399 name,
2400 pBuffer,
2401 bufferSize,
2402 pSizeFilled,
2403 )
2404 }
2405 pub unsafe fn VmbFeatureRawSet(
2406 &self,
2407 handle: VmbHandle_t,
2408 name: *const ::std::os::raw::c_char,
2409 pBuffer: *const ::std::os::raw::c_char,
2410 bufferSize: VmbUint32_t,
2411 ) -> VmbError_t {
2412 (self
2413 .VmbFeatureRawSet
2414 .as_ref()
2415 .expect("Expected function, got error."))(handle, name, pBuffer, bufferSize)
2416 }
2417 pub unsafe fn VmbFeatureRawLengthQuery(
2418 &self,
2419 handle: VmbHandle_t,
2420 name: *const ::std::os::raw::c_char,
2421 pLength: *mut VmbUint32_t,
2422 ) -> VmbError_t {
2423 (self
2424 .VmbFeatureRawLengthQuery
2425 .as_ref()
2426 .expect("Expected function, got error."))(handle, name, pLength)
2427 }
2428 pub unsafe fn VmbFeatureInvalidationRegister(
2429 &self,
2430 handle: VmbHandle_t,
2431 name: *const ::std::os::raw::c_char,
2432 callback: VmbInvalidationCallback,
2433 pUserContext: *mut ::std::os::raw::c_void,
2434 ) -> VmbError_t {
2435 (self
2436 .VmbFeatureInvalidationRegister
2437 .as_ref()
2438 .expect("Expected function, got error."))(handle, name, callback, pUserContext)
2439 }
2440 pub unsafe fn VmbFeatureInvalidationUnregister(
2441 &self,
2442 handle: VmbHandle_t,
2443 name: *const ::std::os::raw::c_char,
2444 callback: VmbInvalidationCallback,
2445 ) -> VmbError_t {
2446 (self
2447 .VmbFeatureInvalidationUnregister
2448 .as_ref()
2449 .expect("Expected function, got error."))(handle, name, callback)
2450 }
2451 pub unsafe fn VmbFrameAnnounce(
2452 &self,
2453 cameraHandle: VmbHandle_t,
2454 pFrame: *const VmbFrame_t,
2455 sizeofFrame: VmbUint32_t,
2456 ) -> VmbError_t {
2457 (self
2458 .VmbFrameAnnounce
2459 .as_ref()
2460 .expect("Expected function, got error."))(cameraHandle, pFrame, sizeofFrame)
2461 }
2462 pub unsafe fn VmbFrameRevoke(
2463 &self,
2464 cameraHandle: VmbHandle_t,
2465 pFrame: *const VmbFrame_t,
2466 ) -> VmbError_t {
2467 (self
2468 .VmbFrameRevoke
2469 .as_ref()
2470 .expect("Expected function, got error."))(cameraHandle, pFrame)
2471 }
2472 pub unsafe fn VmbFrameRevokeAll(&self, cameraHandle: VmbHandle_t) -> VmbError_t {
2473 (self
2474 .VmbFrameRevokeAll
2475 .as_ref()
2476 .expect("Expected function, got error."))(cameraHandle)
2477 }
2478 pub unsafe fn VmbCaptureStart(&self, cameraHandle: VmbHandle_t) -> VmbError_t {
2479 (self
2480 .VmbCaptureStart
2481 .as_ref()
2482 .expect("Expected function, got error."))(cameraHandle)
2483 }
2484 pub unsafe fn VmbCaptureEnd(&self, cameraHandle: VmbHandle_t) -> VmbError_t {
2485 (self
2486 .VmbCaptureEnd
2487 .as_ref()
2488 .expect("Expected function, got error."))(cameraHandle)
2489 }
2490 pub unsafe fn VmbCaptureFrameQueue(
2491 &self,
2492 cameraHandle: VmbHandle_t,
2493 pFrame: *const VmbFrame_t,
2494 callback: VmbFrameCallback,
2495 ) -> VmbError_t {
2496 (self
2497 .VmbCaptureFrameQueue
2498 .as_ref()
2499 .expect("Expected function, got error."))(cameraHandle, pFrame, callback)
2500 }
2501 pub unsafe fn VmbCaptureFrameWait(
2502 &self,
2503 cameraHandle: VmbHandle_t,
2504 pFrame: *const VmbFrame_t,
2505 timeout: VmbUint32_t,
2506 ) -> VmbError_t {
2507 (self
2508 .VmbCaptureFrameWait
2509 .as_ref()
2510 .expect("Expected function, got error."))(cameraHandle, pFrame, timeout)
2511 }
2512 pub unsafe fn VmbCaptureQueueFlush(&self, cameraHandle: VmbHandle_t) -> VmbError_t {
2513 (self
2514 .VmbCaptureQueueFlush
2515 .as_ref()
2516 .expect("Expected function, got error."))(cameraHandle)
2517 }
2518 pub unsafe fn VmbInterfacesList(
2519 &self,
2520 pInterfaceInfo: *mut VmbInterfaceInfo_t,
2521 listLength: VmbUint32_t,
2522 pNumFound: *mut VmbUint32_t,
2523 sizeofInterfaceInfo: VmbUint32_t,
2524 ) -> VmbError_t {
2525 (self
2526 .VmbInterfacesList
2527 .as_ref()
2528 .expect("Expected function, got error."))(
2529 pInterfaceInfo,
2530 listLength,
2531 pNumFound,
2532 sizeofInterfaceInfo,
2533 )
2534 }
2535 pub unsafe fn VmbInterfaceOpen(
2536 &self,
2537 idString: *const ::std::os::raw::c_char,
2538 pInterfaceHandle: *mut VmbHandle_t,
2539 ) -> VmbError_t {
2540 (self
2541 .VmbInterfaceOpen
2542 .as_ref()
2543 .expect("Expected function, got error."))(idString, pInterfaceHandle)
2544 }
2545 pub unsafe fn VmbInterfaceClose(&self, interfaceHandle: VmbHandle_t) -> VmbError_t {
2546 (self
2547 .VmbInterfaceClose
2548 .as_ref()
2549 .expect("Expected function, got error."))(interfaceHandle)
2550 }
2551 pub unsafe fn VmbAncillaryDataOpen(
2552 &self,
2553 pFrame: *mut VmbFrame_t,
2554 pAncillaryDataHandle: *mut VmbHandle_t,
2555 ) -> VmbError_t {
2556 (self
2557 .VmbAncillaryDataOpen
2558 .as_ref()
2559 .expect("Expected function, got error."))(pFrame, pAncillaryDataHandle)
2560 }
2561 pub unsafe fn VmbAncillaryDataClose(&self, ancillaryDataHandle: VmbHandle_t) -> VmbError_t {
2562 (self
2563 .VmbAncillaryDataClose
2564 .as_ref()
2565 .expect("Expected function, got error."))(ancillaryDataHandle)
2566 }
2567 pub unsafe fn VmbMemoryRead(
2568 &self,
2569 handle: VmbHandle_t,
2570 address: VmbUint64_t,
2571 bufferSize: VmbUint32_t,
2572 dataBuffer: *mut ::std::os::raw::c_char,
2573 pSizeComplete: *mut VmbUint32_t,
2574 ) -> VmbError_t {
2575 (self
2576 .VmbMemoryRead
2577 .as_ref()
2578 .expect("Expected function, got error."))(
2579 handle,
2580 address,
2581 bufferSize,
2582 dataBuffer,
2583 pSizeComplete,
2584 )
2585 }
2586 pub unsafe fn VmbMemoryWrite(
2587 &self,
2588 handle: VmbHandle_t,
2589 address: VmbUint64_t,
2590 bufferSize: VmbUint32_t,
2591 dataBuffer: *const ::std::os::raw::c_char,
2592 pSizeComplete: *mut VmbUint32_t,
2593 ) -> VmbError_t {
2594 (self
2595 .VmbMemoryWrite
2596 .as_ref()
2597 .expect("Expected function, got error."))(
2598 handle,
2599 address,
2600 bufferSize,
2601 dataBuffer,
2602 pSizeComplete,
2603 )
2604 }
2605 pub unsafe fn VmbRegistersRead(
2606 &self,
2607 handle: VmbHandle_t,
2608 readCount: VmbUint32_t,
2609 pAddressArray: *const VmbUint64_t,
2610 pDataArray: *mut VmbUint64_t,
2611 pNumCompleteReads: *mut VmbUint32_t,
2612 ) -> VmbError_t {
2613 (self
2614 .VmbRegistersRead
2615 .as_ref()
2616 .expect("Expected function, got error."))(
2617 handle,
2618 readCount,
2619 pAddressArray,
2620 pDataArray,
2621 pNumCompleteReads,
2622 )
2623 }
2624 pub unsafe fn VmbRegistersWrite(
2625 &self,
2626 handle: VmbHandle_t,
2627 writeCount: VmbUint32_t,
2628 pAddressArray: *const VmbUint64_t,
2629 pDataArray: *const VmbUint64_t,
2630 pNumCompleteWrites: *mut VmbUint32_t,
2631 ) -> VmbError_t {
2632 (self
2633 .VmbRegistersWrite
2634 .as_ref()
2635 .expect("Expected function, got error."))(
2636 handle,
2637 writeCount,
2638 pAddressArray,
2639 pDataArray,
2640 pNumCompleteWrites,
2641 )
2642 }
2643 pub unsafe fn VmbCameraSettingsSave(
2644 &self,
2645 handle: VmbHandle_t,
2646 fileName: *const ::std::os::raw::c_char,
2647 pSettings: *mut VmbFeaturePersistSettings_t,
2648 sizeofSettings: VmbUint32_t,
2649 ) -> VmbError_t {
2650 (self
2651 .VmbCameraSettingsSave
2652 .as_ref()
2653 .expect("Expected function, got error."))(
2654 handle, fileName, pSettings, sizeofSettings
2655 )
2656 }
2657 pub unsafe fn VmbCameraSettingsLoad(
2658 &self,
2659 handle: VmbHandle_t,
2660 fileName: *const ::std::os::raw::c_char,
2661 pSettings: *mut VmbFeaturePersistSettings_t,
2662 sizeofSettings: VmbUint32_t,
2663 ) -> VmbError_t {
2664 (self
2665 .VmbCameraSettingsLoad
2666 .as_ref()
2667 .expect("Expected function, got error."))(
2668 handle, fileName, pSettings, sizeofSettings
2669 )
2670 }
2671}