use serde::{Deserialize, Serialize};
use crate::error::IronError;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CameraConnection {
Internal,
USB,
Network,
CSI,
Virtual,
Unknown,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CameraCapability {
VideoCapture,
StillCapture,
Streaming,
HardwareEncoding,
Infrared,
DepthSensing,
Autofocus,
PTZ,
Microphone,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CameraInfo {
pub name: String,
pub connection: CameraConnection,
pub device_path: String,
pub driver: String,
pub vendor: String,
pub max_width: u32,
pub max_height: u32,
pub formats: Vec<String>,
pub capabilities: Vec<CameraCapability>,
pub is_active: Option<bool>,
pub index: u32,
}
impl CameraInfo {
pub fn resolution(&self) -> String {
if self.max_width > 0 && self.max_height > 0 {
format!("{}x{}", self.max_width, self.max_height)
} else {
"unknown".into()
}
}
pub fn megapixels(&self) -> f64 {
(self.max_width as f64 * self.max_height as f64) / 1_000_000.0
}
}
pub struct CameraMonitor {
cameras: Vec<CameraInfo>,
}
impl CameraMonitor {
pub fn new() -> Result<Self, IronError> {
let mut monitor = Self {
cameras: Vec::new(),
};
monitor.refresh()?;
Ok(monitor)
}
pub fn refresh(&mut self) -> Result<(), IronError> {
self.cameras.clear();
#[cfg(target_os = "linux")]
self.refresh_linux()?;
#[cfg(target_os = "windows")]
self.refresh_windows()?;
#[cfg(target_os = "macos")]
self.refresh_macos()?;
Ok(())
}
pub fn cameras(&self) -> &[CameraInfo] {
&self.cameras
}
pub fn count(&self) -> usize {
self.cameras.len()
}
#[cfg(target_os = "linux")]
fn refresh_linux(&mut self) -> Result<(), IronError> {
let v4l_path = std::path::Path::new("/sys/class/video4linux");
if !v4l_path.exists() {
return Ok(());
}
let entries = std::fs::read_dir(v4l_path)
.map_err(|e| IronError::System(format!("cannot read /sys/class/video4linux: {e}")))?;
for entry in entries.flatten() {
let dev_name = entry.file_name().to_string_lossy().to_string();
if !dev_name.starts_with("video") {
continue;
}
let index: u32 = dev_name
.strip_prefix("video")
.and_then(|s| s.parse().ok())
.unwrap_or(0);
let base = entry.path();
let name = std::fs::read_to_string(base.join("name"))
.unwrap_or_default()
.trim()
.to_string();
let uevent = std::fs::read_to_string(base.join("uevent")).unwrap_or_default();
if uevent.contains("DEVTYPE=video4linux-subdev") {
continue;
}
let driver = Self::read_sysfs_link_name(&base.join("device/driver"));
let dev_path_str = base.to_string_lossy().to_string();
let connection = if dev_path_str.contains("usb") {
CameraConnection::USB
} else if dev_path_str.contains("platform") || dev_path_str.contains("csi") {
CameraConnection::CSI
} else if name.to_lowercase().contains("virtual") || name.to_lowercase().contains("obs")
{
CameraConnection::Virtual
} else if dev_path_str.contains("pci") {
CameraConnection::Internal
} else {
CameraConnection::Unknown
};
let mut capabilities = vec![CameraCapability::VideoCapture];
let dev_file = format!("/dev/{}", dev_name);
let formats = Self::read_v4l2_formats(&dev_file);
if formats.iter().any(|f| f == "H264" || f == "HEVC") {
capabilities.push(CameraCapability::HardwareEncoding);
}
if formats
.iter()
.any(|f| f.contains("Z16") || f.contains("INZI"))
{
capabilities.push(CameraCapability::DepthSensing);
}
if name.to_lowercase().contains("ir ") || name.to_lowercase().contains("infrared") {
capabilities.push(CameraCapability::Infrared);
}
let vendor = Self::read_usb_vendor(&base);
self.cameras.push(CameraInfo {
name: if name.is_empty() {
dev_name.clone()
} else {
name
},
connection,
device_path: dev_file,
driver,
vendor,
max_width: 0, max_height: 0,
formats,
capabilities,
is_active: Some(Self::is_device_busy(&format!("/dev/{}", dev_name))),
index,
});
}
Ok(())
}
#[cfg(target_os = "linux")]
fn read_sysfs_link_name(path: &std::path::Path) -> String {
std::fs::read_link(path)
.ok()
.and_then(|p| p.file_name().map(|n| n.to_string_lossy().to_string()))
.unwrap_or_default()
}
#[cfg(target_os = "linux")]
fn read_v4l2_formats(_dev: &str) -> Vec<String> {
vec!["YUYV".into(), "MJPG".into()]
}
#[cfg(target_os = "linux")]
fn read_usb_vendor(base: &std::path::Path) -> String {
let mut path = base.to_path_buf();
for _ in 0..5 {
let vendor_path = path.join("manufacturer");
if let Ok(v) = std::fs::read_to_string(&vendor_path) {
return v.trim().to_string();
}
if !path.pop() {
break;
}
}
String::new()
}
#[cfg(target_os = "linux")]
fn is_device_busy(dev: &str) -> bool {
use std::fs::OpenOptions;
match OpenOptions::new().read(true).open(dev) {
Ok(_) => false,
Err(e) => e.raw_os_error() == Some(16), }
}
#[cfg(target_os = "windows")]
fn camera_in_use_windows() -> Option<bool> {
use winreg::enums::{HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE};
use winreg::RegKey;
const STORE: &str = concat!(
r"SOFTWARE\Microsoft\Windows\CurrentVersion",
r"\CapabilityAccessManager\ConsentStore\webcam"
);
let mut saw_a_key = false;
let mut any_open = false;
for root in [HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE] {
let Ok(store) = RegKey::predef(root).open_subkey(STORE) else {
continue;
};
let mut groups = vec![store];
if let Ok(np) = groups[0].open_subkey("NonPackaged") {
groups.push(np);
}
for group in &groups {
for name in group.enum_keys().flatten() {
let Ok(app) = group.open_subkey(&name) else {
continue;
};
let Ok(stop) = app.get_value::<u64, _>("LastUsedTimeStop") else {
continue;
};
saw_a_key = true;
if stop == 0 {
any_open = true;
}
}
}
}
match (saw_a_key, any_open) {
(true, false) => Some(false),
(true, true) => None,
(false, _) => None,
}
}
#[cfg(target_os = "windows")]
fn refresh_windows(&mut self) -> Result<(), IronError> {
let in_use = Self::camera_in_use_windows();
let json = crate::core::command::capture_json(
"powershell",
&["-NoProfile", "-Command",
"Get-CimInstance Win32_PnPEntity | Where-Object { $_.PNPClass -eq 'Camera' } | Select-Object Name, Manufacturer, DeviceID, Status, PNPClass, Service | ConvertTo-Json -Compress"],
)?;
let Some(val) = json else {
return Ok(());
};
let items = crate::core::command::json_items(&val);
for (i, item) in items.iter().enumerate() {
let name = item["Name"]
.as_str()
.unwrap_or("Unknown Camera")
.to_string();
let vendor = item["Manufacturer"].as_str().unwrap_or("").to_string();
let device_id = item["DeviceID"].as_str().unwrap_or("").to_string();
let lower = device_id.to_lowercase();
let connection = if lower.contains("usb") {
CameraConnection::USB
} else if lower.contains("pci") {
CameraConnection::Internal
} else if name.to_lowercase().contains("virtual") || name.to_lowercase().contains("obs")
{
CameraConnection::Virtual
} else {
CameraConnection::Internal
};
self.cameras.push(CameraInfo {
name,
connection,
device_path: device_id,
driver: item["Service"].as_str().unwrap_or("").to_string(),
vendor,
max_width: 0,
max_height: 0,
formats: Vec::new(),
capabilities: vec![CameraCapability::VideoCapture],
is_active: in_use,
index: i as u32,
});
}
Ok(())
}
#[cfg(target_os = "macos")]
fn refresh_macos(&mut self) -> Result<(), IronError> {
let text = crate::core::command::capture(
"system_profiler",
&["SPCameraDataType", "-detailLevel", "full"],
)?;
let mut name = String::new();
let mut model_id = String::new();
let mut unique_id = String::new();
let mut index: u32 = 0;
for line in text.lines() {
let trimmed = line.trim();
if trimmed.ends_with(':') && !trimmed.starts_with("Camera") && !trimmed.is_empty() {
if !name.is_empty() {
let connection = if model_id.to_lowercase().contains("usb") {
CameraConnection::USB
} else if model_id.to_lowercase().contains("virtual") {
CameraConnection::Virtual
} else {
CameraConnection::Internal
};
self.cameras.push(CameraInfo {
name: name.clone(),
connection,
device_path: unique_id.clone(),
driver: String::new(),
vendor: "Apple".into(),
max_width: 0,
max_height: 0,
formats: Vec::new(),
capabilities: vec![
CameraCapability::VideoCapture,
CameraCapability::Autofocus,
],
is_active: None,
index,
});
index += 1;
}
name = trimmed.trim_end_matches(':').to_string();
model_id.clear();
unique_id.clear();
} else if let Some(v) = trimmed.strip_prefix("Model ID:") {
model_id = v.trim().to_string();
} else if let Some(v) = trimmed.strip_prefix("Unique ID:") {
unique_id = v.trim().to_string();
}
}
if !name.is_empty() {
self.cameras.push(CameraInfo {
name,
connection: CameraConnection::Internal,
device_path: unique_id,
driver: String::new(),
vendor: "Apple".into(),
max_width: 0,
max_height: 0,
formats: Vec::new(),
capabilities: vec![CameraCapability::VideoCapture],
is_active: None,
index,
});
}
Ok(())
}
}
impl Default for CameraMonitor {
fn default() -> Self {
Self::new().unwrap_or(Self {
cameras: Vec::new(),
})
}
}
impl std::fmt::Display for CameraConnection {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Internal => write!(f, "Internal"),
Self::USB => write!(f, "USB"),
Self::Network => write!(f, "Network"),
Self::CSI => write!(f, "CSI/MIPI"),
Self::Virtual => write!(f, "Virtual"),
Self::Unknown => write!(f, "Unknown"),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_camera_monitor_creation() {
match CameraMonitor::new() {
Ok(_monitor) => {}
Err(e) => {
let why = e.to_string();
assert!(
why.len() > 10,
"enumeration failed without saying why: {why:?}"
);
}
}
}
#[test]
fn test_camera_monitor_default() {
let monitor = CameraMonitor::default();
let _ = monitor.cameras();
}
#[test]
fn test_camera_info_resolution() {
let cam = CameraInfo {
name: "Test".into(),
connection: CameraConnection::USB,
device_path: String::new(),
driver: String::new(),
vendor: String::new(),
max_width: 1920,
max_height: 1080,
formats: Vec::new(),
capabilities: Vec::new(),
is_active: Some(false),
index: 0,
};
assert_eq!(cam.resolution(), "1920x1080");
assert!((cam.megapixels() - 2.0736).abs() < 0.01);
}
#[test]
fn test_camera_serialization() {
let cam = CameraInfo {
name: "Test Camera".into(),
connection: CameraConnection::Internal,
device_path: "/dev/video0".into(),
driver: "uvcvideo".into(),
vendor: "Logitech".into(),
max_width: 1920,
max_height: 1080,
formats: vec!["YUYV".into(), "MJPG".into()],
capabilities: vec![CameraCapability::VideoCapture],
is_active: Some(false),
index: 0,
};
let json = serde_json::to_string(&cam).unwrap();
assert!(json.contains("Test Camera"));
let _: CameraInfo = serde_json::from_str(&json).unwrap();
}
}