From b833f3e119e5ab50dafe6c0d7bda25f314845fbd Mon Sep 17 00:00:00 2001 From: Ben B Date: Sat, 29 Nov 2025 13:58:43 -0700 Subject: [PATCH 01/34] added function headers without params --- src/api.rs | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) diff --git a/src/api.rs b/src/api.rs index 1aa9a89..415c81e 100644 --- a/src/api.rs +++ b/src/api.rs @@ -501,3 +501,92 @@ pub fn list_features(handle: &CameraHandle) -> VmbResult> { .collect::>>() } +pub fn feature_info_query() + +pub fn feature_access_query() + +pub fn list_feature_selected() + +pub fn feature_int_get() + +pub fn feature_int_set() + +pub fn feature_int_range_query() + +pub fn feature_int_increment_query() + +pub fn feature_int_valid_value_set_query() + +pub fn feature_float_get() + +pub fn feature_float_set() + +pub fn feature_float_range_query() + +pub fn feature_enum_get() + +pub fn feature_enum_set() + +pub fn feature_enum_range_query() + +pub fn feature_enum_is_available() + +pub fn feature_enum_as_int() + +pub fn feature_enum_as_string() + +pub fn feature_enum_entry_get() + +pub fn feature_string_get() + +pub fn feature_string_set() + +pub fn feature_string_max_length_query() + +pub fn feature_bool_get() + +pub fn feature_bool_set() + +pub fn feature_command_run() + +pub fn feature_command_is_done() + +pub fn feature_raw_get() + +pub fn feature_raw_set() + +pub fn feature_raw_length_query() + +pub fn feature_invalidation_register() + +pub fn feature_invalidation_unregister() + +pub fn frame_announce() + +pub fn frame_revoke() + +pub fn frame_revoke_all() + +pub fn capture_start() + +pub fn capture_end() + +pub fn capture_frame_queue() + +pub fn capture_frame_wait() + +pub fn capture_queue_flush() + +pub fn memory_read() + +pub fn memory_write() + +pub fn registers_read() + +pub fn registers_write() + +pub fn camera_settings_save() + +pub fn camera_settings_load() + +pub fn chunk_data_access() \ No newline at end of file From fcda9847ab7fe63cb0f2659ac623e1d6d7f120da Mon Sep 17 00:00:00 2001 From: Ben B Date: Sat, 29 Nov 2025 14:48:30 -0700 Subject: [PATCH 02/34] feature get functions --- src/api.rs | 107 ++++++++++++++++++++++++++++++----------------------- 1 file changed, 61 insertions(+), 46 deletions(-) diff --git a/src/api.rs b/src/api.rs index 415c81e..e825a2e 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,6 +1,6 @@ use super::{error::*, ffi::*, utils::*}; use std::{ - ffi, + ffi::{self, CString}, mem::{self, MaybeUninit}, ptr, }; @@ -501,92 +501,107 @@ pub fn list_features(handle: &CameraHandle) -> VmbResult> { .collect::>>() } -pub fn feature_info_query() +// pub fn feature_info_query() -pub fn feature_access_query() +// pub fn feature_access_query() -pub fn list_feature_selected() +// pub fn list_feature_selected() -pub fn feature_int_get() +pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; + let mut value = 0 as VmbInt64_t; -pub fn feature_int_set() + vmb_result(unsafe { + VmbFeatureIntGet( + handle.as_raw(), + feature_name.as_ptr(), + &mut value, + ) + })?; -pub fn feature_int_range_query() + Ok(value) +} -pub fn feature_int_increment_query() +// pub fn feature_int_set() -pub fn feature_int_valid_value_set_query() +// pub fn feature_int_range_query() -pub fn feature_float_get() +// pub fn feature_int_increment_query() + +// pub fn feature_int_valid_value_set_query() + +pub fn feature_float_get(hadle: &CameraHandle, name: &str) -> VmbResult> { + +} -pub fn feature_float_set() +// pub fn feature_float_set() -pub fn feature_float_range_query() +// pub fn feature_float_range_query() -pub fn feature_enum_get() +// pub fn feature_enum_get() -pub fn feature_enum_set() +// pub fn feature_enum_set() -pub fn feature_enum_range_query() +// pub fn feature_enum_range_query() -pub fn feature_enum_is_available() +// pub fn feature_enum_is_available() -pub fn feature_enum_as_int() +// pub fn feature_enum_as_int() -pub fn feature_enum_as_string() +// pub fn feature_enum_as_string() -pub fn feature_enum_entry_get() +// pub fn feature_enum_entry_get() -pub fn feature_string_get() +// pub fn feature_string_get() -pub fn feature_string_set() +// pub fn feature_string_set() -pub fn feature_string_max_length_query() +// pub fn feature_string_max_length_query() -pub fn feature_bool_get() +// pub fn feature_bool_get() -pub fn feature_bool_set() +// pub fn feature_bool_set() -pub fn feature_command_run() +// pub fn feature_command_run() -pub fn feature_command_is_done() +// pub fn feature_command_is_done() -pub fn feature_raw_get() +// pub fn feature_raw_get() -pub fn feature_raw_set() +// pub fn feature_raw_set() -pub fn feature_raw_length_query() +// pub fn feature_raw_length_query() -pub fn feature_invalidation_register() +// pub fn feature_invalidation_register() -pub fn feature_invalidation_unregister() +// pub fn feature_invalidation_unregister() -pub fn frame_announce() +// pub fn frame_announce() -pub fn frame_revoke() +// pub fn frame_revoke() -pub fn frame_revoke_all() +// pub fn frame_revoke_all() -pub fn capture_start() +// pub fn capture_start() -pub fn capture_end() +// pub fn capture_end() -pub fn capture_frame_queue() +// pub fn capture_frame_queue() -pub fn capture_frame_wait() +// pub fn capture_frame_wait() -pub fn capture_queue_flush() +// pub fn capture_queue_flush() -pub fn memory_read() +// pub fn memory_read() -pub fn memory_write() +// pub fn memory_write() -pub fn registers_read() +// pub fn registers_read() -pub fn registers_write() +// pub fn registers_write() -pub fn camera_settings_save() +// pub fn camera_settings_save() -pub fn camera_settings_load() +// pub fn camera_settings_load() -pub fn chunk_data_access() \ No newline at end of file +// pub fn chunk_data_access() \ No newline at end of file From baef5c32db1a2c319466427e7608c9c2fee7cf74 Mon Sep 17 00:00:00 2001 From: Ben B Date: Sat, 29 Nov 2025 14:50:46 -0700 Subject: [PATCH 03/34] feature get functions --- src/api.rs | 51 +++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 47 insertions(+), 4 deletions(-) diff --git a/src/api.rs b/src/api.rs index e825a2e..7cbe6ba 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,6 +1,6 @@ use super::{error::*, ffi::*, utils::*}; use std::{ - ffi::{self, CString}, + ffi::{self, CStr, CString}, mem::{self, MaybeUninit}, ptr, }; @@ -530,15 +530,45 @@ pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult> { +pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut value: f64 = 0; + vmb_result( unsafe { + VmbFeatureFloatGet( + handle.as_raw(), + feature_name.as_ptr(), + &mut value, + ) + })?; + + Ok(value) } // pub fn feature_float_set() // pub fn feature_float_range_query() -// pub fn feature_enum_get() +pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut value: *const std::os::raw::c_char = std::ptr::null(); + + vmb_result( unsafe { + VmbFeatureEnumGet( + handle.as_raw(), + feature_name.as_ptr(), + &mut value, + ) + })?; + + if value.is_null() { + return Err(VmbError::BadParameter) + } + + let value = unsafe { CStr::from_ptr(value) }.to_string_lossy().into_owned(); + + Ok(value) +} // pub fn feature_enum_set() @@ -558,7 +588,20 @@ pub fn feature_float_get(hadle: &CameraHandle, name: &str) -> VmbResult VmbResult> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut value = False as VmbBool_t; + + vmb_result( unsafe { + VmbFeatureBoolGet( + handle.as_raw(), + feature_name.as_ptr(), + &mut value, + ) + })?; + + Ok(value) +} // pub fn feature_bool_set() From bcdee07f36d520942ff7955b729b502b1a515440 Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 2 Dec 2025 18:02:40 -0700 Subject: [PATCH 04/34] implemented feature int set --- src/api.rs | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/api.rs b/src/api.rs index 7cbe6ba..9ab71f4 100644 --- a/src/api.rs +++ b/src/api.rs @@ -522,7 +522,20 @@ pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult> { + let value = value as VmbInt64_t; + let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; + + vmb_result(unsafe { + VmbFeatureIntSet( + handle.as_raw(), + feature_name.as_ptr(), + value, + ) + })?; + + Ok(()) +} // pub fn feature_int_range_query() From 27e13ab3a6edecec4641a52a8668956dd2b5629a Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 2 Dec 2025 18:14:48 -0700 Subject: [PATCH 05/34] implemented more setters --- src/api.rs | 36 ++++++++++++++++++++++++++++++++---- 1 file changed, 32 insertions(+), 4 deletions(-) diff --git a/src/api.rs b/src/api.rs index 9ab71f4..486d474 100644 --- a/src/api.rs +++ b/src/api.rs @@ -522,7 +522,7 @@ pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult> { +pub fn feature_int_set(handle: &CameraHandle, name: &str, value: i64) -> VmbResult<()> { let value = value as VmbInt64_t; let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; @@ -551,14 +551,26 @@ pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { + let feature_name= CString::new(name).map_err(|_| VmbError::BadHandle)?; + + vmb_result( unsafe { + VmbFeatureFloatSet( + handle.as_raw(), + feature_name.as_ptr(), + &value, + ) + })?; + + Ok(()) +} // pub fn feature_float_range_query() @@ -616,7 +628,23 @@ pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_value = match value { + true => VmbBoolTrue, + false => VmbBoolFalse, + }; + + vmb_result( unsafe { + VmbFeatureBoolSet( + handle.as_raw(), + feature_name.as_ptr(), + &value, + ) + })?; + + Ok(()) +} // pub fn feature_command_run() From 06f6119678dd45b30315890a65ff6287d2aed80d Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 2 Dec 2025 18:25:28 -0700 Subject: [PATCH 06/34] enum set --- src/api.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/src/api.rs b/src/api.rs index 486d474..b1d5ac1 100644 --- a/src/api.rs +++ b/src/api.rs @@ -595,7 +595,21 @@ pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult Date: Tue, 2 Dec 2025 18:40:13 -0700 Subject: [PATCH 07/34] undo ffi import --- src/api.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/api.rs b/src/api.rs index b1d5ac1..3f03b2a 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,6 +1,6 @@ use super::{error::*, ffi::*, utils::*}; use std::{ - ffi::{self, CStr, CString}, + ffi, mem::{self, MaybeUninit}, ptr, }; From d80908ed27cde0058ce3c6c1a6b1ac6d789dd1c3 Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 2 Dec 2025 18:47:21 -0700 Subject: [PATCH 08/34] added string getter and setter --- src/api.rs | 30 ++++++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/src/api.rs b/src/api.rs index 3f03b2a..6fe4e32 100644 --- a/src/api.rs +++ b/src/api.rs @@ -621,9 +621,35 @@ pub fn feature_enum_set(handle: &CameraHandle, name: &str, value: &str) { // pub fn feature_enum_entry_get() -// pub fn feature_string_get() +pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut value = String::new(); + + vmb_result(unsafe { + VmbFeatureStringGet( + handle.as_raw(), + feature_name.as_ptr(), + &mut value, + ) + })?; -// pub fn feature_string_set() + Ok(value) +} + +pub fn feature_string_set(handle: &CameraHandle, name: &str, value: &str) -> VmbResult> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_value = CString::new(value).map_err(|_| VmbError::BadHandle)?; + + vmb_result(unsafe { + VmbFeatureStringSet( + handle.as_raw(), + feature_name.as_ptr(), + feature_value.as_ptr(), + ) + })?; + + Ok(()) +} // pub fn feature_string_max_length_query() From 65bb3cdbccbfa772239b018ecc75cc198585cec3 Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 2 Dec 2025 18:48:05 -0700 Subject: [PATCH 09/34] updated string setter return value --- src/api.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/api.rs b/src/api.rs index 6fe4e32..db5c0b5 100644 --- a/src/api.rs +++ b/src/api.rs @@ -636,7 +636,7 @@ pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult> { +pub fn feature_string_set(handle: &CameraHandle, name: &str, value: &str) -> VmbResult<()> { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; let feature_value = CString::new(value).map_err(|_| VmbError::BadHandle)?; From c1aa997608f284c8c90d849e7402d015b101668f Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 2 Dec 2025 18:49:42 -0700 Subject: [PATCH 10/34] Fixing missed problems --- src/api.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/api.rs b/src/api.rs index db5c0b5..e365c17 100644 --- a/src/api.rs +++ b/src/api.rs @@ -530,7 +530,7 @@ pub fn feature_int_set(handle: &CameraHandle, name: &str, value: i64) -> VmbResu VmbFeatureIntSet( handle.as_raw(), feature_name.as_ptr(), - value, + &value, ) })?; @@ -633,6 +633,12 @@ pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult Date: Tue, 9 Dec 2025 18:00:44 -0700 Subject: [PATCH 11/34] updated getter return types --- src/api.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/api.rs b/src/api.rs index e365c17..461dcd5 100644 --- a/src/api.rs +++ b/src/api.rs @@ -507,7 +507,7 @@ pub fn list_features(handle: &CameraHandle) -> VmbResult> { // pub fn list_feature_selected() -pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult> { +pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; let mut value = 0 as VmbInt64_t; @@ -543,7 +543,7 @@ pub fn feature_int_set(handle: &CameraHandle, name: &str, value: i64) -> VmbResu // pub fn feature_int_valid_value_set_query() -pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult> { +pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; let mut value: f64 = 0; @@ -574,7 +574,7 @@ pub fn feature_float_set(handle: &CameraHandle, name: &str, value: f64) -> VmbRe // pub fn feature_float_range_query() -pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult> { +pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; let mut value: *const std::os::raw::c_char = std::ptr::null(); @@ -621,7 +621,7 @@ pub fn feature_enum_set(handle: &CameraHandle, name: &str, value: &str) { // pub fn feature_enum_entry_get() -pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult> { +pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; let mut value = String::new(); @@ -659,7 +659,7 @@ pub fn feature_string_set(handle: &CameraHandle, name: &str, value: &str) -> Vmb // pub fn feature_string_max_length_query() -pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult> { +pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; let mut value = False as VmbBool_t; From 5bdf46280b5e75da47ecf7d79f3a318af50cf436 Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 9 Dec 2025 18:23:26 -0700 Subject: [PATCH 12/34] updated string get to pass a string buffer instead of char* --- src/api.rs | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/src/api.rs b/src/api.rs index 461dcd5..5268549 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,6 +1,6 @@ use super::{error::*, ffi::*, utils::*}; use std::{ - ffi, + ffi::{self, CStr, c_char}, mem::{self, MaybeUninit}, ptr, }; @@ -587,7 +587,7 @@ pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; - let mut value = String::new(); - + let mut value_buffer = vec![0u8; 1024]; + vmb_result(unsafe { VmbFeatureStringGet( handle.as_raw(), feature_name.as_ptr(), - &mut value, + value_buffer.as_mut_ptr() as *mut c_char, + value_buffer.len() as u32, + std::ptr::null_mut(), // Change to sizeFilled pointer if desired ) })?; - if value.is_null() { - return Err(VmbError::BadParameter) - } - - let value = unsafe { CStr::from_ptr(value) }.to_string_lossy().into_owned(); - - Ok(value) + let value = unsafe { CStr::from_ptr(value_buffer.as_ptr() as *const c_char) }; + Ok(value.to_string_lossy().into_owned()) } pub fn feature_string_set(handle: &CameraHandle, name: &str, value: &str) -> VmbResult<()> { From b40712028a03ef7724f40eba0ad80f5ab57ae215 Mon Sep 17 00:00:00 2001 From: Ben B Date: Fri, 26 Dec 2025 12:25:10 -0700 Subject: [PATCH 13/34] added feature_info_query and moved convert_feature_info_safe to its own function --- src/api.rs | 74 ++++++++++++++++++++++++++++++++---------------------- 1 file changed, 44 insertions(+), 30 deletions(-) diff --git a/src/api.rs b/src/api.rs index 5268549..106f70a 100644 --- a/src/api.rs +++ b/src/api.rs @@ -453,35 +453,6 @@ pub fn list_features(handle: &CameraHandle) -> VmbResult> { return Ok(Vec::new()); } - fn convert_feature_info_safe( - camera: mem::MaybeUninit, - ) -> VmbResult { - let feature = unsafe { camera.assume_init() }; - - Ok(FeatureInfo { - name: string_from_raw(feature.name).map_err(|_| VmbError::InternalFault)?, - category: string_from_raw(feature.category).map_err(|_| VmbError::InternalFault)?, - display_name: string_from_raw(feature.displayName) - .map_err(|_| VmbError::InternalFault)?, - tool_tip: string_from_raw(feature.tooltip).map_err(|_| VmbError::InternalFault)?, - description: string_from_raw(feature.description) - .map_err(|_| VmbError::InternalFault)?, - namespace: string_from_raw(feature.sfncNamespace) - .map_err(|_| VmbError::InternalFault)?, - unit: string_from_raw(feature.unit).map_err(|_| VmbError::InternalFault)?, - representation: string_from_raw(feature.representation) - .map_err(|_| VmbError::InternalFault)?, - data_type: FeatureDataType::from_repr(feature.featureDataType) - .ok_or(VmbError::InternalFault)?, - flags: FeatureFlags::from_repr(feature.featureFlags).ok_or(VmbError::InternalFault)?, - polling_time: feature.pollingTime, - visibility: FeatureVisibility::from_repr(feature.visibility) - .ok_or(VmbError::InternalFault)?, - is_streamable: feature.isStreamable & 0x01 == 1, - has_selected_features: feature.hasSelectedFeatures & 0x01 == 1, - }) - } - let mut features_raw: Vec> = vec![mem::MaybeUninit::uninit(); found as usize]; @@ -501,7 +472,50 @@ pub fn list_features(handle: &CameraHandle) -> VmbResult> { .collect::>>() } -// pub fn feature_info_query() +fn convert_feature_info_safe(camera: mem::MaybeUninit,) -> VmbResult { + let feature = unsafe { camera.assume_init() }; + + Ok(FeatureInfo { + name: string_from_raw(feature.name).map_err(|_| VmbError::InternalFault)?, + category: string_from_raw(feature.category).map_err(|_| VmbError::InternalFault)?, + display_name: string_from_raw(feature.displayName) + .map_err(|_| VmbError::InternalFault)?, + tool_tip: string_from_raw(feature.tooltip).map_err(|_| VmbError::InternalFault)?, + description: string_from_raw(feature.description) + .map_err(|_| VmbError::InternalFault)?, + namespace: string_from_raw(feature.sfncNamespace) + .map_err(|_| VmbError::InternalFault)?, + unit: string_from_raw(feature.unit).map_err(|_| VmbError::InternalFault)?, + representation: string_from_raw(feature.representation) + .map_err(|_| VmbError::InternalFault)?, + data_type: FeatureDataType::from_repr(feature.featureDataType) + .ok_or(VmbError::InternalFault)?, + flags: FeatureFlags::from_repr(feature.featureFlags).ok_or(VmbError::InternalFault)?, + polling_time: feature.pollingTime, + visibility: FeatureVisibility::from_repr(feature.visibility) + .ok_or(VmbError::InternalFault)?, + is_streamable: feature.isStreamable & 0x01 == 1, + has_selected_features: feature.hasSelectedFeatures & 0x01 == 1, + }) +} + +pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; + + let feature_info_raw = mem::MaybeUninit::::uninit(); + let info_size = mem::size_of::() as VmbUint32_t; + + vmb_result(unsafe { + VmbFeatureInfoQuery( + handle.as_raw(), + feature_name.as_ptr(), + feature_info_raw.as_mut_ptr(), + info_size, + ) + })?; + + convert_feature_info_safe(feature_info_raw) +} // pub fn feature_access_query() From 6c83910bd0be4bdee3cdb7fd33eca5352ae09aa9 Mon Sep 17 00:00:00 2001 From: Ben B Date: Mon, 29 Dec 2025 18:10:25 -0700 Subject: [PATCH 14/34] Implemented more functions: feature_access_query, feature_int_range_query, feature_int_increment_query, feature_float_range_query, feature_enum_range_query --- src/api.rs | 115 ++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 109 insertions(+), 6 deletions(-) diff --git a/src/api.rs b/src/api.rs index 106f70a..32acc95 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,6 +1,6 @@ use super::{error::*, ffi::*, utils::*}; use std::{ - ffi::{self, CStr, c_char}, + ffi::{self, CStr, CString, c_char}, mem::{self, MaybeUninit}, ptr, }; @@ -517,7 +517,22 @@ pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<[bool; 2], VmbError> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut is_readable = False as VmbBool_t; + let mut is_writable = False as VmbBool_t; + + vmb_result(unsafe { + VmbFeatureAccessQuery( + handle.as_raw(), + feature_name.as_ptr(), + &mut is_readable, + &mut is_writable, + ) + })?; + + Ok(vec![is_readable, is_writable]) +} // pub fn list_feature_selected() @@ -551,9 +566,37 @@ pub fn feature_int_set(handle: &CameraHandle, name: &str, value: i64) -> VmbResu Ok(()) } -// pub fn feature_int_range_query() +pub fn feature_int_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[i64; 2], VmbError> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut min: i64 = -1 as VmbInt64_t; + let mut max: i64 = -1 as VmbInt64_t; + + vmb_result(unsafe { + VmbFeatureIntRangeQuery( + handle.as_raw(), + feature_name.as_ptr(), + &mut min, + &mut max, + ) + })?; + + Ok([min, max]) +} + +pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut value = value as VmbInt64_t; -// pub fn feature_int_increment_query() + vmb_result(unsafe{ + VmbFeatureIntIncrementQuery( + handle.as_raw(), + name.as_ptr(), + &mut value, + ) + })?; + + Ok(value) +} // pub fn feature_int_valid_value_set_query() @@ -586,7 +629,22 @@ pub fn feature_float_set(handle: &CameraHandle, name: &str, value: f64) -> VmbRe Ok(()) } -// pub fn feature_float_range_query() +pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[f64; 2], VmbError> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; + let mut min: f64 = -1; + let mut max: f64 = -1; + + vmb_result(unsafe { + VmbFeatureFloatRangeQuery( + handle.as_raw(), + feature_name.as_ptr(), + &mut min, + &mut max, + ) + })?; + + Ok([min, max]) +} pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; @@ -625,7 +683,52 @@ pub fn feature_enum_set(handle: &CameraHandle, name: &str, value: &str) { } -// pub fn feature_enum_range_query() +pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult, VmbError> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut num_found = 0; + + // first call to identify number of valud enums + vmb_result(unsafe { + VmbFeatureEnumRangeQuery( + handle.as_raw(), + feature_name.as_ptr(), + std::ptr::null(), // pass a null pointer to query size + 0, + &mut num_found, + ) + })?; + + if num_found == 0 { + return Ok(Vec::new()); + } + + // allocate space for pointers + let mut raw_ptrs: Vec<*const std::os::raw::c_char> = vec![std::ptr::null(); num_found as usize]; + + // second call writing to raw_ptrs + vmb_result(unsafe { + VmbFeatureEnumRangeQuery( + handle.as_raw(), + feature_name.as_ptr(), + raw_ptrs.as_mut_ptr(), + num_found, + &mut num_found, + ) + })?; + + let mut values = Vec::with_capacity(num_found as usize); + for &ptr in &raw [..num_found] { + if ptr.is_null() { + continue; + } + + let s = unsafe { CStr::from_ptr(ptr)}.to_string_lossy().into_owned(); + + values.push(s); + } + + Ok(values) +} // pub fn feature_enum_is_available() From b67a356dd4bce9e4b323c924e3bd6f6d6c6af15a Mon Sep 17 00:00:00 2001 From: Ben B Date: Mon, 29 Dec 2025 18:17:48 -0700 Subject: [PATCH 15/34] implemented feature_string_max_length_query --- src/api.rs | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/api.rs b/src/api.rs index 32acc95..5c80d42 100644 --- a/src/api.rs +++ b/src/api.rs @@ -771,7 +771,20 @@ pub fn feature_string_set(handle: &CameraHandle, name: &str, value: &str) -> Vmb Ok(()) } -// pub fn feature_string_max_length_query() +pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut max_length: u32 = 0 as VmbUint32_t; + + vmb_result(unsafe { + VmbFeatureStringMaxLengthQuery( + handle.as_raw(), + feature_name.as_ptr(), + &mut max_length, + ) + })?; + + Ok(max_length) +} pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; From 8946bf4eac2955026c8fc046be45a5385a49a285 Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 30 Dec 2025 23:07:55 -0700 Subject: [PATCH 16/34] Implemented more functions --- src/api.rs | 53 +++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 49 insertions(+), 4 deletions(-) diff --git a/src/api.rs b/src/api.rs index 5c80d42..9963a27 100644 --- a/src/api.rs +++ b/src/api.rs @@ -2,7 +2,7 @@ use super::{error::*, ffi::*, utils::*}; use std::{ ffi::{self, CStr, CString, c_char}, mem::{self, MaybeUninit}, - ptr, + ptr, string, }; use strum::FromRepr; @@ -730,11 +730,56 @@ pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult< Ok(values) } -// pub fn feature_enum_is_available() +pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_value = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut is_available = False as VmbBool_t; -// pub fn feature_enum_as_int() + vmb_result(unsafe { + VmbFeatureEnumIsAvailable( + handle.as_raw(), + feature_name.as_ptr(), + feature_value.as_ptr(), + &mut is_available, + ) + })?; -// pub fn feature_enum_as_string() + Ok(isAvailable) +} + +pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_value = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut int_value: i64 = -1 as VmbInt64_t; + + vmb_result(unsafe { + VmbFeatureEnumAsInt( + handle.as_raw(), + feature_name.as_ptr(), + feature_value.as_ptr(), + &mut int_value, + ) + })?; + + Ok(int_value) +} + +pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut string_value = std::ptr::null_mut(); + + vmb_result(unsafe { + VmbFeatureEnumAsString( + handle.as_raw(), + feature_name.as_ptr(), + int_value as VmbInt64_t, + &mut string_value, + ) + })?; + + let value = unsafe { CStr::from_ptr(string_value)}; + Ok(value.to_string_lossy().into_owned()) +} // pub fn feature_enum_entry_get() From f18fcfc90e7a3d250e31cb0351de57f2473347f9 Mon Sep 17 00:00:00 2001 From: Ben B Date: Fri, 2 Jan 2026 13:33:15 -0700 Subject: [PATCH 17/34] finished enum features and implemented command feature access --- src/api.rs | 80 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 72 insertions(+), 8 deletions(-) diff --git a/src/api.rs b/src/api.rs index 9963a27..a938a65 100644 --- a/src/api.rs +++ b/src/api.rs @@ -401,6 +401,16 @@ pub struct FeatureInfo { pub has_selected_features: bool, } +pub struct FeatureEnumEntry { + pub name: String, + pub display_name: String, + pub tooltip: String, + pub description: String, + pub int_value: i64, + pub snfc_namespace: String, + pub visibility: FeatureVisibility, +} + #[repr(u32)] #[derive(Debug, Clone, Copy, FromRepr)] pub enum FeatureDataType { @@ -519,8 +529,8 @@ pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<[bool; 2], VmbError> { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; - let mut is_readable = False as VmbBool_t; - let mut is_writable = False as VmbBool_t; + let mut is_readable = false as VmbBool_t; + let mut is_writable = false as VmbBool_t; vmb_result(unsafe { VmbFeatureAccessQuery( @@ -733,7 +743,7 @@ pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult< pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; let feature_value = CString::new(name).map_err(|_| VmbError::BadHandle)?; - let mut is_available = False as VmbBool_t; + let mut is_available = false as VmbBool_t; vmb_result(unsafe { VmbFeatureEnumIsAvailable( @@ -781,7 +791,25 @@ pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) Ok(value.to_string_lossy().into_owned()) } -// pub fn feature_enum_entry_get() +pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_name: &str) -> VmbResult { + let feature_name = CString::new(feature_name).map_err(|_| VmbError::BadHandle)?; + let entry_name = CString::new(entry_name).map_err(|_| VmbError::BadHandle)?; + + let enum_entry_size = mem::size_of::() as VmbUint32_t; + let mut enum_entry: FeatureEnumEntry = unsafe { std::mem::zeroed() }; + + vmb_result(unsafe { + VmbFeatureEnumEntryGet( + handle.as_raw(), + feature_name.as_ptr(), + entry_name.as_ptr(), + &mut enum_entry as VmbFeatureEnumEntry_t, + enum_entry_size, + ) + })?; + + Ok(enum_entry) +} pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; @@ -833,7 +861,7 @@ pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> Vmb pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; - let mut value = False as VmbBool_t; + let mut value = false as VmbBool_t; vmb_result( unsafe { VmbFeatureBoolGet( @@ -864,11 +892,47 @@ pub fn feature_bool_set(handle: &CameraHandle, name: &str, value: bool) -> VmbRe Ok(()) } -// pub fn feature_command_run() +// --------------------------------------------------------------- +// Command Feature Access +// --------------------------------------------------------------- -// pub fn feature_command_is_done() +pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<(), VmbError> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; -// pub fn feature_raw_get() + vmb_result(unsafe { + VmbFeatureCommandRun( + handle.as_raw(), + feature_name.as_ptr(), + ) + })?; + + Ok(()) +} + +pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut is_done: bool = false as VmbBool_t; + + vmb_result(unsafe { + VmbFeatureCommandIsDone( + handle.as_raw(), + feature_name.as_ptr(), + &mut is_done, + ) + })?; + Ok(is_done) +} + +// --------------------------------------------------------------- +// Raw Feature Access +// --------------------------------------------------------------- + +pub fn feature_raw_get(handle: &CameraHandle, name: &str) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let buffer = ???; initialise buffer pointer (char *) + let buffer_size = feature_raw_length_query(); + let mut size_filled: i32 = 0; +} // pub fn feature_raw_set() From b2aed66e7061c616e09305d6d9537882bd3459bc Mon Sep 17 00:00:00 2001 From: Ben B Date: Sat, 3 Jan 2026 21:08:28 -0700 Subject: [PATCH 18/34] started image acquisition functions --- src/api.rs | 106 ++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 96 insertions(+), 10 deletions(-) diff --git a/src/api.rs b/src/api.rs index a938a65..39ca3f4 100644 --- a/src/api.rs +++ b/src/api.rs @@ -600,7 +600,7 @@ pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64 vmb_result(unsafe{ VmbFeatureIntIncrementQuery( handle.as_raw(), - name.as_ptr(), + feature_name.as_ptr(), &mut value, ) })?; @@ -927,30 +927,116 @@ pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult VmbResult { +pub fn feature_raw_get(handle: &CameraHandle, name: &str) -> VmbResult, VmbError> { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + + let buffer_size = feature_raw_length_query(&handle, &name)?; + let mut buffer = vec![0i8; buffer_size as usize]; + let mut size_filled: u32 = 0 as VmbUint32_t; + + vmb_result(unsafe { + VmbFeatureRawGet( + handle.as_raw(), + feature_name.as_ptr(), + buffer.as_mut_ptr(), + buffer_size as VmbUint32_t, + &mut size_filled, + ) + })?; + + Ok(buffer) +} + +// unsure how to proceed, buffer and buffersize will have to be provided +pub fn feature_raw_set(handle: &CameraHandle, name: &str, buffer: ???, buffer_size: ???) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; - let buffer = ???; initialise buffer pointer (char *) - let buffer_size = feature_raw_length_query(); - let mut size_filled: i32 = 0; + + } -// pub fn feature_raw_set() +pub fn feature_raw_length_query(handle: &CameraHandle, name: &str) -> VmbResult { + let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let mut feature_length: u32 = 0 as VmbUint32_t; + + vmb_result(unsafe { + VmbFeatureRawLengthQuery( + handle.as_raw(), + feature_name.as_ptr(), + &mut feature_length, + ) + })?; -// pub fn feature_raw_length_query() + Ok(feature_length) +} // pub fn feature_invalidation_register() // pub fn feature_invalidation_unregister() -// pub fn frame_announce() +// --------------------------------------------------------------- +// Image Preparation and Acquisition +// --------------------------------------------------------------- + +pub struct VmbFrame { + // in + pub buffer: *mut c_void, + pub buffer_size: u32, + pub context: [*mut c_void; 4], + + // out + pub recieve_status: VmbFrameStatus_t, // still to be implemented + pub frame_id: u64, + pub timestamp: u64, + pub image_data: *mut u8, + pub receive_flags: VmbFrameFlags_t, + pub pixel_format: VmbPixelFormat_t, + pub width: VmbImageDimension_t, + pub height: VmbImageDimension_t, + pub offset_x: VmbImageDimension_t, + pub offset_y: VmbImageDimension_t, + pub payload_type: VmbPayloadType_t, + pub chunk_data_present: bool, +} + + +pub fn payload_size_get(handle: &CameraHandle) -> VmbResult { + let mut payload_size: u32 = 0 as VmbUint32_t; + + vmb_result(unsafe { + VmbPayloadSizeGet( + handle.as_raw(), + &mut payload_size, + ) + })?; + + Ok(payload_size) +} + +pub fn frame_announce(handle: &CameraHandle, ) // pub fn frame_revoke() // pub fn frame_revoke_all() -// pub fn capture_start() +pub fn capture_start(handle: &CameraHandle) -> VmbResult<(), VmbError> { + vmb_result(unsafe { + VmbCaptureStart( + handle.as_raw() + ) + })?; + + Ok(()) +} -// pub fn capture_end() +pub fn capture_end(handle: &CameraHandle) -> VmbResult<(), VmbError> { + vmb_result(unsafe { + VmbCaptureEnd( + handle.as_raw() + ) + })?; + + Ok(()) +} // pub fn capture_frame_queue() From cdbdc65313b6da5fbbd2b0a9db37742033824aa5 Mon Sep 17 00:00:00 2001 From: Ben B Date: Mon, 5 Jan 2026 11:44:27 -0700 Subject: [PATCH 19/34] re-formatted --- src/api.rs | 115 +++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 94 insertions(+), 21 deletions(-) diff --git a/src/api.rs b/src/api.rs index 39ca3f4..02b7486 100644 --- a/src/api.rs +++ b/src/api.rs @@ -2,7 +2,6 @@ use super::{error::*, ffi::*, utils::*}; use std::{ ffi::{self, CStr, CString, c_char}, mem::{self, MaybeUninit}, - ptr, string, }; use strum::FromRepr; @@ -88,6 +87,10 @@ impl CameraHandle { } } +// --------------------------------------------------------------- +// API Version +// --------------------------------------------------------------- + pub fn vmb_version_query() -> VmbResult { let mut version_raw = VmbVersionInfo_t { major: 0, @@ -110,6 +113,25 @@ pub fn vmb_version_query() -> VmbResult { }) } +// --------------------------------------------------------------- +// API Initialization +// --------------------------------------------------------------- + +#[derive(Debug, Clone)] +pub struct CameraInfo { + pub id: String, + pub extended_id: String, + pub camera_name: String, + pub model_name: String, + pub serial_number: String, + pub transport_layer_handle: TransportLayerHandle, + pub interface_handle: InterfaceHandle, + pub local_device_handle: LocalDeviceHandle, + pub stream_handles: StreamHandles, + pub stream_count: u32, + pub access: AccessMode, +} + pub fn startup(path_config: Option<&str>) -> VmbResult<()> { let path = path_config.unwrap_or("/opt/VimbaX-2025_2/cti/VimbaUSBTL.cti"); @@ -124,6 +146,10 @@ pub fn shutdown() { } } +// --------------------------------------------------------------- +// Transportaion Layer Enumeration & Information +// --------------------------------------------------------------- + #[repr(u32)] #[derive(Debug, Clone, Copy, FromRepr)] pub enum TransportLayerType { @@ -202,6 +228,10 @@ pub fn transport_layers_list() -> VmbResult> { .collect::>>() } +// --------------------------------------------------------------- +// Interface Enumeration & Information +// --------------------------------------------------------------- + pub struct InterfaceInfo { pub id: String, pub name: String, @@ -258,20 +288,9 @@ pub fn interfaces_list() -> VmbResult> { .collect::>>() } -#[derive(Debug, Clone)] -pub struct CameraInfo { - pub id: String, - pub extended_id: String, - pub camera_name: String, - pub model_name: String, - pub serial_number: String, - pub transport_layer_handle: TransportLayerHandle, - pub interface_handle: InterfaceHandle, - pub local_device_handle: LocalDeviceHandle, - pub stream_handles: StreamHandles, - pub stream_count: u32, - pub access: AccessMode, -} +// --------------------------------------------------------------- +// Camera Enumeration & Information +// --------------------------------------------------------------- #[repr(u32)] #[derive(Debug, Copy, Clone, FromRepr)] @@ -384,6 +403,10 @@ pub fn camera_close(handle: CameraHandle) -> VmbResult<()> { Ok(()) } +// --------------------------------------------------------------- +// Feature Functions +// --------------------------------------------------------------- + pub struct FeatureInfo { pub name: String, pub category: String, @@ -527,6 +550,8 @@ pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<[bool; 2], VmbError> { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; let mut is_readable = false as VmbBool_t; @@ -544,8 +569,6 @@ pub fn feature_access_query(handle: &CameraHandle, name: &str) -> VmbResult<[boo Ok(vec![is_readable, is_writable]) } -// pub fn list_feature_selected() - pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; let mut value = 0 as VmbInt64_t; @@ -656,6 +679,8 @@ pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult Ok([min, max]) } +// pub fn feature_float_increment_query() + pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; let mut value: *const std::os::raw::c_char = std::ptr::null(); @@ -1012,7 +1037,7 @@ pub fn payload_size_get(handle: &CameraHandle) -> VmbResult { Ok(payload_size) } -pub fn frame_announce(handle: &CameraHandle, ) +// pub fn frame_announce() // pub fn frame_revoke() @@ -1044,16 +1069,64 @@ pub fn capture_end(handle: &CameraHandle) -> VmbResult<(), VmbError> { // pub fn capture_queue_flush() -// pub fn memory_read() +// --------------------------------------------------------------- +// Direct Access +// --------------------------------------------------------------- -// pub fn memory_write() +pub fn memory_read(handle: &CameraHandle, address: u64, buffer_size: u32) -> VmbResult { + // let mut data_buffer: Vec> = + // vec![mem::MaybeUninit::uninit(); found as usize]; + let mut data_buffer = vec![0u8, buffer_size]; + let mut size_complete: u32 = 0; + + vmb_result(unsafe { + VmbMemoryRead( + handle.as_raw(), + address, + buffer_size, + data_buffer.as_mut_ptr().cast(),, + &mut size_complete, + ) + })?; + + // do not know how to return the data + Ok() +} + +pub fn memory_write(handle: &CameraHandle, address: u64, buffer_size: u32, data_buffer: ???) -> VmbResult<(), VmbError> { + let mut size_complete: u32 = 0; + + vmb_result(unsafe { + VmbMemoryWrite( + handle.as_raw(), + address, + buffer_size, + data_buffer, + &mut size_complete, + ) + })?; + + Ok(()) +} // pub fn registers_read() // pub fn registers_write() +// --------------------------------------------------------------- +// Load & Save Settings +// --------------------------------------------------------------- + +pub struct PersistSettings { + pub persist_type: u32, + pub module_persist_flags: u32, + pub max_iterations: u32, +} + // pub fn camera_settings_save() // pub fn camera_settings_load() -// pub fn chunk_data_access() \ No newline at end of file +// pub fn chunk_data_access() + +// pub fn chunk_access_callback() \ No newline at end of file From aa0a988255dfa7d085decfb3440988702775505d Mon Sep 17 00:00:00 2001 From: Ben B Date: Mon, 12 Jan 2026 16:28:40 -0700 Subject: [PATCH 20/34] replaced CString creation with call to util function --- src/api.rs | 64 ++++++++++++++++++++++++++-------------------------- src/utils.rs | 2 ++ 2 files changed, 34 insertions(+), 32 deletions(-) diff --git a/src/api.rs b/src/api.rs index 02b7486..aabd436 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,7 +1,7 @@ use super::{error::*, ffi::*, utils::*}; use std::{ ffi::{self, CStr, CString, c_char}, - mem::{self, MaybeUninit}, + mem::{self, MaybeUninit}, os::raw, }; use strum::FromRepr; @@ -533,7 +533,7 @@ fn convert_feature_info_safe(camera: mem::MaybeUninit,) -> Vmb } pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; + let feature_name = raw_from_str(name)?; let feature_info_raw = mem::MaybeUninit::::uninit(); let info_size = mem::size_of::() as VmbUint32_t; @@ -553,7 +553,7 @@ pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<[bool; 2], VmbError> { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut is_readable = false as VmbBool_t; let mut is_writable = false as VmbBool_t; @@ -570,7 +570,7 @@ pub fn feature_access_query(handle: &CameraHandle, name: &str) -> VmbResult<[boo } pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; + let feature_name = raw_from_str(name)?; let mut value = 0 as VmbInt64_t; vmb_result(unsafe { @@ -586,7 +586,7 @@ pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { let value = value as VmbInt64_t; - let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; + let feature_name = raw_from_str(name)?; vmb_result(unsafe { VmbFeatureIntSet( @@ -600,7 +600,7 @@ pub fn feature_int_set(handle: &CameraHandle, name: &str, value: i64) -> VmbResu } pub fn feature_int_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[i64; 2], VmbError> { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut min: i64 = -1 as VmbInt64_t; let mut max: i64 = -1 as VmbInt64_t; @@ -617,7 +617,7 @@ pub fn feature_int_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[ } pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut value = value as VmbInt64_t; vmb_result(unsafe{ @@ -634,7 +634,7 @@ pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64 // pub fn feature_int_valid_value_set_query() pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut value: f64 = 0; vmb_result( unsafe { @@ -649,7 +649,7 @@ pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { - let feature_name= CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; vmb_result( unsafe { VmbFeatureFloatSet( @@ -663,7 +663,7 @@ pub fn feature_float_set(handle: &CameraHandle, name: &str, value: f64) -> VmbRe } pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[f64; 2], VmbError> { - let feature_name = CString::new(name).map_err(|_| VmbError::BadParameter)?; + let feature_name = raw_from_str(name); let mut min: f64 = -1; let mut max: f64 = -1; @@ -682,7 +682,7 @@ pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult // pub fn feature_float_increment_query() pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut value: *const std::os::raw::c_char = std::ptr::null(); vmb_result( unsafe { @@ -703,8 +703,8 @@ pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult, VmbError> { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut num_found = 0; // first call to identify number of valud enums @@ -766,8 +766,8 @@ pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult< } pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; - let feature_value = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; + let feature_value = raw_from_str(name)?; let mut is_available = false as VmbBool_t; vmb_result(unsafe { @@ -783,8 +783,8 @@ pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) } pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; - let feature_value = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; + let feature_value = raw_from_str(name)?; let mut int_value: i64 = -1 as VmbInt64_t; vmb_result(unsafe { @@ -800,7 +800,7 @@ pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> Vm } pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut string_value = std::ptr::null_mut(); vmb_result(unsafe { @@ -817,8 +817,8 @@ pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) } pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_name: &str) -> VmbResult { - let feature_name = CString::new(feature_name).map_err(|_| VmbError::BadHandle)?; - let entry_name = CString::new(entry_name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; + let entry_name = raw_from_str(name)?; let enum_entry_size = mem::size_of::() as VmbUint32_t; let mut enum_entry: FeatureEnumEntry = unsafe { std::mem::zeroed() }; @@ -837,7 +837,7 @@ pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_n } pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut value_buffer = vec![0u8; 1024]; vmb_result(unsafe { @@ -855,8 +855,8 @@ pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; - let feature_value = CString::new(value).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; + let feature_value = raw_from_str(name)?; vmb_result(unsafe { VmbFeatureStringSet( @@ -870,7 +870,7 @@ pub fn feature_string_set(handle: &CameraHandle, name: &str, value: &str) -> Vmb } pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut max_length: u32 = 0 as VmbUint32_t; vmb_result(unsafe { @@ -885,7 +885,7 @@ pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> Vmb } pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut value = false as VmbBool_t; vmb_result( unsafe { @@ -900,7 +900,7 @@ pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let feature_value = match value { true => VmbBoolTrue, false => VmbBoolFalse, @@ -922,7 +922,7 @@ pub fn feature_bool_set(handle: &CameraHandle, name: &str, value: bool) -> VmbRe // --------------------------------------------------------------- pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<(), VmbError> { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; vmb_result(unsafe { VmbFeatureCommandRun( @@ -935,7 +935,7 @@ pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<(), V } pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut is_done: bool = false as VmbBool_t; vmb_result(unsafe { @@ -953,7 +953,7 @@ pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult VmbResult, VmbError> { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let buffer_size = feature_raw_length_query(&handle, &name)?; let mut buffer = vec![0i8; buffer_size as usize]; @@ -974,13 +974,13 @@ pub fn feature_raw_get(handle: &CameraHandle, name: &str) -> VmbResult, // unsure how to proceed, buffer and buffersize will have to be provided pub fn feature_raw_set(handle: &CameraHandle, name: &str, buffer: ???, buffer_size: ???) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; } pub fn feature_raw_length_query(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = CString::new(name).map_err(|_| VmbError::BadHandle)?; + let feature_name = raw_from_str(name)?; let mut feature_length: u32 = 0 as VmbUint32_t; vmb_result(unsafe { diff --git a/src/utils.rs b/src/utils.rs index 705d564..432efe9 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -6,6 +6,8 @@ pub fn string_from_raw(raw: *const ffi::c_char) -> Result { unsafe { Ok(ffi::CStr::from_ptr(raw).to_str()?.to_string()) } } +pub fn raw_from_str(string: &str) -> *const ffi::c_char { string.as_ptr().cast() } + pub fn vmb_result(err: VmbError_t) -> Result<(), VmbError>{ match VmbError::from_repr(err) { Some(e) => Err(e), From d6baaac5dcb79a3f703830b744fea97d1d7fce82 Mon Sep 17 00:00:00 2001 From: Ben B Date: Mon, 12 Jan 2026 16:44:16 -0700 Subject: [PATCH 21/34] Used util function for converting raw to string --- src/api.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/api.rs b/src/api.rs index aabd436..1368967 100644 --- a/src/api.rs +++ b/src/api.rs @@ -697,8 +697,7 @@ pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult< continue; } - let s = unsafe { CStr::from_ptr(ptr)}.to_string_lossy().into_owned(); - + let value = string_from_raw(ptr)?; values.push(s); } @@ -812,7 +810,7 @@ pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) ) })?; - let value = unsafe { CStr::from_ptr(string_value)}; + let value = string_from_raw(string_value)?; Ok(value.to_string_lossy().into_owned()) } @@ -850,7 +848,7 @@ pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult Date: Wed, 14 Jan 2026 13:21:02 -0700 Subject: [PATCH 22/34] changed Vimba X vers to 3 --- README.md | 2 +- build.rs | 4 ++-- examples/list_tl_layers.rs | 2 +- wrapper.h | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 572f7e9..dc2170b 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ Some extra steps are required to run the `query_version` example. Here I will on After cloning the repository or adding the crate to you Cargo.toml you must add Vimba's library directory to your LD_LIBRARY_PATH so that the example can link at runtime with the libVmbC.so: ``` Bash -export LD_LIBRARY_PATH=/opt/VimbaX_2025-2/api/lib +export LD_LIBRARY_PATH=/opt/VimbaX_2025-3/api/lib ``` Now you can run the `query_version` example: diff --git a/build.rs b/build.rs index 119f368..17ed9b5 100644 --- a/build.rs +++ b/build.rs @@ -2,12 +2,12 @@ use std::env; use std::path::PathBuf; fn main() { - println!("cargo:rustc-link-search=/opt/VimbaX_2025-2/api/lib"); + println!("cargo:rustc-link-search=/opt/VimbaX_2025-3/api/lib"); println!("cargo:rustc-link-lib=VmbC"); unsafe { std::env::set_var( "BINDGEN_EXTRA_CLANG_ARGS", - "-I\"/opt/VimbaX_2025-2/api/include\"", + "-I\"/opt/VimbaX_2025-3/api/include\"", ); }; diff --git a/examples/list_tl_layers.rs b/examples/list_tl_layers.rs index a1dbdcb..3cd4bc4 100644 --- a/examples/list_tl_layers.rs +++ b/examples/list_tl_layers.rs @@ -1,7 +1,7 @@ use vimba_rs::api::{startup, transport_layers_list, shutdown}; fn main() { - match startup(Some("/opt/VimbaX_2025-2/cti/VimbaUSBTL.cti")) { + match startup(Some("/opt/VimbaX_2025-3/cti/VimbaUSBTL.cti")) { Ok(()) => { println!("Successfully started api") } diff --git a/wrapper.h b/wrapper.h index f03b98a..cdf448b 100644 --- a/wrapper.h +++ b/wrapper.h @@ -1 +1 @@ -#include "/opt/VimbaX_2025-2/api/include/VmbC/VmbC.h" +#include "/opt/VimbaX_2025-3/api/include/VmbC/VmbC.h" From ff078ee34f6b1db2b8f59c96021343a8616b8489 Mon Sep 17 00:00:00 2001 From: Ben B Date: Mon, 19 Jan 2026 21:42:45 -0700 Subject: [PATCH 23/34] removed raw feature access wrappers and implemented camera_settings_save --- src/api.rs | 68 ++++++++++++++---------------------------------------- 1 file changed, 17 insertions(+), 51 deletions(-) diff --git a/src/api.rs b/src/api.rs index 1368967..f70a60a 100644 --- a/src/api.rs +++ b/src/api.rs @@ -946,55 +946,6 @@ pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult VmbResult, VmbError> { - let feature_name = raw_from_str(name)?; - - let buffer_size = feature_raw_length_query(&handle, &name)?; - let mut buffer = vec![0i8; buffer_size as usize]; - let mut size_filled: u32 = 0 as VmbUint32_t; - - vmb_result(unsafe { - VmbFeatureRawGet( - handle.as_raw(), - feature_name.as_ptr(), - buffer.as_mut_ptr(), - buffer_size as VmbUint32_t, - &mut size_filled, - ) - })?; - - Ok(buffer) -} - -// unsure how to proceed, buffer and buffersize will have to be provided -pub fn feature_raw_set(handle: &CameraHandle, name: &str, buffer: ???, buffer_size: ???) -> VmbResult { - let feature_name = raw_from_str(name)?; - - -} - -pub fn feature_raw_length_query(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; - let mut feature_length: u32 = 0 as VmbUint32_t; - - vmb_result(unsafe { - VmbFeatureRawLengthQuery( - handle.as_raw(), - feature_name.as_ptr(), - &mut feature_length, - ) - })?; - - Ok(feature_length) -} - -// pub fn feature_invalidation_register() - -// pub fn feature_invalidation_unregister() // --------------------------------------------------------------- // Image Preparation and Acquisition @@ -1082,7 +1033,7 @@ pub fn memory_read(handle: &CameraHandle, address: u64, buffer_size: u32) -> Vmb handle.as_raw(), address, buffer_size, - data_buffer.as_mut_ptr().cast(),, + data_buffer.as_mut_ptr().cast(), &mut size_complete, ) })?; @@ -1121,7 +1072,22 @@ pub struct PersistSettings { pub max_iterations: u32, } -// pub fn camera_settings_save() + +pub fn camera_settings_save(handle: &CameraHandle, &str: filepath, PersistSettings: settings) -> VmbResult<(), VmbError> { + let filepath = raw_from_str(filepath)?; + let mut size_of_settings: u32 = 0; + + vmb_result(unsafe { + VmbSettingsSave( + handle.as_raw(), + filepath.as_ptr(), + settings, + &mut size_of_settings, + ) + })?; + + Ok(()) +} // pub fn camera_settings_load() From dbd82b615a7689bd93a2297eae9c499885d99b26 Mon Sep 17 00:00:00 2001 From: Ben B Date: Mon, 19 Jan 2026 22:09:56 -0700 Subject: [PATCH 24/34] implemented feature_int_valid_value_set_query --- src/api.rs | 60 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 54 insertions(+), 6 deletions(-) diff --git a/src/api.rs b/src/api.rs index f70a60a..20e7901 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,7 +1,6 @@ use super::{error::*, ffi::*, utils::*}; use std::{ - ffi::{self, CStr, CString, c_char}, - mem::{self, MaybeUninit}, os::raw, + collections::btree_map::Values, ffi::{self, CStr, CString, c_char}, fs::FileType, mem::{self, MaybeUninit}, os::raw }; use strum::FromRepr; @@ -631,7 +630,42 @@ pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64 Ok(value) } -// pub fn feature_int_valid_value_set_query() +pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> VmbResult, VmbError> { + let feature_name = raw_from_str(name)?; + let mut set_size: u32 = 0; + let mut buffer_size: u32 = 0; + + // first call to identify size of value set + vmb_result(unsafe { + VmbFeatureIntValidValueSetQuery( + handle.as_raw(), + feature_name.as_ptr(), + std::ptr::null(), // pass null pointer to buffer to only return buffer size in buffer_size + &mut buffer_size, + &mut set_size, + ) + })?; + + if set_size == 0 { + return Ok(Vec::new()); + } + + let mut buffer: Vec = vec![0..set_size]; + let buffer_size: u32 = buffer.len(); + + // second call to populate buffer + vmb_result(unsafe { + VmbFeatureIntValidValueSetQuery( + handle.as_raw(), + feature_name.as_ptr(), + buffer.as_mut_ptr(), + buffer_size, + &mut set_size, + ) + })?; + + Ok(buffer) +} pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; @@ -1074,22 +1108,36 @@ pub struct PersistSettings { pub fn camera_settings_save(handle: &CameraHandle, &str: filepath, PersistSettings: settings) -> VmbResult<(), VmbError> { + // TODO: determine if this is how filepath is to be calculated + // determine how to calculate size_of_settings in bytes for C instead of rust let filepath = raw_from_str(filepath)?; - let mut size_of_settings: u32 = 0; + let size_of_settings: u32 = 0; vmb_result(unsafe { VmbSettingsSave( handle.as_raw(), filepath.as_ptr(), settings, - &mut size_of_settings, + size_of_settings, ) })?; Ok(()) } -// pub fn camera_settings_load() +pub fn camera_settings_load(handle: &CameraHandle, &str: filepath, PersistSettings: settings) -> VmbResult<(), VmbError> { + let filepath = raw_from_str(filepath)?; + let size_of_settings: u32 = 0; + + vmb_result(unsafe { + VmbSettingsLoad( + handle.as_raw(), + filepath.as_ptr(), + setting, + size_of_settings + ) + }) +} // pub fn chunk_data_access() From 26842febbcba1b5f831bc44f72782707d3d7cc67 Mon Sep 17 00:00:00 2001 From: Ben B Date: Tue, 10 Feb 2026 15:06:30 -0700 Subject: [PATCH 25/34] completed implementation of remaining functions --- src/api.rs | 130 ++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 120 insertions(+), 10 deletions(-) diff --git a/src/api.rs b/src/api.rs index 20e7901..6077bf5 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,6 +1,6 @@ use super::{error::*, ffi::*, utils::*}; use std::{ - collections::btree_map::Values, ffi::{self, CStr, CString, c_char}, fs::FileType, mem::{self, MaybeUninit}, os::raw + collections::btree_map::Values, ffi::{self, CStr, CString, c_char, c_double}, fs::FileType, mem::{self, MaybeUninit}, os::raw }; use strum::FromRepr; @@ -86,6 +86,13 @@ impl CameraHandle { } } +pub type VmbFrameCallback = Option< + extern "C" fn( + handle: VmbHandle_t, + frame: *mut VmbFrame, + ) +>; + // --------------------------------------------------------------- // API Version // --------------------------------------------------------------- @@ -548,8 +555,44 @@ pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult VmbResult> { + let feature_name = raw_from_str(name)?; + let mut num_found = 0 as VmbUint32_t; + let feature_info_size = mem::size_of::() as VmbUint32_t; + + vmb_result(unsafe { + VmbFeatureListSelected( + handle.as_raw(), + feature_name.as_ptr(), + pth::null_mut(), // empty feature list + 0 as ffi::c_uint, + &mut num_found, + feature_info_size, + ) + })?; + + if found == 0 { + return Ok(Vec::new()); + } + + let mut features_raw: Vec> = vec![mem::MaybeUninit::uninit(); found as usize]; + + vmb_result(unsafe { + VmbFeatureListSelected( + handle.as_raw(), + feature_name.as_ptr(), + features_raw.as_mut_ptr().cast(), + found, + &mut found, + feature_info_size, + ) + })?; -// pub fn list_feature_selected() + features_raw + .iter() + .map(|feature| convert_feature_info_safe(*feature)) + .collect::>>() +} pub fn feature_access_query(handle: &CameraHandle, name: &str) -> VmbResult<[bool; 2], VmbError> { let feature_name = raw_from_str(name)?; @@ -713,7 +756,22 @@ pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult Ok([min, max]) } -// pub fn feature_float_increment_query() +pub fn feature_float_increment_query(handle: &CameraHandle, name: &str) -> VmbResult { + let feature_name = raw_from_str(name); + let mut hasIncrement = false; + let mut value: = 0.0 as c_double; + + vmb_result(unsafe { + VmbFeatureFloatIncrementQuery( + handle.as_raw(), + feature_name.as_ptr(), + &mut hasIncrement, + &mut value, + ) + })?; + + Ok(value) +} pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; @@ -1020,11 +1078,34 @@ pub fn payload_size_get(handle: &CameraHandle) -> VmbResult { Ok(payload_size) } -// pub fn frame_announce() +pub fn frame_announce(handle: &CameraHandle, frame: VmbFrame, size_of_frame:u16) -> VmbResult<()> { + vmb_result(unsafe { + VmbFrameAnnounce( + handle.as_raw(), + frame as *const VmbFrame, + &mut size_of_frame, + ) + })?; + + Ok(()) +} + +pub fn frame_revoke(handle: &CameraHandle, frame: VmbFrame) -> VmbResult<()> { + vmb_result(unsafe { + VmbFrameRevoke( + handle.as_raw(), + frame as *const VmbFrame, + ) + })?; + + Ok(()) +} -// pub fn frame_revoke() +pub fn frame_revoke_all(handle: &CameraHandle) -> VmbResult<()> { + vmb_result(unsafe {VmbFrameRevokeAll(handle)})?; -// pub fn frame_revoke_all() + Ok(()) +} pub fn capture_start(handle: &CameraHandle) -> VmbResult<(), VmbError> { vmb_result(unsafe { @@ -1046,11 +1127,38 @@ pub fn capture_end(handle: &CameraHandle) -> VmbResult<(), VmbError> { Ok(()) } -// pub fn capture_frame_queue() +pub fn capture_frame_queue(handle: &CameraHandle, frame: &VmbFrame, callback: VmbFrameCallback) -> VmbResult<()> { + vmb_result(unsafe { + VmbCaptureFrameQueue( + handle.as_raw(), + frame as *const VmbFrame, + callback, + ) + })?; -// pub fn capture_frame_wait() + Ok(()) +} + +pub fn capture_frame_wait(handle: &CameraHandle, frame: &VmbFrame, timeout: u32) { + vmb_result(unsafe { + VmbCaptureFrameWait( + handle.as_raw(), + frame as *const VmbFrame, + timeout as VmbUint32_t, + ) + })?; -// pub fn capture_queue_flush() + Ok(()) +} + +pub fn capture_queue_flush(handle: &CameraHandle) -> VmbResult<()> { + vmb_result(unsafe { + VmbCaptureQueueFlush(handle.as_raw()) + + })?; + + Ok(()) +} // --------------------------------------------------------------- // Direct Access @@ -1092,8 +1200,8 @@ pub fn memory_write(handle: &CameraHandle, address: u64, buffer_size: u32, data_ Ok(()) } +// will be implemented if a use case is found // pub fn registers_read() - // pub fn registers_write() // --------------------------------------------------------------- @@ -1139,6 +1247,8 @@ pub fn camera_settings_load(handle: &CameraHandle, &str: filepath, PersistSettin }) } + +// will be implemented if a use case is found // pub fn chunk_data_access() // pub fn chunk_access_callback() \ No newline at end of file From 094b13c7ca0d63f07d0da778965aa0dcda34ff83 Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 12 Feb 2026 18:19:04 -0700 Subject: [PATCH 26/34] removed memory write implementation --- src/api.rs | 18 ++---------------- 1 file changed, 2 insertions(+), 16 deletions(-) diff --git a/src/api.rs b/src/api.rs index 6077bf5..a668ce5 100644 --- a/src/api.rs +++ b/src/api.rs @@ -759,7 +759,7 @@ pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult pub fn feature_float_increment_query(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name); let mut hasIncrement = false; - let mut value: = 0.0 as c_double; + let mut value = 0.0 as c_double; vmb_result(unsafe { VmbFeatureFloatIncrementQuery( @@ -1184,21 +1184,7 @@ pub fn memory_read(handle: &CameraHandle, address: u64, buffer_size: u32) -> Vmb Ok() } -pub fn memory_write(handle: &CameraHandle, address: u64, buffer_size: u32, data_buffer: ???) -> VmbResult<(), VmbError> { - let mut size_complete: u32 = 0; - - vmb_result(unsafe { - VmbMemoryWrite( - handle.as_raw(), - address, - buffer_size, - data_buffer, - &mut size_complete, - ) - })?; - - Ok(()) -} +// pub fn memory_write() // will be implemented if a use case is found // pub fn registers_read() From 4055b11ea344883c619da1ccdb5cbc598ba5a76a Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 12 Feb 2026 18:28:38 -0700 Subject: [PATCH 27/34] fixing errors --- src/api.rs | 43 ++++++++++++------------------------------- 1 file changed, 12 insertions(+), 31 deletions(-) diff --git a/src/api.rs b/src/api.rs index a668ce5..23e6f77 100644 --- a/src/api.rs +++ b/src/api.rs @@ -608,7 +608,7 @@ pub fn feature_access_query(handle: &CameraHandle, name: &str) -> VmbResult<[boo ) })?; - Ok(vec![is_readable, is_writable]) + Ok([is_readable, is_writable]) } pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult { @@ -673,7 +673,7 @@ pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64 Ok(value) } -pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> VmbResult, VmbError> { +pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> VmbResult, VmbError> { let feature_name = raw_from_str(name)?; let mut set_size: u32 = 0; let mut buffer_size: u32 = 0; @@ -693,8 +693,7 @@ pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> V return Ok(Vec::new()); } - let mut buffer: Vec = vec![0..set_size]; - let buffer_size: u32 = buffer.len(); + let mut buffer: Vec = vec![0; set_size as usize]; // second call to populate buffer vmb_result(unsafe { @@ -712,7 +711,7 @@ pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> V pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; - let mut value: f64 = 0; + let mut value: f64 = 0.0; vmb_result( unsafe { VmbFeatureFloatGet( @@ -741,8 +740,8 @@ pub fn feature_float_set(handle: &CameraHandle, name: &str, value: f64) -> VmbRe pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[f64; 2], VmbError> { let feature_name = raw_from_str(name); - let mut min: f64 = -1; - let mut max: f64 = -1; + let mut min: f64 = -1.0; + let mut max: f64 = -1.0; vmb_result(unsafe { VmbFeatureFloatRangeQuery( @@ -756,7 +755,7 @@ pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult Ok([min, max]) } -pub fn feature_float_increment_query(handle: &CameraHandle, name: &str) -> VmbResult { +pub fn feature_float_increment_query(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name); let mut hasIncrement = false; let mut value = 0.0 as c_double; @@ -793,7 +792,7 @@ pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { let feature_name = raw_from_str(name)?; let feature_value = raw_from_str(name)?; @@ -1082,7 +1081,7 @@ pub fn frame_announce(handle: &CameraHandle, frame: VmbFrame, size_of_frame:u16) vmb_result(unsafe { VmbFrameAnnounce( handle.as_raw(), - frame as *const VmbFrame, + frame as VmbFrame, &mut size_of_frame, ) })?; @@ -1094,7 +1093,7 @@ pub fn frame_revoke(handle: &CameraHandle, frame: VmbFrame) -> VmbResult<()> { vmb_result(unsafe { VmbFrameRevoke( handle.as_raw(), - frame as *const VmbFrame, + frame as VmbFrame, ) })?; @@ -1139,7 +1138,7 @@ pub fn capture_frame_queue(handle: &CameraHandle, frame: &VmbFrame, callback: Vm Ok(()) } -pub fn capture_frame_wait(handle: &CameraHandle, frame: &VmbFrame, timeout: u32) { +pub fn capture_frame_wait(handle: &CameraHandle, frame: &VmbFrame, timeout: u32) -> VmbResult<()>{ vmb_result(unsafe { VmbCaptureFrameWait( handle.as_raw(), @@ -1164,25 +1163,7 @@ pub fn capture_queue_flush(handle: &CameraHandle) -> VmbResult<()> { // Direct Access // --------------------------------------------------------------- -pub fn memory_read(handle: &CameraHandle, address: u64, buffer_size: u32) -> VmbResult { - // let mut data_buffer: Vec> = - // vec![mem::MaybeUninit::uninit(); found as usize]; - let mut data_buffer = vec![0u8, buffer_size]; - let mut size_complete: u32 = 0; - - vmb_result(unsafe { - VmbMemoryRead( - handle.as_raw(), - address, - buffer_size, - data_buffer.as_mut_ptr().cast(), - &mut size_complete, - ) - })?; - - // do not know how to return the data - Ok() -} +// pub fn memory_read() // pub fn memory_write() From ed2e8355cb88477ffe6045d0478c838be00528ad Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 12 Feb 2026 18:30:16 -0700 Subject: [PATCH 28/34] fix: swapped variable names --- src/api.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/api.rs b/src/api.rs index 23e6f77..dfdd8c2 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1182,7 +1182,7 @@ pub struct PersistSettings { } -pub fn camera_settings_save(handle: &CameraHandle, &str: filepath, PersistSettings: settings) -> VmbResult<(), VmbError> { +pub fn camera_settings_save(handle: &CameraHandle, filepath: &str, settings: PersistSettings) -> VmbResult<(), VmbError> { // TODO: determine if this is how filepath is to be calculated // determine how to calculate size_of_settings in bytes for C instead of rust let filepath = raw_from_str(filepath)?; @@ -1200,7 +1200,7 @@ pub fn camera_settings_save(handle: &CameraHandle, &str: filepath, PersistSettin Ok(()) } -pub fn camera_settings_load(handle: &CameraHandle, &str: filepath, PersistSettings: settings) -> VmbResult<(), VmbError> { +pub fn camera_settings_load(handle: &CameraHandle, filepath: &str, settings: PersistSettings) -> VmbResult<(), VmbError> { let filepath = raw_from_str(filepath)?; let size_of_settings: u32 = 0; From 9ceaa20bc6ad0efad884bf1436eea0baf3f8e493 Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 12 Feb 2026 18:31:03 -0700 Subject: [PATCH 29/34] moved unused functions --- src/api.rs | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/api.rs b/src/api.rs index dfdd8c2..fca2159 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1161,16 +1161,18 @@ pub fn capture_queue_flush(handle: &CameraHandle) -> VmbResult<()> { // --------------------------------------------------------------- // Direct Access +// will be implemented if a use case is found // --------------------------------------------------------------- // pub fn memory_read() - // pub fn memory_write() -// will be implemented if a use case is found // pub fn registers_read() // pub fn registers_write() +// pub fn chunk_data_access() +// pub fn chunk_access_callback() + // --------------------------------------------------------------- // Load & Save Settings // --------------------------------------------------------------- @@ -1214,8 +1216,3 @@ pub fn camera_settings_load(handle: &CameraHandle, filepath: &str, settings: Per }) } - -// will be implemented if a use case is found -// pub fn chunk_data_access() - -// pub fn chunk_access_callback() \ No newline at end of file From cd09d428c454f0e8ddaa8a2020f8700932b55f7f Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 26 Feb 2026 17:00:46 -0700 Subject: [PATCH 30/34] update readme --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index dc2170b..334f0f4 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,9 @@ After cloning the repository or adding the crate to you Cargo.toml you must add ``` Bash export LD_LIBRARY_PATH=/opt/VimbaX_2025-3/api/lib ++note that the path may be different depending on the version of Vimba you have downloaded. ++As of writing, the latest available version is VimbaX_2025-3. ++Corresponding changes will have to be made to the `wrapper.h` and `build.rs` files to reflect your version ``` Now you can run the `query_version` example: From fed0edb59223ccbbfd78e67461b9684832c3a0f4 Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 26 Feb 2026 17:02:46 -0700 Subject: [PATCH 31/34] readme --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 334f0f4..d207c63 100644 --- a/README.md +++ b/README.md @@ -12,9 +12,9 @@ After cloning the repository or adding the crate to you Cargo.toml you must add ``` Bash export LD_LIBRARY_PATH=/opt/VimbaX_2025-3/api/lib -+note that the path may be different depending on the version of Vimba you have downloaded. -+As of writing, the latest available version is VimbaX_2025-3. -+Corresponding changes will have to be made to the `wrapper.h` and `build.rs` files to reflect your version +note that the path may be different depending on the version of Vimba you have downloaded. +As of writing, the latest available version is VimbaX_2025-3. +Corresponding changes will have to be made to the `wrapper.h` and `build.rs` files to reflect your version ``` Now you can run the `query_version` example: From 2bcf206e2c399cbf05f5d6e496992cd401d68d71 Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 26 Feb 2026 17:41:24 -0700 Subject: [PATCH 32/34] clearing compile errors --- src/api.rs | 91 +++++++++++++++++++++++++++------------------------- src/utils.rs | 7 ++-- 2 files changed, 52 insertions(+), 46 deletions(-) diff --git a/src/api.rs b/src/api.rs index fca2159..ee374fc 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1,6 +1,9 @@ use super::{error::*, ffi::*, utils::*}; use std::{ - collections::btree_map::Values, ffi::{self, CStr, CString, c_char, c_double}, fs::FileType, mem::{self, MaybeUninit}, os::raw + ffi::{self, CStr, CString, c_char, c_double, c_void}, + mem::{self, MaybeUninit}, + ptr, + os::raw, }; use strum::FromRepr; @@ -564,26 +567,26 @@ pub fn list_feature_selected(handle: &CameraHandle, name: &str) -> VmbResult> = vec![mem::MaybeUninit::uninit(); found as usize]; + let mut features_raw: Vec> = vec![mem::MaybeUninit::uninit(); num_found as usize]; vmb_result(unsafe { VmbFeatureListSelected( handle.as_raw(), feature_name.as_ptr(), features_raw.as_mut_ptr().cast(), - found, - &mut found, + num_found, + &mut num_found, feature_info_size, ) })?; @@ -594,7 +597,7 @@ pub fn list_feature_selected(handle: &CameraHandle, name: &str) -> VmbResult>>() } -pub fn feature_access_query(handle: &CameraHandle, name: &str) -> VmbResult<[bool; 2], VmbError> { +pub fn feature_access_query(handle: &CameraHandle, name: &str) -> VmbResult<[i8; 2]> { let feature_name = raw_from_str(name)?; let mut is_readable = false as VmbBool_t; let mut is_writable = false as VmbBool_t; @@ -611,7 +614,7 @@ pub fn feature_access_query(handle: &CameraHandle, name: &str) -> VmbResult<[boo Ok([is_readable, is_writable]) } -pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult { +pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let mut value = 0 as VmbInt64_t; @@ -634,14 +637,14 @@ pub fn feature_int_set(handle: &CameraHandle, name: &str, value: i64) -> VmbResu VmbFeatureIntSet( handle.as_raw(), feature_name.as_ptr(), - &value, + value, ) })?; Ok(()) } -pub fn feature_int_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[i64; 2], VmbError> { +pub fn feature_int_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[i64; 2]> { let feature_name = raw_from_str(name)?; let mut min: i64 = -1 as VmbInt64_t; let mut max: i64 = -1 as VmbInt64_t; @@ -658,7 +661,7 @@ pub fn feature_int_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[ Ok([min, max]) } -pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64) -> VmbResult { +pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64) -> VmbResult { let feature_name = raw_from_str(name)?; let mut value = value as VmbInt64_t; @@ -673,7 +676,7 @@ pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64 Ok(value) } -pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> VmbResult, VmbError> { +pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> VmbResult> { let feature_name = raw_from_str(name)?; let mut set_size: u32 = 0; let mut buffer_size: u32 = 0; @@ -684,7 +687,7 @@ pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> V handle.as_raw(), feature_name.as_ptr(), std::ptr::null(), // pass null pointer to buffer to only return buffer size in buffer_size - &mut buffer_size, + buffer_size, &mut set_size, ) })?; @@ -709,7 +712,7 @@ pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> V Ok(buffer) } -pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult { +pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let mut value: f64 = 0.0; @@ -717,7 +720,7 @@ pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult VmbRe VmbFeatureFloatSet( handle.as_raw(), feature_name.as_ptr(), - &value, + value, ) })?; Ok(()) } -pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[f64; 2], VmbError> { +pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[f64; 2]> { let feature_name = raw_from_str(name); let mut min: f64 = -1.0; let mut max: f64 = -1.0; @@ -757,8 +760,8 @@ pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult pub fn feature_float_increment_query(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name); - let mut hasIncrement = false; - let mut value = 0.0 as c_double; + let mut hasIncrement = VmbBoolVal_VmbBoolFalse; + let mut value: c_double = 0.0; vmb_result(unsafe { VmbFeatureFloatIncrementQuery( @@ -772,7 +775,7 @@ pub fn feature_float_increment_query(handle: &CameraHandle, name: &str) -> VmbRe Ok(value) } -pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult { +pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let mut value: *const std::os::raw::c_char = std::ptr::null(); @@ -808,7 +811,7 @@ pub fn feature_enum_set(handle: &CameraHandle, name: &str, value: &str) -> VmbRe } -pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult, VmbError> { +pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult> { let feature_name = raw_from_str(name)?; let mut num_found = 0; @@ -842,19 +845,19 @@ pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult< })?; let mut values = Vec::with_capacity(num_found as usize); - for &ptr in &raw [..num_found] { + for &ptr in &raw_ptrs[..num_found as usize] { if ptr.is_null() { continue; } let value = string_from_raw(ptr)?; - values.push(s); + values.push(value); } Ok(values) } -pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { +pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let feature_value = raw_from_str(name)?; let mut is_available = false as VmbBool_t; @@ -868,10 +871,10 @@ pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) ) })?; - Ok(isAvailable) + Ok(is_available) } -pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { +pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let feature_value = raw_from_str(name)?; let mut int_value: i64 = -1 as VmbInt64_t; @@ -888,7 +891,7 @@ pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> Vm Ok(int_value) } -pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) -> VmbResult { +pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) -> VmbResult { let feature_name = raw_from_str(name)?; let mut string_value = std::ptr::null_mut(); @@ -905,9 +908,9 @@ pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) Ok(value.to_string_lossy().into_owned()) } -pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; - let entry_name = raw_from_str(name)?; +pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_name: &str) -> VmbResult { + let feature_name = raw_from_str(entry_name)?; + let entry_name = raw_from_str(entry_name)?; let enum_entry_size = mem::size_of::() as VmbUint32_t; let mut enum_entry: FeatureEnumEntry = unsafe { std::mem::zeroed() }; @@ -925,7 +928,7 @@ pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_n Ok(enum_entry) } -pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult { +pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let mut value_buffer = vec![0u8; 1024]; @@ -939,7 +942,7 @@ pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult Vmb Ok(()) } -pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> VmbResult { +pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let mut max_length: u32 = 0 as VmbUint32_t; @@ -973,7 +976,7 @@ pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> Vmb Ok(max_length) } -pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { +pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let mut value = false as VmbBool_t; @@ -991,8 +994,8 @@ pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { let feature_name = raw_from_str(name)?; let feature_value = match value { - true => VmbBoolTrue, - false => VmbBoolFalse, + true => VmbBoolVal_VmbBoolTrue, + false => VmbBoolVal_VmbBoolFalse, }; vmb_result( unsafe { @@ -1010,7 +1013,7 @@ pub fn feature_bool_set(handle: &CameraHandle, name: &str, value: bool) -> VmbRe // Command Feature Access // --------------------------------------------------------------- -pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<(), VmbError> { +pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<()> { let feature_name = raw_from_str(name)?; vmb_result(unsafe { @@ -1023,7 +1026,7 @@ pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<(), V Ok(()) } -pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult { +pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name)?; let mut is_done: bool = false as VmbBool_t; @@ -1064,7 +1067,7 @@ pub struct VmbFrame { } -pub fn payload_size_get(handle: &CameraHandle) -> VmbResult { +pub fn payload_size_get(handle: &CameraHandle) -> VmbResult { let mut payload_size: u32 = 0 as VmbUint32_t; vmb_result(unsafe { @@ -1106,7 +1109,7 @@ pub fn frame_revoke_all(handle: &CameraHandle) -> VmbResult<()> { Ok(()) } -pub fn capture_start(handle: &CameraHandle) -> VmbResult<(), VmbError> { +pub fn capture_start(handle: &CameraHandle) -> VmbResult<()> { vmb_result(unsafe { VmbCaptureStart( handle.as_raw() @@ -1116,7 +1119,7 @@ pub fn capture_start(handle: &CameraHandle) -> VmbResult<(), VmbError> { Ok(()) } -pub fn capture_end(handle: &CameraHandle) -> VmbResult<(), VmbError> { +pub fn capture_end(handle: &CameraHandle) -> VmbResult<()> { vmb_result(unsafe { VmbCaptureEnd( handle.as_raw() @@ -1184,7 +1187,7 @@ pub struct PersistSettings { } -pub fn camera_settings_save(handle: &CameraHandle, filepath: &str, settings: PersistSettings) -> VmbResult<(), VmbError> { +pub fn camera_settings_save(handle: &CameraHandle, filepath: &str, settings: PersistSettings) -> VmbResult<()> { // TODO: determine if this is how filepath is to be calculated // determine how to calculate size_of_settings in bytes for C instead of rust let filepath = raw_from_str(filepath)?; @@ -1202,7 +1205,7 @@ pub fn camera_settings_save(handle: &CameraHandle, filepath: &str, settings: Per Ok(()) } -pub fn camera_settings_load(handle: &CameraHandle, filepath: &str, settings: PersistSettings) -> VmbResult<(), VmbError> { +pub fn camera_settings_load(handle: &CameraHandle, filepath: &str, settings: PersistSettings) -> VmbResult<()> { let filepath = raw_from_str(filepath)?; let size_of_settings: u32 = 0; @@ -1210,7 +1213,7 @@ pub fn camera_settings_load(handle: &CameraHandle, filepath: &str, settings: Per VmbSettingsLoad( handle.as_raw(), filepath.as_ptr(), - setting, + settings, size_of_settings ) }) diff --git a/src/utils.rs b/src/utils.rs index 432efe9..811114b 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,4 +1,4 @@ -use std::{ffi, str::Utf8Error}; +use std::{ffi, ffi::CString, ffi::NulError, str::Utf8Error}; use crate::{error::VmbError, ffi::VmbError_t}; @@ -6,7 +6,10 @@ pub fn string_from_raw(raw: *const ffi::c_char) -> Result { unsafe { Ok(ffi::CStr::from_ptr(raw).to_str()?.to_string()) } } -pub fn raw_from_str(string: &str) -> *const ffi::c_char { string.as_ptr().cast() } +// pub fn raw_from_str(string: &str) -> *const ffi::c_char { string.as_ptr().cast() } +pub fn raw_from_str(string: &str) -> Result { + CString::new(string) // returns Result +} pub fn vmb_result(err: VmbError_t) -> Result<(), VmbError>{ match VmbError::from_repr(err) { From 20e823c06d2d1ec808b54d0c1f98babf26a64245 Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 26 Feb 2026 18:05:34 -0700 Subject: [PATCH 33/34] compiler errors --- src/api.rs | 134 +++++++++++++++++++++++++-------------------------- src/utils.rs | 5 +- 2 files changed, 68 insertions(+), 71 deletions(-) diff --git a/src/api.rs b/src/api.rs index ee374fc..b4f0402 100644 --- a/src/api.rs +++ b/src/api.rs @@ -542,7 +542,7 @@ fn convert_feature_info_safe(camera: mem::MaybeUninit,) -> Vmb } pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let feature_info_raw = mem::MaybeUninit::::uninit(); let info_size = mem::size_of::() as VmbUint32_t; @@ -550,7 +550,7 @@ pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult VmbResult VmbResult> { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut num_found = 0 as VmbUint32_t; let feature_info_size = mem::size_of::() as VmbUint32_t; vmb_result(unsafe { VmbFeatureListSelected( handle.as_raw(), - feature_name.as_ptr(), + feature_name, std::ptr::null_mut(), // empty feature list 0 as ffi::c_uint, &mut num_found, @@ -583,7 +583,7 @@ pub fn list_feature_selected(handle: &CameraHandle, name: &str) -> VmbResult VmbResult VmbResult<[i8; 2]> { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut is_readable = false as VmbBool_t; let mut is_writable = false as VmbBool_t; vmb_result(unsafe { VmbFeatureAccessQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut is_readable, &mut is_writable, ) @@ -615,13 +615,13 @@ pub fn feature_access_query(handle: &CameraHandle, name: &str) -> VmbResult<[i8; } pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut value = 0 as VmbInt64_t; vmb_result(unsafe { VmbFeatureIntGet( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut value, ) })?; @@ -631,12 +631,12 @@ pub fn feature_int_get(handle: &CameraHandle, name: &str) -> VmbResult { pub fn feature_int_set(handle: &CameraHandle, name: &str, value: i64) -> VmbResult<()> { let value = value as VmbInt64_t; - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); vmb_result(unsafe { VmbFeatureIntSet( handle.as_raw(), - feature_name.as_ptr(), + feature_name, value, ) })?; @@ -645,14 +645,14 @@ pub fn feature_int_set(handle: &CameraHandle, name: &str, value: i64) -> VmbResu } pub fn feature_int_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[i64; 2]> { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut min: i64 = -1 as VmbInt64_t; let mut max: i64 = -1 as VmbInt64_t; vmb_result(unsafe { VmbFeatureIntRangeQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut min, &mut max, ) @@ -662,13 +662,13 @@ pub fn feature_int_range_query(handle: &CameraHandle, name: &str) -> VmbResult<[ } pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut value = value as VmbInt64_t; vmb_result(unsafe{ VmbFeatureIntIncrementQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut value, ) })?; @@ -677,7 +677,7 @@ pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64 } pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> VmbResult> { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut set_size: u32 = 0; let mut buffer_size: u32 = 0; @@ -685,7 +685,7 @@ pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> V vmb_result(unsafe { VmbFeatureIntValidValueSetQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, std::ptr::null(), // pass null pointer to buffer to only return buffer size in buffer_size buffer_size, &mut set_size, @@ -702,7 +702,7 @@ pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> V vmb_result(unsafe { VmbFeatureIntValidValueSetQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, buffer.as_mut_ptr(), buffer_size, &mut set_size, @@ -713,13 +713,13 @@ pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> V } pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut value: f64 = 0.0; vmb_result( unsafe { VmbFeatureFloatGet( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut value, ) })?; @@ -728,12 +728,12 @@ pub fn feature_float_get(handle: &CameraHandle, name: &str) -> VmbResult { } pub fn feature_float_set(handle: &CameraHandle, name: &str, value: f64) -> VmbResult<()> { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); vmb_result( unsafe { VmbFeatureFloatSet( handle.as_raw(), - feature_name.as_ptr(), + feature_name, value, ) })?; @@ -749,7 +749,7 @@ pub fn feature_float_range_query(handle: &CameraHandle, name: &str) -> VmbResult vmb_result(unsafe { VmbFeatureFloatRangeQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut min, &mut max, ) @@ -766,7 +766,7 @@ pub fn feature_float_increment_query(handle: &CameraHandle, name: &str) -> VmbRe vmb_result(unsafe { VmbFeatureFloatIncrementQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut hasIncrement, &mut value, ) @@ -776,13 +776,13 @@ pub fn feature_float_increment_query(handle: &CameraHandle, name: &str) -> VmbRe } pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut value: *const std::os::raw::c_char = std::ptr::null(); vmb_result( unsafe { VmbFeatureEnumGet( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut value, ) })?; @@ -796,14 +796,14 @@ pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult } pub fn feature_enum_set(handle: &CameraHandle, name: &str, value: &str) -> VmbResult<()> { - let feature_name = raw_from_str(name)?; - let feature_value = raw_from_str(name)?; + let feature_name = raw_from_str(name); + let feature_value = raw_from_str(value); vmb_result(unsafe { VmbFeatureBoolSet( handle.as_raw(), - feature_name.as_ptr(), - &feature_value.as_ptr(), + feature_name, + &feature_value, ) })?; @@ -812,14 +812,14 @@ pub fn feature_enum_set(handle: &CameraHandle, name: &str, value: &str) -> VmbRe } pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult> { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut num_found = 0; // first call to identify number of valud enums vmb_result(unsafe { VmbFeatureEnumRangeQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, std::ptr::null(), // pass a null pointer to query size 0, &mut num_found, @@ -837,7 +837,7 @@ pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult< vmb_result(unsafe { VmbFeatureEnumRangeQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, raw_ptrs.as_mut_ptr(), num_found, &mut num_found, @@ -858,15 +858,15 @@ pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult< } pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; - let feature_value = raw_from_str(name)?; + let feature_name = raw_from_str(name); + let feature_value = raw_from_str(value); let mut is_available = false as VmbBool_t; vmb_result(unsafe { VmbFeatureEnumIsAvailable( handle.as_raw(), - feature_name.as_ptr(), - feature_value.as_ptr(), + feature_name, + feature_value, &mut is_available, ) })?; @@ -875,15 +875,15 @@ pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) } pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; - let feature_value = raw_from_str(name)?; + let feature_name = raw_from_str(name); + let feature_value = raw_from_str(value); let mut int_value: i64 = -1 as VmbInt64_t; vmb_result(unsafe { VmbFeatureEnumAsInt( handle.as_raw(), - feature_name.as_ptr(), - feature_value.as_ptr(), + feature_name, + feature_value, &mut int_value, ) })?; @@ -892,13 +892,13 @@ pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> Vm } pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut string_value = std::ptr::null_mut(); vmb_result(unsafe { VmbFeatureEnumAsString( handle.as_raw(), - feature_name.as_ptr(), + feature_name, int_value as VmbInt64_t, &mut string_value, ) @@ -909,8 +909,8 @@ pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) } pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_name: &str) -> VmbResult { - let feature_name = raw_from_str(entry_name)?; - let entry_name = raw_from_str(entry_name)?; + let feature_name = raw_from_str(feature_name); + let entry_name = raw_from_str(entry_name); let enum_entry_size = mem::size_of::() as VmbUint32_t; let mut enum_entry: FeatureEnumEntry = unsafe { std::mem::zeroed() }; @@ -918,8 +918,8 @@ pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_n vmb_result(unsafe { VmbFeatureEnumEntryGet( handle.as_raw(), - feature_name.as_ptr(), - entry_name.as_ptr(), + feature_name, + entry_name, &mut enum_entry as VmbFeatureEnumEntry_t, enum_entry_size, ) @@ -929,13 +929,13 @@ pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_n } pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut value_buffer = vec![0u8; 1024]; vmb_result(unsafe { VmbFeatureStringGet( handle.as_raw(), - feature_name.as_ptr(), + feature_name, value_buffer.as_mut_ptr() as *mut c_char, value_buffer.len() as u32, std::ptr::null_mut(), // Change to sizeFilled pointer if desired @@ -947,14 +947,14 @@ pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { - let feature_name = raw_from_str(name)?; - let feature_value = raw_from_str(name)?; + let feature_name = raw_from_str(name); + let feature_value = raw_from_str(value); vmb_result(unsafe { VmbFeatureStringSet( handle.as_raw(), - feature_name.as_ptr(), - feature_value.as_ptr(), + feature_name, + feature_value, ) })?; @@ -962,13 +962,13 @@ pub fn feature_string_set(handle: &CameraHandle, name: &str, value: &str) -> Vmb } pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut max_length: u32 = 0 as VmbUint32_t; vmb_result(unsafe { VmbFeatureStringMaxLengthQuery( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut max_length, ) })?; @@ -977,13 +977,13 @@ pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> Vmb } pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut value = false as VmbBool_t; vmb_result( unsafe { VmbFeatureBoolGet( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut value, ) })?; @@ -992,7 +992,7 @@ pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { } pub fn feature_bool_set(handle: &CameraHandle, name: &str, value: bool) -> VmbResult<()> { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let feature_value = match value { true => VmbBoolVal_VmbBoolTrue, false => VmbBoolVal_VmbBoolFalse, @@ -1001,7 +1001,7 @@ pub fn feature_bool_set(handle: &CameraHandle, name: &str, value: bool) -> VmbRe vmb_result( unsafe { VmbFeatureBoolSet( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &value, ) })?; @@ -1014,12 +1014,12 @@ pub fn feature_bool_set(handle: &CameraHandle, name: &str, value: bool) -> VmbRe // --------------------------------------------------------------- pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<()> { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); vmb_result(unsafe { VmbFeatureCommandRun( handle.as_raw(), - feature_name.as_ptr(), + feature_name, ) })?; @@ -1027,13 +1027,13 @@ pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<()> { } pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult { - let feature_name = raw_from_str(name)?; + let feature_name = raw_from_str(name); let mut is_done: bool = false as VmbBool_t; vmb_result(unsafe { VmbFeatureCommandIsDone( handle.as_raw(), - feature_name.as_ptr(), + feature_name, &mut is_done, ) })?; @@ -1190,13 +1190,13 @@ pub struct PersistSettings { pub fn camera_settings_save(handle: &CameraHandle, filepath: &str, settings: PersistSettings) -> VmbResult<()> { // TODO: determine if this is how filepath is to be calculated // determine how to calculate size_of_settings in bytes for C instead of rust - let filepath = raw_from_str(filepath)?; + let filepath = raw_from_str(filepath); let size_of_settings: u32 = 0; vmb_result(unsafe { VmbSettingsSave( handle.as_raw(), - filepath.as_ptr(), + filepath, settings, size_of_settings, ) @@ -1206,13 +1206,13 @@ pub fn camera_settings_save(handle: &CameraHandle, filepath: &str, settings: Per } pub fn camera_settings_load(handle: &CameraHandle, filepath: &str, settings: PersistSettings) -> VmbResult<()> { - let filepath = raw_from_str(filepath)?; + let filepath = raw_from_str(filepath); let size_of_settings: u32 = 0; vmb_result(unsafe { VmbSettingsLoad( handle.as_raw(), - filepath.as_ptr(), + filepath, settings, size_of_settings ) diff --git a/src/utils.rs b/src/utils.rs index 811114b..0c3a0d7 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -6,10 +6,7 @@ pub fn string_from_raw(raw: *const ffi::c_char) -> Result { unsafe { Ok(ffi::CStr::from_ptr(raw).to_str()?.to_string()) } } -// pub fn raw_from_str(string: &str) -> *const ffi::c_char { string.as_ptr().cast() } -pub fn raw_from_str(string: &str) -> Result { - CString::new(string) // returns Result -} +pub fn raw_from_str(string: &str) -> *const ffi::c_char { string.as_ptr().cast() } pub fn vmb_result(err: VmbError_t) -> Result<(), VmbError>{ match VmbError::from_repr(err) { From 3949762ef75ec24fb84e1393fa87f72ca289881b Mon Sep 17 00:00:00 2001 From: Ben B Date: Thu, 26 Feb 2026 18:33:52 -0700 Subject: [PATCH 34/34] compiler issues --- src/api.rs | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/src/api.rs b/src/api.rs index b4f0402..290c387 100644 --- a/src/api.rs +++ b/src/api.rs @@ -544,7 +544,7 @@ fn convert_feature_info_safe(camera: mem::MaybeUninit,) -> Vmb pub fn feature_info_query(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name); - let feature_info_raw = mem::MaybeUninit::::uninit(); + let mut feature_info_raw = mem::MaybeUninit::::uninit(); let info_size = mem::size_of::() as VmbUint32_t; vmb_result(unsafe { @@ -679,14 +679,14 @@ pub fn feature_int_increment_query(handle: &CameraHandle, name: &str, value: i64 pub fn feature_int_valid_value_set_query(handle: &CameraHandle, name: &str) -> VmbResult> { let feature_name = raw_from_str(name); let mut set_size: u32 = 0; - let mut buffer_size: u32 = 0; + let buffer_size: u32 = 0; // first call to identify size of value set vmb_result(unsafe { VmbFeatureIntValidValueSetQuery( handle.as_raw(), feature_name, - std::ptr::null(), // pass null pointer to buffer to only return buffer size in buffer_size + std::ptr::null_mut(), // pass null pointer to buffer to only return buffer size in buffer_size buffer_size, &mut set_size, ) @@ -791,7 +791,7 @@ pub fn feature_enum_get(handle: &CameraHandle, name: &str) -> VmbResult return Err(VmbError::NoData) } - let value = string_from_raw(value)?; + let value = string_from_raw(value).map_err(|_| VmbError::InternalFault)?; Ok(value) } @@ -800,10 +800,10 @@ pub fn feature_enum_set(handle: &CameraHandle, name: &str, value: &str) -> VmbRe let feature_value = raw_from_str(value); vmb_result(unsafe { - VmbFeatureBoolSet( + VmbFeatureEnumSet( handle.as_raw(), feature_name, - &feature_value, + feature_value, ) })?; @@ -820,7 +820,7 @@ pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult< VmbFeatureEnumRangeQuery( handle.as_raw(), feature_name, - std::ptr::null(), // pass a null pointer to query size + std::ptr::null_mut(), // pass a null pointer to query size 0, &mut num_found, ) @@ -850,7 +850,7 @@ pub fn feature_enum_range_query(handle: &CameraHandle, name: &str) -> VmbResult< continue; } - let value = string_from_raw(ptr)?; + let value = string_from_raw(ptr).map_err(|_| VmbError::InternalFault)?; values.push(value); } @@ -871,7 +871,7 @@ pub fn feature_enum_is_available(handle: &CameraHandle, name: &str, value: &str) ) })?; - Ok(is_available) + Ok(is_available != 0) } pub fn feature_enum_as_int(handle: &CameraHandle, name: &str, value: &str) -> VmbResult { @@ -900,12 +900,12 @@ pub fn feature_enum_as_string(handle: &CameraHandle, name: &str, int_value: i64) handle.as_raw(), feature_name, int_value as VmbInt64_t, - &mut string_value, + string_value, ) })?; - let value = string_from_raw(string_value)?; - Ok(value.to_string_lossy().into_owned()) + let value = string_from_raw(string_value).map_err(|_| VmbError::InternalFault)?; + Ok(value) } pub fn feature_enum_entry_get(handle: &CameraHandle, feature_name: &str, entry_name: &str) -> VmbResult { @@ -942,8 +942,8 @@ pub fn feature_string_get(handle: &CameraHandle, name: &str) -> VmbResult VmbResult<()> { @@ -966,7 +966,7 @@ pub fn feature_string_max_length_query(handle: &CameraHandle, name: &str) -> Vmb let mut max_length: u32 = 0 as VmbUint32_t; vmb_result(unsafe { - VmbFeatureStringMaxLengthQuery( + VmbFeatureStringMaxlengthQuery( handle.as_raw(), feature_name, &mut max_length, @@ -988,7 +988,7 @@ pub fn feature_bool_get(handle: &CameraHandle, name: &str) -> VmbResult { ) })?; - Ok(value) + Ok(value != 0) } pub fn feature_bool_set(handle: &CameraHandle, name: &str, value: bool) -> VmbResult<()> { @@ -1002,7 +1002,7 @@ pub fn feature_bool_set(handle: &CameraHandle, name: &str, value: bool) -> VmbRe VmbFeatureBoolSet( handle.as_raw(), feature_name, - &value, + &feature_value, ) })?; @@ -1028,13 +1028,13 @@ pub fn feature_command_run(handle: &CameraHandle, name: &str) -> VmbResult<()> { pub fn feature_command_is_done(handle: &CameraHandle, name: &str) -> VmbResult { let feature_name = raw_from_str(name); - let mut is_done: bool = false as VmbBool_t; + let mut is_done: VmbBool_t = VmbBoolVal_VmbBoolFalse; vmb_result(unsafe { VmbFeatureCommandIsDone( handle.as_raw(), feature_name, - &mut is_done, + &mut is_done as *mut VmbBool_t, ) })?; Ok(is_done)