gstreamer_rtp/subclass/
rtp_base_depayload.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::ptr;
4
5use glib::translate::*;
6use gst::subclass::prelude::*;
7
8use crate::{RTPBaseDepayload, ffi, prelude::*};
9
10pub trait RTPBaseDepayloadImpl: ElementImpl + ObjectSubclass<Type: IsA<RTPBaseDepayload>> {
11    fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
12        self.parent_set_caps(caps)
13    }
14
15    fn handle_event(&self, event: gst::Event) -> bool {
16        self.parent_handle_event(event)
17    }
18
19    fn packet_lost(&self, event: &gst::EventRef) -> bool {
20        self.parent_packet_lost(event)
21    }
22
23    fn process_rtp_packet(
24        &self,
25        rtp_buffer: &crate::RTPBuffer<crate::rtp_buffer::Readable>,
26    ) -> Option<gst::Buffer> {
27        self.parent_process_rtp_packet(rtp_buffer)
28    }
29}
30
31pub trait RTPBaseDepayloadImplExt: RTPBaseDepayloadImpl {
32    fn parent_set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
33        unsafe {
34            let data = Self::type_data();
35            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBaseDepayloadClass;
36            (*parent_class)
37                .set_caps
38                .map(|f| {
39                    gst::result_from_gboolean!(
40                        f(
41                            self.obj()
42                                .unsafe_cast_ref::<RTPBaseDepayload>()
43                                .to_glib_none()
44                                .0,
45                            caps.to_glib_none().0
46                        ),
47                        gst::CAT_RUST,
48                        "Parent function `set_caps` failed"
49                    )
50                })
51                .unwrap_or(Ok(()))
52        }
53    }
54
55    fn parent_handle_event(&self, event: gst::Event) -> bool {
56        unsafe {
57            let data = Self::type_data();
58            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBaseDepayloadClass;
59            (*parent_class)
60                .handle_event
61                .map(|f| {
62                    from_glib(f(
63                        self.obj()
64                            .unsafe_cast_ref::<RTPBaseDepayload>()
65                            .to_glib_none()
66                            .0,
67                        event.into_glib_ptr(),
68                    ))
69                })
70                .unwrap_or(false)
71        }
72    }
73
74    fn parent_packet_lost(&self, event: &gst::EventRef) -> bool {
75        unsafe {
76            let data = Self::type_data();
77            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBaseDepayloadClass;
78            (*parent_class)
79                .packet_lost
80                .map(|f| {
81                    from_glib(f(
82                        self.obj()
83                            .unsafe_cast_ref::<RTPBaseDepayload>()
84                            .to_glib_none()
85                            .0,
86                        event.as_mut_ptr(),
87                    ))
88                })
89                .unwrap_or(true)
90        }
91    }
92
93    fn parent_process_rtp_packet(
94        &self,
95        rtp_buffer: &crate::RTPBuffer<crate::rtp_buffer::Readable>,
96    ) -> Option<gst::Buffer> {
97        unsafe {
98            let data = Self::type_data();
99            let parent_class = data.as_ref().parent_class() as *mut ffi::GstRTPBaseDepayloadClass;
100
101            let f = (*parent_class)
102                .process_rtp_packet
103                .expect("no parent \"process\" implementation");
104
105            from_glib_full(f(
106                self.obj()
107                    .unsafe_cast_ref::<crate::RTPBaseDepayload>()
108                    .to_glib_none()
109                    .0,
110                mut_override(rtp_buffer.as_ptr()),
111            ))
112        }
113    }
114}
115
116impl<T: RTPBaseDepayloadImpl> RTPBaseDepayloadImplExt for T {}
117
118unsafe impl<T: RTPBaseDepayloadImpl> IsSubclassable<T> for RTPBaseDepayload {
119    fn class_init(klass: &mut glib::Class<Self>) {
120        Self::parent_class_init::<T>(klass);
121        let klass = klass.as_mut();
122
123        klass.process = None;
124        klass.process_rtp_packet = Some(rtp_base_depayload_process_rtp_packet::<T>);
125        klass.set_caps = Some(rtp_base_depayload_set_caps::<T>);
126        klass.handle_event = Some(rtp_base_depayload_handle_event::<T>);
127        klass.packet_lost = Some(rtp_base_depayload_packet_lost::<T>);
128    }
129}
130
131unsafe extern "C" fn rtp_base_depayload_set_caps<T: RTPBaseDepayloadImpl>(
132    ptr: *mut ffi::GstRTPBaseDepayload,
133    caps: *mut gst::ffi::GstCaps,
134) -> glib::ffi::gboolean {
135    unsafe {
136        let instance = &*(ptr as *mut T::Instance);
137        let imp = instance.imp();
138        let caps = from_glib_borrow(caps);
139
140        gst::panic_to_error!(imp, false, {
141            match imp.set_caps(&caps) {
142                Ok(()) => true,
143                Err(err) => {
144                    err.log_with_imp(imp);
145                    false
146                }
147            }
148        })
149        .into_glib()
150    }
151}
152
153unsafe extern "C" fn rtp_base_depayload_handle_event<T: RTPBaseDepayloadImpl>(
154    ptr: *mut ffi::GstRTPBaseDepayload,
155    event: *mut gst::ffi::GstEvent,
156) -> glib::ffi::gboolean {
157    unsafe {
158        let instance = &*(ptr as *mut T::Instance);
159        let imp = instance.imp();
160
161        gst::panic_to_error!(imp, false, { imp.handle_event(from_glib_full(event)) }).into_glib()
162    }
163}
164
165unsafe extern "C" fn rtp_base_depayload_packet_lost<T: RTPBaseDepayloadImpl>(
166    ptr: *mut ffi::GstRTPBaseDepayload,
167    event: *mut gst::ffi::GstEvent,
168) -> glib::ffi::gboolean {
169    unsafe {
170        let instance = &*(ptr as *mut T::Instance);
171        let imp = instance.imp();
172
173        gst::panic_to_error!(imp, false, {
174            imp.packet_lost(gst::EventRef::from_ptr(event))
175        })
176        .into_glib()
177    }
178}
179
180unsafe extern "C" fn rtp_base_depayload_process_rtp_packet<T: RTPBaseDepayloadImpl>(
181    ptr: *mut ffi::GstRTPBaseDepayload,
182    rtp_packet: *mut ffi::GstRTPBuffer,
183) -> *mut gst::ffi::GstBuffer {
184    unsafe {
185        let instance = &*(ptr as *mut T::Instance);
186        let imp = instance.imp();
187
188        gst::panic_to_error!(imp, ptr::null_mut(), {
189            let bufwrap =
190                crate::RTPBuffer::<crate::rtp_buffer::Readable>::from_glib_borrow(rtp_packet);
191
192            imp.process_rtp_packet(&bufwrap)
193                .map(|buffer| buffer.into_glib_ptr())
194                .unwrap_or(ptr::null_mut())
195        })
196    }
197}
gstreamer_rtp/subclass/rtp_base_depayload.rs

gstreamer_rtp/subclass/
rtp_base_depayload.rs
