waterkit-screen 0.2.0

Screen capture with wgpu texture output
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

//! GPU screen capture streaming.

use crate::{Error, ScreenInfo, frame::ScreenFrame, sys};
use std::sync::Arc;
use wgpu::{Device, Queue};

/// Screen capture configuration.
#[derive(Debug, Clone)]
pub struct StreamConfig {
    /// Target frames per second (hint, may not be achieved).
    pub target_fps: u32,
    /// Whether to show cursor in capture.
    pub show_cursor: bool,
}

impl Default for StreamConfig {
    fn default() -> Self {
        Self {
            target_fps: 60,
            show_cursor: true,
        }
    }
}

/// Continuous GPU screen capture stream.
///
/// Provides streaming screen capture with GPU texture output.
/// Frames are delivered as [`ScreenFrame`] values backed by `wgpu` textures.
pub struct ScreenStream {
    inner: sys::ScreenStreamInner,
}

impl std::fmt::Debug for ScreenStream {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ScreenStream").finish_non_exhaustive()
    }
}

impl ScreenStream {
    /// Start a new screen capture stream for the specified display.
    ///
    /// # Arguments
    ///
    /// * `display` - The display to capture.
    /// * `device` - wgpu device (caller-provided).
    /// * `queue` - wgpu queue (caller-provided).
    /// * `config` - Capture configuration.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Platform`] if capture cannot be started.
    #[cfg_attr(
        target_os = "macos",
        expect(
            clippy::future_not_send,
            reason = "the capturer's Objective-C objects are not Send; the caller drives this future"
        )
    )]
    #[cfg_attr(
        target_arch = "wasm32",
        expect(
            clippy::future_not_send,
            reason = "wgpu's WebGPU device is not Send on wasm"
        )
    )]
    pub async fn start(
        display: &ScreenInfo,
        device: Arc<Device>,
        queue: Arc<Queue>,
        config: &StreamConfig,
    ) -> Result<Self, Error> {
        let inner = sys::ScreenStreamInner::new(display, device, queue, config).await?;
        Ok(Self { inner })
    }

    /// Receive the next frame asynchronously.
    ///
    /// Returns `None` if the stream has ended.
    #[allow(
        clippy::future_not_send,
        reason = "the Windows capture session is a thread-affine `*mut c_void`, so `ScreenStream` is deliberately not `Sync` and these futures cannot be `Send`."
    )]
    pub async fn next_frame(&self) -> Option<ScreenFrame> {
        self.inner.next_frame().await
    }

    /// Try to receive a frame without blocking.
    ///
    /// Returns `None` if no frame is currently available.
    #[must_use]
    #[allow(clippy::missing_const_for_fn)] // Not const on all platforms
    pub fn try_next_frame(&self) -> Option<ScreenFrame> {
        self.inner.try_next_frame()
    }

    /// Get the current dimensions of the capture.
    #[must_use]
    pub const fn dimensions(&self) -> (u32, u32) {
        self.inner.dimensions()
    }
}