gstreamer/subclass/
bin.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use glib::{prelude::*, subclass::prelude::*, translate::*};
4
5use super::prelude::*;
6use crate::{Bin, Element, LoggableError, Message, ffi};
7
8pub trait BinImpl: ElementImpl + ObjectSubclass<Type: IsA<Bin>> {
9    fn add_element(&self, element: &Element) -> Result<(), LoggableError> {
10        self.parent_add_element(element)
11    }
12
13    fn remove_element(&self, element: &Element) -> Result<(), LoggableError> {
14        self.parent_remove_element(element)
15    }
16
17    fn do_latency(&self) -> Result<(), LoggableError> {
18        self.parent_do_latency()
19    }
20
21    fn handle_message(&self, message: Message) {
22        self.parent_handle_message(message)
23    }
24}
25
26pub trait BinImplExt: BinImpl {
27    fn parent_add_element(&self, element: &Element) -> Result<(), LoggableError> {
28        unsafe {
29            let data = Self::type_data();
30            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBinClass;
31            let f = (*parent_class).add_element.ok_or_else(|| {
32                loggable_error!(
33                    crate::CAT_RUST,
34                    "Parent function `add_element` is not defined"
35                )
36            })?;
37            result_from_gboolean!(
38                f(
39                    self.obj().unsafe_cast_ref::<crate::Bin>().to_glib_none().0,
40                    element.to_glib_none().0
41                ),
42                crate::CAT_RUST,
43                "Failed to add the element using the parent function"
44            )
45        }
46    }
47
48    fn parent_remove_element(&self, element: &Element) -> Result<(), LoggableError> {
49        unsafe {
50            let data = Self::type_data();
51            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBinClass;
52            let f = (*parent_class).remove_element.ok_or_else(|| {
53                loggable_error!(
54                    crate::CAT_RUST,
55                    "Parent function `remove_element` is not defined"
56                )
57            })?;
58            result_from_gboolean!(
59                f(
60                    self.obj().unsafe_cast_ref::<crate::Bin>().to_glib_none().0,
61                    element.to_glib_none().0
62                ),
63                crate::CAT_RUST,
64                "Failed to remove the element using the parent function"
65            )
66        }
67    }
68
69    fn parent_do_latency(&self) -> Result<(), LoggableError> {
70        unsafe {
71            let data = Self::type_data();
72            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBinClass;
73            let f = (*parent_class).do_latency.ok_or_else(|| {
74                loggable_error!(
75                    crate::CAT_RUST,
76                    "Parent function `do_latency` is not defined"
77                )
78            })?;
79            result_from_gboolean!(
80                f(self.obj().unsafe_cast_ref::<crate::Bin>().to_glib_none().0,),
81                crate::CAT_RUST,
82                "Failed to update latency using the parent function"
83            )
84        }
85    }
86
87    fn parent_handle_message(&self, message: Message) {
88        unsafe {
89            let data = Self::type_data();
90            let parent_class = data.as_ref().parent_class() as *mut ffi::GstBinClass;
91            if let Some(ref f) = (*parent_class).handle_message {
92                f(
93                    self.obj().unsafe_cast_ref::<crate::Bin>().to_glib_none().0,
94                    message.into_glib_ptr(),
95                );
96            }
97        }
98    }
99}
100
101impl<T: BinImpl> BinImplExt for T {}
102
103unsafe impl<T: BinImpl> IsSubclassable<T> for Bin {
104    fn class_init(klass: &mut glib::Class<Self>) {
105        Self::parent_class_init::<T>(klass);
106        let klass = klass.as_mut();
107        klass.add_element = Some(bin_add_element::<T>);
108        klass.remove_element = Some(bin_remove_element::<T>);
109        klass.do_latency = Some(bin_do_latency::<T>);
110        klass.handle_message = Some(bin_handle_message::<T>);
111    }
112}
113
114unsafe extern "C" fn bin_add_element<T: BinImpl>(
115    ptr: *mut ffi::GstBin,
116    element: *mut ffi::GstElement,
117) -> glib::ffi::gboolean {
118    unsafe {
119        let instance = &*(ptr as *mut T::Instance);
120        let imp = instance.imp();
121
122        panic_to_error!(imp, false, {
123            match imp.add_element(&from_glib_none(element)) {
124                Ok(()) => true,
125                Err(err) => {
126                    err.log_with_imp(imp);
127                    false
128                }
129            }
130        })
131        .into_glib()
132    }
133}
134
135unsafe extern "C" fn bin_remove_element<T: BinImpl>(
136    ptr: *mut ffi::GstBin,
137    element: *mut ffi::GstElement,
138) -> glib::ffi::gboolean {
139    unsafe {
140        let instance = &*(ptr as *mut T::Instance);
141        let imp = instance.imp();
142
143        // If we get a floating reference passed simply return FALSE here. It can't be
144        // stored inside this bin, and if we continued to use it we would take ownership
145        // of this floating reference.
146        if glib::gobject_ffi::g_object_is_floating(element as *mut glib::gobject_ffi::GObject)
147            != glib::ffi::GFALSE
148        {
149            return glib::ffi::GFALSE;
150        }
151
152        panic_to_error!(imp, false, {
153            match imp.remove_element(&from_glib_none(element)) {
154                Ok(()) => true,
155                Err(err) => {
156                    err.log_with_imp(imp);
157                    false
158                }
159            }
160        })
161        .into_glib()
162    }
163}
164
165unsafe extern "C" fn bin_do_latency<T: BinImpl>(ptr: *mut ffi::GstBin) -> glib::ffi::gboolean {
166    unsafe {
167        let instance = &*(ptr as *mut T::Instance);
168        let imp = instance.imp();
169
170        panic_to_error!(imp, false, {
171            match imp.do_latency() {
172                Ok(()) => true,
173                Err(err) => {
174                    err.log_with_imp(imp);
175                    false
176                }
177            }
178        })
179        .into_glib()
180    }
181}
182
183unsafe extern "C" fn bin_handle_message<T: BinImpl>(
184    ptr: *mut ffi::GstBin,
185    message: *mut ffi::GstMessage,
186) {
187    unsafe {
188        let instance = &*(ptr as *mut T::Instance);
189        let imp = instance.imp();
190
191        panic_to_error!(imp, (), { imp.handle_message(from_glib_full(message)) });
192    }
193}
gstreamer/subclass/bin.rs

gstreamer/subclass/
bin.rs
