1 // Take a look at the license at the top of the repository in the LICENSE file.
2 
3 use glib::translate::ToGlibPtr;
4 
5 use std::convert;
6 use std::ops;
7 use std::ptr;
8 
9 #[derive(Debug)]
10 #[doc(alias = "GstVideoConverter")]
11 pub struct VideoConverter(ptr::NonNull<ffi::GstVideoConverter>);
12 
13 impl Drop for VideoConverter {
drop(&mut self)14     fn drop(&mut self) {
15         unsafe {
16             ffi::gst_video_converter_free(self.0.as_ptr());
17         }
18     }
19 }
20 
21 unsafe impl Send for VideoConverter {}
22 unsafe impl Sync for VideoConverter {}
23 
24 impl VideoConverter {
25     #[doc(alias = "gst_video_converter_new")]
new( in_info: &crate::VideoInfo, out_info: &crate::VideoInfo, config: Option<VideoConverterConfig>, ) -> Result<Self, glib::BoolError>26     pub fn new(
27         in_info: &crate::VideoInfo,
28         out_info: &crate::VideoInfo,
29         config: Option<VideoConverterConfig>,
30     ) -> Result<Self, glib::BoolError> {
31         assert_initialized_main_thread!();
32         if in_info.fps() != out_info.fps() {
33             return Err(glib::bool_error!("Can't do framerate conversion"));
34         }
35 
36         if in_info.interlace_mode() != out_info.interlace_mode() {
37             return Err(glib::bool_error!("Can't do interlacing conversion"));
38         }
39 
40         unsafe {
41             let ptr = ffi::gst_video_converter_new(
42                 in_info.to_glib_none().0 as *mut _,
43                 out_info.to_glib_none().0 as *mut _,
44                 config.map(|s| s.0.into_ptr()).unwrap_or(ptr::null_mut()),
45             );
46             if ptr.is_null() {
47                 Err(glib::bool_error!("Failed to create video converter"))
48             } else {
49                 Ok(Self(ptr::NonNull::new_unchecked(ptr)))
50             }
51         }
52     }
53 
54     #[doc(alias = "get_config")]
55     #[doc(alias = "gst_video_converter_get_config")]
config(&self) -> VideoConverterConfig56     pub fn config(&self) -> VideoConverterConfig {
57         unsafe {
58             VideoConverterConfig(
59                 gst::StructureRef::from_glib_borrow(ffi::gst_video_converter_get_config(
60                     self.0.as_ptr(),
61                 ))
62                 .to_owned(),
63             )
64         }
65     }
66 
67     #[doc(alias = "gst_video_converter_set_config")]
set_config(&mut self, config: VideoConverterConfig)68     pub fn set_config(&mut self, config: VideoConverterConfig) {
69         unsafe {
70             ffi::gst_video_converter_set_config(self.0.as_ptr(), config.0.into_ptr());
71         }
72     }
73 
74     #[doc(alias = "gst_video_converter_frame")]
frame<T>( &self, src: &crate::VideoFrame<T>, dest: &mut crate::VideoFrame<crate::video_frame::Writable>, )75     pub fn frame<T>(
76         &self,
77         src: &crate::VideoFrame<T>,
78         dest: &mut crate::VideoFrame<crate::video_frame::Writable>,
79     ) {
80         unsafe {
81             ffi::gst_video_converter_frame(self.0.as_ptr(), src.as_ptr(), dest.as_mut_ptr());
82         }
83     }
84 
frame_ref<T>( &self, src: &crate::VideoFrameRef<T>, dest: &mut crate::VideoFrameRef<&mut gst::BufferRef>, )85     pub fn frame_ref<T>(
86         &self,
87         src: &crate::VideoFrameRef<T>,
88         dest: &mut crate::VideoFrameRef<&mut gst::BufferRef>,
89     ) {
90         unsafe {
91             ffi::gst_video_converter_frame(self.0.as_ptr(), src.as_ptr(), dest.as_mut_ptr());
92         }
93     }
94 }
95 
96 #[derive(Debug, Clone, PartialEq, Eq)]
97 pub struct VideoConverterConfig(gst::Structure);
98 
99 impl ops::Deref for VideoConverterConfig {
100     type Target = gst::StructureRef;
101 
deref(&self) -> &gst::StructureRef102     fn deref(&self) -> &gst::StructureRef {
103         self.0.deref()
104     }
105 }
106 
107 impl ops::DerefMut for VideoConverterConfig {
deref_mut(&mut self) -> &mut gst::StructureRef108     fn deref_mut(&mut self) -> &mut gst::StructureRef {
109         self.0.deref_mut()
110     }
111 }
112 
113 impl AsRef<gst::StructureRef> for VideoConverterConfig {
as_ref(&self) -> &gst::StructureRef114     fn as_ref(&self) -> &gst::StructureRef {
115         self.0.as_ref()
116     }
117 }
118 
119 impl AsMut<gst::StructureRef> for VideoConverterConfig {
as_mut(&mut self) -> &mut gst::StructureRef120     fn as_mut(&mut self) -> &mut gst::StructureRef {
121         self.0.as_mut()
122     }
123 }
124 
125 impl Default for VideoConverterConfig {
default() -> Self126     fn default() -> Self {
127         Self::new()
128     }
129 }
130 
131 impl convert::TryFrom<gst::Structure> for VideoConverterConfig {
132     type Error = glib::BoolError;
133 
try_from(v: gst::Structure) -> Result<Self, Self::Error>134     fn try_from(v: gst::Structure) -> Result<Self, Self::Error> {
135         skip_assert_initialized!();
136         if v.name() == "GstVideoConverter" {
137             Ok(Self(v))
138         } else {
139             Err(glib::bool_error!("Structure is no VideoConverterConfig"))
140         }
141     }
142 }
143 
144 impl<'a> convert::TryFrom<&'a gst::StructureRef> for VideoConverterConfig {
145     type Error = glib::BoolError;
146 
try_from(v: &'a gst::StructureRef) -> Result<Self, Self::Error>147     fn try_from(v: &'a gst::StructureRef) -> Result<Self, Self::Error> {
148         skip_assert_initialized!();
149         Self::try_from(v.to_owned())
150     }
151 }
152 
153 impl From<VideoConverterConfig> for gst::Structure {
from(v: VideoConverterConfig) -> Self154     fn from(v: VideoConverterConfig) -> Self {
155         skip_assert_initialized!();
156         v.0
157     }
158 }
159 
160 impl VideoConverterConfig {
new() -> Self161     pub fn new() -> Self {
162         Self(gst::Structure::new_empty("GstVideoConverter"))
163     }
164 
set_resampler_method(&mut self, v: crate::VideoResamplerMethod)165     pub fn set_resampler_method(&mut self, v: crate::VideoResamplerMethod) {
166         self.0.set("GstVideoConverter.resampler-method", &v);
167     }
168 
169     #[doc(alias = "get_resampler_method")]
resampler_method(&self) -> crate::VideoResamplerMethod170     pub fn resampler_method(&self) -> crate::VideoResamplerMethod {
171         self.0
172             .get_optional("GstVideoConverter.resampler-method")
173             .expect("Wrong type")
174             .unwrap_or(crate::VideoResamplerMethod::Cubic)
175     }
176 
set_chroma_resampler_method(&mut self, v: crate::VideoResamplerMethod)177     pub fn set_chroma_resampler_method(&mut self, v: crate::VideoResamplerMethod) {
178         self.0.set("GstVideoConverter.chroma-resampler-method", &v);
179     }
180 
181     #[doc(alias = "get_chroma_resampler_method")]
chroma_resampler_method(&self) -> crate::VideoResamplerMethod182     pub fn chroma_resampler_method(&self) -> crate::VideoResamplerMethod {
183         self.0
184             .get_optional("GstVideoConverter.chroma-resampler-method")
185             .expect("Wrong type")
186             .unwrap_or(crate::VideoResamplerMethod::Linear)
187     }
188 
set_resampler_taps(&mut self, v: u32)189     pub fn set_resampler_taps(&mut self, v: u32) {
190         self.0.set("GstVideoConverter.resampler-taps", &v);
191     }
192 
193     #[doc(alias = "get_resampler_taps")]
resampler_taps(&self) -> u32194     pub fn resampler_taps(&self) -> u32 {
195         self.0
196             .get_optional("GstVideoConverter.resampler-taps")
197             .expect("Wrong type")
198             .unwrap_or(0)
199     }
200 
set_dither_method(&mut self, v: crate::VideoDitherMethod)201     pub fn set_dither_method(&mut self, v: crate::VideoDitherMethod) {
202         self.0.set("GstVideoConverter.dither-method", &v);
203     }
204 
205     #[doc(alias = "get_dither_method")]
dither_method(&self) -> crate::VideoDitherMethod206     pub fn dither_method(&self) -> crate::VideoDitherMethod {
207         self.0
208             .get_optional("GstVideoConverter.dither-method")
209             .expect("Wrong type")
210             .unwrap_or(crate::VideoDitherMethod::Bayer)
211     }
212 
set_dither_quantization(&mut self, v: u32)213     pub fn set_dither_quantization(&mut self, v: u32) {
214         self.0.set("GstVideoConverter.dither-quantization", &v);
215     }
216 
217     #[doc(alias = "get_dither_quantization")]
dither_quantization(&self) -> u32218     pub fn dither_quantization(&self) -> u32 {
219         self.0
220             .get_optional("GstVideoConverter.dither-quantization")
221             .expect("Wrong type")
222             .unwrap_or(1)
223     }
224 
set_src_x(&mut self, v: i32)225     pub fn set_src_x(&mut self, v: i32) {
226         self.0.set("GstVideoConverter.src-x", &v);
227     }
228 
229     #[doc(alias = "get_src_x")]
src_x(&self) -> i32230     pub fn src_x(&self) -> i32 {
231         self.0
232             .get_optional("GstVideoConverter.src-x")
233             .expect("Wrong type")
234             .unwrap_or(0)
235     }
236 
set_src_y(&mut self, v: i32)237     pub fn set_src_y(&mut self, v: i32) {
238         self.0.set("GstVideoConverter.src-y", &v);
239     }
240 
241     #[doc(alias = "get_src_y")]
src_y(&self) -> i32242     pub fn src_y(&self) -> i32 {
243         self.0
244             .get_optional("GstVideoConverter.src-y")
245             .expect("Wrong type")
246             .unwrap_or(0)
247     }
248 
set_src_width(&mut self, v: Option<i32>)249     pub fn set_src_width(&mut self, v: Option<i32>) {
250         if let Some(v) = v {
251             self.0.set("GstVideoConverter.src-width", &v);
252         } else {
253             self.0.remove_field("GstVideoConverter.src-width");
254         }
255     }
256 
257     #[doc(alias = "get_src_width")]
src_width(&self) -> Option<i32>258     pub fn src_width(&self) -> Option<i32> {
259         self.0
260             .get_optional("GstVideoConverter.src-width")
261             .expect("Wrong type")
262     }
263 
set_src_height(&mut self, v: Option<i32>)264     pub fn set_src_height(&mut self, v: Option<i32>) {
265         if let Some(v) = v {
266             self.0.set("GstVideoConverter.src-height", &v);
267         } else {
268             self.0.remove_field("GstVideoConverter.src-height");
269         }
270     }
271 
272     #[doc(alias = "get_src_height")]
src_height(&self) -> Option<i32>273     pub fn src_height(&self) -> Option<i32> {
274         self.0
275             .get_optional("GstVideoConverter.src-height")
276             .expect("Wrong type")
277     }
278 
set_dest_x(&mut self, v: i32)279     pub fn set_dest_x(&mut self, v: i32) {
280         self.0.set("GstVideoConverter.dest-x", &v);
281     }
282 
283     #[doc(alias = "get_dest_x")]
dest_x(&self) -> i32284     pub fn dest_x(&self) -> i32 {
285         self.0
286             .get_optional("GstVideoConverter.dest-x")
287             .expect("Wrong type")
288             .unwrap_or(0)
289     }
290 
set_dest_y(&mut self, v: i32)291     pub fn set_dest_y(&mut self, v: i32) {
292         self.0.set("GstVideoConverter.dest-y", &v);
293     }
294 
295     #[doc(alias = "get_dest_y")]
dest_y(&self) -> i32296     pub fn dest_y(&self) -> i32 {
297         self.0
298             .get_optional("GstVideoConverter.dest-y")
299             .expect("Wrong type")
300             .unwrap_or(0)
301     }
302 
set_dest_width(&mut self, v: Option<i32>)303     pub fn set_dest_width(&mut self, v: Option<i32>) {
304         if let Some(v) = v {
305             self.0.set("GstVideoConverter.dest-width", &v);
306         } else {
307             self.0.remove_field("GstVideoConverter.dest-width");
308         }
309     }
310 
311     #[doc(alias = "get_dest_width")]
dest_width(&self) -> Option<i32>312     pub fn dest_width(&self) -> Option<i32> {
313         self.0
314             .get_optional("GstVideoConverter.dest-width")
315             .expect("Wrong type")
316     }
317 
set_dest_height(&mut self, v: Option<i32>)318     pub fn set_dest_height(&mut self, v: Option<i32>) {
319         if let Some(v) = v {
320             self.0.set("GstVideoConverter.dest-height", &v);
321         } else {
322             self.0.remove_field("GstVideoConverter.dest-height");
323         }
324     }
325 
326     #[doc(alias = "get_dest_height")]
dest_height(&self) -> Option<i32>327     pub fn dest_height(&self) -> Option<i32> {
328         self.0
329             .get_optional("GstVideoConverter.dest-height")
330             .expect("Wrong type")
331     }
332 
set_fill_border(&mut self, v: bool)333     pub fn set_fill_border(&mut self, v: bool) {
334         self.0.set("GstVideoConverter.fill-border", &v);
335     }
336 
337     #[doc(alias = "get_fill_border")]
fills_border(&self) -> bool338     pub fn fills_border(&self) -> bool {
339         self.0
340             .get_optional("GstVideoConverter.fill-border")
341             .expect("Wrong type")
342             .unwrap_or(true)
343     }
344 
set_alpha_value(&mut self, v: f64)345     pub fn set_alpha_value(&mut self, v: f64) {
346         self.0.set("GstVideoConverter.alpha-value", &v);
347     }
348 
349     #[doc(alias = "get_alpha_value")]
alpha_value(&self) -> f64350     pub fn alpha_value(&self) -> f64 {
351         self.0
352             .get_optional("GstVideoConverter.alpha-value")
353             .expect("Wrong type")
354             .unwrap_or(1.0)
355     }
356 
set_alpha_mode(&mut self, v: crate::VideoAlphaMode)357     pub fn set_alpha_mode(&mut self, v: crate::VideoAlphaMode) {
358         self.0.set("GstVideoConverter.alpha-mode", &v);
359     }
360 
361     #[doc(alias = "get_alpha_mode")]
alpha_mode(&self) -> crate::VideoAlphaMode362     pub fn alpha_mode(&self) -> crate::VideoAlphaMode {
363         self.0
364             .get_optional("GstVideoConverter.alpha-mode")
365             .expect("Wrong type")
366             .unwrap_or(crate::VideoAlphaMode::Copy)
367     }
368 
set_border_argb(&mut self, v: u32)369     pub fn set_border_argb(&mut self, v: u32) {
370         self.0.set("GstVideoConverter.border-argb", &v);
371     }
372 
373     #[doc(alias = "get_border_argb")]
border_argb(&self) -> u32374     pub fn border_argb(&self) -> u32 {
375         self.0
376             .get_optional("GstVideoConverter.border-argb")
377             .expect("Wrong type")
378             .unwrap_or(0xff_00_00_00)
379     }
380 
set_chroma_mode(&mut self, v: crate::VideoChromaMode)381     pub fn set_chroma_mode(&mut self, v: crate::VideoChromaMode) {
382         self.0.set("GstVideoConverter.chroma-mode", &v);
383     }
384 
385     #[doc(alias = "get_chroma_mode")]
chroma_mode(&self) -> crate::VideoChromaMode386     pub fn chroma_mode(&self) -> crate::VideoChromaMode {
387         self.0
388             .get_optional("GstVideoConverter.chroma-mode")
389             .expect("Wrong type")
390             .unwrap_or(crate::VideoChromaMode::Full)
391     }
392 
set_matrix_mode(&mut self, v: crate::VideoMatrixMode)393     pub fn set_matrix_mode(&mut self, v: crate::VideoMatrixMode) {
394         self.0.set("GstVideoConverter.matrix-mode", &v);
395     }
396 
397     #[doc(alias = "get_matrix_mode")]
matrix_mode(&self) -> crate::VideoMatrixMode398     pub fn matrix_mode(&self) -> crate::VideoMatrixMode {
399         self.0
400             .get_optional("GstVideoConverter.matrix-mode")
401             .expect("Wrong type")
402             .unwrap_or(crate::VideoMatrixMode::Full)
403     }
404 
set_gamma_mode(&mut self, v: crate::VideoGammaMode)405     pub fn set_gamma_mode(&mut self, v: crate::VideoGammaMode) {
406         self.0.set("GstVideoConverter.gamma-mode", &v);
407     }
408 
409     #[doc(alias = "get_gamma_mode")]
gamma_mode(&self) -> crate::VideoGammaMode410     pub fn gamma_mode(&self) -> crate::VideoGammaMode {
411         self.0
412             .get_optional("GstVideoConverter.gamma-mode")
413             .expect("Wrong type")
414             .unwrap_or(crate::VideoGammaMode::None)
415     }
416 
set_primaries_mode(&mut self, v: crate::VideoPrimariesMode)417     pub fn set_primaries_mode(&mut self, v: crate::VideoPrimariesMode) {
418         self.0.set("GstVideoConverter.primaries-mode", &v);
419     }
420 
421     #[doc(alias = "get_primaries_mode")]
primaries_mode(&self) -> crate::VideoPrimariesMode422     pub fn primaries_mode(&self) -> crate::VideoPrimariesMode {
423         self.0
424             .get_optional("GstVideoConverter.primaries-mode")
425             .expect("Wrong type")
426             .unwrap_or(crate::VideoPrimariesMode::None)
427     }
428 
set_threads(&mut self, v: u32)429     pub fn set_threads(&mut self, v: u32) {
430         self.0.set("GstVideoConverter.threads", &v);
431     }
432 
433     #[doc(alias = "get_threads")]
threads(&self) -> u32434     pub fn threads(&self) -> u32 {
435         self.0
436             .get_optional("GstVideoConverter.threads")
437             .expect("Wrong type")
438             .unwrap_or(1)
439     }
440 }
441