From dc6c7500df3a56e8f62cf8e5d33c2df50f3f0cb6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Mon, 18 Sep 2017 00:32:29 +0300 Subject: [PATCH] Add bindings for remaining pad task functions Especially Pad::start_task() --- Gir_Gst.toml | 1 + gstreamer/src/auto/enums.rs | 60 +++++++++++++++++++++++++++++++++++++ gstreamer/src/auto/mod.rs | 1 + gstreamer/src/auto/pad.rs | 16 ++++++---- gstreamer/src/pad.rs | 32 ++++++++++++++++++++ 5 files changed, 104 insertions(+), 6 deletions(-) diff --git a/Gir_Gst.toml b/Gir_Gst.toml index fa2f45e29..f65a3b702 100644 --- a/Gir_Gst.toml +++ b/Gir_Gst.toml @@ -74,6 +74,7 @@ generate = [ "Gst.StackTraceFlags", "Gst.DebugGraphDetails", "Gst.ParseFlags", + "Gst.TaskState", ] manual = [ diff --git a/gstreamer/src/auto/enums.rs b/gstreamer/src/auto/enums.rs index 37b9ad562..ca68f467e 100644 --- a/gstreamer/src/auto/enums.rs +++ b/gstreamer/src/auto/enums.rs @@ -2342,6 +2342,66 @@ impl SetValue for TagMergeMode { } } +#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)] +pub enum TaskState { + Started, + Stopped, + Paused, + #[doc(hidden)] + __Unknown(i32), +} + +#[doc(hidden)] +impl ToGlib for TaskState { + type GlibType = ffi::GstTaskState; + + fn to_glib(&self) -> ffi::GstTaskState { + match *self { + TaskState::Started => ffi::GST_TASK_STARTED, + TaskState::Stopped => ffi::GST_TASK_STOPPED, + TaskState::Paused => ffi::GST_TASK_PAUSED, + TaskState::__Unknown(value) => unsafe{std::mem::transmute(value)} + } + } +} + +#[doc(hidden)] +impl FromGlib for TaskState { + fn from_glib(value: ffi::GstTaskState) -> Self { + skip_assert_initialized!(); + match value as i32 { + 0 => TaskState::Started, + 1 => TaskState::Stopped, + 2 => TaskState::Paused, + value => TaskState::__Unknown(value), + } + } +} + +impl StaticType for TaskState { + fn static_type() -> Type { + unsafe { from_glib(ffi::gst_task_state_get_type()) } + } +} + +impl<'a> FromValueOptional<'a> for TaskState { + unsafe fn from_value_optional(value: &Value) -> Option { + Some(FromValue::from_value(value)) + } +} + +impl<'a> FromValue<'a> for TaskState { + unsafe fn from_value(value: &Value) -> Self { + from_glib(std::mem::transmute::(gobject_ffi::g_value_get_enum(value.to_glib_none().0))) + } +} + +impl SetValue for TaskState { + unsafe fn set_value(value: &mut Value, this: &Self) { + gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib() as i32) + } +} + #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)] pub enum TocEntryType { Angle, diff --git a/gstreamer/src/auto/mod.rs b/gstreamer/src/auto/mod.rs index 6d945c6ad..c910e3d98 100644 --- a/gstreamer/src/auto/mod.rs +++ b/gstreamer/src/auto/mod.rs @@ -128,6 +128,7 @@ pub use self::enums::StreamError; pub use self::enums::StreamStatusType; pub use self::enums::StructureChangeType; pub use self::enums::TagMergeMode; +pub use self::enums::TaskState; pub use self::enums::TocEntryType; pub use self::enums::TocLoopType; pub use self::enums::TocScope; diff --git a/gstreamer/src/auto/pad.rs b/gstreamer/src/auto/pad.rs index 2e1e89abc..61dbac98e 100644 --- a/gstreamer/src/auto/pad.rs +++ b/gstreamer/src/auto/pad.rs @@ -15,6 +15,8 @@ use PadMode; use PadTemplate; #[cfg(feature = "v1_10")] use Stream; +#[cfg(feature = "v1_12")] +use TaskState; use ffi; use glib; use glib::Value; @@ -116,8 +118,8 @@ pub trait PadExt { fn get_stream_id(&self) -> Option; - //#[cfg(feature = "v1_12")] - //fn get_task_state(&self) -> /*Ignored*/TaskState; + #[cfg(feature = "v1_12")] + fn get_task_state(&self) -> TaskState; fn has_current_caps(&self) -> bool; @@ -348,10 +350,12 @@ impl + IsA> PadExt for O { } } - //#[cfg(feature = "v1_12")] - //fn get_task_state(&self) -> /*Ignored*/TaskState { - // unsafe { TODO: call ffi::gst_pad_get_task_state() } - //} + #[cfg(feature = "v1_12")] + fn get_task_state(&self) -> TaskState { + unsafe { + from_glib(ffi::gst_pad_get_task_state(self.to_glib_none().0)) + } + } fn has_current_caps(&self) -> bool { unsafe { diff --git a/gstreamer/src/pad.rs b/gstreamer/src/pad.rs index f43553151..a62d6be73 100644 --- a/gstreamer/src/pad.rs +++ b/gstreamer/src/pad.rs @@ -20,6 +20,7 @@ use miniobject::MiniObject; use std::mem::transmute; use std::ptr; use std::mem; +use std::cell::RefCell; use glib::{IsA, StaticType}; use glib::translate::{from_glib, from_glib_borrow, from_glib_full, from_glib_none, FromGlib, @@ -166,6 +167,8 @@ pub trait PadExtManual { fn set_unlink_function(&self, func: F) where F: Fn(&Pad, &::Object) + Send + Sync + 'static; + + fn start_task(&self, func: F) -> bool; } impl> PadExtManual for O { @@ -560,6 +563,17 @@ impl> PadExtManual for O { ); } } + + fn start_task(&self, func: F) -> bool { + unsafe { + from_glib(ffi::gst_pad_start_task( + self.to_glib_none().0, + Some(trampoline_pad_task), + into_raw_pad_task(func), + Some(destroy_closure_pad_task), + )) + } + } } unsafe extern "C" fn trampoline_pad_probe( @@ -839,3 +853,21 @@ unsafe extern "C" fn destroy_closure(ptr: gpointer) { let _guard = CallbackGuard::new(); Box::>::from_raw(ptr as *mut _); } + +unsafe extern "C" fn trampoline_pad_task(func: gpointer) { + let _guard = CallbackGuard::new(); + #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))] + let func: &RefCell> = transmute(func); + (&mut *func.borrow_mut())() +} + +unsafe extern "C" fn destroy_closure_pad_task(ptr: gpointer) { + let _guard = CallbackGuard::new(); + Box::>>::from_raw(ptr as *mut _); +} + +fn into_raw_pad_task(func: F) -> gpointer { + #[cfg_attr(feature = "cargo-clippy", allow(type_complexity))] + let func: Box>> = Box::new(RefCell::new(Box::new(func))); + Box::into_raw(func) as gpointer +}