1 // Take a look at the license at the top of the repository in the LICENSE file.
2 
3 use std::ffi::CStr;
4 use std::mem;
5 
6 use glib::translate::*;
7 
8 use once_cell::sync::Lazy;
9 
10 pub static BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META: Lazy<&'static str> =
11     Lazy::new(|| unsafe {
12         CStr::from_ptr(ffi::GST_BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META)
13             .to_str()
14             .unwrap()
15     });
16 pub static BUFFER_POOL_OPTION_VIDEO_ALIGNMENT: Lazy<&'static str> = Lazy::new(|| unsafe {
17     CStr::from_ptr(ffi::GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT)
18         .to_str()
19         .unwrap()
20 });
21 pub static BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META: Lazy<&'static str> =
22     Lazy::new(|| unsafe {
23         CStr::from_ptr(ffi::GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META)
24             .to_str()
25             .unwrap()
26     });
27 pub static BUFFER_POOL_OPTION_VIDEO_META: Lazy<&'static str> = Lazy::new(|| unsafe {
28     CStr::from_ptr(ffi::GST_BUFFER_POOL_OPTION_VIDEO_META)
29         .to_str()
30         .unwrap()
31 });
32 
33 #[derive(Debug, Clone)]
34 #[doc(alias = "GstVideoAlignment")]
35 pub struct VideoAlignment(pub(crate) ffi::GstVideoAlignment);
36 
37 impl VideoAlignment {
38     #[doc(alias = "get_padding_top")]
padding_top(&self) -> u3239     pub fn padding_top(&self) -> u32 {
40         self.0.padding_top
41     }
42     #[doc(alias = "get_padding_bottom")]
padding_bottom(&self) -> u3243     pub fn padding_bottom(&self) -> u32 {
44         self.0.padding_bottom
45     }
46     #[doc(alias = "get_padding_left")]
padding_left(&self) -> u3247     pub fn padding_left(&self) -> u32 {
48         self.0.padding_left
49     }
50     #[doc(alias = "get_padding_right")]
padding_right(&self) -> u3251     pub fn padding_right(&self) -> u32 {
52         self.0.padding_right
53     }
54     #[doc(alias = "get_stride_align")]
stride_align(&self) -> &[u32; ffi::GST_VIDEO_MAX_PLANES as usize]55     pub fn stride_align(&self) -> &[u32; ffi::GST_VIDEO_MAX_PLANES as usize] {
56         &self.0.stride_align
57     }
58 
new( padding_top: u32, padding_bottom: u32, padding_left: u32, padding_right: u32, stride_align: &[u32; ffi::GST_VIDEO_MAX_PLANES as usize], ) -> Self59     pub fn new(
60         padding_top: u32,
61         padding_bottom: u32,
62         padding_left: u32,
63         padding_right: u32,
64         stride_align: &[u32; ffi::GST_VIDEO_MAX_PLANES as usize],
65     ) -> Self {
66         assert_initialized_main_thread!();
67 
68         let videoalignment = ffi::GstVideoAlignment {
69             padding_top,
70             padding_bottom,
71             padding_left,
72             padding_right,
73             stride_align: *stride_align,
74         };
75 
76         Self(videoalignment)
77     }
78 }
79 
80 impl PartialEq for VideoAlignment {
eq(&self, other: &Self) -> bool81     fn eq(&self, other: &Self) -> bool {
82         self.padding_top() == other.padding_top()
83             && self.padding_bottom() == other.padding_bottom()
84             && self.padding_left() == other.padding_left()
85             && self.padding_right() == other.padding_right()
86             && self.stride_align() == other.stride_align()
87     }
88 }
89 
90 impl Eq for VideoAlignment {}
91 
92 #[doc(hidden)]
93 impl<'a> ToGlibPtr<'a, *const ffi::GstVideoAlignment> for VideoAlignment {
94     type Storage = &'a Self;
95 
to_glib_none(&'a self) -> Stash<*const ffi::GstVideoAlignment, Self>96     fn to_glib_none(&'a self) -> Stash<*const ffi::GstVideoAlignment, Self> {
97         Stash(&self.0, self)
98     }
99 }
100 
101 pub trait VideoBufferPoolConfig {
102     #[doc(alias = "get_video_alignment")]
video_alignment(&self) -> Option<VideoAlignment>103     fn video_alignment(&self) -> Option<VideoAlignment>;
104 
set_video_alignment(&mut self, align: &VideoAlignment)105     fn set_video_alignment(&mut self, align: &VideoAlignment);
106 }
107 
108 impl VideoBufferPoolConfig for gst::BufferPoolConfig {
109     #[doc(alias = "gst_buffer_pool_config_get_video_alignment")]
video_alignment(&self) -> Option<VideoAlignment>110     fn video_alignment(&self) -> Option<VideoAlignment> {
111         unsafe {
112             let mut alignment = mem::MaybeUninit::zeroed();
113             let ret = from_glib(ffi::gst_buffer_pool_config_get_video_alignment(
114                 self.as_ref().as_mut_ptr(),
115                 alignment.as_mut_ptr(),
116             ));
117             if ret {
118                 Some(VideoAlignment(alignment.assume_init()))
119             } else {
120                 None
121             }
122         }
123     }
124 
125     #[doc(alias = "gst_buffer_pool_config_set_video_alignment")]
set_video_alignment(&mut self, align: &VideoAlignment)126     fn set_video_alignment(&mut self, align: &VideoAlignment) {
127         unsafe {
128             ffi::gst_buffer_pool_config_set_video_alignment(
129                 self.as_mut().as_mut_ptr(),
130                 &align.0 as *const _ as *mut _,
131             )
132         }
133     }
134 }
135