Skip to content

Expanded support for Libcamera Controls (ControlInfoMap and ControlInfo) #46

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 15 commits into from
Jul 8, 2025
Merged

Expanded support for Libcamera Controls (ControlInfoMap and ControlInfo) #46

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
15 commits
Select commit Hold shift + click to select a range
46ac292
Add support for iterating and getting information from ControlInfoMap
SoZ0 Dec 8, 2024
eff5ee9
cargo fmt
SoZ0 Dec 8, 2024
8e5825c
added method to get name and id from ControlId and PropertyId enums d…
SoZ0 Dec 8, 2024
ad95922
Forgot values method for ControlInfo, now added
SoZ0 Dec 8, 2024
c052b1d
fixed issue with ControlInfo.values() not properly decoding into Rust…
SoZ0 Dec 8, 2024
9295c96
Improved error handling
SoZ0 Dec 10, 2024
200d8bf
rust fmt
SoZ0 Dec 10, 2024
1a26183
yes
SoZ0 Apr 13, 2025
46188bb
fixes for merging into main
SoZ0 May 31, 2025
7cf3573
Merge remote-tracking branch 'upstream/main'
SoZ0 May 31, 2025
a08bd85
Corrected lifetimes
SoZ0 May 31, 2025
ec4916d
Missing control values implamented
SoZ0 May 31, 2025
e9b6c2b
cargo format and clippy - ran a short test and should be ready to merge
SoZ0 May 31, 2025
cedb267
updated examples and new examples. impl debug for ControlInfoMap and …
SoZ0 Jun 3, 2025
c5830dd
regnerate and example fix
SoZ0 Jun 3, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
33 changes: 30 additions & 3 deletions libcamera-meta/src/bin/generate_from_git.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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() {
Expand Down Expand Up @@ -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}};
Expand All @@ -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));
Expand Down
146 changes: 142 additions & 4 deletions libcamera-sys/c_api/controls.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Comment on lines -8 to +28
Copy link
Collaborator

@fishrockz fishrockz Jul 3, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Is this changing the public api of libcamera-sys ? I worry this might need a version bump if it is.

Copy link
Contributor Author

@SoZ0 SoZ0 Jul 4, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Im not 100% sure I understand what you are referring to.

There should be no changes that remove or change functionality for the libcamera-sys only add new methods from structs that were missing

many of the changes in here and this section highlighted in specific is adding the missing functions and or giving a more verbose function signature as some of the methods else would share a very similar name or even have the exact name.

I cant recall exactly which functions it was but a few function names were simply too broad not allowing exposing the other libcamera functions with a convenient naming scheme.

If adding in the new functions and or changing the underlying naming of functions is enough to constitute the public api being changed then yes it has changed and will need a version bump. To be honest with the scale and broad impact of changes being made to me it only makes sense.

Copy link
Collaborator

@fishrockz fishrockz Jul 6, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

So the api for libcamera_control_name seems to change.

const char *libcamera_control_name(enum libcamera_control_id id) {

changes to

const char *libcamera_control_name(libcamera_control_id_t *control){

Which if this makes its way to our rust api/abi will be a braking change for senver rules.

Copy link
Collaborator

@fishrockz fishrockz Jul 6, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

yer so i had a little play and

And this function makes its way into the public api via the bindings

./target/debug/build/libcamera-sys-*/out/bindings.rs:

 pub fn libcamera_control_name(control: *mut libcamera_control_id_t) -> *const ::std::os::raw::c_char;

to

pub fn libcamera_control_name(id: libcamera_control_id::Type) -> *const ::std::os::raw::c_char;

and it can be accessed by

use libcamera_sys::libcamera_control_name;

I would suggest that we re ajust the cpp file so the changes are purely additive

Or we need to bump the version in this MR.

index efef19c..1672f13 100644
--- a/libcamera-sys/Cargo.toml
+++ b/libcamera-sys/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "libcamera-sys"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 description = "Low-level unsafe bindings to libcamera"
 documentation = "https://docs.rs/libcamera-sys"

Copy link
Contributor Author

@SoZ0 SoZ0 Jul 7, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I could refactor it to have them all use:
enum libcamera_control_id_enum
and have the c++ api internally call:
const libcamera_control_id_t *libcamera_control_from_id(enum libcamera_control_id_enum id)
to acces the needed methods. I'm just not sure if this is the right way to go about this.

The current way its laid out in the PR follows how the other structs are handled where it uses the direct reference instead of getting a new one each time.

OR

We could approach it like this to all the effected methods:

const char *libcamera_control_name(enum libcamera_control_id id)
const char *libcamera_control_id_name(libcamera_control_id_t *control)

it just seems weird and a bit redundant to have it like this to me, using the struct pointer seems like the way the api should move towards when working with the controls.

I personally feel like a version bump should be the way to go, but I am willing to refactor the code if a version bump would rather be avoided

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();
Expand Down Expand Up @@ -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;
}


}
52 changes: 47 additions & 5 deletions libcamera-sys/c_api/controls.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand All @@ -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();
Expand All @@ -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
}
Expand Down
20 changes: 20 additions & 0 deletions libcamera/examples/cameras_iter.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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());
}
}
1 change: 1 addition & 0 deletions libcamera/examples/list_cameras.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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();
Expand Down
38 changes: 38 additions & 0 deletions libcamera/examples/read_control.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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);
}
}
}
}
}
Loading