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::{ffi, Bin, Element, LoggableError, Message};
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    let instance = &*(ptr as *mut T::Instance);
119    let imp = instance.imp();
120
121    panic_to_error!(imp, false, {
122        match imp.add_element(&from_glib_none(element)) {
123            Ok(()) => true,
124            Err(err) => {
125                err.log_with_imp(imp);
126                false
127            }
128        }
129    })
130    .into_glib()
131}
132
133unsafe extern "C" fn bin_remove_element<T: BinImpl>(
134    ptr: *mut ffi::GstBin,
135    element: *mut ffi::GstElement,
136) -> glib::ffi::gboolean {
137    let instance = &*(ptr as *mut T::Instance);
138    let imp = instance.imp();
139
140    // If we get a floating reference passed simply return FALSE here. It can't be
141    // stored inside this bin, and if we continued to use it we would take ownership
142    // of this floating reference.
143    if glib::gobject_ffi::g_object_is_floating(element as *mut glib::gobject_ffi::GObject)
144        != glib::ffi::GFALSE
145    {
146        return glib::ffi::GFALSE;
147    }
148
149    panic_to_error!(imp, false, {
150        match imp.remove_element(&from_glib_none(element)) {
151            Ok(()) => true,
152            Err(err) => {
153                err.log_with_imp(imp);
154                false
155            }
156        }
157    })
158    .into_glib()
159}
160
161unsafe extern "C" fn bin_do_latency<T: BinImpl>(ptr: *mut ffi::GstBin) -> glib::ffi::gboolean {
162    let instance = &*(ptr as *mut T::Instance);
163    let imp = instance.imp();
164
165    panic_to_error!(imp, false, {
166        match imp.do_latency() {
167            Ok(()) => true,
168            Err(err) => {
169                err.log_with_imp(imp);
170                false
171            }
172        }
173    })
174    .into_glib()
175}
176
177unsafe extern "C" fn bin_handle_message<T: BinImpl>(
178    ptr: *mut ffi::GstBin,
179    message: *mut ffi::GstMessage,
180) {
181    let instance = &*(ptr as *mut T::Instance);
182    let imp = instance.imp();
183
184    panic_to_error!(imp, (), { imp.handle_message(from_glib_full(message)) });
185}
gstreamer/subclass/bin.rs

gstreamer/subclass/
bin.rs
