scrcap 0.1.0-alpha.1

Screen and system-audio capture for Windows, macOS and Linux
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! The frames that flow over the channels, and the traits encoders consume

use std::fmt;

use crate::format::{PixFmt, SampleFmt};

/// Owned video frame.
#[derive(Clone)]
pub struct VideoFrame {
    /// Video data
    pub vframe: Vec<u8>,
    /// (Width, Height) of the video frame
    pub size: (u32, u32),
    /// Pixel format of the video frame
    pub pix_fmt: PixFmt,
    /// Capture timestamp, see [`VFrame::ts`]
    pub ts: u64,
}

impl fmt::Debug for VideoFrame {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        #[allow(unused)]
        #[derive(Debug)]
        struct VideoFrameDebug {
            vframe: usize,
            size: (u32, u32),
            pix_fmt: PixFmt,
            ts: u64,
        }
        fmt::Debug::fmt(
            &VideoFrameDebug {
                vframe: self.vframe.len(),
                size: self.size,
                pix_fmt: self.pix_fmt,
                ts: self.ts,
            },
            f,
        )
    }
}

impl AsRef<[u8]> for VideoFrame {
    fn as_ref(&self) -> &[u8] {
        self.vframe.as_ref()
    }
}

impl VFrame for VideoFrame {
    fn size(&self) -> (u32, u32) {
        (self.size.0, self.size.1)
    }

    fn pix_fmt(&self) -> PixFmt {
        self.pix_fmt
    }

    fn ts(&self) -> u64 {
        self.ts
    }
}

/// Owned audio frame.
#[derive(Clone)]
pub struct AudioFrame {
    /// Audio data
    pub aframe: Vec<u8>,
    /// Number of audio samples **per channel**
    pub nb_samples: i32,
    /// Sample rate of the audio
    pub sample_rate: i32,
    /// Number of audio channels
    pub nb_channels: i32,
    /// Sample format of the audio frame
    pub sample_fmt: SampleFmt,
    /// Capture timestamp, see [`AFrame::ts`]
    pub ts: u64,
}

impl fmt::Debug for AudioFrame {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        #[allow(unused)]
        #[derive(Debug)]
        struct AudioFrameDebug {
            aframe: usize,
            nb_samples: i32,
            sample_rate: i32,
            nb_channels: i32,
            sample_fmt: SampleFmt,
            ts: u64,
        }
        fmt::Debug::fmt(
            &AudioFrameDebug {
                aframe: self.aframe.len(),
                nb_samples: self.nb_samples,
                sample_rate: self.sample_rate,
                nb_channels: self.nb_channels,
                sample_fmt: self.sample_fmt,
                ts: self.ts,
            },
            f,
        )
    }
}

impl AsRef<[u8]> for AudioFrame {
    fn as_ref(&self) -> &[u8] {
        self.aframe.as_ref()
    }
}

impl AFrame for AudioFrame {
    fn nb_samples(&self) -> i32 {
        self.nb_samples
    }

    fn sample_rate(&self) -> i32 {
        self.sample_rate
    }

    fn nb_channels(&self) -> i32 {
        self.nb_channels
    }

    fn sample_fmt(&self) -> SampleFmt {
        self.sample_fmt
    }

    fn ts(&self) -> u64 {
        self.ts
    }
}

/// What a video frame must expose for an encoder to consume it.
pub trait VFrame: AsRef<[u8]> {
    /// (Width, Height) of the frame.
    fn size(&self) -> (u32, u32);
    /// Pixel format of the frame.
    fn pix_fmt(&self) -> PixFmt;
    /// When the frame was captured, in nanoseconds on a monotonic platform clock.
    ///
    /// The origin is platform defined and meaningless on its own, so subtract the first
    /// timestamp of the session. Video and audio of one session share the clock.
    fn ts(&self) -> u64;
}

/// What an audio frame must expose for an encoder to consume it.
pub trait AFrame: AsRef<[u8]> {
    /// Number of samples **per channel**.
    fn nb_samples(&self) -> i32;
    /// Sample rate of the frame.
    fn sample_rate(&self) -> i32;
    /// Number of channels.
    fn nb_channels(&self) -> i32;
    /// Sample format of the frame.
    fn sample_fmt(&self) -> SampleFmt;
    /// When the frame was captured, see [`VFrame::ts`].
    fn ts(&self) -> u64;
}