feat: 完善架构优化性能

- 调整音视频架构，提升 RKMPP 编码 MJPEG-->H264 性能，同时解决丢帧马赛克问题；
- 删除多用户逻辑，只保留单用户，支持设置 web 单会话；
- 修复删除体验不好的的回退逻辑，前端页面菜单位置微调；
- 增加 OTG USB 设备动态调整功能；
- 修复 mdns 问题，webrtc 视频切换更顺畅。

src/stream/mjpeg_streamer.rs

@@ -15,11 +15,18 @@
 //!
 //! Note: Audio WebSocket is handled separately by audio_ws.rs (/api/ws/audio)
 
+use std::io;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use tokio::sync::{broadcast, RwLock};
-use tracing::info;
+use tokio::sync::{Mutex, RwLock};
+use tracing::{error, info, warn};
+use v4l::buffer::Type as BufferType;
+use v4l::io::traits::CaptureStream;
+use v4l::prelude::*;
+use v4l::video::Capture;
+use v4l::video::capture::Parameters;
+use v4l::Format;
 
 use crate::audio::AudioController;
 use crate::error::{AppError, Result};
@@ -28,11 +35,16 @@ use crate::hid::HidController;
 use crate::video::capture::{CaptureConfig, VideoCapturer};
 use crate::video::device::{enumerate_devices, find_best_device, VideoDeviceInfo};
 use crate::video::format::{PixelFormat, Resolution};
-use crate::video::frame::VideoFrame;
+use crate::video::frame::{FrameBuffer, FrameBufferPool, VideoFrame};
 
 use super::mjpeg::MjpegStreamHandler;
 use super::ws_hid::WsHidHandler;
 
+/// Minimum valid frame size for capture
+const MIN_CAPTURE_FRAME_SIZE: usize = 128;
+/// Validate JPEG header every N frames to reduce overhead
+const JPEG_VALIDATE_INTERVAL: u64 = 30;
+
 /// MJPEG streamer configuration
 #[derive(Debug, Clone)]
 pub struct MjpegStreamerConfig {
@@ -104,8 +116,6 @@ pub struct MjpegStreamerStats {
     pub mjpeg_clients: u64,
     /// WebSocket HID client count
     pub ws_hid_clients: usize,
-    /// Total frames captured
-    pub frames_captured: u64,
 }
 
 /// MJPEG Streamer
@@ -130,6 +140,9 @@ pub struct MjpegStreamer {
 
     // === Control ===
     start_lock: tokio::sync::Mutex<()>,
+    direct_stop: AtomicBool,
+    direct_active: AtomicBool,
+    direct_handle: Mutex<Option<tokio::task::JoinHandle<()>>>,
     events: RwLock<Option<Arc<EventBus>>>,
     config_changing: AtomicBool,
 }
@@ -148,6 +161,9 @@ impl MjpegStreamer {
             ws_hid_handler: WsHidHandler::new(),
             hid_controller: RwLock::new(None),
             start_lock: tokio::sync::Mutex::new(()),
+            direct_stop: AtomicBool::new(false),
+            direct_active: AtomicBool::new(false),
+            direct_handle: Mutex::new(None),
             events: RwLock::new(None),
             config_changing: AtomicBool::new(false),
         })
@@ -166,6 +182,9 @@ impl MjpegStreamer {
             ws_hid_handler: WsHidHandler::new(),
             hid_controller: RwLock::new(None),
             start_lock: tokio::sync::Mutex::new(()),
+            direct_stop: AtomicBool::new(false),
+            direct_active: AtomicBool::new(false),
+            direct_handle: Mutex::new(None),
             events: RwLock::new(None),
             config_changing: AtomicBool::new(false),
         })
