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

gstreamer_base/subclass/
base_parse.rs
