mirror of
https://github.com/mofeng-git/One-KVM.git
synced 2026-04-02 18:06:34 +08:00
836 lines
28 KiB
Rust
836 lines
28 KiB
Rust
//! V4L2 device enumeration and capability query
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use std::fs::File;
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::mpsc;
|
|
use std::time::Duration;
|
|
use tracing::{debug, info, warn};
|
|
use v4l2r::bindings::{
|
|
v4l2_bt_timings, v4l2_dv_timings, v4l2_frmivalenum, v4l2_frmsizeenum, v4l2_streamparm,
|
|
V4L2_DV_BT_656_1120,
|
|
};
|
|
use v4l2r::ioctl::{
|
|
self, Capabilities, Capability as V4l2rCapability, FormatIterator, FrmIvalTypes, FrmSizeTypes,
|
|
};
|
|
use v4l2r::nix::errno::Errno;
|
|
use v4l2r::{Format as V4l2rFormat, QueueType};
|
|
|
|
use super::format::{PixelFormat, Resolution};
|
|
use super::is_rk_hdmirx_driver;
|
|
use crate::error::{AppError, Result};
|
|
|
|
const DEVICE_PROBE_TIMEOUT_MS: u64 = 400;
|
|
|
|
/// Information about a video device
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct VideoDeviceInfo {
|
|
/// Device path (e.g., /dev/video0)
|
|
pub path: PathBuf,
|
|
/// Device name from driver
|
|
pub name: String,
|
|
/// Driver name
|
|
pub driver: String,
|
|
/// Bus info
|
|
pub bus_info: String,
|
|
/// Card name
|
|
pub card: String,
|
|
/// Supported pixel formats
|
|
pub formats: Vec<FormatInfo>,
|
|
/// Device capabilities
|
|
pub capabilities: DeviceCapabilities,
|
|
/// Whether this is likely an HDMI capture card
|
|
pub is_capture_card: bool,
|
|
/// Priority score for device selection (higher is better)
|
|
pub priority: u32,
|
|
}
|
|
|
|
/// Information about a supported format
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct FormatInfo {
|
|
/// Pixel format
|
|
pub format: PixelFormat,
|
|
/// Supported resolutions
|
|
pub resolutions: Vec<ResolutionInfo>,
|
|
/// Description from driver
|
|
pub description: String,
|
|
}
|
|
|
|
/// Information about a supported resolution and frame rates
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct ResolutionInfo {
|
|
pub width: u32,
|
|
pub height: u32,
|
|
pub fps: Vec<f64>,
|
|
}
|
|
|
|
impl ResolutionInfo {
|
|
pub fn new(width: u32, height: u32, fps: Vec<f64>) -> Self {
|
|
Self { width, height, fps }
|
|
}
|
|
|
|
pub fn resolution(&self) -> Resolution {
|
|
Resolution::new(self.width, self.height)
|
|
}
|
|
}
|
|
|
|
/// Device capabilities
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
|
pub struct DeviceCapabilities {
|
|
pub video_capture: bool,
|
|
pub video_capture_mplane: bool,
|
|
pub video_output: bool,
|
|
pub streaming: bool,
|
|
pub read_write: bool,
|
|
}
|
|
|
|
/// Wrapper around a V4L2 video device
|
|
pub struct VideoDevice {
|
|
pub path: PathBuf,
|
|
fd: File,
|
|
}
|
|
|
|
impl VideoDevice {
|
|
/// Open a video device by path
|
|
pub fn open(path: impl AsRef<Path>) -> Result<Self> {
|
|
let path = path.as_ref().to_path_buf();
|
|
debug!("Opening video device: {:?}", path);
|
|
|
|
let fd = File::options()
|
|
.read(true)
|
|
.write(true)
|
|
.open(&path)
|
|
.map_err(|e| {
|
|
AppError::VideoError(format!("Failed to open device {:?}: {}", path, e))
|
|
})?;
|
|
|
|
Ok(Self { path, fd })
|
|
}
|
|
|
|
/// Open a video device read-only (for probing/enumeration)
|
|
pub fn open_readonly(path: impl AsRef<Path>) -> Result<Self> {
|
|
let path = path.as_ref().to_path_buf();
|
|
debug!("Opening video device (read-only): {:?}", path);
|
|
|
|
let fd = File::options().read(true).open(&path).map_err(|e| {
|
|
AppError::VideoError(format!("Failed to open device {:?}: {}", path, e))
|
|
})?;
|
|
|
|
Ok(Self { path, fd })
|
|
}
|
|
|
|
/// Get device capabilities
|
|
pub fn capabilities(&self) -> Result<DeviceCapabilities> {
|
|
let caps: V4l2rCapability = ioctl::querycap(&self.fd)
|
|
.map_err(|e| AppError::VideoError(format!("Failed to query capabilities: {}", e)))?;
|
|
let flags = caps.device_caps();
|
|
|
|
Ok(DeviceCapabilities {
|
|
video_capture: flags.contains(Capabilities::VIDEO_CAPTURE),
|
|
video_capture_mplane: flags.contains(Capabilities::VIDEO_CAPTURE_MPLANE),
|
|
video_output: flags.contains(Capabilities::VIDEO_OUTPUT),
|
|
streaming: flags.contains(Capabilities::STREAMING),
|
|
read_write: flags.contains(Capabilities::READWRITE),
|
|
})
|
|
}
|
|
|
|
/// Get detailed device information
|
|
pub fn info(&self) -> Result<VideoDeviceInfo> {
|
|
let caps: V4l2rCapability = ioctl::querycap(&self.fd)
|
|
.map_err(|e| AppError::VideoError(format!("Failed to query capabilities: {}", e)))?;
|
|
let flags = caps.device_caps();
|
|
let capabilities = DeviceCapabilities {
|
|
video_capture: flags.contains(Capabilities::VIDEO_CAPTURE),
|
|
video_capture_mplane: flags.contains(Capabilities::VIDEO_CAPTURE_MPLANE),
|
|
video_output: flags.contains(Capabilities::VIDEO_OUTPUT),
|
|
streaming: flags.contains(Capabilities::STREAMING),
|
|
read_write: flags.contains(Capabilities::READWRITE),
|
|
};
|
|
|
|
let formats = if is_rk_hdmirx_driver(&caps.driver, &caps.card) {
|
|
self.enumerate_current_format_only()?
|
|
} else {
|
|
self.enumerate_formats()?
|
|
};
|
|
|
|
// Determine if this is likely an HDMI capture card
|
|
let is_capture_card = Self::detect_capture_card(&caps.card, &caps.driver, &formats);
|
|
|
|
// Calculate priority score
|
|
let priority =
|
|
Self::calculate_priority(&caps.card, &caps.driver, &formats, is_capture_card);
|
|
|
|
Ok(VideoDeviceInfo {
|
|
path: self.path.clone(),
|
|
name: caps.card.clone(),
|
|
driver: caps.driver.clone(),
|
|
bus_info: caps.bus_info.clone(),
|
|
card: caps.card,
|
|
formats,
|
|
capabilities,
|
|
is_capture_card,
|
|
priority,
|
|
})
|
|
}
|
|
|
|
/// Enumerate supported formats
|
|
pub fn enumerate_formats(&self) -> Result<Vec<FormatInfo>> {
|
|
let mut formats = Vec::new();
|
|
|
|
let queue = self.capture_queue_type()?;
|
|
let format_descs = FormatIterator::new(&self.fd, queue);
|
|
|
|
for desc in format_descs {
|
|
// Try to convert FourCC to our PixelFormat
|
|
if let Some(format) = PixelFormat::from_v4l2r(desc.pixelformat) {
|
|
let resolutions = self.enumerate_resolutions(desc.pixelformat)?;
|
|
let is_current_format = self.current_active_format() == Some(format);
|
|
|
|
if resolutions.is_empty() && !is_current_format {
|
|
debug!(
|
|
"Skipping format {:?} ({}): not usable for current active mode",
|
|
desc.pixelformat, desc.description
|
|
);
|
|
continue;
|
|
}
|
|
|
|
formats.push(FormatInfo {
|
|
format,
|
|
resolutions,
|
|
description: desc.description.clone(),
|
|
});
|
|
} else {
|
|
debug!(
|
|
"Skipping unsupported format: {:?} ({})",
|
|
desc.pixelformat, desc.description
|
|
);
|
|
}
|
|
}
|
|
|
|
// Sort by format priority (MJPEG first)
|
|
formats.sort_by(|a, b| b.format.priority().cmp(&a.format.priority()));
|
|
|
|
Ok(formats)
|
|
}
|
|
|
|
fn enumerate_current_format_only(&self) -> Result<Vec<FormatInfo>> {
|
|
let current = self.get_format()?;
|
|
let Some(format) = PixelFormat::from_v4l2r(current.pixelformat) else {
|
|
debug!(
|
|
"Current active format {:?} is not supported by One-KVM, falling back to full enumeration",
|
|
current.pixelformat
|
|
);
|
|
return self.enumerate_formats();
|
|
};
|
|
|
|
let description = self
|
|
.format_description(current.pixelformat)
|
|
.unwrap_or_else(|| format.to_string());
|
|
|
|
let mut resolutions = self.enumerate_resolutions(current.pixelformat)?;
|
|
if resolutions.is_empty() {
|
|
if let Some(current_mode) = self.current_mode_resolution_info() {
|
|
resolutions.push(current_mode);
|
|
}
|
|
}
|
|
|
|
Ok(vec![FormatInfo {
|
|
format,
|
|
resolutions,
|
|
description,
|
|
}])
|
|
}
|
|
|
|
/// Enumerate resolutions for a specific format
|
|
fn enumerate_resolutions(&self, fourcc: v4l2r::PixelFormat) -> Result<Vec<ResolutionInfo>> {
|
|
let mut resolutions = Vec::new();
|
|
let mut should_fallback_to_current_mode = false;
|
|
|
|
let mut index = 0u32;
|
|
loop {
|
|
match ioctl::enum_frame_sizes::<v4l2_frmsizeenum>(&self.fd, index, fourcc) {
|
|
Ok(size) => {
|
|
if let Some(size) = size.size() {
|
|
match size {
|
|
FrmSizeTypes::Discrete(d) => {
|
|
let fps = self
|
|
.enumerate_fps(fourcc, d.width, d.height)
|
|
.unwrap_or_default();
|
|
resolutions.push(ResolutionInfo::new(d.width, d.height, fps));
|
|
}
|
|
FrmSizeTypes::StepWise(s) => {
|
|
for res in [
|
|
Resolution::VGA,
|
|
Resolution::HD720,
|
|
Resolution::HD1080,
|
|
Resolution::UHD4K,
|
|
] {
|
|
if res.width >= s.min_width
|
|
&& res.width <= s.max_width
|
|
&& res.height >= s.min_height
|
|
&& res.height <= s.max_height
|
|
{
|
|
let fps = self
|
|
.enumerate_fps(fourcc, res.width, res.height)
|
|
.unwrap_or_default();
|
|
resolutions
|
|
.push(ResolutionInfo::new(res.width, res.height, fps));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
index += 1;
|
|
}
|
|
Err(e) => {
|
|
let is_einval = matches!(
|
|
e,
|
|
v4l2r::ioctl::FrameSizeError::IoctlError(err) if err == Errno::EINVAL
|
|
);
|
|
let is_unsupported = matches!(
|
|
e,
|
|
v4l2r::ioctl::FrameSizeError::IoctlError(err)
|
|
if matches!(err, Errno::ENOTTY | Errno::ENOSYS | Errno::EOPNOTSUPP)
|
|
);
|
|
if is_unsupported && resolutions.is_empty() {
|
|
should_fallback_to_current_mode = true;
|
|
}
|
|
if !is_einval && !is_unsupported {
|
|
debug!("Failed to enumerate frame sizes for {:?}: {}", fourcc, e);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if should_fallback_to_current_mode {
|
|
if let Some(resolution) = self.current_mode_resolution_info() {
|
|
if self.format_works_for_resolution(fourcc, resolution.width, resolution.height) {
|
|
debug!(
|
|
"Falling back to current active mode for {:?}: {}x{} @ {:?} fps",
|
|
fourcc, resolution.width, resolution.height, resolution.fps
|
|
);
|
|
resolutions.push(resolution);
|
|
} else {
|
|
debug!(
|
|
"Skipping current-mode fallback for {:?}: TRY_FMT rejected {}x{}",
|
|
fourcc, resolution.width, resolution.height
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort by resolution (largest first)
|
|
resolutions.sort_by(|a, b| (b.width * b.height).cmp(&(a.width * a.height)));
|
|
resolutions.dedup_by(|a, b| a.width == b.width && a.height == b.height);
|
|
|
|
Ok(resolutions)
|
|
}
|
|
|
|
/// Enumerate FPS for a specific resolution
|
|
fn enumerate_fps(
|
|
&self,
|
|
fourcc: v4l2r::PixelFormat,
|
|
width: u32,
|
|
height: u32,
|
|
) -> Result<Vec<f64>> {
|
|
let mut fps_list = Vec::new();
|
|
let mut should_fallback_to_current_mode = false;
|
|
|
|
let mut index = 0u32;
|
|
loop {
|
|
match ioctl::enum_frame_intervals::<v4l2_frmivalenum>(
|
|
&self.fd, index, fourcc, width, height,
|
|
) {
|
|
Ok(interval) => {
|
|
if let Some(interval) = interval.intervals() {
|
|
match interval {
|
|
FrmIvalTypes::Discrete(fraction) => {
|
|
if fraction.numerator > 0 && fraction.denominator > 0 {
|
|
let fps =
|
|
fraction.denominator as f64 / fraction.numerator as f64;
|
|
fps_list.push(fps);
|
|
}
|
|
}
|
|
FrmIvalTypes::StepWise(step) => {
|
|
if step.max.numerator > 0 && step.max.denominator > 0 {
|
|
let min_fps =
|
|
step.max.denominator as f64 / step.max.numerator as f64;
|
|
let max_fps =
|
|
step.min.denominator as f64 / step.min.numerator as f64;
|
|
fps_list.push(min_fps);
|
|
if max_fps != min_fps {
|
|
fps_list.push(max_fps);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
index += 1;
|
|
}
|
|
Err(e) => {
|
|
let is_einval = matches!(
|
|
e,
|
|
v4l2r::ioctl::FrameIntervalsError::IoctlError(err) if err == Errno::EINVAL
|
|
);
|
|
let is_unsupported = matches!(
|
|
e,
|
|
v4l2r::ioctl::FrameIntervalsError::IoctlError(err)
|
|
if matches!(err, Errno::ENOTTY | Errno::ENOSYS | Errno::EOPNOTSUPP)
|
|
);
|
|
if is_unsupported && fps_list.is_empty() {
|
|
should_fallback_to_current_mode = true;
|
|
}
|
|
if !is_einval && !is_unsupported {
|
|
debug!(
|
|
"Failed to enumerate frame intervals for {:?} {}x{}: {}",
|
|
fourcc, width, height, e
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if should_fallback_to_current_mode {
|
|
fps_list.extend(self.current_mode_fps());
|
|
}
|
|
|
|
normalize_fps_list(&mut fps_list);
|
|
Ok(fps_list)
|
|
}
|
|
|
|
/// Get current format
|
|
pub fn get_format(&self) -> Result<V4l2rFormat> {
|
|
let queue = self.capture_queue_type()?;
|
|
ioctl::g_fmt(&self.fd, queue)
|
|
.map_err(|e| AppError::VideoError(format!("Failed to get format: {}", e)))
|
|
}
|
|
|
|
/// Set capture format
|
|
pub fn set_format(&self, width: u32, height: u32, format: PixelFormat) -> Result<V4l2rFormat> {
|
|
let queue = self.capture_queue_type()?;
|
|
let mut fmt: V4l2rFormat = ioctl::g_fmt(&self.fd, queue)
|
|
.map_err(|e| AppError::VideoError(format!("Failed to get format: {}", e)))?;
|
|
fmt.width = width;
|
|
fmt.height = height;
|
|
fmt.pixelformat = format.to_v4l2r();
|
|
|
|
let mut fd = self
|
|
.fd
|
|
.try_clone()
|
|
.map_err(|e| AppError::VideoError(format!("Failed to clone device fd: {}", e)))?;
|
|
let actual: V4l2rFormat = ioctl::s_fmt(&mut fd, (queue, &fmt))
|
|
.map_err(|e| AppError::VideoError(format!("Failed to set format: {}", e)))?;
|
|
|
|
if actual.width != width || actual.height != height {
|
|
warn!(
|
|
"Requested {}x{}, got {}x{}",
|
|
width, height, actual.width, actual.height
|
|
);
|
|
}
|
|
|
|
Ok(actual)
|
|
}
|
|
|
|
/// Detect if device is likely an HDMI capture card
|
|
fn detect_capture_card(card: &str, driver: &str, formats: &[FormatInfo]) -> bool {
|
|
let card_lower = card.to_lowercase();
|
|
let driver_lower = driver.to_lowercase();
|
|
|
|
// Known capture card patterns
|
|
let capture_patterns = [
|
|
"hdmi",
|
|
"capture",
|
|
"grabber",
|
|
"usb3",
|
|
"ms2109",
|
|
"ms2130",
|
|
"macrosilicon",
|
|
"tc358743",
|
|
"uvc",
|
|
];
|
|
|
|
// Check card/driver names
|
|
for pattern in capture_patterns {
|
|
if card_lower.contains(pattern) || driver_lower.contains(pattern) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Capture cards usually support MJPEG and high resolutions
|
|
let has_mjpeg = formats.iter().any(|f| f.format == PixelFormat::Mjpeg);
|
|
let has_1080p = formats.iter().any(|f| {
|
|
f.resolutions
|
|
.iter()
|
|
.any(|r| r.width >= 1920 && r.height >= 1080)
|
|
});
|
|
|
|
has_mjpeg && has_1080p
|
|
}
|
|
|
|
/// Calculate device priority for selection
|
|
fn calculate_priority(
|
|
_card: &str,
|
|
driver: &str,
|
|
formats: &[FormatInfo],
|
|
is_capture_card: bool,
|
|
) -> u32 {
|
|
let mut priority = 0u32;
|
|
|
|
// Capture cards get highest priority
|
|
if is_capture_card {
|
|
priority += 1000;
|
|
}
|
|
|
|
// MJPEG support is valuable
|
|
if formats.iter().any(|f| f.format == PixelFormat::Mjpeg) {
|
|
priority += 100;
|
|
}
|
|
|
|
// High resolution support
|
|
let max_resolution = formats
|
|
.iter()
|
|
.flat_map(|f| &f.resolutions)
|
|
.map(|r| r.width * r.height)
|
|
.max()
|
|
.unwrap_or(0);
|
|
|
|
priority += max_resolution / 100000;
|
|
|
|
// Known good drivers get bonus
|
|
let good_drivers = ["uvcvideo", "tc358743"];
|
|
if good_drivers.iter().any(|d| driver.contains(d)) {
|
|
priority += 50;
|
|
}
|
|
|
|
priority
|
|
}
|
|
|
|
/// Get the inner device reference (for advanced usage)
|
|
pub fn inner(&self) -> &File {
|
|
&self.fd
|
|
}
|
|
|
|
fn current_mode_resolution_info(&self) -> Option<ResolutionInfo> {
|
|
let (width, height) = self
|
|
.current_dv_timings_mode()
|
|
.map(|(width, height, _)| (width, height))
|
|
.or_else(|| self.current_format_resolution())?;
|
|
Some(ResolutionInfo::new(width, height, self.current_mode_fps()))
|
|
}
|
|
|
|
fn current_mode_fps(&self) -> Vec<f64> {
|
|
let mut fps = Vec::new();
|
|
|
|
if let Some(frame_rate) = self.current_parm_fps() {
|
|
fps.push(frame_rate);
|
|
}
|
|
|
|
if let Some((_, _, Some(frame_rate))) = self.current_dv_timings_mode() {
|
|
fps.push(frame_rate);
|
|
}
|
|
|
|
normalize_fps_list(&mut fps);
|
|
fps
|
|
}
|
|
|
|
fn current_parm_fps(&self) -> Option<f64> {
|
|
let queue = self.capture_queue_type().ok()?;
|
|
let params: v4l2_streamparm = ioctl::g_parm(&self.fd, queue).ok()?;
|
|
let capture = unsafe { params.parm.capture };
|
|
let timeperframe = capture.timeperframe;
|
|
if timeperframe.numerator == 0 || timeperframe.denominator == 0 {
|
|
return None;
|
|
}
|
|
Some(timeperframe.denominator as f64 / timeperframe.numerator as f64)
|
|
}
|
|
|
|
fn current_dv_timings_mode(&self) -> Option<(u32, u32, Option<f64>)> {
|
|
let timings = ioctl::query_dv_timings::<v4l2_dv_timings>(&self.fd)
|
|
.or_else(|_| ioctl::g_dv_timings::<v4l2_dv_timings>(&self.fd))
|
|
.ok()?;
|
|
|
|
if timings.type_ != V4L2_DV_BT_656_1120 {
|
|
return None;
|
|
}
|
|
|
|
let bt = unsafe { timings.__bindgen_anon_1.bt };
|
|
if bt.width == 0 || bt.height == 0 {
|
|
return None;
|
|
}
|
|
|
|
Some((bt.width, bt.height, dv_timings_fps(&bt)))
|
|
}
|
|
|
|
fn current_format_resolution(&self) -> Option<(u32, u32)> {
|
|
let format = self.get_format().ok()?;
|
|
if format.width == 0 || format.height == 0 {
|
|
return None;
|
|
}
|
|
Some((format.width, format.height))
|
|
}
|
|
|
|
fn current_active_format(&self) -> Option<PixelFormat> {
|
|
let format = self.get_format().ok()?;
|
|
PixelFormat::from_v4l2r(format.pixelformat)
|
|
}
|
|
|
|
fn format_description(&self, fourcc: v4l2r::PixelFormat) -> Option<String> {
|
|
let queue = self.capture_queue_type().ok()?;
|
|
FormatIterator::new(&self.fd, queue)
|
|
.find(|desc| desc.pixelformat == fourcc)
|
|
.map(|desc| desc.description)
|
|
}
|
|
|
|
fn format_works_for_resolution(
|
|
&self,
|
|
fourcc: v4l2r::PixelFormat,
|
|
width: u32,
|
|
height: u32,
|
|
) -> bool {
|
|
let queue = match self.capture_queue_type() {
|
|
Ok(queue) => queue,
|
|
Err(_) => return false,
|
|
};
|
|
|
|
let mut fmt = match ioctl::g_fmt::<V4l2rFormat>(&self.fd, queue) {
|
|
Ok(fmt) => fmt,
|
|
Err(_) => return false,
|
|
};
|
|
|
|
fmt.width = width;
|
|
fmt.height = height;
|
|
fmt.pixelformat = fourcc;
|
|
|
|
let actual = match ioctl::try_fmt::<_, V4l2rFormat>(&self.fd, (queue, &fmt)) {
|
|
Ok(actual) => actual,
|
|
Err(_) => return false,
|
|
};
|
|
|
|
actual.pixelformat == fourcc && actual.width == width && actual.height == height
|
|
}
|
|
|
|
fn capture_queue_type(&self) -> Result<QueueType> {
|
|
let caps = self.capabilities()?;
|
|
if caps.video_capture {
|
|
Ok(QueueType::VideoCapture)
|
|
} else if caps.video_capture_mplane {
|
|
Ok(QueueType::VideoCaptureMplane)
|
|
} else {
|
|
Err(AppError::VideoError(
|
|
"Device does not expose a capture queue".to_string(),
|
|
))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Enumerate all video capture devices
|
|
pub fn enumerate_devices() -> Result<Vec<VideoDeviceInfo>> {
|
|
info!("Enumerating video devices...");
|
|
|
|
let mut devices = Vec::new();
|
|
|
|
// Scan /dev/video* devices
|
|
for entry in std::fs::read_dir("/dev")
|
|
.map_err(|e| AppError::VideoError(format!("Failed to read /dev: {}", e)))?
|
|
{
|
|
let entry = match entry {
|
|
Ok(e) => e,
|
|
Err(_) => continue,
|
|
};
|
|
|
|
let path = entry.path();
|
|
let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
|
|
|
|
if !name.starts_with("video") {
|
|
continue;
|
|
}
|
|
|
|
debug!("Found video device: {:?}", path);
|
|
|
|
if !sysfs_maybe_capture(&path) {
|
|
debug!("Skipping non-capture candidate (sysfs): {:?}", path);
|
|
continue;
|
|
}
|
|
|
|
// Try to open and query the device (with timeout)
|
|
match probe_device_with_timeout(&path, Duration::from_millis(DEVICE_PROBE_TIMEOUT_MS)) {
|
|
Some(info) => {
|
|
// Only include devices with video capture capability
|
|
if info.capabilities.video_capture || info.capabilities.video_capture_mplane {
|
|
info!(
|
|
"Found capture device: {} ({}) - {} formats",
|
|
info.name,
|
|
info.driver,
|
|
info.formats.len()
|
|
);
|
|
devices.push(info);
|
|
} else {
|
|
debug!("Skipping non-capture device: {:?}", path);
|
|
}
|
|
}
|
|
None => {
|
|
debug!("Failed to probe {:?}", path);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort by priority (highest first)
|
|
devices.sort_by(|a, b| b.priority.cmp(&a.priority));
|
|
|
|
info!("Found {} video capture devices", devices.len());
|
|
Ok(devices)
|
|
}
|
|
|
|
fn probe_device_with_timeout(path: &Path, timeout: Duration) -> Option<VideoDeviceInfo> {
|
|
let path = path.to_path_buf();
|
|
let path_for_thread = path.clone();
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
std::thread::spawn(move || {
|
|
let result = (|| -> Result<VideoDeviceInfo> {
|
|
let device = VideoDevice::open_readonly(&path_for_thread)?;
|
|
device.info()
|
|
})();
|
|
let _ = tx.send(result);
|
|
});
|
|
|
|
match rx.recv_timeout(timeout) {
|
|
Ok(Ok(info)) => Some(info),
|
|
Ok(Err(e)) => {
|
|
debug!("Failed to get info for {:?}: {}", path, e);
|
|
None
|
|
}
|
|
Err(mpsc::RecvTimeoutError::Timeout) => {
|
|
warn!("Timed out probing video device: {:?}", path);
|
|
None
|
|
}
|
|
Err(_) => None,
|
|
}
|
|
}
|
|
|
|
fn sysfs_maybe_capture(path: &Path) -> bool {
|
|
let name = match path.file_name().and_then(|n| n.to_str()) {
|
|
Some(name) => name,
|
|
None => return true,
|
|
};
|
|
let sysfs_base = Path::new("/sys/class/video4linux").join(name);
|
|
|
|
let sysfs_name = read_sysfs_string(&sysfs_base.join("name"))
|
|
.unwrap_or_default()
|
|
.to_lowercase();
|
|
let uevent = read_sysfs_string(&sysfs_base.join("device/uevent"))
|
|
.unwrap_or_default()
|
|
.to_lowercase();
|
|
let driver = extract_uevent_value(&uevent, "driver");
|
|
|
|
let mut maybe_capture = false;
|
|
let capture_hints = [
|
|
"capture",
|
|
"hdmi",
|
|
"usb",
|
|
"uvc",
|
|
"ms2109",
|
|
"ms2130",
|
|
"macrosilicon",
|
|
"tc358743",
|
|
"grabber",
|
|
];
|
|
if capture_hints.iter().any(|hint| sysfs_name.contains(hint)) {
|
|
maybe_capture = true;
|
|
}
|
|
if let Some(driver) = driver {
|
|
if driver.contains("uvcvideo") || driver.contains("tc358743") {
|
|
maybe_capture = true;
|
|
}
|
|
}
|
|
|
|
let skip_hints = [
|
|
"codec", "decoder", "encoder", "isp", "mem2mem", "m2m", "vbi", "radio", "metadata",
|
|
"output",
|
|
];
|
|
if skip_hints.iter().any(|hint| sysfs_name.contains(hint)) && !maybe_capture {
|
|
return false;
|
|
}
|
|
|
|
true
|
|
}
|
|
|
|
fn read_sysfs_string(path: &Path) -> Option<String> {
|
|
std::fs::read_to_string(path)
|
|
.ok()
|
|
.map(|value| value.trim().to_string())
|
|
}
|
|
|
|
fn extract_uevent_value(content: &str, key: &str) -> Option<String> {
|
|
let key_upper = key.to_ascii_uppercase();
|
|
for line in content.lines() {
|
|
if let Some(value) = line.strip_prefix(&format!("{}=", key_upper)) {
|
|
return Some(value.to_lowercase());
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn dv_timings_fps(bt: &v4l2_bt_timings) -> Option<f64> {
|
|
let total_width = bt.width + bt.hfrontporch + bt.hsync + bt.hbackporch;
|
|
let total_height = if bt.interlaced != 0 {
|
|
bt.height
|
|
+ bt.vfrontporch
|
|
+ bt.vsync
|
|
+ bt.vbackporch
|
|
+ bt.il_vfrontporch
|
|
+ bt.il_vsync
|
|
+ bt.il_vbackporch
|
|
} else {
|
|
bt.height + bt.vfrontporch + bt.vsync + bt.vbackporch
|
|
};
|
|
|
|
if bt.pixelclock == 0 || total_width == 0 || total_height == 0 {
|
|
return None;
|
|
}
|
|
|
|
Some(bt.pixelclock as f64 / total_width as f64 / total_height as f64)
|
|
}
|
|
|
|
fn normalize_fps_list(fps_list: &mut Vec<f64>) {
|
|
fps_list.retain(|fps| fps.is_finite() && *fps > 0.0);
|
|
for fps in fps_list.iter_mut() {
|
|
*fps = (*fps * 100.0).round() / 100.0;
|
|
}
|
|
fps_list.sort_by(|a, b| b.total_cmp(a));
|
|
fps_list.dedup_by(|a, b| (*a - *b).abs() < 0.01);
|
|
}
|
|
|
|
/// Find the best video device for KVM use
|
|
pub fn find_best_device() -> Result<VideoDeviceInfo> {
|
|
let devices = enumerate_devices()?;
|
|
|
|
devices
|
|
.into_iter()
|
|
.next()
|
|
.ok_or_else(|| AppError::VideoError("No video capture devices found".to_string()))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_pixel_format_conversion() {
|
|
let format = PixelFormat::Mjpeg;
|
|
let fourcc = format.to_fourcc();
|
|
let back = PixelFormat::from_fourcc(fourcc);
|
|
assert_eq!(back, Some(format));
|
|
}
|
|
|
|
#[test]
|
|
fn test_resolution() {
|
|
let res = Resolution::HD1080;
|
|
assert_eq!(res.width, 1920);
|
|
assert_eq!(res.height, 1080);
|
|
assert!(res.is_valid());
|
|
}
|
|
}
|