vncrs 0.1.2

A pure Rust VNC server library for Windows
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use super::ScreenCapture;
use crate::error::{Result, VncError};
use std::io::ErrorKind;
use std::thread;
use std::time::{Duration, Instant};

pub struct ScrapCapture {
    capturer: scrap::Capturer,
    width: u16,
    height: u16,
    stride: usize,
}

impl ScrapCapture {
    pub fn new() -> Result<Self> {
        let display = scrap::Display::primary().map_err(|e| VncError::Capture(e.to_string()))?;
        let w = display.width() as u16;
        let h = display.height() as u16;
        let capturer =
            scrap::Capturer::new(display).map_err(|e| VncError::Capture(e.to_string()))?;

        Ok(Self {
            capturer,
            width: w,
            height: h,
            stride: w as usize * 4,
        })
    }

    fn reinit(&mut self) -> Result<()> {
        let display = scrap::Display::primary().map_err(|e| VncError::Capture(e.to_string()))?;
        let w = display.width() as u16;
        let h = display.height() as u16;
        let capturer =
            scrap::Capturer::new(display).map_err(|e| VncError::Capture(e.to_string()))?;

        self.capturer = capturer;
        self.width = w;
        self.height = h;
        self.stride = w as usize * 4;

        Ok(())
    }
}

impl ScreenCapture for ScrapCapture {
    fn width(&self) -> u16 {
        self.width
    }

    fn height(&self) -> u16 {
        self.height
    }

    fn stride(&self) -> usize {
        self.stride
    }

    fn capture_frame(&mut self) -> Result<Option<Vec<u8>>> {
        let start = Instant::now();
        let timeout = Duration::from_millis(50);

        loop {
            match self.capturer.frame() {
                Ok(frame) => {
                    self.stride = frame.len() / self.height as usize;
                    return Ok(Some(frame.to_vec()));
                }
                Err(ref e) if e.kind() == ErrorKind::WouldBlock => {
                    if start.elapsed() > timeout {
                        return Ok(None);
                    }
                    thread::sleep(Duration::from_millis(1));
                }
                Err(e) => {
                    log::warn!("Capture error ({}), reinitializing DXGI session...", e);

                    // Back off briefly before trying to reinit — the GPU/display
                    // driver may need a moment to settle (e.g. after unlock or
                    // display mode change).
                    thread::sleep(Duration::from_millis(500));

                    let mut attempt = 1u64;
                    loop {
                        match self.reinit() {
                            Ok(()) => {
                                log::info!("DXGI session reinitialized (attempt {})", attempt);
                                // Return None so the caller sends an empty update
                                // rather than stalling — the next call will capture
                                // a real frame.
                                return Ok(None);
                            }
                            Err(reinit_err) => {
                                let delay = Duration::from_millis((200 * attempt).min(10_000));
                                log::warn!(
                                    "Reinit attempt {} failed: {}. Retrying in {:?}...",
                                    attempt,
                                    reinit_err,
                                    delay
                                );
                                thread::sleep(delay);
                                attempt += 1;
                            }
                        }
                    }
                }
            }
        }
    }
}