mirror of
https://github.com/mofeng-git/One-KVM.git
synced 2026-04-30 01:46:37 +08:00
656 lines
22 KiB
Rust
656 lines
22 KiB
Rust
//! MJPEG stream handler
|
|
//!
|
|
//! Manages video frame distribution and per-client statistics.
|
|
|
|
use arc_swap::ArcSwap;
|
|
use parking_lot::Mutex as ParkingMutex;
|
|
use parking_lot::RwLock as ParkingRwLock;
|
|
use std::collections::{HashMap, VecDeque};
|
|
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
|
|
use std::sync::Arc;
|
|
use std::time::{Duration, Instant};
|
|
use tokio::sync::broadcast;
|
|
use tracing::{debug, info, warn};
|
|
|
|
use crate::video::encoder::traits::{Encoder, EncoderConfig};
|
|
use crate::video::encoder::JpegEncoder;
|
|
use crate::video::format::PixelFormat;
|
|
use crate::video::VideoFrame;
|
|
|
|
// No placeholder JPEGs: capture calls `set_offline()`; UI uses `stream.state_changed`.
|
|
|
|
/// Client ID type (UUID string)
|
|
pub type ClientId = String;
|
|
|
|
/// Per-client session information
|
|
#[derive(Debug, Clone)]
|
|
pub struct ClientSession {
|
|
/// Unique client ID
|
|
pub id: ClientId,
|
|
/// Connection timestamp
|
|
pub connected_at: Instant,
|
|
/// Last activity timestamp (frame sent)
|
|
pub last_activity: Instant,
|
|
/// Frames sent to this client
|
|
pub frames_sent: u64,
|
|
/// FPS calculator (1-second rolling window)
|
|
pub fps_calculator: FpsCalculator,
|
|
}
|
|
|
|
impl ClientSession {
|
|
/// Create a new client session
|
|
pub fn new(id: ClientId) -> Self {
|
|
let now = Instant::now();
|
|
Self {
|
|
id,
|
|
connected_at: now,
|
|
last_activity: now,
|
|
frames_sent: 0,
|
|
fps_calculator: FpsCalculator::new(),
|
|
}
|
|
}
|
|
|
|
/// Get connection duration
|
|
pub fn connected_duration(&self) -> Duration {
|
|
self.last_activity.duration_since(self.connected_at)
|
|
}
|
|
|
|
/// Get idle duration
|
|
pub fn idle_duration(&self) -> Duration {
|
|
Instant::now().duration_since(self.last_activity)
|
|
}
|
|
}
|
|
|
|
/// Rolling window FPS calculator
|
|
#[derive(Debug, Clone)]
|
|
pub struct FpsCalculator {
|
|
/// Frame timestamps in last window
|
|
frame_times: VecDeque<Instant>,
|
|
/// Window duration (default 1 second)
|
|
window: Duration,
|
|
/// Cached count of frames in current window (optimization to avoid O(n) filtering)
|
|
count_in_window: usize,
|
|
}
|
|
|
|
impl FpsCalculator {
|
|
/// Create a new FPS calculator with 1-second window
|
|
pub fn new() -> Self {
|
|
Self {
|
|
frame_times: VecDeque::with_capacity(120), // Max 120fps tracking
|
|
window: Duration::from_secs(1),
|
|
count_in_window: 0,
|
|
}
|
|
}
|
|
|
|
/// Record a frame sent
|
|
pub fn record_frame(&mut self) {
|
|
let now = Instant::now();
|
|
self.frame_times.push_back(now);
|
|
|
|
// Remove frames outside window and maintain count
|
|
let cutoff = now - self.window;
|
|
while let Some(&oldest) = self.frame_times.front() {
|
|
if oldest < cutoff {
|
|
self.frame_times.pop_front();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Update cached count
|
|
self.count_in_window = self.frame_times.len();
|
|
}
|
|
|
|
/// Calculate current FPS (frames in last 1 second window)
|
|
pub fn current_fps(&self) -> u32 {
|
|
// Return cached count instead of filtering entire deque (O(1) instead of O(n))
|
|
self.count_in_window as u32
|
|
}
|
|
}
|
|
|
|
impl Default for FpsCalculator {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
/// Auto-pause configuration
|
|
#[derive(Debug, Clone)]
|
|
pub struct AutoPauseConfig {
|
|
/// Enable auto-pause when no clients
|
|
pub enabled: bool,
|
|
/// Delay before pausing (default 10s)
|
|
pub shutdown_delay_secs: u64,
|
|
/// Client timeout for cleanup (default 30s)
|
|
pub client_timeout_secs: u64,
|
|
}
|
|
|
|
impl Default for AutoPauseConfig {
|
|
fn default() -> Self {
|
|
Self {
|
|
enabled: false,
|
|
shutdown_delay_secs: 10,
|
|
client_timeout_secs: 30,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// MJPEG stream handler
|
|
/// Manages video frame distribution to HTTP clients
|
|
pub struct MjpegStreamHandler {
|
|
/// Current frame (latest) - using ArcSwap for lock-free reads
|
|
current_frame: ArcSwap<Option<VideoFrame>>,
|
|
/// Frame update notification
|
|
frame_notify: broadcast::Sender<()>,
|
|
/// Whether stream is online
|
|
online: AtomicBool,
|
|
/// Frame sequence counter
|
|
sequence: AtomicU64,
|
|
/// Per-client sessions (ClientId -> ClientSession)
|
|
/// Use parking_lot::RwLock for better performance
|
|
clients: ParkingRwLock<HashMap<ClientId, ClientSession>>,
|
|
/// Auto-pause configuration
|
|
auto_pause_config: ParkingRwLock<AutoPauseConfig>,
|
|
/// Last frame timestamp
|
|
last_frame_ts: ParkingRwLock<Option<Instant>>,
|
|
/// Dropped same frames count
|
|
dropped_same_frames: AtomicU64,
|
|
/// Maximum consecutive same frames to drop (0 = disabled)
|
|
max_drop_same_frames: AtomicU64,
|
|
/// JPEG encoder for non-JPEG input formats
|
|
jpeg_encoder: ParkingMutex<Option<JpegEncoder>>,
|
|
/// JPEG quality for software encoding (1-100)
|
|
jpeg_quality: AtomicU64,
|
|
}
|
|
|
|
impl MjpegStreamHandler {
|
|
/// Create a new MJPEG stream handler
|
|
pub fn new() -> Self {
|
|
Self::with_drop_limit(100) // Default: drop up to 100 same frames
|
|
}
|
|
|
|
/// Create handler with custom drop limit
|
|
pub fn with_drop_limit(max_drop: u64) -> Self {
|
|
let (frame_notify, _) = broadcast::channel(16); // Buffer size 16 for low latency
|
|
Self {
|
|
current_frame: ArcSwap::from_pointee(None),
|
|
frame_notify,
|
|
online: AtomicBool::new(false),
|
|
sequence: AtomicU64::new(0),
|
|
clients: ParkingRwLock::new(HashMap::new()),
|
|
jpeg_encoder: ParkingMutex::new(None),
|
|
auto_pause_config: ParkingRwLock::new(AutoPauseConfig::default()),
|
|
last_frame_ts: ParkingRwLock::new(None),
|
|
dropped_same_frames: AtomicU64::new(0),
|
|
max_drop_same_frames: AtomicU64::new(max_drop),
|
|
jpeg_quality: AtomicU64::new(80),
|
|
}
|
|
}
|
|
|
|
/// Set JPEG quality for software encoding (1-100)
|
|
pub fn set_jpeg_quality(&self, quality: u8) {
|
|
let clamped = quality.clamp(1, 100) as u64;
|
|
self.jpeg_quality.store(clamped, Ordering::Relaxed);
|
|
}
|
|
|
|
/// Update current frame
|
|
pub fn update_frame(&self, frame: VideoFrame) {
|
|
// Fast path: if no MJPEG clients are connected, do minimal bookkeeping and avoid
|
|
// expensive work (JPEG encoding and per-frame dedup hashing).
|
|
let has_clients = !self.clients.read().is_empty();
|
|
if !has_clients {
|
|
self.dropped_same_frames.store(0, Ordering::Relaxed);
|
|
self.sequence.fetch_add(1, Ordering::Relaxed);
|
|
self.online.store(frame.online, Ordering::SeqCst);
|
|
*self.last_frame_ts.write() = Some(Instant::now());
|
|
|
|
// Keep the latest compressed frame for "instant first frame" when a client connects.
|
|
// Avoid retaining large raw buffers when there are no MJPEG clients.
|
|
if frame.format.is_compressed() {
|
|
self.current_frame.store(Arc::new(Some(frame)));
|
|
} else {
|
|
self.current_frame.store(Arc::new(None));
|
|
}
|
|
return;
|
|
}
|
|
|
|
// If frame is not JPEG, encode it
|
|
let frame = if !frame.format.is_compressed() {
|
|
match self.encode_to_jpeg(&frame) {
|
|
Ok(jpeg_frame) => jpeg_frame,
|
|
Err(e) => {
|
|
warn!("Failed to encode frame to JPEG: {}", e);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
frame
|
|
};
|
|
|
|
// Frame deduplication (ustreamer-style)
|
|
// Check if this frame is identical to the previous one
|
|
let max_drop = self.max_drop_same_frames.load(Ordering::Relaxed);
|
|
if max_drop > 0 && frame.online {
|
|
let current = self.current_frame.load();
|
|
if let Some(ref prev_frame) = **current {
|
|
let dropped_count = self.dropped_same_frames.load(Ordering::Relaxed);
|
|
|
|
// Check if we should drop this frame
|
|
if dropped_count < max_drop && frames_are_identical(prev_frame, &frame) {
|
|
// Check last frame timestamp to ensure minimum 1fps
|
|
let last_ts = *self.last_frame_ts.read();
|
|
let should_force_send = if let Some(ts) = last_ts {
|
|
ts.elapsed() >= Duration::from_secs(1)
|
|
} else {
|
|
false
|
|
};
|
|
|
|
if !should_force_send {
|
|
// Drop this duplicate frame
|
|
self.dropped_same_frames.fetch_add(1, Ordering::Relaxed);
|
|
return;
|
|
}
|
|
// If more than 1 second since last frame, force send even if identical
|
|
}
|
|
}
|
|
}
|
|
|
|
// Frame is different or limit reached or forced by 1fps guarantee, update
|
|
self.dropped_same_frames.store(0, Ordering::Relaxed);
|
|
|
|
self.sequence.fetch_add(1, Ordering::Relaxed);
|
|
self.online.store(frame.online, Ordering::SeqCst);
|
|
*self.last_frame_ts.write() = Some(Instant::now());
|
|
self.current_frame.store(Arc::new(Some(frame)));
|
|
|
|
// Notify waiting clients
|
|
let _ = self.frame_notify.send(());
|
|
}
|
|
|
|
/// Encode a non-JPEG frame to JPEG
|
|
fn encode_to_jpeg(&self, frame: &VideoFrame) -> Result<VideoFrame, String> {
|
|
let resolution = frame.resolution;
|
|
let sequence = self.sequence.load(Ordering::Relaxed);
|
|
let desired_quality = self.jpeg_quality.load(Ordering::Relaxed) as u32;
|
|
|
|
// Get or create encoder
|
|
let mut encoder_guard = self.jpeg_encoder.lock();
|
|
let encoder = encoder_guard.get_or_insert_with(|| {
|
|
let config = EncoderConfig::jpeg(resolution, desired_quality);
|
|
match JpegEncoder::new(config) {
|
|
Ok(enc) => {
|
|
debug!(
|
|
"Created JPEG encoder for MJPEG stream: {}x{} (q={})",
|
|
resolution.width, resolution.height, desired_quality
|
|
);
|
|
enc
|
|
}
|
|
Err(e) => {
|
|
warn!("Failed to create JPEG encoder: {}, using default", e);
|
|
// Try with default config
|
|
JpegEncoder::new(EncoderConfig::jpeg(resolution, desired_quality))
|
|
.expect("Failed to create default JPEG encoder")
|
|
}
|
|
}
|
|
});
|
|
|
|
// Check if resolution changed
|
|
if encoder.config().resolution != resolution {
|
|
debug!(
|
|
"Resolution changed, recreating JPEG encoder: {}x{}",
|
|
resolution.width, resolution.height
|
|
);
|
|
let config = EncoderConfig::jpeg(resolution, desired_quality);
|
|
*encoder =
|
|
JpegEncoder::new(config).map_err(|e| format!("Failed to create encoder: {}", e))?;
|
|
} else if encoder.config().quality != desired_quality {
|
|
if let Err(e) = encoder.set_quality(desired_quality) {
|
|
warn!("Failed to set JPEG quality: {}, recreating encoder", e);
|
|
let config = EncoderConfig::jpeg(resolution, desired_quality);
|
|
*encoder = JpegEncoder::new(config)
|
|
.map_err(|e| format!("Failed to create encoder: {}", e))?;
|
|
}
|
|
}
|
|
|
|
// Encode based on input format
|
|
let encoded = match frame.format {
|
|
PixelFormat::Yuyv => encoder
|
|
.encode_yuyv(frame.data(), sequence)
|
|
.map_err(|e| format!("YUYV encode failed: {}", e))?,
|
|
PixelFormat::Yvyu => encoder
|
|
.encode_yvyu(frame.data(), sequence)
|
|
.map_err(|e| format!("YVYU encode failed: {}", e))?,
|
|
PixelFormat::Nv12 => encoder
|
|
.encode_nv12(frame.data(), sequence)
|
|
.map_err(|e| format!("NV12 encode failed: {}", e))?,
|
|
PixelFormat::Nv16 => encoder
|
|
.encode_nv16(frame.data(), sequence)
|
|
.map_err(|e| format!("NV16 encode failed: {}", e))?,
|
|
PixelFormat::Nv24 => encoder
|
|
.encode_nv24(frame.data(), sequence)
|
|
.map_err(|e| format!("NV24 encode failed: {}", e))?,
|
|
PixelFormat::Rgb24 => encoder
|
|
.encode_rgb(frame.data(), sequence)
|
|
.map_err(|e| format!("RGB encode failed: {}", e))?,
|
|
PixelFormat::Bgr24 => encoder
|
|
.encode_bgr(frame.data(), sequence)
|
|
.map_err(|e| format!("BGR encode failed: {}", e))?,
|
|
_ => {
|
|
return Err(format!(
|
|
"Unsupported format for JPEG encoding: {}",
|
|
frame.format
|
|
));
|
|
}
|
|
};
|
|
|
|
// Create new VideoFrame with JPEG data (zero-copy: Bytes -> Arc<Bytes>)
|
|
Ok(VideoFrame::new(
|
|
encoded.data,
|
|
resolution,
|
|
PixelFormat::Mjpeg,
|
|
0, // stride not relevant for JPEG
|
|
sequence,
|
|
))
|
|
}
|
|
|
|
/// Marks offline; clients exit their read loop. UI overlay comes from `stream.state_changed`.
|
|
pub fn set_offline(&self) {
|
|
self.online.store(false, Ordering::SeqCst);
|
|
let _ = self.frame_notify.send(());
|
|
}
|
|
|
|
/// Set stream online (called when streaming starts)
|
|
pub fn set_online(&self) {
|
|
self.online.store(true, Ordering::SeqCst);
|
|
}
|
|
|
|
/// Check if stream is online
|
|
pub fn is_online(&self) -> bool {
|
|
self.online.load(Ordering::SeqCst)
|
|
}
|
|
|
|
/// Get current client count
|
|
pub fn client_count(&self) -> u64 {
|
|
self.clients.read().len() as u64
|
|
}
|
|
|
|
/// Register a new client
|
|
pub fn register_client(&self, client_id: ClientId) {
|
|
let session = ClientSession::new(client_id.clone());
|
|
self.clients.write().insert(client_id.clone(), session);
|
|
info!(
|
|
"Client {} connected (total: {})",
|
|
client_id,
|
|
self.client_count()
|
|
);
|
|
}
|
|
|
|
/// Unregister a client
|
|
pub fn unregister_client(&self, client_id: &str) {
|
|
if let Some(session) = self.clients.write().remove(client_id) {
|
|
let duration = session.connected_duration();
|
|
let duration_secs = duration.as_secs_f32();
|
|
let avg_fps = if duration_secs > 0.1 {
|
|
session.frames_sent as f32 / duration_secs
|
|
} else {
|
|
0.0
|
|
};
|
|
info!(
|
|
"Client {} disconnected after {:.1}s ({} frames, {:.1} avg FPS)",
|
|
client_id, duration_secs, session.frames_sent, avg_fps
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Record frame sent to a specific client
|
|
pub fn record_frame_sent(&self, client_id: &str) {
|
|
if let Some(session) = self.clients.write().get_mut(client_id) {
|
|
session.last_activity = Instant::now();
|
|
session.frames_sent += 1;
|
|
session.fps_calculator.record_frame();
|
|
}
|
|
}
|
|
|
|
/// Get per-client statistics
|
|
pub fn get_clients_stat(&self) -> HashMap<String, crate::events::types::ClientStats> {
|
|
self.clients
|
|
.read()
|
|
.iter()
|
|
.map(|(id, session)| {
|
|
(
|
|
id.clone(),
|
|
crate::events::types::ClientStats {
|
|
id: id.clone(),
|
|
fps: session.fps_calculator.current_fps(),
|
|
connected_secs: session.connected_duration().as_secs(),
|
|
},
|
|
)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Get auto-pause configuration
|
|
pub fn auto_pause_config(&self) -> AutoPauseConfig {
|
|
self.auto_pause_config.read().clone()
|
|
}
|
|
|
|
/// Update auto-pause configuration
|
|
pub fn set_auto_pause_config(&self, config: AutoPauseConfig) {
|
|
let config_clone = config.clone();
|
|
*self.auto_pause_config.write() = config;
|
|
info!(
|
|
"Auto-pause config updated: enabled={}, delay={}s, timeout={}s",
|
|
config_clone.enabled,
|
|
config_clone.shutdown_delay_secs,
|
|
config_clone.client_timeout_secs
|
|
);
|
|
}
|
|
|
|
/// Get current frame (if any)
|
|
pub fn current_frame(&self) -> Option<VideoFrame> {
|
|
(**self.current_frame.load()).clone()
|
|
}
|
|
|
|
/// Subscribe to frame updates
|
|
pub fn subscribe(&self) -> broadcast::Receiver<()> {
|
|
self.frame_notify.subscribe()
|
|
}
|
|
|
|
/// Disconnect all clients (used during config changes)
|
|
/// This clears the client list and sets the stream offline,
|
|
/// which will cause all active MJPEG streams to terminate.
|
|
pub fn disconnect_all_clients(&self) {
|
|
let count = {
|
|
let mut clients = self.clients.write();
|
|
let count = clients.len();
|
|
clients.clear();
|
|
count
|
|
};
|
|
if count > 0 {
|
|
info!("Disconnected all {} MJPEG clients for config change", count);
|
|
}
|
|
// Set offline to signal all streaming tasks to stop
|
|
self.set_offline();
|
|
}
|
|
}
|
|
|
|
impl Default for MjpegStreamHandler {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
/// RAII guard for client lifecycle management
|
|
/// Ensures cleanup even on panic or abrupt disconnection
|
|
pub struct ClientGuard {
|
|
client_id: ClientId,
|
|
handler: Arc<MjpegStreamHandler>,
|
|
}
|
|
|
|
impl ClientGuard {
|
|
/// Create a new client guard
|
|
pub fn new(client_id: ClientId, handler: Arc<MjpegStreamHandler>) -> Self {
|
|
handler.register_client(client_id.clone());
|
|
Self { client_id, handler }
|
|
}
|
|
|
|
/// Get client ID
|
|
pub fn id(&self) -> &ClientId {
|
|
&self.client_id
|
|
}
|
|
}
|
|
|
|
impl Drop for ClientGuard {
|
|
fn drop(&mut self) {
|
|
self.handler.unregister_client(&self.client_id);
|
|
}
|
|
}
|
|
|
|
impl MjpegStreamHandler {
|
|
/// Start stale client cleanup task
|
|
/// Should be called once when handler is created
|
|
pub fn start_cleanup_task(self: Arc<Self>) {
|
|
let handler = self.clone();
|
|
tokio::spawn(async move {
|
|
let mut interval = tokio::time::interval(Duration::from_secs(5));
|
|
|
|
loop {
|
|
interval.tick().await;
|
|
|
|
let timeout_secs = handler.auto_pause_config().client_timeout_secs;
|
|
let timeout = Duration::from_secs(timeout_secs);
|
|
let now = Instant::now();
|
|
let mut stale = Vec::new();
|
|
|
|
// Find stale clients
|
|
{
|
|
let clients = handler.clients.read();
|
|
for (id, session) in clients.iter() {
|
|
if now.duration_since(session.last_activity) > timeout {
|
|
stale.push(id.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove stale clients
|
|
if !stale.is_empty() {
|
|
let mut clients = handler.clients.write();
|
|
for id in stale {
|
|
if let Some(session) = clients.remove(&id) {
|
|
warn!(
|
|
"Removed stale client {} (inactive for {:.1}s)",
|
|
id,
|
|
now.duration_since(session.last_activity).as_secs_f32()
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/// Compare two frames for equality (hash-based, ustreamer-style)
|
|
/// Returns true if frames are identical in geometry and content
|
|
fn frames_are_identical(a: &VideoFrame, b: &VideoFrame) -> bool {
|
|
// Quick checks first (geometry)
|
|
if a.len() != b.len() {
|
|
return false;
|
|
}
|
|
|
|
if a.resolution.width != b.resolution.width || a.resolution.height != b.resolution.height {
|
|
return false;
|
|
}
|
|
|
|
if a.format != b.format {
|
|
return false;
|
|
}
|
|
|
|
if a.stride != b.stride {
|
|
return false;
|
|
}
|
|
|
|
if a.online != b.online {
|
|
return false;
|
|
}
|
|
|
|
// Avoid hashing the whole frame for obviously different frames by sampling a few
|
|
// fixed-size windows first. If all samples match, fall back to the cached hash.
|
|
let a_data = a.data();
|
|
let b_data = b.data();
|
|
let len = a_data.len();
|
|
|
|
// Small frames: direct compare is cheap.
|
|
if len <= 256 {
|
|
return a_data == b_data;
|
|
}
|
|
|
|
const SAMPLE: usize = 16;
|
|
debug_assert!(len == b_data.len());
|
|
|
|
// Head + tail.
|
|
if a_data[..SAMPLE] != b_data[..SAMPLE] {
|
|
return false;
|
|
}
|
|
if a_data[len - SAMPLE..] != b_data[len - SAMPLE..] {
|
|
return false;
|
|
}
|
|
|
|
// Two interior samples (quarter + middle) to catch common "same header/footer" cases.
|
|
let quarter = len / 4;
|
|
let quarter_start = quarter.saturating_sub(SAMPLE / 2);
|
|
if a_data[quarter_start..quarter_start + SAMPLE]
|
|
!= b_data[quarter_start..quarter_start + SAMPLE]
|
|
{
|
|
return false;
|
|
}
|
|
let mid = len / 2;
|
|
let mid_start = mid.saturating_sub(SAMPLE / 2);
|
|
if a_data[mid_start..mid_start + SAMPLE] != b_data[mid_start..mid_start + SAMPLE] {
|
|
return false;
|
|
}
|
|
|
|
// Compare hashes instead of full binary data.
|
|
// Hash is computed once and cached in OnceLock for efficiency.
|
|
a.get_hash() == b.get_hash()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::video::{format::Resolution, PixelFormat};
|
|
use bytes::Bytes;
|
|
|
|
#[tokio::test]
|
|
async fn test_stream_handler() {
|
|
let handler = MjpegStreamHandler::new();
|
|
assert!(!handler.is_online());
|
|
assert_eq!(handler.client_count(), 0);
|
|
|
|
// Create a frame
|
|
let _frame = VideoFrame::new(
|
|
Bytes::from(vec![0xFF, 0xD8, 0x00, 0x00, 0xFF, 0xD9]),
|
|
Resolution::VGA,
|
|
PixelFormat::Mjpeg,
|
|
0,
|
|
1,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_fps_calculator() {
|
|
let mut calc = FpsCalculator::new();
|
|
|
|
// Initially empty
|
|
assert_eq!(calc.current_fps(), 0);
|
|
|
|
// Record some frames
|
|
calc.record_frame();
|
|
calc.record_frame();
|
|
calc.record_frame();
|
|
|
|
// Should have 3 frames in window
|
|
assert!(calc.frame_times.len() == 3);
|
|
}
|
|
}
|