gstreamer_base/
base_parse.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::mem;
4
5use glib::{prelude::*, translate::*};
6use gst::{
7    format::{FormattedValue, SpecificFormattedValueFullRange},
8    prelude::*,
9};
10
11use crate::{ffi, BaseParse, BaseParseFrame};
12
13pub trait BaseParseExtManual: IsA<BaseParse> + 'static {
14    #[doc(alias = "get_sink_pad")]
15    fn sink_pad(&self) -> &gst::Pad {
16        unsafe {
17            let elt = &*(self.as_ptr() as *const ffi::GstBaseParse);
18            &*(&elt.sinkpad as *const *mut gst::ffi::GstPad as *const gst::Pad)
19        }
20    }
21
22    #[doc(alias = "get_src_pad")]
23    fn src_pad(&self) -> &gst::Pad {
24        unsafe {
25            let elt = &*(self.as_ptr() as *const ffi::GstBaseParse);
26            &*(&elt.srcpad as *const *mut gst::ffi::GstPad as *const gst::Pad)
27        }
28    }
29
30    fn segment(&self) -> gst::Segment {
31        unsafe {
32            let ptr: &ffi::GstBaseParse = &*(self.as_ptr() as *const _);
33            let sinkpad = self.sink_pad();
34            let _guard = sinkpad.stream_lock();
35            from_glib_none(&ptr.segment as *const gst::ffi::GstSegment)
36        }
37    }
38
39    fn lost_sync(&self) -> bool {
40        unsafe {
41            let ptr: &ffi::GstBaseParse = &*(self.as_ptr() as *const _);
42            let sinkpad = self.sink_pad();
43            let _guard = sinkpad.stream_lock();
44            ptr.flags & ffi::GST_BASE_PARSE_FLAG_LOST_SYNC as u32 != 0
45        }
46    }
47
48    fn is_draining(&self) -> bool {
49        unsafe {
50            let ptr: &ffi::GstBaseParse = &*(self.as_ptr() as *const _);
51            let sinkpad = self.sink_pad();
52            let _guard = sinkpad.stream_lock();
53            ptr.flags & ffi::GST_BASE_PARSE_FLAG_DRAINING as u32 != 0
54        }
55    }
56
57    #[doc(alias = "gst_base_parse_set_duration")]
58    fn set_duration(&self, duration: impl FormattedValue, interval: u32) {
59        unsafe {
60            ffi::gst_base_parse_set_duration(
61                self.as_ref().to_glib_none().0,
62                duration.format().into_glib(),
63                duration.into_raw_value(),
64                interval as i32,
65            );
66        }
67    }
68
69    #[doc(alias = "gst_base_parse_set_frame_rate")]
70    fn set_frame_rate(&self, fps: gst::Fraction, lead_in: u32, lead_out: u32) {
71        let (fps_num, fps_den) = fps.into();
72        unsafe {
73            ffi::gst_base_parse_set_frame_rate(
74                self.as_ref().to_glib_none().0,
75                fps_num as u32,
76                fps_den as u32,
77                lead_in,
78                lead_out,
79            );
80        }
81    }
82
83    #[doc(alias = "gst_base_parse_convert_default")]
84    fn convert_default<U: SpecificFormattedValueFullRange>(
85        &self,
86        src_val: impl FormattedValue,
87    ) -> Option<U> {
88        unsafe {
89            let mut dest_val = mem::MaybeUninit::uninit();
90            let ret = from_glib(ffi::gst_base_parse_convert_default(
91                self.as_ref().to_glib_none().0,
92                src_val.format().into_glib(),
93                src_val.into_raw_value(),
94                U::default_format().into_glib(),
95                dest_val.as_mut_ptr(),
96            ));
97            if ret {
98                Some(U::from_raw(U::default_format(), dest_val.assume_init()))
99            } else {
100                None
101            }
102        }
103    }
104
105    fn convert_default_generic(
106        &self,
107        src_val: impl FormattedValue,
108        dest_format: gst::Format,
109    ) -> Option<gst::GenericFormattedValue> {
110        unsafe {
111            let mut dest_val = mem::MaybeUninit::uninit();
112            let ret = from_glib(ffi::gst_base_parse_convert_default(
113                self.as_ref().to_glib_none().0,
114                src_val.format().into_glib(),
115                src_val.into_raw_value(),
116                dest_format.into_glib(),
117                dest_val.as_mut_ptr(),
118            ));
119            if ret {
120                Some(gst::GenericFormattedValue::new(
121                    dest_format,
122                    dest_val.assume_init(),
123                ))
124            } else {
125                None
126            }
127        }
128    }
129
130    #[doc(alias = "gst_base_parse_finish_frame")]
131    fn finish_frame(
132        &self,
133        frame: BaseParseFrame,
134        size: u32,
135    ) -> Result<gst::FlowSuccess, gst::FlowError> {
136        unsafe {
137            try_from_glib(ffi::gst_base_parse_finish_frame(
138                self.as_ref().to_glib_none().0,
139                frame.to_glib_none().0,
140                i32::try_from(size).expect("size higher than i32::MAX"),
141            ))
142        }
143    }
144}
145
146impl<O: IsA<BaseParse>> BaseParseExtManual for O {}
gstreamer_base/base_parse.rs

gstreamer_base/
base_parse.rs
