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::{ffi, prelude::*, BaseParse, BaseParseFrame};
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    let instance = &*(ptr as *mut T::Instance);
182    let imp = instance.imp();
183
184    gst::panic_to_error!(imp, false, {
185        match imp.start() {
186            Ok(()) => true,
187            Err(err) => {
188                imp.post_error_message(err);
189                false
190            }
191        }
192    })
193    .into_glib()
194}
195
196unsafe extern "C" fn base_parse_stop<T: BaseParseImpl>(
197    ptr: *mut ffi::GstBaseParse,
198) -> glib::ffi::gboolean {
199    let instance = &*(ptr as *mut T::Instance);
200    let imp = instance.imp();
201
202    gst::panic_to_error!(imp, false, {
203        match imp.stop() {
204            Ok(()) => true,
205            Err(err) => {
206                imp.post_error_message(err);
207                false
208            }
209        }
210    })
211    .into_glib()
212}
213
214unsafe extern "C" fn base_parse_set_sink_caps<T: BaseParseImpl>(
215    ptr: *mut ffi::GstBaseParse,
216    caps: *mut gst::ffi::GstCaps,
217) -> glib::ffi::gboolean {
218    let instance = &*(ptr as *mut T::Instance);
219    let imp = instance.imp();
220    let caps: Borrowed<gst::Caps> = from_glib_borrow(caps);
221
222    gst::panic_to_error!(imp, false, {
223        match imp.set_sink_caps(&caps) {
224            Ok(()) => true,
225            Err(err) => {
226                err.log_with_imp(imp);
227                false
228            }
229        }
230    })
231    .into_glib()
232}
233
234unsafe extern "C" fn base_parse_handle_frame<T: BaseParseImpl>(
235    ptr: *mut ffi::GstBaseParse,
236    frame: *mut ffi::GstBaseParseFrame,
237    skipsize: *mut i32,
238) -> gst::ffi::GstFlowReturn {
239    let instance = &*(ptr as *mut T::Instance);
240    let imp = instance.imp();
241    let instance = imp.obj();
242    let instance = instance.unsafe_cast_ref::<BaseParse>();
243    let wrap_frame = BaseParseFrame::new(frame, instance);
244
245    let res = gst::panic_to_error!(imp, Err(gst::FlowError::Error), {
246        imp.handle_frame(wrap_frame)
247    });
248
249    match res {
250        Ok((flow, skip)) => {
251            *skipsize = i32::try_from(skip).expect("skip is higher than i32::MAX");
252            gst::FlowReturn::from_ok(flow)
253        }
254        Err(flow) => gst::FlowReturn::from_error(flow),
255    }
256    .into_glib()
257}
258
259unsafe extern "C" fn base_parse_convert<T: BaseParseImpl>(
260    ptr: *mut ffi::GstBaseParse,
261    source_format: gst::ffi::GstFormat,
262    source_value: i64,
263    dest_format: gst::ffi::GstFormat,
264    dest_value: *mut i64,
265) -> glib::ffi::gboolean {
266    let instance = &*(ptr as *mut T::Instance);
267    let imp = instance.imp();
268    let source = gst::GenericFormattedValue::new(from_glib(source_format), source_value);
269
270    let res = gst::panic_to_error!(imp, None, { imp.convert(source, from_glib(dest_format)) });
271
272    match res {
273        Some(dest) => {
274            *dest_value = dest.into_raw_value();
275            true
276        }
277        _ => false,
278    }
279    .into_glib()
280}
gstreamer_base/subclass/base_parse.rs

gstreamer_base/subclass/
base_parse.rs
