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
use gst_video_sys;
use std::ffi::CStr;
use std::fmt;
use std::str;
use glib::translate::{from_glib, FromGlib, ToGlib, ToGlibPtr};
#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
pub enum VideoEndianness {
Unknown,
LittleEndian = 1234,
BigEndian = 4321,
}
impl FromGlib<i32> for VideoEndianness {
fn from_glib(value: i32) -> Self {
skip_assert_initialized!();
match value {
1234 => VideoEndianness::LittleEndian,
4321 => VideoEndianness::BigEndian,
_ => VideoEndianness::Unknown,
}
}
}
impl ToGlib for VideoEndianness {
type GlibType = i32;
fn to_glib(&self) -> i32 {
match *self {
VideoEndianness::LittleEndian => 1234,
VideoEndianness::BigEndian => 4321,
_ => 0,
}
}
}
impl ::VideoFormat {
pub fn from_fourcc(fourcc: u32) -> ::VideoFormat {
assert_initialized_main_thread!();
unsafe { from_glib(gst_video_sys::gst_video_format_from_fourcc(fourcc)) }
}
pub fn from_masks(
depth: u32,
bpp: u32,
endianness: ::VideoEndianness,
red_mask: u32,
blue_mask: u32,
green_mask: u32,
alpha_mask: u32,
) -> ::VideoFormat {
assert_initialized_main_thread!();
unsafe {
from_glib(gst_video_sys::gst_video_format_from_masks(
depth as i32,
bpp as i32,
endianness.to_glib(),
red_mask,
blue_mask,
green_mask,
alpha_mask,
))
}
}
pub fn to_str<'a>(self) -> &'a str {
if self == ::VideoFormat::Unknown {
return "UNKNOWN";
}
unsafe {
CStr::from_ptr(gst_video_sys::gst_video_format_to_string(self.to_glib()))
.to_str()
.unwrap()
}
}
}
impl str::FromStr for ::VideoFormat {
type Err = glib::BoolError;
fn from_str(s: &str) -> Result<Self, glib::BoolError> {
assert_initialized_main_thread!();
unsafe {
let fmt = ::VideoFormat::from_glib(gst_video_sys::gst_video_format_from_string(
s.to_glib_none().0,
));
if fmt == ::VideoFormat::Unknown {
Err(glib_bool_error!("Failed to parse video format from string"))
} else {
Ok(fmt)
}
}
}
}
impl fmt::Display for ::VideoFormat {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.write_str((*self).to_str())
}
}
#[cfg(test)]
mod tests {
use gst;
#[test]
fn test_display() {
gst::init().unwrap();
format!("{}", ::VideoFormat::Nv16);
}
}