Expanded support for Libcamera Controls (ControlInfoMap and ControlInfo)

libcamera-meta/src/bin/generate_from_git.rs

@@ -308,6 +308,35 @@ mod generate_rust {
         }
         out += "}\n";
 
+        let ffi_binding = match ty {
+            ControlsType::Control => "libcamera_control_name_from_id",
+            ControlsType::Property => "libcamera_property_name_by_id",
+        };
+
+        out += &format!("impl {} {{\n", name);
+        out += r#"
+            fn id(&self) -> u32 {
+                *self as u32
+            }
+            "#;
+        out += "\n";
+        out += r#"
+            pub fn name(&self) -> String {
+                unsafe {"#;
+        out += &format!("       let c_str = {}(self.id());\n", ffi_binding);
+        out += r#"
+                    if c_str.is_null() {
+                        // Handle null pointer as empty strings
+                        return "".into();
+                    }
+                    // Convert the C string to a Rust &str
+                    CStr::from_ptr(c_str).to_str().unwrap().into()
+                }
+            }
+        "#;
+
+        out += "}\n";
+
         let mut dyn_variants = String::new();
 
         for ctrl in controls.iter() {
@@ -429,7 +458,7 @@ mod generate_rust {
 
     pub fn generate_controls_file(controls: &[Control], ty: ControlsType) -> String {
         let header = r#"
-                use std::ops::{{Deref, DerefMut}};
+                use std::{ffi::CStr, ops::{{Deref, DerefMut}}};
                 use num_enum::{{IntoPrimitive, TryFromPrimitive}};
                 #[allow(unused_imports)]
                 use crate::control::{{Control, Property, ControlEntry, DynControlEntry}};
@@ -438,8 +467,6 @@ mod generate_rust {
                 use crate::geometry::{{Rectangle, Point, Size}};
                 #[allow(unused_imports)]
                 use libcamera_sys::*;
-
-
                 "#;
 
         let file = format!("{header}\n{}", generate_controls(controls, ty));

libcamera-sys/c_api/controls.cpp

@@ -5,31 +5,51 @@
 
 extern "C" {
 
-const char *libcamera_control_name(enum libcamera_control_id id) {
+enum libcamera_control_id_enum libcamera_control_id(libcamera_control_id_t *control){
+    return (enum libcamera_control_id_enum)control->id();
+}
+
+const char *libcamera_control_name(libcamera_control_id_t *control){
+    return control->name().c_str();
+}
+
+enum libcamera_control_type libcamera_control_type(libcamera_control_id_t *control) {
+    return (enum libcamera_control_type) control->type();
+}
+
+const libcamera_control_id_t *libcamera_control_from_id(enum libcamera_control_id_enum id){
+     auto it = libcamera::controls::controls.find(id);
+    if (it != libcamera::controls::controls.end())
+        return it->second;
+    else
+        return nullptr;
+}
+
+const char *libcamera_control_name_from_id(enum libcamera_control_id_enum id) {
     auto it = libcamera::controls::controls.find(id);
     if (it != libcamera::controls::controls.end())
         return it->second->name().c_str();
     else
         return nullptr;
 }
 
-enum libcamera_control_type libcamera_control_type(enum libcamera_control_id id) {
+enum libcamera_control_type libcamera_control_type_from_id(enum libcamera_control_id_enum id) {
     auto it = libcamera::controls::controls.find(id);
     if (it != libcamera::controls::controls.end())
         return (enum libcamera_control_type)it->second->type();
     else
         return LIBCAMERA_CONTROL_TYPE_NONE;
 }
 
-const char *libcamera_property_name(enum libcamera_property_id id) {
+const char *libcamera_property_name_by_id(enum libcamera_property_id id) {
     auto it = libcamera::properties::properties.find(id);
     if (it != libcamera::properties::properties.end())
         return it->second->name().c_str();
     else
         return nullptr;
 }
 
-enum libcamera_control_type libcamera_property_type(enum libcamera_property_id id) {
+enum libcamera_control_type libcamera_property_type_by_id(enum libcamera_property_id id) {
     auto it = libcamera::properties::properties.find(id);
     if (it != libcamera::properties::properties.end())
         return (enum libcamera_control_type)it->second->type();
@@ -120,4 +140,122 @@ void libcamera_control_value_set(libcamera_control_value_t *val, enum libcamera_
     memcpy(storage.data(), data, storage.size());
 }
 
+size_t libcamera_control_value_size() {
+     return sizeof(libcamera::ControlValue);
+}
+
+const libcamera_control_value_t *libcamera_control_info_max(libcamera_control_info_t *val){
+    return &val->max();
+}
+const libcamera_control_value_t *libcamera_control_info_min(libcamera_control_info_t *val){
+    return &val->min();
+}
+const libcamera_control_value_t *libcamera_control_info_def(libcamera_control_info_t *val){
+    return &val->def();
+}
+
+const libcamera_control_value_t* libcamera_control_info_values(const libcamera_control_info_t* info, size_t* size)
+{
+    if (!info || !size) return nullptr;
+    const std::vector<libcamera::ControlValue>& values = info->values();
+    *size = values.size();
+    return reinterpret_cast<const libcamera_control_value_t*>(values.data());
+}
+
+bool libcamera_control_id_map_add(libcamera_control_id_map_t *idmap, unsigned int key, const libcamera_control_id_t *control_id)
+{
+	if (!idmap || !control_id)
+		return false;
+
+	(*idmap)[key] = control_id;
+	return true;
+}
+
+const libcamera_control_id_t *libcamera_control_id_map_get(libcamera_control_id_map_t *idmap, unsigned int key)
+{
+	if (!idmap)
+		return nullptr;
+
+	auto it = idmap->find(key);
+	if (it != idmap->end())
+		return it->second;
+	return nullptr;
+}
+
+
+const libcamera_control_info_t *libcamera_control_info_map_at(libcamera_control_info_map_t *map, unsigned int key)
+{
+	if (!map)
+		return nullptr;
+
+	try {
+		return &map->at(key);
+	} catch (const std::out_of_range &) {
+		return nullptr;
+	}
+}
+
+size_t libcamera_control_info_map_count(const libcamera_control_info_map_t *map, unsigned int key)
+{
+	if (!map)
+		return 0;
+
+	return map->count(key);
+}
+
+size_t libcamera_control_info_map_size(const libcamera_control_info_map_t *map)
+{
+	if (!map)
+		return 0;
+
+	return map->size();
+}
+
+const libcamera_control_info_t *libcamera_control_info_map_find(const libcamera_control_info_map_t *map, unsigned int key)
+{
+	if (!map)
+		return nullptr;
+
+	auto it = map->find(key);
+	if (it != map->end()) {
+		return &it->second;
+	}
+
+	return nullptr;
+}
+
+
+libcamera_control_info_map_iter_t* libcamera_control_info_map_iter_create(const libcamera_control_info_map_t* map) {
+    if (!map) return nullptr;
+    libcamera_control_info_map_iter_t* iter = new libcamera_control_info_map_iter_t();
+    iter->current = map->begin();
+    iter->end = map->end();
+    return iter;
+}
+
+bool libcamera_control_info_map_iter_has_next(const libcamera_control_info_map_iter_t* iter) {
+    if (!iter) return false;
+    return iter->current != iter->end;
+}
+
+unsigned int libcamera_control_info_map_iter_key(const libcamera_control_info_map_iter_t* iter) {
+    if (!iter || iter->current == iter->end) return 0;
+    return iter->current->first->id();
+}
+
+const libcamera_control_info_t* libcamera_control_info_map_iter_value(const libcamera_control_info_map_iter_t* iter) {
+    if (!iter || iter->current == iter->end) return nullptr;
+    return &(iter->current->second);
+}
+
+void libcamera_control_info_map_iter_next(libcamera_control_info_map_iter_t* iter) {
+    if (!iter || iter->current == iter->end) return;
+    ++(iter->current);
+}
+
+void libcamera_control_info_map_iter_destroy(libcamera_control_info_map_iter_t* iter) {
+    delete iter;
+}
+
+
 }

libcamera-sys/c_api/controls.h

@@ -13,20 +13,35 @@ struct libcamera_control_list_iter {
 	libcamera::ControlList::iterator it;
 };
 
+struct libcamera_control_info_map_iter {
+    libcamera::ControlInfoMap::const_iterator current;
+    libcamera::ControlInfoMap::const_iterator end;
+};
+
+
 typedef libcamera::ControlValue libcamera_control_value_t;
 typedef libcamera::ControlList libcamera_control_list_t;
 typedef struct libcamera_control_list_iter libcamera_control_list_iter_t;
+typedef struct libcamera_control_info_map_iter libcamera_control_info_map_iter_t;
 typedef libcamera::ControlInfoMap libcamera_control_info_map_t;
+typedef libcamera::ControlIdMap libcamera_control_id_map_t;
+typedef libcamera::ControlId libcamera_control_id_t;
+typedef libcamera::ControlInfo libcamera_control_info_t;
 
 extern "C" {
 #else
 typedef struct libcamera_control_value libcamera_control_value_t;
 typedef struct libcamera_control_list libcamera_control_list_t;
 typedef struct libcamera_control_list_iter libcamera_control_list_iter_t;
+typedef struct libcamera_control_info_map_iter libcamera_control_info_map_iter_t;
 typedef struct libcamera_control_info_map libcamera_control_info_map_t;
+typedef struct libcamera_control_id libcamera_control_id_t;
+typedef struct libcamera_control_info libcamera_control_info_t;
+typedef struct libcamera_control_id_map libcamera_control_id_map_t;
+
 #endif
 
-enum libcamera_control_id { libcamera_control_id_DUMMY };
+enum libcamera_control_id_enum { libcamera_control_id_DUMMY };
 enum libcamera_property_id { libcamera_property_id_DUMMY };
 
 enum libcamera_control_type {
@@ -45,12 +60,16 @@ enum libcamera_control_type {
 };
 
 // --- libcamera_control_id ---
-const char *libcamera_control_name(enum libcamera_control_id id);
-enum libcamera_control_type libcamera_control_type(enum libcamera_control_id id);
+const libcamera_control_id_t *libcamera_control_from_id(enum libcamera_control_id_enum id);
+const char *libcamera_control_name_from_id(enum libcamera_control_id_enum id);
+enum libcamera_control_type libcamera_control_type_from_id(enum libcamera_control_id_enum id);
 
+enum libcamera_control_id_enum libcamera_control_id(libcamera_control_id_t *control);
+const char *libcamera_control_name(libcamera_control_id_t *control);
+enum libcamera_control_type libcamera_control_type(libcamera_control_id_t *control);
 // --- libcamera_property_id ---
-const char *libcamera_property_name(enum libcamera_property_id id);
-enum libcamera_control_type libcamera_property_type(enum libcamera_property_id id);
+const char *libcamera_property_name_by_id(enum libcamera_property_id id);
+enum libcamera_control_type libcamera_property_type_by_id(enum libcamera_property_id id);
 
 // --- libcamera_control_list_t ---
 libcamera_control_list_t *libcamera_control_list_create();
@@ -75,6 +94,29 @@ bool libcamera_control_value_is_array(const libcamera_control_value_t *val);
 size_t libcamera_control_value_num_elements(const libcamera_control_value_t *val);
 const void *libcamera_control_value_get(const libcamera_control_value_t *val);
 void libcamera_control_value_set(libcamera_control_value_t *val, enum libcamera_control_type type, const void *data, bool is_array, size_t num_elements);
+size_t libcamera_control_value_size();
+// --- libcamera_control_info_t ---
+const libcamera_control_value_t *libcamera_control_info_max(libcamera_control_info_t *val);
+const libcamera_control_value_t *libcamera_control_info_min(libcamera_control_info_t *val);
+const libcamera_control_value_t *libcamera_control_info_def(libcamera_control_info_t *val);
+const libcamera_control_value_t* libcamera_control_info_values(const libcamera_control_info_t* info, size_t* size);
+// --- libcamera_control_id_map ---
+bool libcamera_control_id_map_add(libcamera_control_id_map_t *idmap, unsigned int key, const libcamera_control_id_t *control_id);
+const libcamera_control_id_t *libcamera_control_id_map_get(libcamera_control_id_map_t *idmap, unsigned int key);
+
+// --- libcamera_control_info_map ---
+const libcamera_control_info_t *libcamera_control_info_map_at(libcamera_control_info_map_t *map, unsigned int key);
+size_t libcamera_control_info_map_size(const libcamera_control_info_map_t *map);
+size_t libcamera_control_info_map_count(const libcamera_control_info_map_t *map, unsigned int key);
+const libcamera_control_info_t * libcamera_control_info_map_find(const libcamera_control_info_map_t *map, unsigned int key);
+
+// --- libcamera_control_info_map_iter_t ---
+libcamera_control_info_map_iter_t* libcamera_control_info_map_iter_create(const libcamera_control_info_map_t* map);
+bool libcamera_control_info_map_iter_has_next(const libcamera_control_info_map_iter_t* iter);
+unsigned int libcamera_control_info_map_iter_key(const libcamera_control_info_map_iter_t* iter);
+const libcamera_control_info_t* libcamera_control_info_map_iter_value(const libcamera_control_info_map_iter_t* iter);
+void libcamera_control_info_map_iter_next(libcamera_control_info_map_iter_t* iter);
+void libcamera_control_info_map_iter_destroy(libcamera_control_info_map_iter_t* iter);
 
 #ifdef __cplusplus
 }

libcamera/examples/cameras_iter.rs

@@ -0,0 +1,20 @@
+use libcamera::{camera_manager::CameraManager, logging::LoggingLevel, stream::StreamRole};
+
+fn main() {
+    let mgr = CameraManager::new().unwrap();
+
+    mgr.log_set_level("Camera", LoggingLevel::Error);
+
+    let cameras = mgr.cameras();
+
+    for cam in cameras.iter() {
+        println!("ID: {}", cam.id());
+
+        println!("Properties: {:#?}", cam.properties());
+        println!("Controls: {:#?}", cam.controls());
+
+        let config = cam.generate_configuration(&[StreamRole::ViewFinder]).unwrap();
+        let view_finder_cfg = config.get(0).unwrap();
+        println!("Available formats: {:#?}", view_finder_cfg.formats());
+    }
+}

libcamera/examples/list_cameras.rs

@@ -13,6 +13,7 @@ fn main() {
         println!("ID: {}", cam.id());
 
         println!("Properties: {:#?}", cam.properties());
+        println!("Controls: {:#?}", cam.controls());
 
         let config = cam.generate_configuration(&[StreamRole::ViewFinder]).unwrap();
         let view_finder_cfg = config.get(0).unwrap();

libcamera/examples/read_control.rs

@@ -0,0 +1,38 @@
+use libcamera::{camera_manager::CameraManager, controls::ControlId, logging::LoggingLevel};
+
+fn main() {
+    let mgr = CameraManager::new().unwrap();
+
+    mgr.log_set_level("Camera", LoggingLevel::Error);
+
+    let cameras = mgr.cameras();
+
+    //Grab the first camera, if one exists
+    for cam in cameras.iter().take(1) {
+        println!("ID: {}", cam.id());
+
+        //Read the first ControlInfo
+        for (id, control_info) in cam.controls().into_iter().take(1) {
+            //Attempt to get ControlID
+            match ControlId::try_from(id) {
+                Ok(id) => println!("Control Id {:?} - {:?}", id as u32, id),
+                Err(_) => println!("Control Id {:?} - UNKOWN", id),
+            }
+
+            println!("Control Max: {:?}", control_info.max());
+            println!("Control Min: {:?}", control_info.min());
+            println!("Control Defualt: {:?}", control_info.def());
+
+            let values = control_info.values();
+
+            //Some controls only support specific values within their ranges.
+            //this will display those possible values if they exist
+            if values.len() > 0 {
+                println!("Supported Values:");
+                for value in values {
+                    println!("{:?}", value);
+                }
+            }
+        }
+    }
+}