From 4246a560fc6ac46acbd4ef2bbb821e2ab76ac188 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 10 Jul 2020 15:04:23 +0300 Subject: [PATCH] gstreamer/ghost_pad: Move GhostPad specific code into the ghost_pad module --- gstreamer/src/ghost_pad.rs | 294 ++++++++++++++++++++++++++++++++++++- gstreamer/src/pad.rs | 287 +----------------------------------- 2 files changed, 294 insertions(+), 287 deletions(-) diff --git a/gstreamer/src/ghost_pad.rs b/gstreamer/src/ghost_pad.rs index 03df5f204..a4bd78c68 100644 --- a/gstreamer/src/ghost_pad.rs +++ b/gstreamer/src/ghost_pad.rs @@ -6,12 +6,21 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use glib::object::IsA; +use glib::prelude::*; use glib::translate::*; use gst_sys; +use FlowError; +use FlowSuccess; use GhostPad; +use LoggableError; use Object; +use Pad; +use PadBuilder; +use PadExtManual; +use PadFlags; +use PadGetRangeSuccess; use PadMode; +use StaticPadTemplate; impl GhostPad { pub fn activate_mode_default, Q: IsA>( @@ -56,4 +65,287 @@ impl GhostPad { ) } } + + pub fn new(name: Option<&str>, direction: ::PadDirection) -> Self { + skip_assert_initialized!(); + Self::builder(name, direction).build() + } + + pub fn builder(name: Option<&str>, direction: ::PadDirection) -> PadBuilder { + skip_assert_initialized!(); + PadBuilder::new(name, direction) + } + + pub fn from_static_template(templ: &StaticPadTemplate, name: Option<&str>) -> Self { + skip_assert_initialized!(); + Self::builder_with_static_template(templ, name).build() + } + + pub fn builder_with_static_template( + templ: &StaticPadTemplate, + name: Option<&str>, + ) -> PadBuilder { + skip_assert_initialized!(); + PadBuilder::from_static_template(templ, name) + } + + pub fn from_template(templ: &::PadTemplate, name: Option<&str>) -> Self { + skip_assert_initialized!(); + Self::builder_with_template(templ, name).build() + } + + pub fn builder_with_template(templ: &::PadTemplate, name: Option<&str>) -> PadBuilder { + skip_assert_initialized!(); + PadBuilder::from_template(templ, name) + } +} + +impl + IsA> PadBuilder { + pub fn proxy_pad_activate_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>) -> Result<(), LoggableError> + Send + Sync + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_activate_function(func); + } + + self + } + + pub fn proxy_pad_activatemode_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>, ::PadMode, bool) -> Result<(), LoggableError> + + Send + + Sync + + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_activatemode_function(func); + } + + self + } + + pub fn proxy_pad_chain_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>, ::Buffer) -> Result + + Send + + Sync + + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_chain_function(func); + } + + self + } + + pub fn proxy_pad_chain_list_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>, ::BufferList) -> Result + + Send + + Sync + + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_chain_list_function(func); + } + + self + } + + pub fn proxy_pad_event_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>, ::Event) -> bool + Send + Sync + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_event_function(func); + } + + self + } + + pub fn proxy_pad_event_full_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>, ::Event) -> Result + + Send + + Sync + + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_event_full_function(func); + } + + self + } + + pub fn proxy_pad_getrange_function(self, func: F) -> Self + where + F: Fn( + &::ProxyPad, + Option<&::Object>, + u64, + Option<&mut ::BufferRef>, + u32, + ) -> Result + + Send + + Sync + + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_getrange_function(func); + } + + self + } + + pub fn proxy_pad_iterate_internal_links_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>) -> ::Iterator + Send + Sync + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_iterate_internal_links_function(func); + } + + self + } + + pub fn proxy_pad_link_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>, &Pad) -> Result<::PadLinkSuccess, ::PadLinkError> + + Send + + Sync + + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_link_function(func); + } + + self + } + + pub fn proxy_pad_query_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>, &mut ::QueryRef) -> bool + Send + Sync + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_query_function(func); + } + + self + } + + pub fn proxy_pad_unlink_function(self, func: F) -> Self + where + F: Fn(&::ProxyPad, Option<&::Object>) + Send + Sync + 'static, + { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_unlink_function(func); + } + + self + } + + pub fn proxy_pad_flags(self, flags: PadFlags) -> Self { + use ProxyPadExt; + + unsafe { + let proxy = self + .0 + .unsafe_cast_ref::<::ProxyPad>() + .get_internal() + .unwrap(); + proxy.set_pad_flags(flags); + } + + self + } + + pub fn build_with_target>(self, target: &P) -> Result { + use GhostPadExt; + use PadExt; + + assert_eq!(self.0.get_direction(), target.get_direction()); + + self.0.set_target(Some(target))?; + + Ok(self.0) + } } diff --git a/gstreamer/src/pad.rs b/gstreamer/src/pad.rs index ef158a7d0..bd735c453 100644 --- a/gstreamer/src/pad.rs +++ b/gstreamer/src/pad.rs @@ -1578,42 +1578,7 @@ impl Pad { } } -impl ::GhostPad { - pub fn new(name: Option<&str>, direction: ::PadDirection) -> Self { - skip_assert_initialized!(); - Self::builder(name, direction).build() - } - - pub fn builder(name: Option<&str>, direction: ::PadDirection) -> PadBuilder { - skip_assert_initialized!(); - PadBuilder::new(name, direction) - } - - pub fn from_static_template(templ: &StaticPadTemplate, name: Option<&str>) -> Self { - skip_assert_initialized!(); - Self::builder_with_static_template(templ, name).build() - } - - pub fn builder_with_static_template( - templ: &StaticPadTemplate, - name: Option<&str>, - ) -> PadBuilder { - skip_assert_initialized!(); - PadBuilder::from_static_template(templ, name) - } - - pub fn from_template(templ: &::PadTemplate, name: Option<&str>) -> Self { - skip_assert_initialized!(); - Self::builder_with_template(templ, name).build() - } - - pub fn builder_with_template(templ: &::PadTemplate, name: Option<&str>) -> PadBuilder { - skip_assert_initialized!(); - PadBuilder::from_template(templ, name) - } -} - -pub struct PadBuilder(T); +pub struct PadBuilder(pub(crate) T); impl + IsA> PadBuilder { pub fn new(name: Option<&str>, direction: ::PadDirection) -> Self { @@ -1854,256 +1819,6 @@ impl + IsA> PadBuilder { } } -impl + IsA> PadBuilder { - pub fn proxy_pad_activate_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>) -> Result<(), LoggableError> + Send + Sync + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_activate_function(func); - } - - self - } - - pub fn proxy_pad_activatemode_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>, ::PadMode, bool) -> Result<(), LoggableError> - + Send - + Sync - + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_activatemode_function(func); - } - - self - } - - pub fn proxy_pad_chain_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>, ::Buffer) -> Result - + Send - + Sync - + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_chain_function(func); - } - - self - } - - pub fn proxy_pad_chain_list_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>, ::BufferList) -> Result - + Send - + Sync - + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_chain_list_function(func); - } - - self - } - - pub fn proxy_pad_event_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>, ::Event) -> bool + Send + Sync + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_event_function(func); - } - - self - } - - pub fn proxy_pad_event_full_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>, ::Event) -> Result - + Send - + Sync - + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_event_full_function(func); - } - - self - } - - pub fn proxy_pad_getrange_function(self, func: F) -> Self - where - F: Fn( - &::ProxyPad, - Option<&::Object>, - u64, - Option<&mut ::BufferRef>, - u32, - ) -> Result - + Send - + Sync - + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_getrange_function(func); - } - - self - } - - pub fn proxy_pad_iterate_internal_links_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>) -> ::Iterator + Send + Sync + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_iterate_internal_links_function(func); - } - - self - } - - pub fn proxy_pad_link_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>, &Pad) -> Result<::PadLinkSuccess, ::PadLinkError> - + Send - + Sync - + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_link_function(func); - } - - self - } - - pub fn proxy_pad_query_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>, &mut ::QueryRef) -> bool + Send + Sync + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_query_function(func); - } - - self - } - - pub fn proxy_pad_unlink_function(self, func: F) -> Self - where - F: Fn(&::ProxyPad, Option<&::Object>) + Send + Sync + 'static, - { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_unlink_function(func); - } - - self - } - - pub fn proxy_pad_flags(self, flags: PadFlags) -> Self { - use ProxyPadExt; - - unsafe { - let proxy = self - .0 - .unsafe_cast_ref::<::ProxyPad>() - .get_internal() - .unwrap(); - proxy.set_pad_flags(flags); - } - - self - } - - pub fn build_with_target>(self, target: &P) -> Result { - use GhostPadExt; - use PadExt; - - assert_eq!(self.0.get_direction(), target.get_direction()); - - self.0.set_target(Some(target))?; - - Ok(self.0) - } -} - #[cfg(test)] mod tests { use super::*;