refactor: 删除部分多余的代码和注释

src/rustdesk/frame_adapters.rs

@@ -1,8 +1,3 @@
-//! RustDesk Frame Adapters
-//!
-//! Converts One-KVM video/audio frames to RustDesk protocol format.
-//! Optimized for zero-copy where possible and buffer reuse.
-
 use bytes::Bytes;
 use protobuf::Message as ProtobufMessage;
 
@@ -11,7 +6,6 @@ use super::protocol::hbb::message::{
     CursorData, CursorPosition, EncodedVideoFrame, EncodedVideoFrames, Message, Misc, VideoFrame,
 };
 
-/// Video codec type for RustDesk
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum VideoCodec {
     H264,
@@ -22,7 +16,6 @@ pub enum VideoCodec {
 }
 
 impl VideoCodec {
-    /// Get the codec ID for the RustDesk protocol
     pub fn to_codec_id(self) -> i32 {
         match self {
             VideoCodec::H264 => 0,
@@ -34,21 +27,15 @@ impl VideoCodec {
     }
 }
 
-/// Video frame adapter for converting to RustDesk format
 pub struct VideoFrameAdapter {
-    /// Current codec
     codec: VideoCodec,
-    /// Frame sequence number
     seq: u32,
-    /// Timestamp offset
     timestamp_base: u64,
-    /// Cached H264 SPS/PPS (Annex B NAL without start code)
     h264_sps: Option<Bytes>,
     h264_pps: Option<Bytes>,
 }
 
 impl VideoFrameAdapter {
-    /// Create a new video frame adapter
     pub fn new(codec: VideoCodec) -> Self {
         Self {
             codec,
@@ -59,14 +46,10 @@ impl VideoFrameAdapter {
         }
     }
 
-    /// Set codec type
     pub fn set_codec(&mut self, codec: VideoCodec) {
         self.codec = codec;
     }
 
-    /// Convert encoded video data to RustDesk Message (zero-copy version)
-    ///
-    /// This version takes Bytes directly to avoid copying the frame data.
     pub fn encode_frame_from_bytes(
         &mut self,
         data: Bytes,
@@ -74,7 +57,6 @@ impl VideoFrameAdapter {
         timestamp_ms: u64,
     ) -> Message {
         let data = self.prepare_h264_frame(data, is_keyframe);
-        // Calculate relative timestamp
         if self.seq == 0 {
             self.timestamp_base = timestamp_ms;
         }
@@ -87,11 +69,9 @@ impl VideoFrameAdapter {
 
         self.seq = self.seq.wrapping_add(1);
 
-        // Wrap in EncodedVideoFrames container
         let mut frames = EncodedVideoFrames::new();
         frames.frames.push(frame);
 
-        // Create the appropriate VideoFrame variant based on codec
         let mut video_frame = VideoFrame::new();
         match self.codec {
             VideoCodec::H264 => video_frame.union = Some(vf_union::Union::H264s(frames)),
@@ -111,7 +91,6 @@ impl VideoFrameAdapter {
             return data;
         }
 
-        // Parse SPS/PPS from Annex B data (without start codes)
         let (sps, pps) = crate::webrtc::rtp::extract_sps_pps(&data);
         let mut has_sps = false;
         let mut has_pps = false;
@@ -125,7 +104,6 @@ impl VideoFrameAdapter {
             has_pps = true;
         }
 
-        // Inject cached SPS/PPS before IDR when missing
         if is_keyframe && (!has_sps || !has_pps) {
             if let (Some(sps), Some(pps)) = (self.h264_sps.as_ref(), self.h264_pps.as_ref()) {
                 let mut out = Vec::with_capacity(8 + sps.len() + pps.len() + data.len());
@@ -141,14 +119,10 @@ impl VideoFrameAdapter {
         data
     }
 
-    /// Convert encoded video data to RustDesk Message
     pub fn encode_frame(&mut self, data: &[u8], is_keyframe: bool, timestamp_ms: u64) -> Message {
         self.encode_frame_from_bytes(Bytes::copy_from_slice(data), is_keyframe, timestamp_ms)
     }
 
-    /// Encode frame to bytes for sending (zero-copy version)
-    ///
-    /// Takes Bytes directly to avoid copying the frame data.
     pub fn encode_frame_bytes_zero_copy(
         &mut self,
         data: Bytes,
@@ -159,7 +133,6 @@ impl VideoFrameAdapter {
         Bytes::from(msg.write_to_bytes().unwrap_or_default())
     }
 
-    /// Encode frame to bytes for sending
     pub fn encode_frame_bytes(
         &mut self,
         data: &[u8],
@@ -169,24 +142,18 @@ impl VideoFrameAdapter {
         self.encode_frame_bytes_zero_copy(Bytes::copy_from_slice(data), is_keyframe, timestamp_ms)
     }
 
-    /// Get current sequence number
     pub fn seq(&self) -> u32 {
         self.seq
     }
 }
 
-/// Audio frame adapter for converting to RustDesk format
 pub struct AudioFrameAdapter {
-    /// Sample rate
     sample_rate: u32,
-    /// Channels
     channels: u8,
-    /// Format sent flag
     format_sent: bool,
 }
 
 impl AudioFrameAdapter {
-    /// Create a new audio frame adapter
     pub fn new(sample_rate: u32, channels: u8) -> Self {
         Self {
             sample_rate,
@@ -195,7 +162,6 @@ impl AudioFrameAdapter {
         }
     }
 
-    /// Create audio format message (should be sent once before audio frames)
     pub fn create_format_message(&mut self) -> Message {
         self.format_sent = true;
 
@@ -211,12 +177,10 @@ impl AudioFrameAdapter {
         msg
     }
 
-    /// Check if format message has been sent
     pub fn format_sent(&self) -> bool {
         self.format_sent
     }
 
-    /// Convert Opus audio data to RustDesk Message
     pub fn encode_opus_frame(&self, data: &[u8]) -> Message {
         let mut frame = AudioFrame::new();
         frame.data = Bytes::copy_from_slice(data);
@@ -226,23 +190,19 @@ impl AudioFrameAdapter {
         msg
     }
 
-    /// Encode Opus frame to bytes for sending
     pub fn encode_opus_bytes(&self, data: &[u8]) -> Bytes {
         let msg = self.encode_opus_frame(data);
         Bytes::from(msg.write_to_bytes().unwrap_or_default())
     }
 
-    /// Reset state (call when restarting audio stream)
     pub fn reset(&mut self) {
         self.format_sent = false;
     }
 }
 
-/// Cursor data adapter
 pub struct CursorAdapter;
 
 impl CursorAdapter {
-    /// Create cursor data message
     pub fn encode_cursor(
         id: u64,
         hotx: i32,
@@ -264,7 +224,6 @@ impl CursorAdapter {
         msg
     }
 
-    /// Create cursor position message
     pub fn encode_position(x: i32, y: i32) -> Message {
         let mut pos = CursorPosition::new();
         pos.x = x;
@@ -284,7 +243,6 @@ mod tests {
     fn test_video_frame_encoding() {
         let mut adapter = VideoFrameAdapter::new(VideoCodec::H264);
 
-        // Encode a keyframe
         let data = vec![0x00, 0x00, 0x00, 0x01, 0x67]; // H264 SPS NAL
         let msg = adapter.encode_frame(&data, true, 0);
 
@@ -324,7 +282,6 @@ mod tests {
     fn test_audio_frame_encoding() {
         let adapter = AudioFrameAdapter::new(48000, 2);
 
-        // Encode an Opus frame
         let opus_data = vec![0xFC, 0x01, 0x02]; // Fake Opus data
         let msg = adapter.encode_opus_frame(&opus_data);