pinray 0.2.4

Multi-platform screen capture library for Rust
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

use std::time::Duration;

use pinray::{
    BackendPreference, CaptureEvent, CaptureSession, FrameData, PixelFormat, SourceId,
    VideoCaptureTarget,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "debug".into()),
        )
        .init();

    println!("[1] enumerating sources...");
    let sources = pinray::enumerate_sources()?;
    for src in &sources {
        println!("    source: {:?}", src);
    }

    println!("[2] building capture session (first display)...");
    let mut session = CaptureSession::builder()
        .backend_preference(BackendPreference::MacScreenCaptureKit)
        .video_target(VideoCaptureTarget::Display(SourceId::new("auto")))
        .pixel_format(PixelFormat::Bgra8888)
        .frame_rate(Some(30))
        .build()?;

    println!("[3] backend: {:?}", session.backend_info().kind);
    println!(
        "    supports_audio={} zero_copy={}",
        session.backend_info().supports_audio,
        session.backend_info().zero_copy,
    );

    println!("[4] starting...");
    session.start()?;

    for idx in 0..5 {
        println!("[5] waiting for event #{idx}...");
        match session.next_event(Some(Duration::from_secs(10)))? {
            CaptureEvent::Video(frame) => {
                let byte_count = match &frame.data {
                    FrameData::Host(b) => b.len(),
                    _ => 0,
                };
                println!(
                    "[6] video #{idx}: {}x{} stride={} format={:?} time_ns={} bytes={}",
                    frame.width,
                    frame.height,
                    frame.stride,
                    frame.pixel_format,
                    frame.stream_time_ns,
                    byte_count,
                );

                // Sanity check: data must be non-empty and at least width*height*4 bytes
                assert!(
                    byte_count >= (frame.width * frame.height * 4) as usize,
                    "frame data smaller than expected: got {byte_count} want {}",
                    frame.width * frame.height * 4
                );
            }
            CaptureEvent::Audio(frame) => {
                println!(
                    "[6] audio #{idx}: rate={} ch={} fmt={:?} time_ns={}",
                    frame.sample_rate, frame.channels, frame.sample_format, frame.stream_time_ns,
                );
            }
            other => println!("[6] other event #{idx}: {:?}", other),
        }
    }

    println!("[7] stopping...");
    session.stop()?;
    println!("[8] stop -> start -> stop (lifecycle test)...");

    session.start()?;
    let ev = session.next_event(Some(Duration::from_secs(10)))?;
    println!("[9] second-run event: {:?}", ev.is_video_or_audio());
    session.stop()?;

    println!("[10] done. smoke test passed.");
    Ok(())
}

trait EventKind {
    fn is_video_or_audio(&self) -> &'static str;
}

impl EventKind for CaptureEvent {
    fn is_video_or_audio(&self) -> &'static str {
        match self {
            CaptureEvent::Video(_) => "Video",
            CaptureEvent::Audio(_) => "Audio",
            CaptureEvent::Gap(_) => "Gap",
            CaptureEvent::End => "End",
        }
    }
}