grim-rs 0.1.9

Rust implementation of grim screenshot utility for Wayland
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
122
123
124
125
126
127
128
129
130
131
132
133
134

use grim_rs::Grim;
use std::time::Instant;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let mut grim = Grim::new()?;

    println!("grim-rs Performance Profiling\n");

    println!("1. Full screen capture:");
    let start = Instant::now();
    let result = grim.capture_all()?;
    let capture_time = start.elapsed();
    println!("Time: {:?}", capture_time);
    println!("Size: {}x{}", result.width(), result.height());
    println!(
        "Data: {} bytes ({:.2} MB)\n",
        result.data().len(),
        result.data().len() as f64 / 1024.0 / 1024.0
    );

    println!("2. PNG encoding (different compression levels):");
    for level in [1, 6, 9] {
        let start = Instant::now();
        let png_data =
            grim.to_png_with_compression(result.data(), result.width(), result.height(), level)?;
        let encode_time = start.elapsed();
        println!(
            "Level {}: {:?} -> {} bytes ({:.2} MB)",
            level,
            encode_time,
            png_data.len(),
            png_data.len() as f64 / 1024.0 / 1024.0
        );
    }

    #[cfg(feature = "jpeg")]
    {
        println!("3. JPEG encoding (different quality levels):");
        for quality in [60, 80, 95] {
            let start = Instant::now();
            let jpeg_data =
                grim.to_jpeg_with_quality(result.data(), result.width(), result.height(), quality)?;
            let encode_time = start.elapsed();
            println!(
                "Quality {}: {:?} -> {} bytes ({:.2} MB)",
                quality,
                encode_time,
                jpeg_data.len(),
                jpeg_data.len() as f64 / 1024.0 / 1024.0
            );
        }
        println!();
    }

    println!("4. Capture with different scales:");
    for scale in [0.5, 1.0, 2.0] {
        let start = Instant::now();
        let scaled_result = grim.capture_all_with_scale(scale)?;
        let scale_time = start.elapsed();
        println!(
            "Scale {:.1}: {:?} -> {}x{} ({:.2} MB)",
            scale,
            scale_time,
            scaled_result.width(),
            scaled_result.height(),
            scaled_result.data().len() as f64 / 1024.0 / 1024.0
        );
    }

    println!("6. Get outputs info:");
    let start = Instant::now();
    let outputs = grim.get_outputs()?;
    let outputs_time = start.elapsed();
    println!("Time: {:?}", outputs_time);
    println!("Outputs found: {}", outputs.len());
    for output in &outputs {
        println!(
            "- {} ({}x{}) scale={}",
            output.name(),
            output.geometry().width(),
            output.geometry().height(),
            output.scale()
        );
    }

    let iterations = 10;
    println!("7. Stress test ({} iterations):", iterations);
    let start = Instant::now();
    for i in 0..iterations {
        let _result = grim.capture_all()?;
        if (i + 1) % 5 == 0 {
            println!("Progress: {}/{}", i + 1, iterations);
        }
    }
    let total = start.elapsed();
    let avg = total / iterations;
    println!("Total time: {:?}", total);
    println!("Average per capture: {:?}", avg);
    println!("Captures per second: {:.2}\n", 1.0 / avg.as_secs_f64());

    println!("8. Region capture (different sizes):");
    let regions = [
        ("Small (100x100)", grim_rs::Region::new(0, 0, 100, 100)),
        ("Medium (500x500)", grim_rs::Region::new(0, 0, 500, 500)),
        ("Large (1920x1080)", grim_rs::Region::new(0, 0, 1920, 1080)),
    ];

    for (name, region) in &regions {
        let start = Instant::now();
        match grim.capture_region(*region) {
            Ok(region_result) => {
                let region_time = start.elapsed();
                println!(
                    "{}: {:?} -> {}x{} ({:.2} MB)",
                    name,
                    region_time,
                    region_result.width(),
                    region_result.height(),
                    region_result.data().len() as f64 / 1024.0 / 1024.0
                );
            }
            Err(e) => {
                println!("{}: Error - {}", name, e);
            }
        }
    }
    println!();

    println!("Profiling Complete");

    Ok(())
}