pinray-core 0.2.0

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

use crate::{
    error::{PinrayError, Result},
    frame::{ColorSpace, PixelFormat, Rect},
    source::SourceId,
};

/// Whether the pointer is drawn into captured frames.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CursorMode {
    Embedded,
    Hidden,
}

/// What to capture video from; ids come from source enumeration or
/// `SourceId::new("auto")` for the primary display.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum VideoCaptureTarget {
    Display(SourceId),
    Window(SourceId),
}

/// What to capture audio from.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AudioCapture {
    /// Everything the system plays (loopback / sink monitor).
    SystemMix,
    /// A microphone device (not implemented by any backend yet).
    Microphone(SourceId),
}

/// Validated session configuration; construct through the session builder.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SessionConfig {
    pub backend_preference: crate::backend::BackendPreference,
    pub video_target: Option<VideoCaptureTarget>,
    pub audio_capture: Option<AudioCapture>,
    pub restore_token: Option<String>,
    pub pixel_format: PixelFormat,
    pub color_space: Option<ColorSpace>,
    pub cursor_mode: CursorMode,
    pub crop_rect: Option<Rect>,
    pub frame_rate: Option<u32>,
    pub queue_depth: u32,
}

impl Default for SessionConfig {
    fn default() -> Self {
        Self {
            backend_preference: crate::backend::BackendPreference::Auto,
            video_target: None,
            audio_capture: None,
            restore_token: None,
            pixel_format: PixelFormat::Bgra8888,
            color_space: Some(ColorSpace::Srgb),
            cursor_mode: CursorMode::Embedded,
            crop_rect: None,
            frame_rate: Some(60),
            queue_depth: 2,
        }
    }
}

impl SessionConfig {
    pub fn validate(&self) -> Result<()> {
        if self.video_target.is_none() && self.audio_capture.is_none() {
            return Err(PinrayError::InvalidConfig(
                "at least one of video_target or audio_capture must be set".into(),
            ));
        }

        if let Some(frame_rate) = self.frame_rate
            && frame_rate == 0
        {
            return Err(PinrayError::InvalidConfig(
                "frame_rate must be greater than zero".into(),
            ));
        }

        if self.queue_depth == 0 {
            return Err(PinrayError::InvalidConfig(
                "queue_depth must be greater than zero".into(),
            ));
        }

        if let Some(rect) = self.crop_rect
            && (rect.width == 0 || rect.height == 0)
        {
            return Err(PinrayError::InvalidConfig(
                "crop_rect width and height must be greater than zero".into(),
            ));
        }

        Ok(())
    }
}