feat: AI's refactoring

backend/src/engine.rs

@@ -0,0 +1,176 @@
+use std::num::NonZero;
+use std::thread;
+use std::time::{Duration, Instant};
+
+use anyhow::{Context, Result};
+use tokio::sync::broadcast;
+use tracing::{error, info, warn};
+use vpx_rs::enc::{CodecId, EncoderFrameFlags, EncodingDeadline};
+use vpx_rs::{Encoder, EncoderConfig, RateControl, Timebase};
+use scap::capturer::{Area, Capturer, Options, Point, Resolution, Size};
+use scap::frame::FrameType;
+
+use crate::config::Args;
+use crate::pixelutil;
+
+/// Represents a video packet to be sent to clients.
+#[derive(Clone, Debug)]
+pub struct VideoPacket {
+    pub data: Vec<u8>,
+    pub is_key: bool,
+}
+
+/// Manages video capture and encoding.
+pub struct VideoEngine {
+    args: Args,
+    packet_tx: broadcast::Sender<VideoPacket>,
+    shutdown_tx: broadcast::Sender<()>,
+}
+
+impl VideoEngine {
+    pub fn new(args: Args) -> Self {
+        let (packet_tx, _) = broadcast::channel(100);
+        let (shutdown_tx, _) = broadcast::channel(1);
+        Self {
+            args,
+            packet_tx,
+            shutdown_tx,
+        }
+    }
+
+    pub fn subscribe(&self) -> broadcast::Receiver<VideoPacket> {
+        self.packet_tx.subscribe()
+    }
+
+    pub fn start(&self) {
+        let args = self.args.clone();
+        let packet_tx = self.packet_tx.clone();
+        let mut shutdown_rx = self.shutdown_tx.subscribe();
+
+        // Spawn the capture/encode loop in a separate dedicated thread
+        // because it involves blocking heavy computation.
+        thread::spawn(move || {
+            if let Err(e) = run_capture_loop(args, packet_tx, &mut shutdown_rx) {
+                error!("Capture loop failed: {:?}", e);
+            }
+        });
+    }
+
+    #[allow(dead_code)]
+    pub fn stop(&self) {
+        let _ = self.shutdown_tx.send(());
+    }
+}
+
+fn run_capture_loop(
+    args: Args,
+    packet_tx: broadcast::Sender<VideoPacket>,
+    shutdown_rx: &mut broadcast::Receiver<()>,
+) -> Result<()> {
+    // 1. Setup Capturer
+    let options = Options {
+        fps: args.fps,
+        show_cursor: true,
+        show_highlight: true,
+        output_type: FrameType::YUVFrame,
+        output_resolution: Resolution::_1080p,
+        crop_area: Some(Area {
+            origin: Point { x: 0.0, y: 0.0 },
+            size: Size {
+                width: args.width as f64,
+                height: args.height as f64,
+            },
+        }),
+        ..Default::default()
+    };
+
+    let mut capturer = Capturer::build(options).context("Failed to build capturer")?;
+    capturer.start_capture();
+
+    // 2. Setup Encoder
+    let mut config = EncoderConfig::<u8>::new(
+        CodecId::VP9,
+        args.width,
+        args.height,
+        Timebase {
+            num: NonZero::new(1).unwrap(),
+            den: NonZero::new(args.fps).unwrap(),
+        },
+        RateControl::ConstantBitRate(args.bitrate),
+    )
+    .context("Failed to create encoder config")?;
+    
+    config.threads = 4; // Use reasonable number of threads
+    config.lag_in_frames = 0; // Low latency
+
+    let mut encoder = Encoder::new(config).context("Failed to create encoder")?;
+
+    let frame_duration = Duration::from_secs_f64(1.0 / args.fps as f64);
+    let mut next_frame_time = Instant::now();
+    let mut pts: i64 = 0;
+
+    info!("Starting capture loop: {}x{} @ {}fps", args.width, args.height, args.fps);
+
+    loop {
+        // Check for shutdown signal
+        if shutdown_rx.try_recv().is_ok() {
+            info!("Shutting down capture loop");
+            break;
+        }
+
+        let now = Instant::now();
+        if now < next_frame_time {
+            thread::sleep(next_frame_time - now);
+        }
+        next_frame_time += frame_duration;
+
+        match capturer.get_next_frame() {
+            Ok(captured_frame) => {
+                // Convert frame
+                let yuv_buffer = pixelutil::frame_to_yuv(captured_frame);
+                let yuv_image = pixelutil::apply_frame(&yuv_buffer, args.width as usize, args.height as usize);
+
+                // Encode
+                // For real-time streaming, we force keyframes periodically could be an improvement,
+                // but for now relying on default behavior or client requests (not impl here).
+                let flags = EncoderFrameFlags::empty(); 
+                
+                match encoder.encode(
+                    pts,
+                    1, // Duration (in timebase units)
+                    yuv_image,
+                    EncodingDeadline::Realtime,
+                    flags,
+                ) {
+                    Ok(packets) => {
+                         for packet in packets {
+                            if let vpx_rs::Packet::CompressedFrame(frame) = packet {
+                                let video_packet = VideoPacket {
+                                    data: frame.data.to_vec(),
+                                    is_key: frame.flags.is_key,
+                                };
+                                
+                                // Broadcast to all connected clients
+                                // It's okay if no one is listening
+                                let _ = packet_tx.send(video_packet);
+                            }
+                        }
+                        pts += 1;
+                    },
+                    Err(e) => {
+                        error!("Encoding error: {:?}", e);
+                        // Continue loop, maybe transient
+                    }
+                }
+            }
+            Err(e) => {
+                // Scap might return error if no frame is available yet or other issues
+                // We just log debug/warn and continue
+                 warn!("Capture error (might be transient): {:?}", e);
+                 thread::sleep(Duration::from_millis(10));
+            }
+        }
+    }
+
+    Ok(())
+}