@@ -228,17 +247,22 @@ impl MjpegStreamer {
         let device = self.current_device.read().await;
         let config = self.config.read().await;
 
-        let (resolution, format, frames_captured) =
-            if let Some(ref cap) = *self.capturer.read().await {
-                let stats = cap.stats().await;
+        let (resolution, format) = {
+            if self.direct_active.load(Ordering::Relaxed) {
+                (
+                    Some((config.resolution.width, config.resolution.height)),
+                    Some(config.format.to_string()),
+                )
+            } else if let Some(ref cap) = *self.capturer.read().await {
+                let _ = cap;
                 (
                     Some((config.resolution.width, config.resolution.height)),
                     Some(config.format.to_string()),
-                    stats.frames_captured,
                 )
             } else {
-                (None, None, 0)
-            };
+                (None, None)
+            }
+        };
 
         MjpegStreamerStats {
             state: state.to_string(),
@@ -248,7 +272,6 @@ impl MjpegStreamer {
             fps: config.fps,
             mjpeg_clients: self.mjpeg_handler.client_count(),
             ws_hid_clients: self.ws_hid_handler.client_count(),
-            frames_captured,
         }
     }
 
@@ -266,15 +289,6 @@ impl MjpegStreamer {
         self.ws_hid_handler.clone()
     }
 
-    /// Get frame sender for WebRTC integration
-    pub async fn frame_sender(&self) -> Option<broadcast::Sender<VideoFrame>> {
-        if let Some(ref cap) = *self.capturer.read().await {
-            Some(cap.frame_sender())
-        } else {
-            None
-        }
-    }
-
     // ========================================================================
     // Initialization
     // ========================================================================
@@ -293,6 +307,7 @@ impl MjpegStreamer {
         );
 
         let config = self.config.read().await.clone();
+        self.mjpeg_handler.set_jpeg_quality(config.jpeg_quality);
 
         // Create capture config
         let capture_config = CaptureConfig {
@@ -336,22 +351,23 @@ impl MjpegStreamer {
             return Ok(());
         }
 
-        // Get capturer
-        let capturer = self.capturer.read().await.clone();
-        let capturer =
-            capturer.ok_or_else(|| AppError::VideoError("Not initialized".to_string()))?;
+        let device = self
+            .current_device
+            .read()
+            .await
+            .clone()
+            .ok_or_else(|| AppError::VideoError("Not initialized".to_string()))?;
 
-        // Start capture
-        capturer.start().await?;
+        let config = self.config.read().await.clone();
 
-        // Start frame forwarding task
-        let handler = self.mjpeg_handler.clone();
-        let mut frame_rx = capturer.frame_sender().subscribe();
-        tokio::spawn(async move {
-            while let Ok(frame) = frame_rx.recv().await {
-                handler.update_frame(frame);
-            }
+        self.direct_stop.store(false, Ordering::SeqCst);
+        self.direct_active.store(true, Ordering::SeqCst);
+
+        let streamer = self.clone();
+        let handle = tokio::task::spawn_blocking(move || {
+            streamer.run_direct_capture(device.path, config);
         });
+        *self.direct_handle.lock().await = Some(handle);
 
         // Note: Audio WebSocket is handled separately by audio_ws.rs (/api/ws/audio)
 
@@ -370,7 +386,14 @@ impl MjpegStreamer {
             return Ok(());
         }
 
-        // Stop capturer
+        self.direct_stop.store(true, Ordering::SeqCst);
+
+        if let Some(handle) = self.direct_handle.lock().await.take() {
+            let _ = handle.await;
+        }
+        self.direct_active.store(false, Ordering::SeqCst);
+
+        // Stop capturer (legacy path)
         if let Some(ref cap) = *self.capturer.read().await {
             let _ = cap.stop().await;
         }
@@ -412,6 +435,7 @@ impl MjpegStreamer {
 
         // Update config
         *self.config.write().await = config.clone();
+        self.mjpeg_handler.set_jpeg_quality(config.jpeg_quality);
 
         // Re-initialize if device path is set
         if let Some(ref path) = config.device_path {
@@ -448,6 +472,202 @@ impl MjpegStreamer {
             });
         }
     }
+
+    /// Direct capture loop for MJPEG mode (single loop, no broadcast)
+    fn run_direct_capture(self: Arc<Self>, device_path: PathBuf, config: MjpegStreamerConfig) {
+        const MAX_RETRIES: u32 = 5;
+        const RETRY_DELAY_MS: u64 = 200;
+
+        let handle = tokio::runtime::Handle::current();
+        let mut last_state = MjpegStreamerState::Streaming;
+
+        let mut set_state = |new_state: MjpegStreamerState| {
+            if new_state != last_state {
+                handle.block_on(async {
+                    *self.state.write().await = new_state;
+                    self.publish_state_change().await;
+                });
+                last_state = new_state;
+            }
+        };
+
+        let mut device_opt: Option<Device> = None;
+        let mut format_opt: Option<Format> = None;
+        let mut last_error: Option<String> = None;
+
+        for attempt in 0..MAX_RETRIES {
+            if self.direct_stop.load(Ordering::Relaxed) {
+                self.direct_active.store(false, Ordering::SeqCst);
+                return;
+            }
+
+            let device = match Device::with_path(&device_path) {
+                Ok(d) => d,
+                Err(e) => {
+                    let err_str = e.to_string();
+                    if err_str.contains("busy") || err_str.contains("resource") {
+                        warn!(
+                            "Device busy on attempt {}/{}, retrying in {}ms...",
+                            attempt + 1,
+                            MAX_RETRIES,
+                            RETRY_DELAY_MS
+                        );
+                        std::thread::sleep(std::time::Duration::from_millis(RETRY_DELAY_MS));
+                        last_error = Some(err_str);
+                        continue;
+                    }
+                    last_error = Some(err_str);
+                    break;
+                }
+            };
+
+            let requested = Format::new(
+                config.resolution.width,
+                config.resolution.height,
+                config.format.to_fourcc(),
+            );
+
+            match device.set_format(&requested) {
+                Ok(actual) => {
+                    device_opt = Some(device);
+                    format_opt = Some(actual);
+                    break;
+                }
+                Err(e) => {
+                    let err_str = e.to_string();
+                    if err_str.contains("busy") || err_str.contains("resource") {
+                        warn!(
+                            "Device busy on set_format attempt {}/{}, retrying in {}ms...",
+                            attempt + 1,
+                            MAX_RETRIES,
+                            RETRY_DELAY_MS
+                        );
+                        std::thread::sleep(std::time::Duration::from_millis(RETRY_DELAY_MS));
+                        last_error = Some(err_str);
+                        continue;
+                    }
+                    last_error = Some(err_str);
+                    break;
+                }
+            }
+        }
+
+        let (device, actual_format) = match (device_opt, format_opt) {
+            (Some(d), Some(f)) => (d, f),
+            _ => {
+                error!(
+                    "Failed to open device {:?}: {}",
+                    device_path,
+                    last_error.unwrap_or_else(|| "unknown error".to_string())
+                );
+                set_state(MjpegStreamerState::Error);
+                self.mjpeg_handler.set_offline();
+                self.direct_active.store(false, Ordering::SeqCst);
+                return;
+            }
+        };
+
+        info!(
+            "Capture format: {}x{} {:?} stride={}",
+            actual_format.width, actual_format.height, actual_format.fourcc, actual_format.stride
+        );
+
+        let resolution = Resolution::new(actual_format.width, actual_format.height);
+        let pixel_format =
+            PixelFormat::from_fourcc(actual_format.fourcc).unwrap_or(config.format);
+
+        if config.fps > 0 {
+            if let Err(e) = device.set_params(&Parameters::with_fps(config.fps)) {
+                warn!("Failed to set hardware FPS: {}", e);
+            }
+        }
+
+        let mut stream = match MmapStream::with_buffers(&device, BufferType::VideoCapture, 4) {
+            Ok(s) => s,
+            Err(e) => {
+                error!("Failed to create capture stream: {}", e);
+                set_state(MjpegStreamerState::Error);
+                self.mjpeg_handler.set_offline();
+                self.direct_active.store(false, Ordering::SeqCst);
+                return;
+            }
+        };
+
+        let buffer_pool = Arc::new(FrameBufferPool::new(8));
+        let mut signal_present = true;
+        let mut sequence: u64 = 0;
+        let mut validate_counter: u64 = 0;
+
+        while !self.direct_stop.load(Ordering::Relaxed) {
+            let (buf, meta) = match stream.next() {
+                Ok(frame_data) => frame_data,
+                Err(e) => {
+                    if e.kind() == io::ErrorKind::TimedOut {
+                        if signal_present {
+                            signal_present = false;
+                            set_state(MjpegStreamerState::NoSignal);
+                        }
+                        std::thread::sleep(std::time::Duration::from_millis(100));
+                        continue;
+                    }
+
+                    let is_device_lost = match e.raw_os_error() {
+                        Some(6) => true,   // ENXIO
+                        Some(19) => true,  // ENODEV
+                        Some(5) => true,   // EIO
+                        Some(32) => true,  // EPIPE
+                        Some(108) => true, // ESHUTDOWN
+                        _ => false,
+                    };
+
+                    if is_device_lost {
+                        error!("Video device lost: {} - {}", device_path.display(), e);
+                        set_state(MjpegStreamerState::Error);
+                        self.mjpeg_handler.set_offline();
+                        self.direct_active.store(false, Ordering::SeqCst);
+                        return;
+                    }
+
+                    error!("Capture error: {}", e);
+                    continue;
+                }
+            };
+
+            let frame_size = meta.bytesused as usize;
+            if frame_size < MIN_CAPTURE_FRAME_SIZE {
+                continue;
+            }
+
+            validate_counter = validate_counter.wrapping_add(1);
+            if pixel_format.is_compressed()
+                && validate_counter % JPEG_VALIDATE_INTERVAL == 0
+                && !VideoFrame::is_valid_jpeg_bytes(&buf[..frame_size])
+            {
+                continue;
+            }
+
+            let mut owned = buffer_pool.take(frame_size);
+            owned.resize(frame_size, 0);
+            owned[..frame_size].copy_from_slice(&buf[..frame_size]);
+            let frame = VideoFrame::from_pooled(
+                Arc::new(FrameBuffer::new(owned, Some(buffer_pool.clone()))),
+                resolution,
+                pixel_format,
+                actual_format.stride,
+                sequence,
+            );
+            sequence = sequence.wrapping_add(1);
+
+            if !signal_present {
+                signal_present = true;
+                set_state(MjpegStreamerState::Streaming);
+            }
+
+            self.mjpeg_handler.update_frame(frame);
+        }
+
+        self.direct_active.store(false, Ordering::SeqCst);
+    }
 }
 
 impl Default for MjpegStreamer {
@@ -463,6 +683,9 @@ impl Default for MjpegStreamer {
             ws_hid_handler: WsHidHandler::new(),
             hid_controller: RwLock::new(None),
             start_lock: tokio::sync::Mutex::new(()),
+            direct_stop: AtomicBool::new(false),
+            direct_active: AtomicBool::new(false),
+            direct_handle: Mutex::new(None),
             events: RwLock::new(None),
             config_changing: AtomicBool::new(false),
         }