waycap-rs 0.1.2

High-level Wayland screen capture library with hardware-accelerated encoding
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

use std::{
    sync::{atomic::AtomicBool, Arc},
    time::Duration,
};

use ringbuf::traits::Consumer;
use waycap_rs::{
    pipeline::builder::CaptureBuilder,
    types::{
        config::{AudioEncoder, QualityPreset, VideoEncoder},
        error::WaycapError,
    },
};

fn main() -> Result<(), WaycapError> {
    simple_logging::log_to_stderr(log::LevelFilter::Info);
    log::info!("Simple Capture Example");
    log::info!("=====================");
    log::info!("This example will capture your screen");
    log::info!("and print the frame information to the console");
    log::info!("");
    log::info!("Press Enter to start...");

    // Wait for user input
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let stop = Arc::new(AtomicBool::new(false));

    let mut capture = CaptureBuilder::new()
        .with_audio()
        .with_quality_preset(QualityPreset::Medium)
        .with_cursor_shown()
        .with_video_encoder(VideoEncoder::H264Nvenc)
        .with_audio_encoder(AudioEncoder::Opus)
        .build()?;

    capture.start()?;

    let mut video_recv = capture.take_video_receiver();
    let mut audio_recv = capture.take_audio_receiver().unwrap();

    let ctrlc_clone = Arc::clone(&stop);
    ctrlc::set_handler(move || {
        println!("Stopping...");
        capture.close().unwrap();
        ctrlc_clone.store(true, std::sync::atomic::Ordering::Relaxed);
    })
    .unwrap();

    let h1stop = Arc::clone(&stop);
    let handle1 = std::thread::spawn(move || loop {
        if h1stop.load(std::sync::atomic::Ordering::Acquire) {
            break;
        }

        while let Some(encoded_frame) = video_recv.try_pop() {
            log::info!("======= NEW VIDEO FRAME =======");
            log::info!("Is Key Frame: {:?}", encoded_frame.is_keyframe);
            log::info!("PTS: {:?}", encoded_frame.pts);
            log::info!("DTS: {:?}", encoded_frame.dts);
            log::info!("===============================");
        }
        std::thread::sleep(Duration::from_nanos(100));
    });

    let h2stop = Arc::clone(&stop);
    let handle2 = std::thread::spawn(move || loop {
        if h2stop.load(std::sync::atomic::Ordering::Acquire) {
            break;
        }

        while let Some(encoded_frame) = audio_recv.try_pop() {
            log::info!("======= NEW AUDIO FRAME =======");
            log::info!("PTS: {:?}", encoded_frame.pts);
            log::info!("Capture Time Stamp: {:?}", encoded_frame.timestamp);
            log::info!("===============================");
        }

        std::thread::sleep(Duration::from_nanos(100));
    });

    while !stop.load(std::sync::atomic::Ordering::Acquire) {
        std::thread::sleep(Duration::from_millis(100));
    }

    let _ = handle1.join();
    let _ = handle2.join();

    Ok(())
}