gstreamer_base/subclass/
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::translate::*;
6use gst::subclass::prelude::*;
7
8use crate::{BaseParse, BaseParseFrame, ffi, prelude::*};
9
10pub trait BaseParseImpl: ElementImpl + ObjectSubclass<Type: IsA<BaseParse>> {
11    fn start(&self) -> Result<(), gst::ErrorMessage> {
12        self.parent_start()
13    }
14
15    fn stop(&self) -> Result<(), gst::ErrorMessage> {
16        self.parent_stop()
17    }
18
19    fn set_sink_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
20        self.parent_set_sink_caps(caps)
21    }
22
23    fn handle_frame(
24        &self,
25        frame: BaseParseFrame,
26    ) -> Result<(gst::FlowSuccess, u32), gst::FlowError> {
27        self.parent_handle_frame(frame)
28    }
29
30    fn convert(
31        &self,
32        src_val: impl gst::format::FormattedValue,
33        dest_format: gst::Format,
34    ) -> Option<gst::GenericFormattedValue> {
35        self.parent_convert(src_val, dest_format)
36    }
37}
38
39pub trait BaseParseImplExt: BaseParseImpl {
40    fn parent_start(&self) -> Result<(), gst::ErrorMessage> {
41        unsafe {
42            let data = Self::type_data();
43            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass;
44            (*parent_class)
45                .start
46                .map(|f| {
47                    if from_glib(f(self
48                        .obj()
49                        .unsafe_cast_ref::<BaseParse>()
50                        .to_glib_none()
51                        .0))
52                    {
53                        Ok(())
54                    } else {
55                        Err(gst::error_msg!(
56                            gst::CoreError::StateChange,
57                            ["Parent function `start` failed"]
58                        ))
59                    }
60                })
61                .unwrap_or(Ok(()))
62        }
63    }
64
65    fn parent_stop(&self) -> Result<(), gst::ErrorMessage> {
66        unsafe {
67            let data = Self::type_data();
68            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass;
69            (*parent_class)
70                .stop
71                .map(|f| {
72                    if from_glib(f(self
73                        .obj()
74                        .unsafe_cast_ref::<BaseParse>()
75                        .to_glib_none()
76                        .0))
77                    {
78                        Ok(())
79                    } else {
80                        Err(gst::error_msg!(
81                            gst::CoreError::StateChange,
82                            ["Parent function `stop` failed"]
83                        ))
84                    }
85                })
86                .unwrap_or(Ok(()))
87        }
88    }
89
90    fn parent_set_sink_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
91        unsafe {
92            let data = Self::type_data();
93            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass;
94            (*parent_class)
95                .set_sink_caps
96                .map(|f| {
97                    gst::result_from_gboolean!(
98                        f(
99                            self.obj().unsafe_cast_ref::<BaseParse>().to_glib_none().0,
100                            caps.to_glib_none().0,
101                        ),
102                        gst::CAT_RUST,
103                        "Parent function `set_sink_caps` failed",
104                    )
105                })
106                .unwrap_or(Ok(()))
107        }
108    }
109
110    fn parent_handle_frame(
111        &self,
112        frame: BaseParseFrame,
113    ) -> Result<(gst::FlowSuccess, u32), gst::FlowError> {
114        unsafe {
115            let data = Self::type_data();
116            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass;
117            let mut skipsize = 0;
118            (*parent_class)
119                .handle_frame
120                .map(|f| {
121                    let res = try_from_glib(f(
122                        self.obj().unsafe_cast_ref::<BaseParse>().to_glib_none().0,
123                        frame.to_glib_none().0,
124                        &mut skipsize,
125                    ));
126                    (res.unwrap(), skipsize as u32)
127                })
128                .ok_or(gst::FlowError::Error)
129        }
130    }
131
132    fn parent_convert(
133        &self,
134        src_val: impl gst::format::FormattedValue,
135        dest_format: gst::Format,
136    ) -> Option<gst::GenericFormattedValue> {
137        unsafe {
138            let data = Self::type_data();
139            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBaseParseClass;
140            let res = (*parent_class).convert.map(|f| {
141                let mut dest_val = mem::MaybeUninit::uninit();
142
143                let res = from_glib(f(
144                    self.obj().unsafe_cast_ref::<BaseParse>().to_glib_none().0,
145                    src_val.format().into_glib(),
146                    src_val.into_raw_value(),
147                    dest_format.into_glib(),
148                    dest_val.as_mut_ptr(),
149                ));
150                (res, dest_val)
151            });
152
153            match res {
154                Some((true, dest_val)) => Some(gst::GenericFormattedValue::new(
155                    dest_format,
156                    dest_val.assume_init(),
157                )),
158                _ => None,
159            }
160        }
161    }
162}
163
164impl<T: BaseParseImpl> BaseParseImplExt for T {}
165
166unsafe impl<T: BaseParseImpl> IsSubclassable<T> for BaseParse {
167    fn class_init(klass: &mut glib::Class<Self>) {
168        Self::parent_class_init::<T>(klass);
169        let klass = klass.as_mut();
170        klass.start = Some(base_parse_start::<T>);
171        klass.stop = Some(base_parse_stop::<T>);
172        klass.set_sink_caps = Some(base_parse_set_sink_caps::<T>);
173        klass.handle_frame = Some(base_parse_handle_frame::<T>);
174        klass.convert = Some(base_parse_convert::<T>);
175    }
176}
177
178unsafe extern "C" fn base_parse_start<T: BaseParseImpl>(
179    ptr: *mut ffi::GstBaseParse,
180) -> glib::ffi::gboolean {
181    unsafe {
182        let instance = &*(ptr as *mut T::Instance);
183        let imp = instance.imp();
184
185        gst::panic_to_error!(imp, false, {
186            match imp.start() {
187                Ok(()) => true,
188                Err(err) => {
189                    imp.post_error_message(err);
190                    false
191                }
192            }
193        })
194        .into_glib()
195    }
196}
197
198unsafe extern "C" fn base_parse_stop<T: BaseParseImpl>(
199    ptr: *mut ffi::GstBaseParse,
200) -> glib::ffi::gboolean {
201    unsafe {
202        let instance = &*(ptr as *mut T::Instance);
203        let imp = instance.imp();
204
205        gst::panic_to_error!(imp, false, {
206            match imp.stop() {
207                Ok(()) => true,
208                Err(err) => {
209                    imp.post_error_message(err);
210                    false
211                }
212            }
213        })
214        .into_glib()
215    }
216}
217
218unsafe extern "C" fn base_parse_set_sink_caps<T: BaseParseImpl>(
219    ptr: *mut ffi::GstBaseParse,
220    caps: *mut gst::ffi::GstCaps,
221) -> glib::ffi::gboolean {
222    unsafe {
223        let instance = &*(ptr as *mut T::Instance);
224        let imp = instance.imp();
225        let caps: Borrowed<gst::Caps> = from_glib_borrow(caps);
226
227        gst::panic_to_error!(imp, false, {
228            match imp.set_sink_caps(&caps) {
229                Ok(()) => true,
230                Err(err) => {
231                    err.log_with_imp(imp);
232                    false
233                }
234            }
235        })
236        .into_glib()
237    }
238}
239
240unsafe extern "C" fn base_parse_handle_frame<T: BaseParseImpl>(
241    ptr: *mut ffi::GstBaseParse,
242    frame: *mut ffi::GstBaseParseFrame,
243    skipsize: *mut i32,
244) -> gst::ffi::GstFlowReturn {
245    unsafe {
246        let instance = &*(ptr as *mut T::Instance);
247        let imp = instance.imp();
248        let instance = imp.obj();
249        let instance = instance.unsafe_cast_ref::<BaseParse>();
250        let wrap_frame = BaseParseFrame::new(frame, instance);
251
252        let res = gst::panic_to_error!(imp, Err(gst::FlowError::Error), {
253            imp.handle_frame(wrap_frame)
254        });
255
256        match res {
257            Ok((flow, skip)) => {
258                *skipsize = i32::try_from(skip).expect("skip is higher than i32::MAX");
259                gst::FlowReturn::from_ok(flow)
260            }
261            Err(flow) => gst::FlowReturn::from_error(flow),
262        }
263        .into_glib()
264    }
265}
266
267unsafe extern "C" fn base_parse_convert<T: BaseParseImpl>(
268    ptr: *mut ffi::GstBaseParse,
269    source_format: gst::ffi::GstFormat,
270    source_value: i64,
271    dest_format: gst::ffi::GstFormat,
272    dest_value: *mut i64,
273) -> glib::ffi::gboolean {
274    unsafe {
275        let instance = &*(ptr as *mut T::Instance);
276        let imp = instance.imp();
277        let source = gst::GenericFormattedValue::new(from_glib(source_format), source_value);
278
279        let res = gst::panic_to_error!(imp, None, { imp.convert(source, from_glib(dest_format)) });
280
281        match res {
282            Some(dest) => {
283                *dest_value = dest.into_raw_value();
284                true
285            }
286            _ => false,
287        }
288        .into_glib()
289    }
290}
gstreamer_base/subclass/base_parse.rs

gstreamer_base/subclass/
base_parse.rs
