vncrs 0.1.6

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
111
112
113
114
115
116
117
118
119
120
121

use std::collections::VecDeque;
use std::time::{Duration, Instant};

pub struct FpsCounter {
    times: VecDeque<Instant>,
    sizes: VecDeque<usize>,
    dirty: VecDeque<usize>,
    total: u64,
    start: Instant,
    last_print: Instant,
}

impl FpsCounter {
    pub fn new() -> Self {
        let now = Instant::now();
        Self {
            times: VecDeque::with_capacity(300),
            sizes: VecDeque::with_capacity(300),
            dirty: VecDeque::with_capacity(300),
            total: 0,
            start: now,
            last_print: now,
        }
    }

    pub fn frame(&mut self, bytes: usize, dirty_count: usize) {
        let now = Instant::now();
        self.times.push_back(now);
        self.sizes.push_back(bytes);
        self.dirty.push_back(dirty_count);
        self.total += 1;

        let window = Duration::from_secs(2);
        while self
            .times
            .front()
            .is_some_and(|t| now.duration_since(*t) > window)
        {
            self.times.pop_front();
            self.sizes.pop_front();
            self.dirty.pop_front();
        }

        if now.duration_since(self.last_print) >= Duration::from_secs(1) {
            self.print_stats();
            self.last_print = now;
        }
    }

    pub fn fps(&self) -> f64 {
        if self.times.len() < 2 {
            return 0.0;
        }
        let elapsed = self
            .times
            .back()
            .unwrap()
            .duration_since(*self.times.front().unwrap())
            .as_secs_f64();
        if elapsed > 0.0 {
            (self.times.len() - 1) as f64 / elapsed
        } else {
            0.0
        }
    }

    pub fn print_stats(&self) {
        let fps = self.fps();
        let avg_size = if self.sizes.is_empty() {
            0
        } else {
            self.sizes.iter().sum::<usize>() / self.sizes.len()
        };
        let avg_dirty = if self.dirty.is_empty() {
            0.0
        } else {
            self.dirty.iter().sum::<usize>() as f64 / self.dirty.len() as f64
        };
        let mbps = if self.times.len() < 2 {
            0.0
        } else {
            let elapsed = self
                .times
                .back()
                .unwrap()
                .duration_since(*self.times.front().unwrap())
                .as_secs_f64();
            if elapsed > 0.0 {
                self.sizes.iter().sum::<usize>() as f64 * 8.0 / elapsed / 1_000_000.0
            } else {
                0.0
            }
        };

        let icon = if fps >= 25.0 {
            ""
        } else if fps >= 15.0 {
            ""
        } else {
            ""
        };
        let size = if avg_size >= 1_048_576 {
            format!("{:.1}MB", avg_size as f64 / 1_048_576.0)
        } else if avg_size >= 1024 {
            format!("{:.0}KB", avg_size as f64 / 1024.0)
        } else {
            format!("{}B", avg_size)
        };

        println!(
            "{} {:5.1}fps {:>7} {:5.1}Mbps d:{:.0} #{} {}s",
            icon,
            fps,
            size,
            mbps,
            avg_dirty,
            self.total,
            self.start.elapsed().as_secs()
        );
    }
}