opt: read uint8list directly from rust codes

src/client.rs

@@ -817,7 +817,7 @@ impl AudioHandler {
 pub struct VideoHandler {
     decoder: Decoder,
     latency_controller: Arc<Mutex<LatencyController>>,
-    pub rgb: Arc<RwLock<Vec<u8>>>,
+    pub rgb: Vec<u8>,
     recorder: Arc<Mutex<Option<Recorder>>>,
     record: bool,
 }
@@ -850,7 +850,7 @@ impl VideoHandler {
         }
         match &vf.union {
             Some(frame) => {
-                let res = self.decoder.handle_video_frame(frame, &mut self.rgb.write().unwrap());
+                let res = self.decoder.handle_video_frame(frame, &mut self.rgb);
                 if self.record {
                     self.recorder
                         .lock()
@@ -1545,7 +1545,7 @@ pub type MediaSender = mpsc::Sender<MediaData>;
 /// * `video_callback` - The callback for video frame. Being called when a video frame is ready.
 pub fn start_video_audio_threads<F>(video_callback: F) -> (MediaSender, MediaSender)
 where
-    F: 'static + FnMut(Arc<RwLock<Vec<u8>>>) + Send,
+    F: 'static + FnMut(&mut Vec<u8>) + Send,
 {
     let (video_sender, video_receiver) = mpsc::channel::<MediaData>();
     let mut video_callback = video_callback;
@@ -1560,7 +1560,7 @@ where
                 match data {
                     MediaData::VideoFrame(vf) => {
                         if let Ok(true) = video_handler.handle_frame(vf) {
-                            video_callback(video_handler.rgb.clone());
+                            video_callback(&mut video_handler.rgb);
                         }
                     }
                     MediaData::Reset => {

src/flutter.rs

@@ -15,7 +15,7 @@ use std::{
     os::raw::{c_char, c_int},
     sync::{Arc, RwLock},
 };
-use libc::memcpy;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 pub(super) const APP_TYPE_MAIN: &str = "main";
 pub(super) const APP_TYPE_CM: &str = "cm";
@@ -111,8 +111,10 @@ pub unsafe extern "C" fn free_c_args(ptr: *mut *mut c_char, len: c_int) {
 #[derive(Default, Clone)]
 pub struct FlutterHandler {
     pub event_stream: Arc<RwLock<Option<StreamSink<EventToUI>>>>,
+    // SAFETY: [rgba] is guarded by [rgba_valid], and it's safe to reach [rgba] with `rgba_valid == true`.
+    // We must check the `rgba_valid` before reading [rgba].
     pub rgba: Arc<RwLock<Vec<u8>>>,
-    pub rgba_valid: Arc<RwLock<bool>>
+    pub rgba_valid: Arc<AtomicBool>
 }
 
 impl FlutterHandler {
@@ -291,18 +293,18 @@ impl InvokeUiSession for FlutterHandler {
     // unused in flutter
     fn adapt_size(&self) {}
 
-    fn on_rgba(&self, data: Arc<RwLock<Vec<u8>>>) {
+    fn on_rgba(&self, data: &mut Vec<u8>) {
         // If the current rgba is not fetched by flutter, i.e., is valid.
         // We give up sending a new event to flutter.
-        if *self.rgba_valid.read().unwrap() {
+        if self.rgba_valid.load(Ordering::Relaxed) {
             return;
         }
+        self.rgba_valid.store(true, Ordering::Relaxed);
         // Return the rgba buffer to the video handler for reusing allocated rgba buffer.
-        std::mem::swap::<Vec<u8>>(data.write().unwrap().as_mut(), self.rgba.write().unwrap().as_mut());
+        std::mem::swap::<Vec<u8>>(data, &mut *self.rgba.write().unwrap());
         if let Some(stream) = &*self.event_stream.read().unwrap() {
             stream.add(EventToUI::Rgba);
         }
-        let _ = std::mem::replace(&mut *self.rgba_valid.write().unwrap(), true);
     }
 
     fn set_peer_info(&self, pi: &PeerInfo) {
@@ -421,13 +423,17 @@ impl InvokeUiSession for FlutterHandler {
         self.push_event("on_voice_call_incoming", [].into());
     }
 
-    fn get_rgba(&mut self, buffer: *mut u8) {
-        // [Safety]
-        // * It must be ensures the buffer has enough space to place the whole rgba.
-        let max_len = self.rgba.read().unwrap().len();
-        unsafe { std::ptr::copy_nonoverlapping(self.rgba.read().unwrap().as_ptr(), buffer, max_len)};
-        // mark the rgba has been taken from flutter.
-        let _ = std::mem::replace(&mut *self.rgba_valid.write().unwrap(), false);
+    #[inline]
+    fn get_rgba(&self) -> *const u8 {
+        if self.rgba_valid.load(Ordering::Relaxed) {
+            return self.rgba.read().unwrap().as_ptr();
+        }
+        std::ptr::null_mut()
+    }
+
+    #[inline]
+    fn next_rgba(&mut self) {
+        self.rgba_valid.store(false, Ordering::Relaxed);
     }
 }
 
@@ -668,11 +674,22 @@ pub fn session_get_rgba_size(id: *const char) -> usize {
 }
 
 #[no_mangle]
-pub fn session_get_rgba(id: *const char, buffer: *mut u8) {
+pub fn session_get_rgba(id: *const char) -> *const u8 {
     let id = unsafe { std::ffi::CStr::from_ptr(id as _) };
     if let Ok(id) = id.to_str() {
         if let Some(session) = SESSIONS.write().unwrap().get_mut(id) {
-            return session.get_rgba(buffer);
+            return session.get_rgba();
+        }
+    }
+    std::ptr::null()
+}
+
+#[no_mangle]
+pub fn session_next_rgba(id: *const char) {
+    let id = unsafe { std::ffi::CStr::from_ptr(id as _) };
+    if let Ok(id) = id.to_str() {
+        if let Some(session) = SESSIONS.write().unwrap().get_mut(id) {
+            return session.next_rgba();
         }
     }
 }

src/ui/remote.rs

@@ -203,12 +203,12 @@ impl InvokeUiSession for SciterHandler {
         self.call("adaptSize", &make_args!());
     }
 
-    fn on_rgba(&self, data: Arc<RwLock<Vec<u8>>>) {
+    fn on_rgba(&self, data: &mut Vec<u8>) {
         VIDEO
             .lock()
             .unwrap()
             .as_mut()
-            .map(|v| v.render_frame(data.read().unwrap().as_ref()).ok());
+            .map(|v| v.render_frame(data).ok());
     }
 
     fn set_peer_info(&self, pi: &PeerInfo) {
@@ -286,7 +286,9 @@ impl InvokeUiSession for SciterHandler {
     }
 
     /// RGBA is directly rendered by [on_rgba]. No need to store the rgba for the sciter ui.
-    fn get_rgba(&mut self, _buffer: *mut u8)  {}
+    fn get_rgba(&self) -> *const u8  { std::ptr::null() }
+
+    fn next_rgba(&mut self) {}
 }
 
 pub struct SciterSession(Session<SciterHandler>);

src/ui_session_interface.rs

@@ -712,7 +712,7 @@ pub trait InvokeUiSession: Send + Sync + Clone + 'static + Sized + Default {
     fn update_block_input_state(&self, on: bool);
     fn job_progress(&self, id: i32, file_num: i32, speed: f64, finished_size: f64);
     fn adapt_size(&self);
-    fn on_rgba(&self, data: Arc<RwLock<Vec<u8>>>);
+    fn on_rgba(&self, data: &mut Vec<u8>);
     fn msgbox(&self, msgtype: &str, title: &str, text: &str, link: &str, retry: bool);
     #[cfg(any(target_os = "android", target_os = "ios"))]
     fn clipboard(&self, content: String);
@@ -722,7 +722,8 @@ pub trait InvokeUiSession: Send + Sync + Clone + 'static + Sized + Default {
     fn on_voice_call_closed(&self, reason: &str);
     fn on_voice_call_waiting(&self);
     fn on_voice_call_incoming(&self);
-    fn get_rgba(&mut self, buffer: *mut u8);
+    fn get_rgba(&self) -> *const u8;
+    fn next_rgba(&mut self);
 }
 
 impl<T: InvokeUiSession> Deref for Session<T> {
@@ -957,7 +958,7 @@ pub async fn io_loop<T: InvokeUiSession>(handler: Session<T>) {
     let frame_count = Arc::new(AtomicUsize::new(0));
     let frame_count_cl = frame_count.clone();
     let ui_handler = handler.ui_handler.clone();
-    let (video_sender, audio_sender) = start_video_audio_threads(move |data: Arc<RwLock<Vec<u8>>> | {
+    let (video_sender, audio_sender) = start_video_audio_threads(move |data: &mut Vec<u8> | {
         frame_count_cl.fetch_add(1, Ordering::Relaxed);
         ui_handler.on_rgba(data);
     });