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::{ffi, prelude::*, RTPBaseDepayload};
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    let instance = &*(ptr as *mut T::Instance);
136    let imp = instance.imp();
137    let caps = from_glib_borrow(caps);
138
139    gst::panic_to_error!(imp, false, {
140        match imp.set_caps(&caps) {
141            Ok(()) => true,
142            Err(err) => {
143                err.log_with_imp(imp);
144                false
145            }
146        }
147    })
148    .into_glib()
149}
150
151unsafe extern "C" fn rtp_base_depayload_handle_event<T: RTPBaseDepayloadImpl>(
152    ptr: *mut ffi::GstRTPBaseDepayload,
153    event: *mut gst::ffi::GstEvent,
154) -> glib::ffi::gboolean {
155    let instance = &*(ptr as *mut T::Instance);
156    let imp = instance.imp();
157
158    gst::panic_to_error!(imp, false, { imp.handle_event(from_glib_full(event)) }).into_glib()
159}
160
161unsafe extern "C" fn rtp_base_depayload_packet_lost<T: RTPBaseDepayloadImpl>(
162    ptr: *mut ffi::GstRTPBaseDepayload,
163    event: *mut gst::ffi::GstEvent,
164) -> glib::ffi::gboolean {
165    let instance = &*(ptr as *mut T::Instance);
166    let imp = instance.imp();
167
168    gst::panic_to_error!(imp, false, {
169        imp.packet_lost(gst::EventRef::from_ptr(event))
170    })
171    .into_glib()
172}
173
174unsafe extern "C" fn rtp_base_depayload_process_rtp_packet<T: RTPBaseDepayloadImpl>(
175    ptr: *mut ffi::GstRTPBaseDepayload,
176    rtp_packet: *mut ffi::GstRTPBuffer,
177) -> *mut gst::ffi::GstBuffer {
178    let instance = &*(ptr as *mut T::Instance);
179    let imp = instance.imp();
180
181    gst::panic_to_error!(imp, ptr::null_mut(), {
182        let bufwrap = crate::RTPBuffer::<crate::rtp_buffer::Readable>::from_glib_borrow(rtp_packet);
183
184        imp.process_rtp_packet(&bufwrap)
185            .map(|buffer| buffer.into_glib_ptr())
186            .unwrap_or(ptr::null_mut())
187    })
188}
gstreamer_rtp/subclass/rtp_base_depayload.rs

gstreamer_rtp/subclass/
rtp_base_depayload.rs
