将rgb转换为yuv传输

Author: pysrc

dsclient/src/client.rs

@@ -1,4 +1,4 @@
-use flate2::write::ZlibDecoder;
+use flate2::write::DeflateDecoder;
 use fltk::button::Button;
 use fltk::draw;
 use fltk::enums::Color;
@@ -65,55 +65,6 @@ fn depack(buffer: &[u8]) -> usize {
     ((buffer[0] as usize) << 16) | ((buffer[1] as usize) << 8) | (buffer[2] as usize)
 }
 
-struct DefDecoder {
-    decoder: ZlibDecoder<Vec<u8>>,
-}
-
-impl DefDecoder {
-    #[inline]
-    fn new(mut swap: Vec<u8>) -> Self {
-        unsafe {
-            swap.set_len(0);
-        }
-        Self {
-            decoder: ZlibDecoder::new(swap),
-        }
-    }
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) {
-        self.decoder.write_all(buf).unwrap();
-    }
-    #[inline]
-    fn read(&mut self, mut swap: Vec<u8>) -> Vec<u8> {
-        unsafe {
-            swap.set_len(0);
-        }
-        let s = self.decoder.reset(swap).unwrap();
-        return s;
-    }
-}
-
-/*
-a: 老图像
-b: 压缩图像
-return: 新图像, 老图像
- */
-#[inline]
-fn unzip_and_swap(
-    mut unzip: DefDecoder,
-    a: Vec<u8>,
-    mut b: Vec<u8>,
-) -> (DefDecoder, Vec<u8>, Vec<u8>) {
-    // 解压
-    unzip.write_all(&mut b);
-    let mut b = unzip.read(b);
-    // 计算差异
-    b.par_iter_mut().zip(a.par_iter()).for_each(|(d1, d2)| {
-        *d1 ^= *d2;
-    });
-    return (unzip, b, a);
-}
-
 fn draw(host: String, pwd: String) {
     let mut conn = TcpStream::connect(host).unwrap();
     // 认证
@@ -286,10 +237,12 @@ fn draw(host: String, pwd: String) {
     let (tx, rx) = app::channel::<Msg>();
 
     std::thread::spawn(move || {
-        let a = Vec::<u8>::with_capacity(dlen);
-        let mut b = Vec::<u8>::with_capacity(dlen);
-        let c = Vec::<u8>::with_capacity(dlen);
-        let mut unzip = DefDecoder::new(c);
+        let u = (w * h) as usize;
+        let v = u + u/4;
+        let mut yuv = Vec::<u8>::new();
+        let mut _yuv = Vec::<u8>::new();
+        let mut buf = Vec::<u8>::new();
+
         // FPS
         let mut last = std::time::Instant::now();
         let mut fps = 0u8;
@@ -304,18 +257,25 @@ fn draw(host: String, pwd: String) {
         }
         let recv_len = depack(&header);
         _length_sum += recv_len;
-        unsafe {
-            b.set_len(recv_len);
+        
+        if buf.capacity() < recv_len {
+            buf.resize(recv_len, 0u8);
         }
-        if let Err(e) = conn.read_exact(&mut b) {
+        if let Err(e) = conn.read_exact(&mut buf) {
             println!("error {}", e);
             return;
         }
-        unzip.write_all(&b);
-        let mut a = unzip.read(a);
+        unsafe {
+            yuv.set_len(0);
+        }
+        let mut d = DeflateDecoder::new(yuv);
+        d.write_all(&buf).unwrap();
+        yuv = d.reset(Vec::new()).unwrap();
+
         if let Ok(mut _buf) = work_buf.write() {
-            _buf.copy_from_slice(&a);
+            dscom::convert::i420_to_rgb(w as usize, h as usize, &yuv[..u], &yuv[u..v], &yuv[v..], &mut _buf);
         }
+        (_yuv, yuv) = (yuv, _yuv);
         tx.send(Msg::Draw);
 
         loop {
@@ -324,16 +284,31 @@ fn draw(host: String, pwd: String) {
             }
             let recv_len = depack(&header);
             _length_sum += recv_len;
-            unsafe {
-                b.set_len(recv_len);
+            
+            if buf.capacity() < recv_len {
+                buf.resize(recv_len, 0u8);
+            } else {
+                unsafe {
+                    buf.set_len(recv_len);
+                }
             }
-            if let Err(_) = conn.read_exact(&mut b) {
+            if let Err(_) = conn.read_exact(&mut buf) {
                 return;
             }
-            (unzip, a, b) = unzip_and_swap(unzip, a, b);
+            unsafe {
+                yuv.set_len(0);
+            }
+            d.write_all(&buf).unwrap();
+            yuv = d.reset(yuv).unwrap();
+
+            yuv.par_iter_mut().zip(_yuv.par_iter()).for_each(|(a, b)| {
+                *a = b.wrapping_sub(*a);
+            });
+
             if let Ok(mut _buf) = work_buf.write() {
-                _buf.copy_from_slice(&a);
+                dscom::convert::i420_to_rgb(w as usize, h as usize, &yuv[..u], &yuv[u..v], &yuv[v..], &mut _buf);
             }
+            (_yuv, yuv) = (yuv, _yuv);
             {
                 let cur = std::time::Instant::now();
                 let dur = cur.duration_since(last);

dsclient/src/main.rs

@@ -1,4 +1,4 @@
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+// #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 mod bitmap;
 mod client;
 

dscom/src/convert.rs

@@ -0,0 +1,70 @@
+pub fn bgra_to_i420(width: usize, height: usize, src: &[u8], dest: &mut Vec<u8>) {
+    let stride = src.len() / height;
+    unsafe {
+        dest.set_len(0);
+    }
+
+    for y in 0..height {
+        for x in 0..width {
+            let o = y * stride + 4 * x;
+
+            let b = src[o] as i32;
+            let g = src[o + 1] as i32;
+            let r = src[o + 2] as i32;
+
+            let y = (66 * r + 129 * g + 25 * b + 128) / 256 + 16;
+            dest.push(clamp(y));
+        }
+    }
+
+    for y in (0..height).step_by(2) {
+        for x in (0..width).step_by(2) {
+            let o = y * stride + 4 * x;
+
+            let b = src[o] as i32;
+            let g = src[o + 1] as i32;
+            let r = src[o + 2] as i32;
+
+            let u = (-38 * r - 74 * g + 112 * b + 128) / 256 + 128;
+            dest.push(clamp(u));
+        }
+    }
+
+    for y in (0..height).step_by(2) {
+        for x in (0..width).step_by(2) {
+            let o = y * stride + 4 * x;
+
+            let b = src[o] as i32;
+            let g = src[o + 1] as i32;
+            let r = src[o + 2] as i32;
+
+            let v = (112 * r - 94 * g - 18 * b + 128) / 256 + 128;
+            dest.push(clamp(v));
+        }
+    }
+}
+
+fn clamp(x: i32) -> u8 {
+    x.min(255).max(0) as u8
+}
+
+pub fn i420_to_rgb(width: usize, height: usize, sy: &[u8], su: &[u8], sv: &[u8], dest: &mut [u8]) {
+    let uvw = width >> 1;
+    for i in 0..height {
+        let sw = i * width;
+        let t = (i >> 1) * uvw;
+        for j in 0..width {
+            let mut rgbstart = sw + j;
+            let uvi = t + (j >> 1);
+
+            let y = sy[rgbstart] as i32;
+            let u = su[uvi] as i32 - 128;
+            let v = sv[uvi] as i32 - 128;
+
+            rgbstart *= 3;
+            dest[rgbstart] = clamp(y + (v * 359 >> 8));
+            dest[rgbstart + 1] = clamp(y - (u * 88 >> 8) - (v * 182 >> 8));
+            dest[rgbstart + 2] = clamp(y + (u * 453 >> 8));
+        }
+    }
+}

dscom/src/lib.rs

@@ -8,3 +8,4 @@ pub const MOUSE_WHEEL_UP: u8 = 5;
 pub const MOUSE_WHEEL_DOWN: u8 = 6;
 pub const MOVE: u8 = 7;
 // key事件 end
+pub mod convert;

dsserver/src/config.rs

@@ -1,7 +1,6 @@
 mod key_mouse;
 mod screen;
 mod server;
-mod config;
 fn main() {
     let args: Vec<String> = std::env::args().collect();
 

dsserver/src/main.rs

@@ -1,18 +1,15 @@
 use scrap::Capturer;
 use scrap::Display;
 use std::io::ErrorKind::WouldBlock;
+use std::slice::from_raw_parts;
 use std::time::Duration;
-use rayon::prelude::*;
-
-use crate::config;
 
 /**
  * 截屏
  */
 pub struct Cap {
     w: usize,
     h: usize,
-    // org_len: usize,
     capturer: Option<Capturer>,
     sleep: Duration,
 }
@@ -24,7 +21,6 @@ impl Cap {
         Cap {
             w,
             h,
-            // org_len: w * h * 4,
             capturer: Some(capturer),
             sleep: Duration::new(1, 0) / 60,
         }
@@ -45,12 +41,11 @@ impl Cap {
         };
         self.capturer = Some(capturer);
     }
-    #[inline]
     pub fn wh(&self) -> (usize, usize) {
-        return (self.w, self.h);
+        (self.w, self.h)
     }
     #[inline]
-    pub fn cap(&mut self, cap_buf: &mut [u8]) {
+    pub fn cap(&mut self) -> &[u8] {
         loop {
             match &mut self.capturer {
                 Some(capturer) => {
@@ -70,14 +65,7 @@ impl Cap {
                             }
                         }
                     };
-
-                    // 转换成rgb图像数组
-                    cap_buf.par_chunks_exact_mut(3).zip(buffer.par_chunks_exact(4)).for_each(|(c, b)|{
-                        c[0] = b[2] & config::BIT_MASK;
-                        c[1] = b[1] & config::BIT_MASK;
-                        c[2] = b[0] & config::BIT_MASK;
-                    });
-                    break;
+                    return unsafe { from_raw_parts(buffer.as_ptr(), buffer.len()) };
                 }
                 None => {
                     std::thread::sleep(std::time::Duration::from_millis(200));