1use crate::pixels::Pixels as Array3;
8use crate::{
9 CameraConfig, CameraControlRange, CameraControlType, CameraControlValue, CameraDeviceInfo,
10 CameraResult,
11};
12use std::time::Duration;
13
14pub trait CameraManager {
16 fn list_devices() -> CameraResult<Vec<CameraDeviceInfo>>;
18
19 fn get_supported_configs(device_index: u32) -> CameraResult<Vec<CameraConfig>>;
21
22 fn is_config_supported(device_index: u32, config: &CameraConfig) -> CameraResult<bool>;
24}
25
26#[allow(async_fn_in_trait)]
28pub trait StreamingCamera: Send + Sync {
29 fn frame_hub(&self) -> Option<&crate::FrameHub> {
31 None
32 }
33
34 fn get_shared_frame(&self) -> CameraResult<Option<std::sync::Arc<crate::CapturedFrame>>> {
35 self.frame_hub().map(|hub| hub.latest()).ok_or_else(|| {
36 crate::CameraError::stream_error("Shared frames unavailable for this backend".into())
37 })
38 }
39
40 async fn wait_for_shared_frame(
41 &self,
42 after: Option<crate::FrameKey>,
43 timeout: Duration,
44 ) -> CameraResult<std::sync::Arc<crate::CapturedFrame>> {
45 self.frame_hub()
46 .ok_or_else(|| {
47 crate::CameraError::stream_error(
48 "Shared frames unavailable for this backend".into(),
49 )
50 })?
51 .wait_after(after, timeout)
52 .await
53 }
54 async fn start_stream(&self, config: CameraConfig) -> CameraResult<()>;
58
59 async fn stop_stream(&self) -> CameraResult<()>;
61
62 fn get_latest_frame(&self) -> CameraResult<Option<Array3<u8>>>;
67
68 async fn wait_for_frame(&self, timeout: Duration) -> CameraResult<Array3<u8>>;
71
72 fn is_streaming(&self) -> bool;
74
75 fn get_config(&self) -> Option<CameraConfig>;
77
78 fn get_stats(&self) -> StreamStats;
80
81 async fn set_buffer_size(&self, size: usize) -> CameraResult<()>;
83}
84
85#[derive(Debug, Clone, Default)]
87pub struct StreamStats {
88 pub total_frames: u64,
90 pub dropped_frames: u64,
92 pub current_fps: f64,
94 pub buffer_size: usize,
96 pub buffered_frames: usize,
98 pub uptime_seconds: u64,
100}
101
102impl StreamStats {
103 pub fn drop_rate(&self) -> f64 {
105 if self.total_frames == 0 {
106 0.0
107 } else {
108 self.dropped_frames as f64 / self.total_frames as f64
109 }
110 }
111
112 pub fn buffer_usage(&self) -> f64 {
114 if self.buffer_size == 0 {
115 0.0
116 } else {
117 self.buffered_frames as f64 / self.buffer_size as f64
118 }
119 }
120}
121
122#[allow(async_fn_in_trait)]
128pub trait CameraControl {
129 fn get_control(&self, control: CameraControlType) -> CameraResult<CameraControlValue>;
131
132 fn set_control(
134 &self,
135 control: CameraControlType,
136 value: CameraControlValue,
137 ) -> CameraResult<()>;
138
139 fn get_control_range(&self, control: CameraControlType) -> CameraResult<CameraControlRange>;
141
142 fn supports_control(&self, control: CameraControlType) -> bool;
144
145 fn get_supported_controls(&self) -> Vec<CameraControlType>;
147
148 fn reset_control(&self, control: CameraControlType) -> CameraResult<()> {
150 let range = self.get_control_range(control)?;
151 self.set_control(control, CameraControlValue::manual(range.default))
152 }
153
154 fn reset_all_controls(&self) -> CameraResult<()> {
156 let mut failures = Vec::new();
157 for control in self.get_supported_controls() {
158 if let Err(error) = self.reset_control(control) {
159 failures.push(std::sync::Arc::new(
160 error.with_operation(format!("{control:?}")),
161 ));
162 }
163 }
164 if failures.is_empty() {
165 Ok(())
166 } else {
167 Err(crate::CameraError::control_batch(failures))
168 }
169 }
170}
171
172#[cfg(test)]
173mod camera_control_tests {
174 use super::*;
175
176 #[test]
177 fn test_stream_stats_default() {
178 let stats = StreamStats::default();
179 assert_eq!(stats.total_frames, 0);
180 assert_eq!(stats.dropped_frames, 0);
181 assert_eq!(stats.current_fps, 0.0);
182 assert_eq!(stats.buffer_size, 0);
183 assert_eq!(stats.buffered_frames, 0);
184 assert_eq!(stats.uptime_seconds, 0);
185 }
186
187 #[test]
188 fn test_stream_stats_drop_rate() {
189 let mut stats = StreamStats::default();
190
191 assert_eq!(stats.drop_rate(), 0.0);
193
194 stats.total_frames = 100;
196 stats.dropped_frames = 0;
197 assert_eq!(stats.drop_rate(), 0.0);
198
199 stats.dropped_frames = 10;
201 assert_eq!(stats.drop_rate(), 0.1);
202
203 stats.dropped_frames = 100;
205 assert_eq!(stats.drop_rate(), 1.0);
206 }
207
208 #[test]
209 fn test_stream_stats_buffer_usage() {
210 let mut stats = StreamStats::default();
211
212 assert_eq!(stats.buffer_usage(), 0.0);
214
215 stats.buffer_size = 10;
217 stats.buffered_frames = 0;
218 assert_eq!(stats.buffer_usage(), 0.0);
219
220 stats.buffered_frames = 5;
222 assert_eq!(stats.buffer_usage(), 0.5);
223
224 stats.buffered_frames = 10;
226 assert_eq!(stats.buffer_usage(), 1.0);
227 }
228
229 #[test]
230 fn test_stream_stats_calculations() {
231 let stats = StreamStats {
232 total_frames: 1000,
233 dropped_frames: 50,
234 current_fps: 29.5,
235 buffer_size: 20,
236 buffered_frames: 15,
237 uptime_seconds: 60,
238 };
239
240 assert_eq!(stats.drop_rate(), 0.05);
241 assert_eq!(stats.buffer_usage(), 0.75);
242 }
243}