mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-11-25 11:01:10 +00:00
Code Issues Projects Releases Wiki Activity

Regenerate everything

Browse source
This commit is contained in:
Sebastian Dröge 2019-06-18 13:10:46 +03:00
parent 93dc69f3f3
commit e5aa6f59f9
84 changed files with 1651 additions and 1775 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
gstreamer-app/src/auto/app_sink.rs
View file

@ -4,7 +4,7 @@
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -158,6 +158,10 @@ impl AppSink {
} }
pub fn connect_eos<F: Fn(&AppSink) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_eos<F: Fn(&AppSink) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn eos_trampoline<F: Fn(&AppSink) + Send + 'static>(this: *mut gst_app_sys::GstAppSink, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"eos\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"eos\0".as_ptr() as *const _,
@ -166,6 +170,10 @@ impl AppSink {
} }
pub fn connect_property_buffer_list_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_buffer_list_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_buffer_list_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::buffer-list\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::buffer-list\0".as_ptr() as *const _,
@ -174,6 +182,10 @@ impl AppSink {
} }
pub fn connect_property_caps_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_caps_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _,
@ -182,6 +194,10 @@ impl AppSink {
} }
pub fn connect_property_drop_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_drop_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_drop_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::drop\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::drop\0".as_ptr() as *const _,
@ -190,6 +206,10 @@ impl AppSink {
} }
pub fn connect_property_emit_signals_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_emit_signals_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_emit_signals_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _,
@ -198,6 +218,10 @@ impl AppSink {
} }
pub fn connect_property_eos_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_eos_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_eos_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::eos\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::eos\0".as_ptr() as *const _,
@ -206,6 +230,10 @@ impl AppSink {
} }
pub fn connect_property_max_buffers_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_max_buffers_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_buffers_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-buffers\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-buffers\0".as_ptr() as *const _,
@ -214,6 +242,10 @@ impl AppSink {
} }
pub fn connect_property_wait_on_eos_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_wait_on_eos_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_wait_on_eos_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::wait-on-eos\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::wait-on-eos\0".as_ptr() as *const _,
@ -224,43 +256,3 @@ impl AppSink {
unsafe impl Send for AppSink {} unsafe impl Send for AppSink {}
unsafe impl Sync for AppSink {} unsafe impl Sync for AppSink {}
unsafe extern "C" fn eos_trampoline<F: Fn(&AppSink) + Send + 'static>(this: *mut gst_app_sys::GstAppSink, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_buffer_list_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_drop_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_emit_signals_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_eos_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_max_buffers_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_wait_on_eos_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

146
gstreamer-app/src/auto/app_src.rs
View file

@ -5,7 +5,7 @@
use AppStreamType; use AppStreamType;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -210,6 +210,10 @@ impl AppSrc {
} }
pub fn connect_enough_data<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_enough_data<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn enough_data_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"enough-data\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"enough-data\0".as_ptr() as *const _,
@ -218,6 +222,10 @@ impl AppSrc {
} }
pub fn connect_need_data<F: Fn(&AppSrc, u32) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_need_data<F: Fn(&AppSrc, u32) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn need_data_trampoline<F: Fn(&AppSrc, u32) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, length: libc::c_uint, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), length)
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"need-data\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"need-data\0".as_ptr() as *const _,
@ -226,6 +234,10 @@ impl AppSrc {
} }
pub fn connect_seek_data<F: Fn(&AppSrc, u64) -> bool + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_seek_data<F: Fn(&AppSrc, u64) -> bool + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn seek_data_trampoline<F: Fn(&AppSrc, u64) -> bool + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, offset: u64, f: glib_sys::gpointer) -> glib_sys::gboolean {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), offset).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"seek-data\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"seek-data\0".as_ptr() as *const _,
@ -234,6 +246,10 @@ impl AppSrc {
} }
pub fn connect_property_block_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_block_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_block_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::block\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::block\0".as_ptr() as *const _,
@ -242,6 +258,10 @@ impl AppSrc {
} }
pub fn connect_property_caps_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_caps_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _,
@ -250,6 +270,10 @@ impl AppSrc {
} }
pub fn connect_property_current_level_bytes_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_current_level_bytes_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_current_level_bytes_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::current-level-bytes\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::current-level-bytes\0".as_ptr() as *const _,
@ -258,6 +282,10 @@ impl AppSrc {
} }
pub fn connect_property_duration_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_duration_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _,
@ -266,6 +294,10 @@ impl AppSrc {
} }
pub fn connect_property_emit_signals_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_emit_signals_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_emit_signals_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _,
@ -274,6 +306,10 @@ impl AppSrc {
} }
pub fn connect_property_format_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_format_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_format_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::format\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::format\0".as_ptr() as *const _,
@ -282,6 +318,10 @@ impl AppSrc {
} }
pub fn connect_property_is_live_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_is_live_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_is_live_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::is-live\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::is-live\0".as_ptr() as *const _,
@ -290,6 +330,10 @@ impl AppSrc {
} }
pub fn connect_property_max_bytes_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_max_bytes_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_bytes_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-bytes\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-bytes\0".as_ptr() as *const _,
@ -298,6 +342,10 @@ impl AppSrc {
} }
pub fn connect_property_max_latency_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_max_latency_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_latency_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-latency\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-latency\0".as_ptr() as *const _,
@ -306,6 +354,10 @@ impl AppSrc {
} }
pub fn connect_property_min_latency_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_min_latency_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_min_latency_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::min-latency\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::min-latency\0".as_ptr() as *const _,
@ -314,6 +366,10 @@ impl AppSrc {
} }
pub fn connect_property_min_percent_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_min_percent_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_min_percent_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::min-percent\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::min-percent\0".as_ptr() as *const _,
@ -322,6 +378,10 @@ impl AppSrc {
} }
pub fn connect_property_size_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_size_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_size_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::size\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::size\0".as_ptr() as *const _,
@ -330,6 +390,10 @@ impl AppSrc {
} }
pub fn connect_property_stream_type_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_stream_type_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_stream_type_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::stream-type\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::stream-type\0".as_ptr() as *const _,
@ -340,83 +404,3 @@ impl AppSrc {
unsafe impl Send for AppSrc {} unsafe impl Send for AppSrc {}
unsafe impl Sync for AppSrc {} unsafe impl Sync for AppSrc {}
unsafe extern "C" fn enough_data_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn need_data_trampoline<F: Fn(&AppSrc, u32) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, length: libc::c_uint, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), length)
}
unsafe extern "C" fn seek_data_trampoline<F: Fn(&AppSrc, u64) -> bool + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, offset: u64, f: glib_sys::gpointer) -> glib_sys::gboolean {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), offset).to_glib()
}
unsafe extern "C" fn notify_block_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_current_level_bytes_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_duration_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_emit_signals_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_format_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_is_live_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_max_bytes_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_max_latency_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_min_latency_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_min_percent_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_size_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_stream_type_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

2
gstreamer-app/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

24
gstreamer-audio/src/auto/stream_volume.rs
View file

@ -75,6 +75,12 @@ impl<O: IsA<StreamVolume>> StreamVolumeExt for O {
} }
fn connect_property_mute_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mute_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_audio_sys::GstStreamVolume, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<StreamVolume>
{
let f: &F = &*(f as *const F);
f(&StreamVolume::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mute\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::mute\0".as_ptr() as *const _,
@ -83,6 +89,12 @@ impl<O: IsA<StreamVolume>> StreamVolumeExt for O {
} }
fn connect_property_volume_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_volume_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_volume_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_audio_sys::GstStreamVolume, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<StreamVolume>
{
let f: &F = &*(f as *const F);
f(&StreamVolume::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::volume\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::volume\0".as_ptr() as *const _,
@ -90,15 +102,3 @@ impl<O: IsA<StreamVolume>> StreamVolumeExt for O {
} }
} }
} }
unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_audio_sys::GstStreamVolume, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<StreamVolume> {
let f: &F = &*(f as *const F);
f(&StreamVolume::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_volume_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_audio_sys::GstStreamVolume, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<StreamVolume> {
let f: &F = &*(f as *const F);
f(&StreamVolume::from_glib_borrow(this).unsafe_cast())
}

2
gstreamer-audio/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

25
gstreamer-base/src/auto/aggregator.rs
View file

@ -115,6 +115,12 @@ impl<O: IsA<Aggregator>> AggregatorExt for O {
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregator, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Aggregator>
{
let f: &F = &*(f as *const F);
f(&Aggregator::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _,
@ -123,6 +129,12 @@ impl<O: IsA<Aggregator>> AggregatorExt for O {
} }
fn connect_property_start_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_start_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_start_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregator, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Aggregator>
{
let f: &F = &*(f as *const F);
f(&Aggregator::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::start-time\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::start-time\0".as_ptr() as *const _,
@ -130,16 +142,3 @@ impl<O: IsA<Aggregator>> AggregatorExt for O {
} }
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))]
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregator, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Aggregator> {
let f: &F = &*(f as *const F);
f(&Aggregator::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_start_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregator, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Aggregator> {
let f: &F = &*(f as *const F);
f(&Aggregator::from_glib_borrow(this).unsafe_cast())
}

25
gstreamer-base/src/auto/aggregator_pad.rs
View file

@ -114,6 +114,12 @@ impl<O: IsA<AggregatorPad>> AggregatorPadExt for O {
} }
fn connect_buffer_consumed<F: Fn(&Self, &gst::Buffer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_buffer_consumed<F: Fn(&Self, &gst::Buffer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn buffer_consumed_trampoline<P, F: Fn(&P, &gst::Buffer) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregatorPad, object: *mut gst_sys::GstBuffer, f: glib_sys::gpointer)
where P: IsA<AggregatorPad>
{
let f: &F = &*(f as *const F);
f(&AggregatorPad::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"buffer-consumed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"buffer-consumed\0".as_ptr() as *const _,
@ -123,6 +129,12 @@ impl<O: IsA<AggregatorPad>> AggregatorPadExt for O {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn connect_property_emit_signals_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_emit_signals_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_emit_signals_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregatorPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<AggregatorPad>
{
let f: &F = &*(f as *const F);
f(&AggregatorPad::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _,
@ -130,16 +142,3 @@ impl<O: IsA<AggregatorPad>> AggregatorPadExt for O {
} }
} }
} }
unsafe extern "C" fn buffer_consumed_trampoline<P, F: Fn(&P, &gst::Buffer) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregatorPad, object: *mut gst_sys::GstBuffer, f: glib_sys::gpointer)
where P: IsA<AggregatorPad> {
let f: &F = &*(f as *const F);
f(&AggregatorPad::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
#[cfg(any(feature = "v1_16", feature = "dox"))]
unsafe extern "C" fn notify_emit_signals_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregatorPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<AggregatorPad> {
let f: &F = &*(f as *const F);
f(&AggregatorPad::from_glib_borrow(this).unsafe_cast())
}

12
gstreamer-base/src/auto/base_parse.rs
View file

@ -151,6 +151,12 @@ impl<O: IsA<BaseParse>> BaseParseExt for O {
} }
fn connect_property_disable_passthrough_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_disable_passthrough_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_disable_passthrough_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseParse, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseParse>
{
let f: &F = &*(f as *const F);
f(&BaseParse::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::disable-passthrough\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::disable-passthrough\0".as_ptr() as *const _,
@ -158,9 +164,3 @@ impl<O: IsA<BaseParse>> BaseParseExt for O {
} }
} }
} }
unsafe extern "C" fn notify_disable_passthrough_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseParse, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseParse> {
let f: &F = &*(f as *const F);
f(&BaseParse::from_glib_borrow(this).unsafe_cast())
}

145
gstreamer-base/src/auto/base_sink.rs
View file

@ -358,6 +358,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_async_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::async\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::async\0".as_ptr() as *const _,
@ -366,6 +372,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::blocksize\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::blocksize\0".as_ptr() as *const _,
@ -374,6 +386,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_enable_last_sample_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::enable-last-sample\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::enable-last-sample\0".as_ptr() as *const _,
@ -382,6 +400,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_last_sample_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::last-sample\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::last-sample\0".as_ptr() as *const _,
@ -390,6 +414,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_bitrate_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-bitrate\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-bitrate\0".as_ptr() as *const _,
@ -398,6 +428,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_lateness_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-lateness\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-lateness\0".as_ptr() as *const _,
@ -407,6 +443,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn connect_property_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_processing_deadline_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::processing-deadline\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::processing-deadline\0".as_ptr() as *const _,
@ -415,6 +457,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::qos\0".as_ptr() as *const _,
@ -423,6 +471,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_render_delay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::render-delay\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::render-delay\0".as_ptr() as *const _,
@ -431,6 +485,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_sync_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::sync\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::sync\0".as_ptr() as *const _,
@ -439,6 +499,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_throttle_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::throttle-time\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::throttle-time\0".as_ptr() as *const _,
@ -447,6 +513,12 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_ts_offset_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink>
{
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::ts-offset\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::ts-offset\0".as_ptr() as *const _,
@ -454,76 +526,3 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
} }
} }
} }
unsafe extern "C" fn notify_async_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_enable_last_sample_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_last_sample_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_max_bitrate_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_max_lateness_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
#[cfg(any(feature = "v1_16", feature = "dox"))]
unsafe extern "C" fn notify_processing_deadline_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_render_delay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_sync_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_throttle_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_ts_offset_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSink> {
let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast())
}

48
gstreamer-base/src/auto/base_src.rs
View file

@ -209,6 +209,12 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
} }
fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSrc>
{
let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::blocksize\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::blocksize\0".as_ptr() as *const _,
@ -217,6 +223,12 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
} }
fn connect_property_do_timestamp_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_do_timestamp_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_do_timestamp_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSrc>
{
let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::do-timestamp\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::do-timestamp\0".as_ptr() as *const _,
@ -225,6 +237,12 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
} }
fn connect_property_num_buffers_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_num_buffers_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_num_buffers_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSrc>
{
let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::num-buffers\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::num-buffers\0".as_ptr() as *const _,
@ -233,6 +251,12 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
} }
fn connect_property_typefind_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_typefind_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_typefind_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSrc>
{
let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::typefind\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::typefind\0".as_ptr() as *const _,
@ -240,27 +264,3 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
} }
} }
} }
unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSrc> {
let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_do_timestamp_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSrc> {
let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_num_buffers_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSrc> {
let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_typefind_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseSrc> {
let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
}

12
gstreamer-base/src/auto/base_transform.rs
View file

@ -164,6 +164,12 @@ impl<O: IsA<BaseTransform>> BaseTransformExt for O {
} }
fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseTransform, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseTransform>
{
let f: &F = &*(f as *const F);
f(&BaseTransform::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::qos\0".as_ptr() as *const _,
@ -171,9 +177,3 @@ impl<O: IsA<BaseTransform>> BaseTransformExt for O {
} }
} }
} }
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseTransform, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<BaseTransform> {
let f: &F = &*(f as *const F);
f(&BaseTransform::from_glib_borrow(this).unsafe_cast())
}

2
gstreamer-base/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ f511aae) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

11
gstreamer-check/src/auto/test_clock.rs
View file

@ -5,7 +5,7 @@
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -131,6 +131,10 @@ impl TestClock {
//} //}
pub fn connect_property_clock_type_notify<F: Fn(&TestClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_clock_type_notify<F: Fn(&TestClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_clock_type_trampoline<F: Fn(&TestClock) + Send + Sync + 'static>(this: *mut gst_check_sys::GstTestClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::clock-type\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::clock-type\0".as_ptr() as *const _,
@ -147,8 +151,3 @@ impl Default for TestClock {
unsafe impl Send for TestClock {} unsafe impl Send for TestClock {}
unsafe impl Sync for TestClock {} unsafe impl Sync for TestClock {}
unsafe extern "C" fn notify_clock_type_trampoline<F: Fn(&TestClock) + Send + Sync + 'static>(this: *mut gst_check_sys::GstTestClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

2
gstreamer-check/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

28
gstreamer-editing-services/src/auto/asset.rs
View file

@ -5,7 +5,7 @@
use Error; use Error;
use Extractable; use Extractable;
#[cfg(feature = "futures")] #[cfg(feature = "futures")]
use futures_core; use futures::future;
use ges_sys; use ges_sys;
use gio; use gio;
use gio_sys; use gio_sys;
@ -65,7 +65,7 @@ impl Asset {
} }
#[cfg(feature = "futures")] #[cfg(feature = "futures")]
pub fn request_async_future(extractable_type: glib::types::Type, id: &str) -> Box_<futures_core::Future<Item = Asset, Error = Error>> { pub fn request_async_future(extractable_type: glib::types::Type, id: &str) -> Box_<dyn future::Future<Output = Result<Asset, Error>> + std::marker::Unpin> {
use gio::GioFuture; use gio::GioFuture;
use fragile::Fragile; use fragile::Fragile;
@ -179,6 +179,12 @@ impl<O: IsA<Asset>> AssetExt for O {
} }
fn connect_property_proxy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_proxy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_proxy_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Asset>
{
let f: &F = &*(f as *const F);
f(&Asset::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::proxy\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::proxy\0".as_ptr() as *const _,
@ -187,6 +193,12 @@ impl<O: IsA<Asset>> AssetExt for O {
} }
fn connect_property_proxy_target_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_proxy_target_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_proxy_target_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Asset>
{
let f: &F = &*(f as *const F);
f(&Asset::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::proxy-target\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::proxy-target\0".as_ptr() as *const _,
@ -194,15 +206,3 @@ impl<O: IsA<Asset>> AssetExt for O {
} }
} }
} }
unsafe extern "C" fn notify_proxy_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Asset> {
let f: &F = &*(f as *const F);
f(&Asset::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_proxy_target_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Asset> {
let f: &F = &*(f as *const F);
f(&Asset::from_glib_borrow(this).unsafe_cast())
}

24
gstreamer-editing-services/src/auto/clip.rs
View file

@ -144,6 +144,12 @@ impl<O: IsA<Clip>> ClipExt for O {
} }
fn connect_property_layer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_layer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_layer_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clip>
{
let f: &F = &*(f as *const F);
f(&Clip::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::layer\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::layer\0".as_ptr() as *const _,
@ -152,6 +158,12 @@ impl<O: IsA<Clip>> ClipExt for O {
} }
fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clip>
{
let f: &F = &*(f as *const F);
f(&Clip::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::supported-formats\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::supported-formats\0".as_ptr() as *const _,
@ -159,15 +171,3 @@ impl<O: IsA<Clip>> ClipExt for O {
} }
} }
} }
unsafe extern "C" fn notify_layer_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clip> {
let f: &F = &*(f as *const F);
f(&Clip::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clip> {
let f: &F = &*(f as *const F);
f(&Clip::from_glib_borrow(this).unsafe_cast())
}

36
gstreamer-editing-services/src/auto/container.rs
View file

@ -100,6 +100,12 @@ impl<O: IsA<Container>> GESContainerExt for O {
} }
fn connect_child_added<F: Fn(&Self, &TimelineElement) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_child_added<F: Fn(&Self, &TimelineElement) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn child_added_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(this: *mut ges_sys::GESContainer, element: *mut ges_sys::GESTimelineElement, f: glib_sys::gpointer)
where P: IsA<Container>
{
let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"child-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"child-added\0".as_ptr() as *const _,
@ -108,6 +114,12 @@ impl<O: IsA<Container>> GESContainerExt for O {
} }
fn connect_child_removed<F: Fn(&Self, &TimelineElement) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_child_removed<F: Fn(&Self, &TimelineElement) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn child_removed_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(this: *mut ges_sys::GESContainer, element: *mut ges_sys::GESTimelineElement, f: glib_sys::gpointer)
where P: IsA<Container>
{
let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"child-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"child-removed\0".as_ptr() as *const _,
@ -116,6 +128,12 @@ impl<O: IsA<Container>> GESContainerExt for O {
} }
fn connect_property_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_height_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESContainer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Container>
{
let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::height\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::height\0".as_ptr() as *const _,
@ -123,21 +141,3 @@ impl<O: IsA<Container>> GESContainerExt for O {
} }
} }
} }
unsafe extern "C" fn child_added_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(this: *mut ges_sys::GESContainer, element: *mut ges_sys::GESTimelineElement, f: glib_sys::gpointer)
where P: IsA<Container> {
let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element))
}
unsafe extern "C" fn child_removed_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(this: *mut ges_sys::GESContainer, element: *mut ges_sys::GESTimelineElement, f: glib_sys::gpointer)
where P: IsA<Container> {
let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element))
}
unsafe extern "C" fn notify_height_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESContainer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Container> {
let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast())
}

60
gstreamer-editing-services/src/auto/group.rs
View file

@ -147,6 +147,12 @@ impl<O: IsA<Group>> GroupExt for O {
} }
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group>
{
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _,
@ -155,6 +161,12 @@ impl<O: IsA<Group>> GroupExt for O {
} }
fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_in_point_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group>
{
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::in-point\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::in-point\0".as_ptr() as *const _,
@ -163,6 +175,12 @@ impl<O: IsA<Group>> GroupExt for O {
} }
fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group>
{
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-duration\0".as_ptr() as *const _,
@ -171,6 +189,12 @@ impl<O: IsA<Group>> GroupExt for O {
} }
fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group>
{
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _,
@ -179,6 +203,12 @@ impl<O: IsA<Group>> GroupExt for O {
} }
fn connect_property_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_start_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group>
{
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::start\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::start\0".as_ptr() as *const _,
@ -186,33 +216,3 @@ impl<O: IsA<Group>> GroupExt for O {
} }
} }
} }
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group> {
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_in_point_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group> {
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_max_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group> {
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group> {
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_start_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Group> {
let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast())
}

48
gstreamer-editing-services/src/auto/layer.rs
View file

@ -162,6 +162,12 @@ impl<O: IsA<Layer>> LayerExt for O {
} }
fn connect_clip_added<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_clip_added<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn clip_added_trampoline<P, F: Fn(&P, &Clip) + 'static>(this: *mut ges_sys::GESLayer, clip: *mut ges_sys::GESClip, f: glib_sys::gpointer)
where P: IsA<Layer>
{
let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(clip))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"clip-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"clip-added\0".as_ptr() as *const _,
@ -170,6 +176,12 @@ impl<O: IsA<Layer>> LayerExt for O {
} }
fn connect_clip_removed<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_clip_removed<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn clip_removed_trampoline<P, F: Fn(&P, &Clip) + 'static>(this: *mut ges_sys::GESLayer, clip: *mut ges_sys::GESClip, f: glib_sys::gpointer)
where P: IsA<Layer>
{
let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(clip))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"clip-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"clip-removed\0".as_ptr() as *const _,
@ -178,6 +190,12 @@ impl<O: IsA<Layer>> LayerExt for O {
} }
fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_auto_transition_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESLayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Layer>
{
let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::auto-transition\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::auto-transition\0".as_ptr() as *const _,
@ -186,6 +204,12 @@ impl<O: IsA<Layer>> LayerExt for O {
} }
fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESLayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Layer>
{
let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _,
@ -193,27 +217,3 @@ impl<O: IsA<Layer>> LayerExt for O {
} }
} }
} }
unsafe extern "C" fn clip_added_trampoline<P, F: Fn(&P, &Clip) + 'static>(this: *mut ges_sys::GESLayer, clip: *mut ges_sys::GESClip, f: glib_sys::gpointer)
where P: IsA<Layer> {
let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(clip))
}
unsafe extern "C" fn clip_removed_trampoline<P, F: Fn(&P, &Clip) + 'static>(this: *mut ges_sys::GESLayer, clip: *mut ges_sys::GESClip, f: glib_sys::gpointer)
where P: IsA<Layer> {
let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(clip))
}
unsafe extern "C" fn notify_auto_transition_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESLayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Layer> {
let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESLayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Layer> {
let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast())
}

72
gstreamer-editing-services/src/auto/pipeline.rs
View file

@ -235,6 +235,12 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
} }
fn connect_property_audio_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_audio_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_audio_filter_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::audio-filter\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::audio-filter\0".as_ptr() as *const _,
@ -243,6 +249,12 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
} }
fn connect_property_audio_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_audio_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_audio_sink_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::audio-sink\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::audio-sink\0".as_ptr() as *const _,
@ -251,6 +263,12 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
} }
fn connect_property_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mode_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mode\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::mode\0".as_ptr() as *const _,
@ -259,6 +277,12 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
} }
fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_timeline_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::timeline\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::timeline\0".as_ptr() as *const _,
@ -267,6 +291,12 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
} }
fn connect_property_video_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_video_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_video_filter_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::video-filter\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::video-filter\0".as_ptr() as *const _,
@ -275,6 +305,12 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
} }
fn connect_property_video_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_video_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_video_sink_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::video-sink\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::video-sink\0".as_ptr() as *const _,
@ -282,39 +318,3 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
} }
} }
} }
unsafe extern "C" fn notify_audio_filter_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_audio_sink_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_mode_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_timeline_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_video_filter_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_video_sink_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}

72
gstreamer-editing-services/src/auto/project.rs
View file

@ -157,6 +157,12 @@ impl<O: IsA<Project>> ProjectExt for O {
} }
fn connect_asset_added<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_asset_added<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn asset_added_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer)
where P: IsA<Project>
{
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"asset-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"asset-added\0".as_ptr() as *const _,
@ -165,6 +171,12 @@ impl<O: IsA<Project>> ProjectExt for O {
} }
fn connect_asset_loading<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_asset_loading<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn asset_loading_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer)
where P: IsA<Project>
{
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"asset-loading\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"asset-loading\0".as_ptr() as *const _,
@ -173,6 +185,12 @@ impl<O: IsA<Project>> ProjectExt for O {
} }
fn connect_asset_removed<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_asset_removed<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn asset_removed_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer)
where P: IsA<Project>
{
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"asset-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"asset-removed\0".as_ptr() as *const _,
@ -181,6 +199,12 @@ impl<O: IsA<Project>> ProjectExt for O {
} }
fn connect_error_loading_asset<F: Fn(&Self, &Error, &str, glib::types::Type) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_error_loading_asset<F: Fn(&Self, &Error, &str, glib::types::Type) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn error_loading_asset_trampoline<P, F: Fn(&P, &Error, &str, glib::types::Type) + 'static>(this: *mut ges_sys::GESProject, error: *mut glib_sys::GError, id: *mut libc::c_char, extractable_type: glib_sys::GType, f: glib_sys::gpointer)
where P: IsA<Project>
{
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(error), &GString::from_glib_borrow(id), from_glib(extractable_type))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"error-loading-asset\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"error-loading-asset\0".as_ptr() as *const _,
@ -189,6 +213,12 @@ impl<O: IsA<Project>> ProjectExt for O {
} }
fn connect_loaded<F: Fn(&Self, &Timeline) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_loaded<F: Fn(&Self, &Timeline) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn loaded_trampoline<P, F: Fn(&P, &Timeline) + 'static>(this: *mut ges_sys::GESProject, timeline: *mut ges_sys::GESTimeline, f: glib_sys::gpointer)
where P: IsA<Project>
{
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(timeline))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"loaded\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"loaded\0".as_ptr() as *const _,
@ -197,6 +227,12 @@ impl<O: IsA<Project>> ProjectExt for O {
} }
fn connect_missing_uri<F: Fn(&Self, &Error, &Asset) -> Option<GString> + 'static>(&self, f: F) -> SignalHandlerId { fn connect_missing_uri<F: Fn(&Self, &Error, &Asset) -> Option<GString> + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn missing_uri_trampoline<P, F: Fn(&P, &Error, &Asset) -> Option<GString> + 'static>(this: *mut ges_sys::GESProject, error: *mut glib_sys::GError, wrong_asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer) -> *mut libc::c_char
where P: IsA<Project>
{
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(error), &from_glib_borrow(wrong_asset)).to_glib_full()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"missing-uri\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"missing-uri\0".as_ptr() as *const _,
@ -204,39 +240,3 @@ impl<O: IsA<Project>> ProjectExt for O {
} }
} }
} }
unsafe extern "C" fn asset_added_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer)
where P: IsA<Project> {
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset))
}
unsafe extern "C" fn asset_loading_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer)
where P: IsA<Project> {
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset))
}
unsafe extern "C" fn asset_removed_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer)
where P: IsA<Project> {
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset))
}
unsafe extern "C" fn error_loading_asset_trampoline<P, F: Fn(&P, &Error, &str, glib::types::Type) + 'static>(this: *mut ges_sys::GESProject, error: *mut glib_sys::GError, id: *mut libc::c_char, extractable_type: glib_sys::GType, f: glib_sys::gpointer)
where P: IsA<Project> {
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(error), &GString::from_glib_borrow(id), from_glib(extractable_type))
}
unsafe extern "C" fn loaded_trampoline<P, F: Fn(&P, &Timeline) + 'static>(this: *mut ges_sys::GESProject, timeline: *mut ges_sys::GESTimeline, f: glib_sys::gpointer)
where P: IsA<Project> {
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(timeline))
}
unsafe extern "C" fn missing_uri_trampoline<P, F: Fn(&P, &Error, &Asset) -> Option<GString> + 'static>(this: *mut ges_sys::GESProject, error: *mut glib_sys::GError, wrong_asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer) -> *mut libc::c_char
where P: IsA<Project> {
let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(error), &from_glib_borrow(wrong_asset)).to_glib_full()
}

132
gstreamer-editing-services/src/auto/timeline.rs
View file

@ -290,6 +290,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"commited\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"commited\0".as_ptr() as *const _,
@ -298,6 +304,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_group_added<F: Fn(&Self, &Group) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_group_added<F: Fn(&Self, &Group) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn group_added_trampoline<P, F: Fn(&P, &Group) + 'static>(this: *mut ges_sys::GESTimeline, group: *mut ges_sys::GESGroup, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(group))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"group-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"group-added\0".as_ptr() as *const _,
@ -310,6 +322,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
//} //}
fn connect_layer_added<F: Fn(&Self, &Layer) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_layer_added<F: Fn(&Self, &Layer) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn layer_added_trampoline<P, F: Fn(&P, &Layer) + 'static>(this: *mut ges_sys::GESTimeline, layer: *mut ges_sys::GESLayer, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(layer))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"layer-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"layer-added\0".as_ptr() as *const _,
@ -318,6 +336,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_layer_removed<F: Fn(&Self, &Layer) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_layer_removed<F: Fn(&Self, &Layer) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn layer_removed_trampoline<P, F: Fn(&P, &Layer) + 'static>(this: *mut ges_sys::GESTimeline, layer: *mut ges_sys::GESLayer, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(layer))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"layer-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"layer-removed\0".as_ptr() as *const _,
@ -330,6 +354,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
//} //}
fn connect_snapping_ended<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_snapping_ended<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn snapping_ended_trampoline<P, F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static>(this: *mut ges_sys::GESTimeline, obj1: *mut ges_sys::GESTrackElement, obj2: *mut ges_sys::GESTrackElement, position: u64, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(obj1), &from_glib_borrow(obj2), position)
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"snapping-ended\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"snapping-ended\0".as_ptr() as *const _,
@ -338,6 +368,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_snapping_started<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_snapping_started<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn snapping_started_trampoline<P, F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static>(this: *mut ges_sys::GESTimeline, obj1: *mut ges_sys::GESTrackElement, obj2: *mut ges_sys::GESTrackElement, position: u64, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(obj1), &from_glib_borrow(obj2), position)
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"snapping-started\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"snapping-started\0".as_ptr() as *const _,
@ -346,6 +382,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_track_added<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_track_added<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn track_added_trampoline<P, F: Fn(&P, &Track) + 'static>(this: *mut ges_sys::GESTimeline, track: *mut ges_sys::GESTrack, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(track))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"track-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"track-added\0".as_ptr() as *const _,
@ -354,6 +396,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_track_removed<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_track_removed<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn track_removed_trampoline<P, F: Fn(&P, &Track) + 'static>(this: *mut ges_sys::GESTimeline, track: *mut ges_sys::GESTrack, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(track))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"track-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"track-removed\0".as_ptr() as *const _,
@ -362,6 +410,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_auto_transition_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::auto-transition\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::auto-transition\0".as_ptr() as *const _,
@ -370,6 +424,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _,
@ -378,6 +438,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
fn connect_property_snapping_distance_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_snapping_distance_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_snapping_distance_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Timeline>
{
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::snapping-distance\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::snapping-distance\0".as_ptr() as *const _,
@ -385,69 +451,3 @@ impl<O: IsA<Timeline>> TimelineExt for O {
} }
} }
} }
unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn group_added_trampoline<P, F: Fn(&P, &Group) + 'static>(this: *mut ges_sys::GESTimeline, group: *mut ges_sys::GESGroup, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(group))
}
unsafe extern "C" fn layer_added_trampoline<P, F: Fn(&P, &Layer) + 'static>(this: *mut ges_sys::GESTimeline, layer: *mut ges_sys::GESLayer, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(layer))
}
unsafe extern "C" fn layer_removed_trampoline<P, F: Fn(&P, &Layer) + 'static>(this: *mut ges_sys::GESTimeline, layer: *mut ges_sys::GESLayer, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(layer))
}
unsafe extern "C" fn snapping_ended_trampoline<P, F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static>(this: *mut ges_sys::GESTimeline, obj1: *mut ges_sys::GESTrackElement, obj2: *mut ges_sys::GESTrackElement, position: u64, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(obj1), &from_glib_borrow(obj2), position)
}
unsafe extern "C" fn snapping_started_trampoline<P, F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static>(this: *mut ges_sys::GESTimeline, obj1: *mut ges_sys::GESTrackElement, obj2: *mut ges_sys::GESTrackElement, position: u64, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(obj1), &from_glib_borrow(obj2), position)
}
unsafe extern "C" fn track_added_trampoline<P, F: Fn(&P, &Track) + 'static>(this: *mut ges_sys::GESTimeline, track: *mut ges_sys::GESTrack, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(track))
}
unsafe extern "C" fn track_removed_trampoline<P, F: Fn(&P, &Track) + 'static>(this: *mut ges_sys::GESTimeline, track: *mut ges_sys::GESTrack, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(track))
}
unsafe extern "C" fn notify_auto_transition_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_snapping_distance_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Timeline> {
let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast())
}

108
gstreamer-editing-services/src/auto/timeline_element.rs
View file

@ -375,6 +375,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
//} //}
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _,
@ -383,6 +389,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_in_point_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::in-point\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::in-point\0".as_ptr() as *const _,
@ -391,6 +403,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-duration\0".as_ptr() as *const _,
@ -399,6 +417,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
fn connect_property_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_name_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::name\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::name\0".as_ptr() as *const _,
@ -407,6 +431,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
fn connect_property_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_parent_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::parent\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::parent\0".as_ptr() as *const _,
@ -415,6 +445,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _,
@ -423,6 +459,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
fn connect_property_serialize_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_serialize_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_serialize_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::serialize\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::serialize\0".as_ptr() as *const _,
@ -431,6 +473,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
fn connect_property_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_start_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::start\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::start\0".as_ptr() as *const _,
@ -439,6 +487,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_timeline_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement>
{
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::timeline\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::timeline\0".as_ptr() as *const _,
@ -446,57 +500,3 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
} }
} }
} }
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_in_point_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_max_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_name_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_parent_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_serialize_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_start_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_timeline_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TimelineElement> {
let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
}

72
gstreamer-editing-services/src/auto/track.rs
View file

@ -179,6 +179,12 @@ impl<O: IsA<Track>> GESTrackExt for O {
} }
fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, f: glib_sys::gpointer)
where P: IsA<Track>
{
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"commited\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"commited\0".as_ptr() as *const _,
@ -187,6 +193,12 @@ impl<O: IsA<Track>> GESTrackExt for O {
} }
fn connect_track_element_added<F: Fn(&Self, &TrackElement) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_track_element_added<F: Fn(&Self, &TrackElement) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn track_element_added_trampoline<P, F: Fn(&P, &TrackElement) + 'static>(this: *mut ges_sys::GESTrack, effect: *mut ges_sys::GESTrackElement, f: glib_sys::gpointer)
where P: IsA<Track>
{
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(effect))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"track-element-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"track-element-added\0".as_ptr() as *const _,
@ -195,6 +207,12 @@ impl<O: IsA<Track>> GESTrackExt for O {
} }
fn connect_track_element_removed<F: Fn(&Self, &TrackElement) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_track_element_removed<F: Fn(&Self, &TrackElement) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn track_element_removed_trampoline<P, F: Fn(&P, &TrackElement) + 'static>(this: *mut ges_sys::GESTrack, effect: *mut ges_sys::GESTrackElement, f: glib_sys::gpointer)
where P: IsA<Track>
{
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(effect))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"track-element-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"track-element-removed\0".as_ptr() as *const _,
@ -203,6 +221,12 @@ impl<O: IsA<Track>> GESTrackExt for O {
} }
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Track>
{
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _,
@ -211,6 +235,12 @@ impl<O: IsA<Track>> GESTrackExt for O {
} }
fn connect_property_mixing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mixing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mixing_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Track>
{
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mixing\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::mixing\0".as_ptr() as *const _,
@ -219,6 +249,12 @@ impl<O: IsA<Track>> GESTrackExt for O {
} }
fn connect_property_restriction_caps_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_restriction_caps_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_restriction_caps_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Track>
{
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::restriction-caps\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::restriction-caps\0".as_ptr() as *const _,
@ -226,39 +262,3 @@ impl<O: IsA<Track>> GESTrackExt for O {
} }
} }
} }
unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, f: glib_sys::gpointer)
where P: IsA<Track> {
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn track_element_added_trampoline<P, F: Fn(&P, &TrackElement) + 'static>(this: *mut ges_sys::GESTrack, effect: *mut ges_sys::GESTrackElement, f: glib_sys::gpointer)
where P: IsA<Track> {
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(effect))
}
unsafe extern "C" fn track_element_removed_trampoline<P, F: Fn(&P, &TrackElement) + 'static>(this: *mut ges_sys::GESTrack, effect: *mut ges_sys::GESTrackElement, f: glib_sys::gpointer)
where P: IsA<Track> {
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(effect))
}
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Track> {
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_mixing_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Track> {
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_restriction_caps_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Track> {
let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast())
}

36
gstreamer-editing-services/src/auto/track_element.rs
View file

@ -179,6 +179,12 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
//} //}
fn connect_property_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_active_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TrackElement>
{
let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::active\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::active\0".as_ptr() as *const _,
@ -187,6 +193,12 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
} }
fn connect_property_track_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_track_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_track_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TrackElement>
{
let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::track\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::track\0".as_ptr() as *const _,
@ -195,6 +207,12 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
} }
fn connect_property_track_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_track_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_track_type_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TrackElement>
{
let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::track-type\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::track-type\0".as_ptr() as *const _,
@ -202,21 +220,3 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
} }
} }
} }
unsafe extern "C" fn notify_active_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TrackElement> {
let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_track_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TrackElement> {
let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_track_type_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<TrackElement> {
let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast())
}

36
gstreamer-editing-services/src/auto/uri_clip.rs
View file

@ -109,6 +109,12 @@ impl<O: IsA<UriClip>> UriClipExt for O {
} }
fn connect_property_is_image_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_is_image_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_is_image_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<UriClip>
{
let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::is-image\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::is-image\0".as_ptr() as *const _,
@ -117,6 +123,12 @@ impl<O: IsA<UriClip>> UriClipExt for O {
} }
fn connect_property_mute_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mute_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<UriClip>
{
let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mute\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::mute\0".as_ptr() as *const _,
@ -125,6 +137,12 @@ impl<O: IsA<UriClip>> UriClipExt for O {
} }
fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<UriClip>
{
let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::supported-formats\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::supported-formats\0".as_ptr() as *const _,
@ -132,21 +150,3 @@ impl<O: IsA<UriClip>> UriClipExt for O {
} }
} }
} }
unsafe extern "C" fn notify_is_image_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<UriClip> {
let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<UriClip> {
let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<UriClip> {
let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast())
}

12
gstreamer-editing-services/src/auto/uri_clip_asset.rs
View file

@ -95,6 +95,12 @@ impl<O: IsA<UriClipAsset>> UriClipAssetExt for O {
} }
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClipAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<UriClipAsset>
{
let f: &F = &*(f as *const F);
f(&UriClipAsset::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _,
@ -102,9 +108,3 @@ impl<O: IsA<UriClipAsset>> UriClipAssetExt for O {
} }
} }
} }
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClipAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<UriClipAsset> {
let f: &F = &*(f as *const F);
f(&UriClipAsset::from_glib_borrow(this).unsafe_cast())
}

2
gstreamer-editing-services/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 7cf0b0e) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

12
gstreamer-gl/src/auto/gl_base_filter.rs
View file

@ -56,6 +56,12 @@ impl<O: IsA<GLBaseFilter>> GLBaseFilterExt for O {
} }
fn connect_property_context_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_context_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_context_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLBaseFilter, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<GLBaseFilter>
{
let f: &F = &*(f as *const F);
f(&GLBaseFilter::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::context\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::context\0".as_ptr() as *const _,
@ -63,9 +69,3 @@ impl<O: IsA<GLBaseFilter>> GLBaseFilterExt for O {
} }
} }
} }
unsafe extern "C" fn notify_context_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLBaseFilter, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<GLBaseFilter> {
let f: &F = &*(f as *const F);
f(&GLBaseFilter::from_glib_borrow(this).unsafe_cast())
}

12
gstreamer-gl/src/auto/gl_display.rs
View file

@ -121,6 +121,12 @@ impl<O: IsA<GLDisplay>> GLDisplayExt for O {
} }
fn connect_create_context<F: Fn(&Self, &GLContext) -> GLContext + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_create_context<F: Fn(&Self, &GLContext) -> GLContext + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn create_context_trampoline<P, F: Fn(&P, &GLContext) -> GLContext + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLDisplay, context: *mut gst_gl_sys::GstGLContext, f: glib_sys::gpointer) -> *mut gst_gl_sys::GstGLContext
where P: IsA<GLDisplay>
{
let f: &F = &*(f as *const F);
f(&GLDisplay::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(context)).to_glib_full()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"create-context\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"create-context\0".as_ptr() as *const _,
@ -128,9 +134,3 @@ impl<O: IsA<GLDisplay>> GLDisplayExt for O {
} }
} }
} }
unsafe extern "C" fn create_context_trampoline<P, F: Fn(&P, &GLContext) -> GLContext + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLDisplay, context: *mut gst_gl_sys::GstGLContext, f: glib_sys::gpointer) -> *mut gst_gl_sys::GstGLContext
where P: IsA<GLDisplay> {
let f: &F = &*(f as *const F);
f(&GLDisplay::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(context)).to_glib_full()
}

12
gstreamer-gl/src/auto/gl_overlay_compositor.rs
View file

@ -9,7 +9,7 @@ use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::IsA; use glib::object::IsA;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
@ -79,6 +79,10 @@ impl GLOverlayCompositor {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn connect_property_yinvert_notify<F: Fn(&GLOverlayCompositor) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_yinvert_notify<F: Fn(&GLOverlayCompositor) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_yinvert_trampoline<F: Fn(&GLOverlayCompositor) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLOverlayCompositor, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::yinvert\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::yinvert\0".as_ptr() as *const _,
@ -89,9 +93,3 @@ impl GLOverlayCompositor {
unsafe impl Send for GLOverlayCompositor {} unsafe impl Send for GLOverlayCompositor {}
unsafe impl Sync for GLOverlayCompositor {} unsafe impl Sync for GLOverlayCompositor {}
#[cfg(any(feature = "v1_16", feature = "dox"))]
unsafe extern "C" fn notify_yinvert_trampoline<F: Fn(&GLOverlayCompositor) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLOverlayCompositor, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

11
gstreamer-gl/src/auto/gl_shader.rs
View file

@ -15,7 +15,7 @@ use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::IsA; use glib::object::IsA;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -285,6 +285,10 @@ impl GLShader {
} }
pub fn connect_property_linked_notify<F: Fn(&GLShader) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_linked_notify<F: Fn(&GLShader) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_linked_trampoline<F: Fn(&GLShader) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLShader, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::linked\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::linked\0".as_ptr() as *const _,
@ -295,8 +299,3 @@ impl GLShader {
unsafe impl Send for GLShader {} unsafe impl Send for GLShader {}
unsafe impl Sync for GLShader {} unsafe impl Sync for GLShader {}
unsafe extern "C" fn notify_linked_trampoline<F: Fn(&GLShader) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLShader, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

47
gstreamer-gl/src/auto/gl_view_convert.rs
View file

@ -8,7 +8,7 @@ use glib;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::IsA; use glib::object::IsA;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -137,6 +137,10 @@ impl GLViewConvert {
} }
pub fn connect_property_downmix_mode_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_downmix_mode_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_downmix_mode_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::downmix-mode\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::downmix-mode\0".as_ptr() as *const _,
@ -145,6 +149,10 @@ impl GLViewConvert {
} }
pub fn connect_property_input_flags_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_input_flags_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_input_flags_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::input-flags-override\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::input-flags-override\0".as_ptr() as *const _,
@ -153,6 +161,10 @@ impl GLViewConvert {
} }
pub fn connect_property_input_mode_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_input_mode_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_input_mode_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::input-mode-override\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::input-mode-override\0".as_ptr() as *const _,
@ -161,6 +173,10 @@ impl GLViewConvert {
} }
pub fn connect_property_output_flags_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_output_flags_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_output_flags_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::output-flags-override\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::output-flags-override\0".as_ptr() as *const _,
@ -169,6 +185,10 @@ impl GLViewConvert {
} }
pub fn connect_property_output_mode_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_output_mode_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_output_mode_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::output-mode-override\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::output-mode-override\0".as_ptr() as *const _,
@ -185,28 +205,3 @@ impl Default for GLViewConvert {
unsafe impl Send for GLViewConvert {} unsafe impl Send for GLViewConvert {}
unsafe impl Sync for GLViewConvert {} unsafe impl Sync for GLViewConvert {}
unsafe extern "C" fn notify_downmix_mode_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_input_flags_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_input_mode_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_output_flags_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_output_mode_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

24
gstreamer-gl/src/auto/gl_window.rs
View file

@ -166,6 +166,12 @@ impl<O: IsA<GLWindow>> GLWindowExt for O {
} }
fn connect_key_event<F: Fn(&Self, &str, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_key_event<F: Fn(&Self, &str, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn key_event_trampoline<P, F: Fn(&P, &str, &str) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLWindow, id: *mut libc::c_char, key: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<GLWindow>
{
let f: &F = &*(f as *const F);
f(&GLWindow::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(id), &GString::from_glib_borrow(key))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"key-event\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"key-event\0".as_ptr() as *const _,
@ -174,6 +180,12 @@ impl<O: IsA<GLWindow>> GLWindowExt for O {
} }
fn connect_mouse_event<F: Fn(&Self, &str, i32, f64, f64) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_mouse_event<F: Fn(&Self, &str, i32, f64, f64) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn mouse_event_trampoline<P, F: Fn(&P, &str, i32, f64, f64) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLWindow, id: *mut libc::c_char, button: libc::c_int, x: libc::c_double, y: libc::c_double, f: glib_sys::gpointer)
where P: IsA<GLWindow>
{
let f: &F = &*(f as *const F);
f(&GLWindow::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(id), button, x, y)
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"mouse-event\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"mouse-event\0".as_ptr() as *const _,
@ -181,15 +193,3 @@ impl<O: IsA<GLWindow>> GLWindowExt for O {
} }
} }
} }
unsafe extern "C" fn key_event_trampoline<P, F: Fn(&P, &str, &str) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLWindow, id: *mut libc::c_char, key: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<GLWindow> {
let f: &F = &*(f as *const F);
f(&GLWindow::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(id), &GString::from_glib_borrow(key))
}
unsafe extern "C" fn mouse_event_trampoline<P, F: Fn(&P, &str, i32, f64, f64) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLWindow, id: *mut libc::c_char, button: libc::c_int, x: libc::c_double, y: libc::c_double, f: glib_sys::gpointer)
where P: IsA<GLWindow> {
let f: &F = &*(f as *const F);
f(&GLWindow::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(id), button, x, y)
}

2
gstreamer-gl/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

65
gstreamer-net/src/auto/net_client_clock.rs
View file

@ -5,7 +5,7 @@
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -126,6 +126,10 @@ impl NetClientClock {
} }
pub fn connect_property_address_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_address_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_address_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::address\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::address\0".as_ptr() as *const _,
@ -134,6 +138,10 @@ impl NetClientClock {
} }
pub fn connect_property_bus_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_bus_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_bus_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::bus\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::bus\0".as_ptr() as *const _,
@ -142,6 +150,10 @@ impl NetClientClock {
} }
pub fn connect_property_internal_clock_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_internal_clock_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_internal_clock_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::internal-clock\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::internal-clock\0".as_ptr() as *const _,
@ -150,6 +162,10 @@ impl NetClientClock {
} }
pub fn connect_property_minimum_update_interval_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_minimum_update_interval_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_minimum_update_interval_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::minimum-update-interval\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::minimum-update-interval\0".as_ptr() as *const _,
@ -158,6 +174,10 @@ impl NetClientClock {
} }
pub fn connect_property_port_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_port_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_port_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::port\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::port\0".as_ptr() as *const _,
@ -166,6 +186,10 @@ impl NetClientClock {
} }
pub fn connect_property_qos_dscp_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_qos_dscp_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_dscp_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos-dscp\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::qos-dscp\0".as_ptr() as *const _,
@ -174,6 +198,10 @@ impl NetClientClock {
} }
pub fn connect_property_round_trip_limit_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_round_trip_limit_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_round_trip_limit_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::round-trip-limit\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::round-trip-limit\0".as_ptr() as *const _,
@ -184,38 +212,3 @@ impl NetClientClock {
unsafe impl Send for NetClientClock {} unsafe impl Send for NetClientClock {}
unsafe impl Sync for NetClientClock {} unsafe impl Sync for NetClientClock {}
unsafe extern "C" fn notify_address_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_bus_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_internal_clock_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_minimum_update_interval_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_port_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_qos_dscp_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_round_trip_limit_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

20
gstreamer-net/src/auto/net_time_provider.rs
View file

@ -5,7 +5,7 @@
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -78,6 +78,10 @@ impl NetTimeProvider {
} }
pub fn connect_property_active_notify<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_active_notify<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_active_trampoline<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetTimeProvider, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::active\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::active\0".as_ptr() as *const _,
@ -86,6 +90,10 @@ impl NetTimeProvider {
} }
pub fn connect_property_qos_dscp_notify<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_qos_dscp_notify<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_dscp_trampoline<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetTimeProvider, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos-dscp\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::qos-dscp\0".as_ptr() as *const _,
@ -96,13 +104,3 @@ impl NetTimeProvider {
unsafe impl Send for NetTimeProvider {} unsafe impl Send for NetTimeProvider {}
unsafe impl Sync for NetTimeProvider {} unsafe impl Sync for NetTimeProvider {}
unsafe extern "C" fn notify_active_trampoline<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetTimeProvider, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_qos_dscp_trampoline<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetTimeProvider, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

29
gstreamer-net/src/auto/ptp_clock.rs
View file

@ -4,7 +4,7 @@
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -57,6 +57,10 @@ impl PtpClock {
} }
pub fn connect_property_grandmaster_clock_id_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_grandmaster_clock_id_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_grandmaster_clock_id_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::grandmaster-clock-id\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::grandmaster-clock-id\0".as_ptr() as *const _,
@ -65,6 +69,10 @@ impl PtpClock {
} }
pub fn connect_property_internal_clock_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_internal_clock_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_internal_clock_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::internal-clock\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::internal-clock\0".as_ptr() as *const _,
@ -73,6 +81,10 @@ impl PtpClock {
} }
pub fn connect_property_master_clock_id_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_master_clock_id_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_master_clock_id_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::master-clock-id\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::master-clock-id\0".as_ptr() as *const _,
@ -83,18 +95,3 @@ impl PtpClock {
unsafe impl Send for PtpClock {} unsafe impl Send for PtpClock {}
unsafe impl Sync for PtpClock {} unsafe impl Sync for PtpClock {}
unsafe extern "C" fn notify_grandmaster_clock_id_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_internal_clock_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_master_clock_id_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

2
gstreamer-net/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

48
gstreamer-pbutils/src/auto/discoverer.rs
View file

@ -9,7 +9,7 @@ use glib;
use glib::StaticType; use glib::StaticType;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -84,6 +84,10 @@ impl Discoverer {
} }
pub fn connect_discovered<F: Fn(&Discoverer, &DiscovererInfo, Option<&Error>) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_discovered<F: Fn(&Discoverer, &DiscovererInfo, Option<&Error>) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn discovered_trampoline<F: Fn(&Discoverer, &DiscovererInfo, Option<&Error>) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, info: *mut gst_pbutils_sys::GstDiscovererInfo, error: *mut glib_sys::GError, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(info), Option::<Error>::from_glib_borrow(error).as_ref())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"discovered\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"discovered\0".as_ptr() as *const _,
@ -92,6 +96,10 @@ impl Discoverer {
} }
pub fn connect_finished<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_finished<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn finished_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"finished\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"finished\0".as_ptr() as *const _,
@ -100,6 +108,10 @@ impl Discoverer {
} }
pub fn connect_source_setup<F: Fn(&Discoverer, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_source_setup<F: Fn(&Discoverer, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn source_setup_trampoline<F: Fn(&Discoverer, &gst::Element) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, source: *mut gst_sys::GstElement, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(source))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"source-setup\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"source-setup\0".as_ptr() as *const _,
@ -108,6 +120,10 @@ impl Discoverer {
} }
pub fn connect_starting<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_starting<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn starting_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"starting\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"starting\0".as_ptr() as *const _,
@ -117,6 +133,10 @@ impl Discoverer {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn connect_property_use_cache_notify<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_use_cache_notify<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_use_cache_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::use-cache\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::use-cache\0".as_ptr() as *const _,
@ -127,29 +147,3 @@ impl Discoverer {
unsafe impl Send for Discoverer {} unsafe impl Send for Discoverer {}
unsafe impl Sync for Discoverer {} unsafe impl Sync for Discoverer {}
unsafe extern "C" fn discovered_trampoline<F: Fn(&Discoverer, &DiscovererInfo, Option<&Error>) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, info: *mut gst_pbutils_sys::GstDiscovererInfo, error: *mut glib_sys::GError, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(info), Option::<Error>::from_glib_borrow(error).as_ref())
}
unsafe extern "C" fn finished_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn source_setup_trampoline<F: Fn(&Discoverer, &gst::Element) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, source: *mut gst_sys::GstElement, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(source))
}
unsafe extern "C" fn starting_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
#[cfg(any(feature = "v1_16", feature = "dox"))]
unsafe extern "C" fn notify_use_cache_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

36
gstreamer-pbutils/src/auto/encoding_container_profile.rs
View file

@ -15,27 +15,19 @@ glib_wrapper! {
} }
} }
impl EncodingContainerProfile {
pub fn contains_profile<P: IsA<EncodingProfile>>(&self, profile: &P) -> bool {
unsafe {
from_glib(gst_pbutils_sys::gst_encoding_container_profile_contains_profile(self.to_glib_none().0, profile.as_ref().to_glib_none().0))
}
}
pub fn get_profiles(&self) -> Vec<EncodingProfile> {
unsafe {
FromGlibPtrContainer::from_glib_none(gst_pbutils_sys::gst_encoding_container_profile_get_profiles(self.to_glib_none().0))
}
}
}
unsafe impl Send for EncodingContainerProfile {} unsafe impl Send for EncodingContainerProfile {}
unsafe impl Sync for EncodingContainerProfile {} unsafe impl Sync for EncodingContainerProfile {}
pub const NONE_ENCODING_CONTAINER_PROFILE: Option<&EncodingContainerProfile> = None;
pub trait EncodingContainerProfileExt: 'static {
fn contains_profile<P: IsA<EncodingProfile>>(&self, profile: &P) -> bool;
fn get_profiles(&self) -> Vec<EncodingProfile>;
}
impl<O: IsA<EncodingContainerProfile>> EncodingContainerProfileExt for O {
fn contains_profile<P: IsA<EncodingProfile>>(&self, profile: &P) -> bool {
unsafe {
from_glib(gst_pbutils_sys::gst_encoding_container_profile_contains_profile(self.as_ref().to_glib_none().0, profile.as_ref().to_glib_none().0))
}
}
fn get_profiles(&self) -> Vec<EncodingProfile> {
unsafe {
FromGlibPtrContainer::from_glib_none(gst_pbutils_sys::gst_encoding_container_profile_get_profiles(self.as_ref().to_glib_none().0))
}
}
}

4
gstreamer-pbutils/src/auto/mod.rs
View file

@ -28,8 +28,7 @@ mod encoding_audio_profile;
pub use self::encoding_audio_profile::{EncodingAudioProfile, EncodingAudioProfileClass}; pub use self::encoding_audio_profile::{EncodingAudioProfile, EncodingAudioProfileClass};
mod encoding_container_profile; mod encoding_container_profile;
pub use self::encoding_container_profile::{EncodingContainerProfile, EncodingContainerProfileClass, NONE_ENCODING_CONTAINER_PROFILE}; pub use self::encoding_container_profile::{EncodingContainerProfile, EncodingContainerProfileClass};
pub use self::encoding_container_profile::EncodingContainerProfileExt;
mod encoding_profile; mod encoding_profile;
pub use self::encoding_profile::{EncodingProfile, EncodingProfileClass, NONE_ENCODING_PROFILE}; pub use self::encoding_profile::{EncodingProfile, EncodingProfileClass, NONE_ENCODING_PROFILE};
@ -52,6 +51,5 @@ pub mod functions;
#[doc(hidden)] #[doc(hidden)]
pub mod traits { pub mod traits {
pub use super::DiscovererStreamInfoExt; pub use super::DiscovererStreamInfoExt;
pub use super::EncodingContainerProfileExt;
pub use super::EncodingProfileExt; pub use super::EncodingProfileExt;
} }

2
gstreamer-pbutils/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

237
gstreamer-player/src/auto/player.rs
View file

@ -15,7 +15,7 @@ use glib;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -362,6 +362,10 @@ impl Player {
} }
pub fn connect_buffering<F: Fn(&Player, i32) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_buffering<F: Fn(&Player, i32) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn buffering_trampoline<F: Fn(&Player, i32) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: libc::c_int, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), object)
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"buffering\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"buffering\0".as_ptr() as *const _,
@ -370,6 +374,10 @@ impl Player {
} }
pub fn connect_end_of_stream<F: Fn(&Player) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_end_of_stream<F: Fn(&Player) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn end_of_stream_trampoline<F: Fn(&Player) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"end-of-stream\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"end-of-stream\0".as_ptr() as *const _,
@ -378,6 +386,10 @@ impl Player {
} }
pub fn connect_error<F: Fn(&Player, &Error) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_error<F: Fn(&Player, &Error) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn error_trampoline<F: Fn(&Player, &Error) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: *mut glib_sys::GError, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"error\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"error\0".as_ptr() as *const _,
@ -386,6 +398,10 @@ impl Player {
} }
pub fn connect_media_info_updated<F: Fn(&Player, &PlayerMediaInfo) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_media_info_updated<F: Fn(&Player, &PlayerMediaInfo) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn media_info_updated_trampoline<F: Fn(&Player, &PlayerMediaInfo) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: *mut gst_player_sys::GstPlayerMediaInfo, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"media-info-updated\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"media-info-updated\0".as_ptr() as *const _,
@ -394,6 +410,10 @@ impl Player {
} }
pub fn connect_mute_changed<F: Fn(&Player) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_mute_changed<F: Fn(&Player) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn mute_changed_trampoline<F: Fn(&Player) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"mute-changed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"mute-changed\0".as_ptr() as *const _,
@ -402,6 +422,10 @@ impl Player {
} }
pub fn connect_state_changed<F: Fn(&Player, PlayerState) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_state_changed<F: Fn(&Player, PlayerState) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn state_changed_trampoline<F: Fn(&Player, PlayerState) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: gst_player_sys::GstPlayerState, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), from_glib(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"state-changed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"state-changed\0".as_ptr() as *const _,
@ -410,6 +434,10 @@ impl Player {
} }
pub fn connect_uri_loaded<F: Fn(&Player, &str) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_uri_loaded<F: Fn(&Player, &str) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn uri_loaded_trampoline<F: Fn(&Player, &str) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: *mut libc::c_char, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &GString::from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"uri-loaded\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"uri-loaded\0".as_ptr() as *const _,
@ -418,6 +446,10 @@ impl Player {
} }
pub fn connect_video_dimensions_changed<F: Fn(&Player, i32, i32) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_video_dimensions_changed<F: Fn(&Player, i32, i32) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn video_dimensions_changed_trampoline<F: Fn(&Player, i32, i32) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: libc::c_int, p0: libc::c_int, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), object, p0)
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"video-dimensions-changed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"video-dimensions-changed\0".as_ptr() as *const _,
@ -426,6 +458,10 @@ impl Player {
} }
pub fn connect_volume_changed<F: Fn(&Player) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_volume_changed<F: Fn(&Player) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn volume_changed_trampoline<F: Fn(&Player) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"volume-changed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"volume-changed\0".as_ptr() as *const _,
@ -434,6 +470,10 @@ impl Player {
} }
pub fn connect_warning<F: Fn(&Player, &Error) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_warning<F: Fn(&Player, &Error) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn warning_trampoline<F: Fn(&Player, &Error) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: *mut glib_sys::GError, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"warning\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"warning\0".as_ptr() as *const _,
@ -442,6 +482,10 @@ impl Player {
} }
pub fn connect_property_audio_video_offset_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_audio_video_offset_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_audio_video_offset_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::audio-video-offset\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::audio-video-offset\0".as_ptr() as *const _,
@ -450,6 +494,10 @@ impl Player {
} }
pub fn connect_property_current_audio_track_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_current_audio_track_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_current_audio_track_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::current-audio-track\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::current-audio-track\0".as_ptr() as *const _,
@ -458,6 +506,10 @@ impl Player {
} }
pub fn connect_property_current_subtitle_track_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_current_subtitle_track_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_current_subtitle_track_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::current-subtitle-track\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::current-subtitle-track\0".as_ptr() as *const _,
@ -466,6 +518,10 @@ impl Player {
} }
pub fn connect_property_current_video_track_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_current_video_track_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_current_video_track_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::current-video-track\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::current-video-track\0".as_ptr() as *const _,
@ -474,6 +530,10 @@ impl Player {
} }
pub fn connect_property_duration_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_duration_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _,
@ -482,6 +542,10 @@ impl Player {
} }
pub fn connect_property_media_info_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_media_info_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_media_info_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::media-info\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::media-info\0".as_ptr() as *const _,
@ -490,6 +554,10 @@ impl Player {
} }
pub fn connect_property_mute_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_mute_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mute_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mute\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::mute\0".as_ptr() as *const _,
@ -498,6 +566,10 @@ impl Player {
} }
pub fn connect_property_pipeline_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_pipeline_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_pipeline_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::pipeline\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::pipeline\0".as_ptr() as *const _,
@ -506,6 +578,10 @@ impl Player {
} }
pub fn connect_property_position_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_position_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_position_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::position\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::position\0".as_ptr() as *const _,
@ -514,6 +590,10 @@ impl Player {
} }
pub fn connect_property_rate_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_rate_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_rate_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::rate\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::rate\0".as_ptr() as *const _,
@ -523,6 +603,10 @@ impl Player {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn connect_property_subtitle_video_offset_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_subtitle_video_offset_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_subtitle_video_offset_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::subtitle-video-offset\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::subtitle-video-offset\0".as_ptr() as *const _,
@ -531,6 +615,10 @@ impl Player {
} }
pub fn connect_property_suburi_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_suburi_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_suburi_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::suburi\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::suburi\0".as_ptr() as *const _,
@ -539,6 +627,10 @@ impl Player {
} }
pub fn connect_property_uri_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_uri_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_uri_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::uri\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::uri\0".as_ptr() as *const _,
@ -547,6 +639,10 @@ impl Player {
} }
pub fn connect_property_video_multiview_flags_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_video_multiview_flags_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_video_multiview_flags_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::video-multiview-flags\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::video-multiview-flags\0".as_ptr() as *const _,
@ -555,6 +651,10 @@ impl Player {
} }
pub fn connect_property_video_multiview_mode_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_video_multiview_mode_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_video_multiview_mode_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::video-multiview-mode\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::video-multiview-mode\0".as_ptr() as *const _,
@ -563,6 +663,10 @@ impl Player {
} }
pub fn connect_property_volume_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_volume_notify<F: Fn(&Player) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_volume_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::volume\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::volume\0".as_ptr() as *const _,
@ -573,134 +677,3 @@ impl Player {
unsafe impl Send for Player {} unsafe impl Send for Player {}
unsafe impl Sync for Player {} unsafe impl Sync for Player {}
unsafe extern "C" fn buffering_trampoline<F: Fn(&Player, i32) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: libc::c_int, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), object)
}
unsafe extern "C" fn end_of_stream_trampoline<F: Fn(&Player) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn error_trampoline<F: Fn(&Player, &Error) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: *mut glib_sys::GError, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(object))
}
unsafe extern "C" fn media_info_updated_trampoline<F: Fn(&Player, &PlayerMediaInfo) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: *mut gst_player_sys::GstPlayerMediaInfo, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(object))
}
unsafe extern "C" fn mute_changed_trampoline<F: Fn(&Player) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn state_changed_trampoline<F: Fn(&Player, PlayerState) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: gst_player_sys::GstPlayerState, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), from_glib(object))
}
unsafe extern "C" fn uri_loaded_trampoline<F: Fn(&Player, &str) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: *mut libc::c_char, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &GString::from_glib_borrow(object))
}
unsafe extern "C" fn video_dimensions_changed_trampoline<F: Fn(&Player, i32, i32) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: libc::c_int, p0: libc::c_int, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), object, p0)
}
unsafe extern "C" fn volume_changed_trampoline<F: Fn(&Player) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn warning_trampoline<F: Fn(&Player, &Error) + Send + 'static>(this: *mut gst_player_sys::GstPlayer, object: *mut glib_sys::GError, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(object))
}
unsafe extern "C" fn notify_audio_video_offset_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_current_audio_track_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_current_subtitle_track_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_current_video_track_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_duration_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_media_info_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_mute_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_pipeline_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_position_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_rate_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
#[cfg(any(feature = "v1_16", feature = "dox"))]
unsafe extern "C" fn notify_subtitle_video_offset_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_suburi_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_uri_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_video_multiview_flags_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_video_multiview_mode_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_volume_trampoline<F: Fn(&Player) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

2
gstreamer-player/src/auto/player_gmain_context_signal_dispatcher.rs
View file

@ -6,7 +6,7 @@ use PlayerSignalDispatcher;
use glib; use glib;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::translate::*; use glib::translate::*;
use gobject_sys; use gobject_sys;
use gst_player_sys; use gst_player_sys;

20
gstreamer-player/src/auto/player_video_overlay_video_renderer.rs
View file

@ -5,7 +5,7 @@
use PlayerVideoRenderer; use PlayerVideoRenderer;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -80,6 +80,10 @@ impl PlayerVideoOverlayVideoRenderer {
//} //}
pub fn connect_property_video_sink_notify<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_video_sink_notify<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_video_sink_trampoline<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayerVideoOverlayVideoRenderer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::video-sink\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::video-sink\0".as_ptr() as *const _,
@ -88,6 +92,10 @@ impl PlayerVideoOverlayVideoRenderer {
} }
pub fn connect_property_window_handle_notify<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_window_handle_notify<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_window_handle_trampoline<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayerVideoOverlayVideoRenderer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::window-handle\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::window-handle\0".as_ptr() as *const _,
@ -98,13 +106,3 @@ impl PlayerVideoOverlayVideoRenderer {
unsafe impl Send for PlayerVideoOverlayVideoRenderer {} unsafe impl Send for PlayerVideoOverlayVideoRenderer {}
unsafe impl Sync for PlayerVideoOverlayVideoRenderer {} unsafe impl Sync for PlayerVideoOverlayVideoRenderer {}
unsafe extern "C" fn notify_video_sink_trampoline<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayerVideoOverlayVideoRenderer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_window_handle_trampoline<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayerVideoOverlayVideoRenderer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

2
gstreamer-player/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

12
gstreamer-rtsp-server/src/auto/rtsp_auth.rs
View file

@ -210,6 +210,12 @@ impl<O: IsA<RTSPAuth>> RTSPAuthExt for O {
} }
fn connect_accept_certificate<F: Fn(&Self, &gio::TlsConnection, &gio::TlsCertificate, gio::TlsCertificateFlags) -> bool + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_accept_certificate<F: Fn(&Self, &gio::TlsConnection, &gio::TlsCertificate, gio::TlsCertificateFlags) -> bool + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn accept_certificate_trampoline<P, F: Fn(&P, &gio::TlsConnection, &gio::TlsCertificate, gio::TlsCertificateFlags) -> bool + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPAuth, connection: *mut gio_sys::GTlsConnection, peer_cert: *mut gio_sys::GTlsCertificate, errors: gio_sys::GTlsCertificateFlags, f: glib_sys::gpointer) -> glib_sys::gboolean
where P: IsA<RTSPAuth>
{
let f: &F = &*(f as *const F);
f(&RTSPAuth::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(connection), &from_glib_borrow(peer_cert), from_glib(errors)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"accept-certificate\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"accept-certificate\0".as_ptr() as *const _,
@ -217,9 +223,3 @@ impl<O: IsA<RTSPAuth>> RTSPAuthExt for O {
} }
} }
} }
unsafe extern "C" fn accept_certificate_trampoline<P, F: Fn(&P, &gio::TlsConnection, &gio::TlsCertificate, gio::TlsCertificateFlags) -> bool + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPAuth, connection: *mut gio_sys::GTlsConnection, peer_cert: *mut gio_sys::GTlsCertificate, errors: gio_sys::GTlsCertificateFlags, f: glib_sys::gpointer) -> glib_sys::gboolean
where P: IsA<RTSPAuth> {
let f: &F = &*(f as *const F);
f(&RTSPAuth::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(connection), &from_glib_borrow(peer_cert), from_glib(errors)).to_glib()
}

322
gstreamer-rtsp-server/src/auto/rtsp_client.rs
View file

@ -274,6 +274,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_announce_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_announce_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn announce_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"announce-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"announce-request\0".as_ptr() as *const _,
@ -286,6 +292,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
//} //}
fn connect_closed<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_closed<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn closed_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"closed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"closed\0".as_ptr() as *const _,
@ -294,6 +306,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_describe_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_describe_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn describe_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"describe-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"describe-request\0".as_ptr() as *const _,
@ -302,6 +320,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_get_parameter_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_get_parameter_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn get_parameter_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"get-parameter-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"get-parameter-request\0".as_ptr() as *const _,
@ -310,6 +334,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_handle_response<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_handle_response<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn handle_response_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"handle-response\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"handle-response\0".as_ptr() as *const _,
@ -318,6 +348,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_new_session<F: Fn(&Self, &RTSPSession) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_new_session<F: Fn(&Self, &RTSPSession) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn new_session_trampoline<P, F: Fn(&P, &RTSPSession) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, object: *mut gst_rtsp_server_sys::GstRTSPSession, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"new-session\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"new-session\0".as_ptr() as *const _,
@ -326,6 +362,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_options_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_options_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn options_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"options-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"options-request\0".as_ptr() as *const _,
@ -334,6 +376,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_pause_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pause_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pause_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pause-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pause-request\0".as_ptr() as *const _,
@ -342,6 +390,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_play_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_play_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn play_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"play-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"play-request\0".as_ptr() as *const _,
@ -351,6 +405,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_announce_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_announce_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_announce_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-announce-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-announce-request\0".as_ptr() as *const _,
@ -360,6 +420,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_describe_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_describe_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_describe_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-describe-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-describe-request\0".as_ptr() as *const _,
@ -369,6 +435,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_get_parameter_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_get_parameter_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_get_parameter_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-get-parameter-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-get-parameter-request\0".as_ptr() as *const _,
@ -378,6 +450,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_options_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_options_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_options_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-options-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-options-request\0".as_ptr() as *const _,
@ -387,6 +465,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_pause_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_pause_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_pause_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-pause-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-pause-request\0".as_ptr() as *const _,
@ -396,6 +480,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_play_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_play_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_play_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-play-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-play-request\0".as_ptr() as *const _,
@ -405,6 +495,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_record_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_record_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_record_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-record-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-record-request\0".as_ptr() as *const _,
@ -414,6 +510,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_set_parameter_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_set_parameter_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_set_parameter_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-set-parameter-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-set-parameter-request\0".as_ptr() as *const _,
@ -423,6 +525,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_setup_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_setup_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_setup_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-setup-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-setup-request\0".as_ptr() as *const _,
@ -432,6 +540,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn connect_pre_teardown_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pre_teardown_request<F: Fn(&Self, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pre_teardown_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pre-teardown-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pre-teardown-request\0".as_ptr() as *const _,
@ -440,6 +554,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_record_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_record_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn record_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"record-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"record-request\0".as_ptr() as *const _,
@ -452,6 +572,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
//} //}
fn connect_set_parameter_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_set_parameter_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn set_parameter_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"set-parameter-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"set-parameter-request\0".as_ptr() as *const _,
@ -460,6 +586,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_setup_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_setup_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn setup_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"setup-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"setup-request\0".as_ptr() as *const _,
@ -468,6 +600,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_teardown_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_teardown_request<F: Fn(&Self, &RTSPContext) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn teardown_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"teardown-request\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"teardown-request\0".as_ptr() as *const _,
@ -476,6 +614,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_property_drop_backlog_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_drop_backlog_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_drop_backlog_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::drop-backlog\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::drop-backlog\0".as_ptr() as *const _,
@ -484,6 +628,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_property_mount_points_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mount_points_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mount_points_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mount-points\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::mount-points\0".as_ptr() as *const _,
@ -492,6 +642,12 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
fn connect_property_session_pool_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_session_pool_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_session_pool_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPClient>
{
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::session-pool\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::session-pool\0".as_ptr() as *const _,
@ -499,169 +655,3 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
} }
} }
} }
unsafe extern "C" fn announce_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn closed_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn describe_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn get_parameter_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn handle_response_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn new_session_trampoline<P, F: Fn(&P, &RTSPSession) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, object: *mut gst_rtsp_server_sys::GstRTSPSession, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn options_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn pause_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn play_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_announce_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_describe_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_get_parameter_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_options_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_pause_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_play_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_record_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_set_parameter_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_setup_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
#[cfg(any(feature = "v1_12", feature = "dox"))]
unsafe extern "C" fn pre_teardown_request_trampoline<P, F: Fn(&P, &RTSPContext) -> gst_rtsp::RTSPStatusCode + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer) -> gst_rtsp_sys::GstRTSPStatusCode
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx)).to_glib()
}
unsafe extern "C" fn record_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn set_parameter_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn setup_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn teardown_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, ctx: *mut gst_rtsp_server_sys::GstRTSPContext, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(ctx))
}
unsafe extern "C" fn notify_drop_backlog_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_mount_points_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_session_pool_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPClient, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPClient> {
let f: &F = &*(f as *const F);
f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
}

240
gstreamer-rtsp-server/src/auto/rtsp_media.rs
View file

@ -676,6 +676,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_new_state<F: Fn(&Self, i32) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_new_state<F: Fn(&Self, i32) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn new_state_trampoline<P, F: Fn(&P, i32) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, object: libc::c_int, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast(), object)
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"new-state\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"new-state\0".as_ptr() as *const _,
@ -684,6 +690,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_new_stream<F: Fn(&Self, &RTSPStream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_new_stream<F: Fn(&Self, &RTSPStream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn new_stream_trampoline<P, F: Fn(&P, &RTSPStream) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, object: *mut gst_rtsp_server_sys::GstRTSPStream, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"new-stream\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"new-stream\0".as_ptr() as *const _,
@ -692,6 +704,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_prepared<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_prepared<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn prepared_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"prepared\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"prepared\0".as_ptr() as *const _,
@ -700,6 +718,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_removed_stream<F: Fn(&Self, &RTSPStream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_removed_stream<F: Fn(&Self, &RTSPStream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn removed_stream_trampoline<P, F: Fn(&P, &RTSPStream) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, object: *mut gst_rtsp_server_sys::GstRTSPStream, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"removed-stream\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"removed-stream\0".as_ptr() as *const _,
@ -708,6 +732,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_target_state<F: Fn(&Self, i32) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_target_state<F: Fn(&Self, i32) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn target_state_trampoline<P, F: Fn(&P, i32) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, object: libc::c_int, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast(), object)
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"target-state\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"target-state\0".as_ptr() as *const _,
@ -716,6 +746,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_unprepared<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_unprepared<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn unprepared_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"unprepared\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"unprepared\0".as_ptr() as *const _,
@ -724,6 +760,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_bind_mcast_address_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_bind_mcast_address_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_bind_mcast_address_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::bind-mcast-address\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::bind-mcast-address\0".as_ptr() as *const _,
@ -732,6 +774,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_buffer_size_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_buffer_size_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_buffer_size_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::buffer-size\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::buffer-size\0".as_ptr() as *const _,
@ -740,6 +788,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_clock_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_clock_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_clock_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::clock\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::clock\0".as_ptr() as *const _,
@ -748,6 +802,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_eos_shutdown_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_eos_shutdown_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_eos_shutdown_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::eos-shutdown\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::eos-shutdown\0".as_ptr() as *const _,
@ -756,6 +816,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _,
@ -764,6 +830,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_max_mcast_ttl_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_mcast_ttl_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_mcast_ttl_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-mcast-ttl\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-mcast-ttl\0".as_ptr() as *const _,
@ -772,6 +844,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_profiles_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_profiles_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_profiles_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::profiles\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::profiles\0".as_ptr() as *const _,
@ -780,6 +858,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_protocols_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_protocols_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_protocols_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::protocols\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::protocols\0".as_ptr() as *const _,
@ -788,6 +872,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_reusable_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_reusable_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_reusable_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::reusable\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::reusable\0".as_ptr() as *const _,
@ -796,6 +886,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_shared_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_shared_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_shared_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::shared\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::shared\0".as_ptr() as *const _,
@ -804,6 +900,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_stop_on_disconnect_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_stop_on_disconnect_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_stop_on_disconnect_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::stop-on-disconnect\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::stop-on-disconnect\0".as_ptr() as *const _,
@ -812,6 +914,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_suspend_mode_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_suspend_mode_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_suspend_mode_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::suspend-mode\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::suspend-mode\0".as_ptr() as *const _,
@ -820,6 +928,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_time_provider_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_time_provider_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_time_provider_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::time-provider\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::time-provider\0".as_ptr() as *const _,
@ -828,6 +942,12 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
fn connect_property_transport_mode_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_transport_mode_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_transport_mode_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia>
{
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::transport-mode\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::transport-mode\0".as_ptr() as *const _,
@ -835,123 +955,3 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
} }
} }
} }
unsafe extern "C" fn new_state_trampoline<P, F: Fn(&P, i32) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, object: libc::c_int, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast(), object)
}
unsafe extern "C" fn new_stream_trampoline<P, F: Fn(&P, &RTSPStream) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, object: *mut gst_rtsp_server_sys::GstRTSPStream, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn prepared_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn removed_stream_trampoline<P, F: Fn(&P, &RTSPStream) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, object: *mut gst_rtsp_server_sys::GstRTSPStream, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn target_state_trampoline<P, F: Fn(&P, i32) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, object: libc::c_int, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast(), object)
}
unsafe extern "C" fn unprepared_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_bind_mcast_address_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_buffer_size_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_clock_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_eos_shutdown_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_max_mcast_ttl_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_profiles_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_protocols_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_reusable_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_shared_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_stop_on_disconnect_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_suspend_mode_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_time_provider_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_transport_mode_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMedia, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMedia> {
let f: &F = &*(f as *const F);
f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
}

180
gstreamer-rtsp-server/src/auto/rtsp_media_factory.rs
View file

@ -502,6 +502,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_media_configure<F: Fn(&Self, &RTSPMedia) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_media_configure<F: Fn(&Self, &RTSPMedia) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn media_configure_trampoline<P, F: Fn(&P, &RTSPMedia) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, object: *mut gst_rtsp_server_sys::GstRTSPMedia, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"media-configure\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"media-configure\0".as_ptr() as *const _,
@ -510,6 +516,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_media_constructed<F: Fn(&Self, &RTSPMedia) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_media_constructed<F: Fn(&Self, &RTSPMedia) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn media_constructed_trampoline<P, F: Fn(&P, &RTSPMedia) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, object: *mut gst_rtsp_server_sys::GstRTSPMedia, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"media-constructed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"media-constructed\0".as_ptr() as *const _,
@ -518,6 +530,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_bind_mcast_address_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_bind_mcast_address_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_bind_mcast_address_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::bind-mcast-address\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::bind-mcast-address\0".as_ptr() as *const _,
@ -526,6 +544,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_buffer_size_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_buffer_size_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_buffer_size_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::buffer-size\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::buffer-size\0".as_ptr() as *const _,
@ -534,6 +558,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_clock_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_clock_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_clock_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::clock\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::clock\0".as_ptr() as *const _,
@ -542,6 +572,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_eos_shutdown_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_eos_shutdown_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_eos_shutdown_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::eos-shutdown\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::eos-shutdown\0".as_ptr() as *const _,
@ -550,6 +586,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _,
@ -558,6 +600,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_launch_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_launch_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_launch_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::launch\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::launch\0".as_ptr() as *const _,
@ -566,6 +614,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_max_mcast_ttl_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_mcast_ttl_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_mcast_ttl_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-mcast-ttl\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-mcast-ttl\0".as_ptr() as *const _,
@ -574,6 +628,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_profiles_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_profiles_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_profiles_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::profiles\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::profiles\0".as_ptr() as *const _,
@ -582,6 +642,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_protocols_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_protocols_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_protocols_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::protocols\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::protocols\0".as_ptr() as *const _,
@ -590,6 +656,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_shared_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_shared_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_shared_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::shared\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::shared\0".as_ptr() as *const _,
@ -598,6 +670,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_stop_on_disconnect_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_stop_on_disconnect_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_stop_on_disconnect_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::stop-on-disconnect\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::stop-on-disconnect\0".as_ptr() as *const _,
@ -606,6 +684,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_suspend_mode_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_suspend_mode_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_suspend_mode_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::suspend-mode\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::suspend-mode\0".as_ptr() as *const _,
@ -614,6 +698,12 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
fn connect_property_transport_mode_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_transport_mode_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_transport_mode_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::transport-mode\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::transport-mode\0".as_ptr() as *const _,
@ -621,93 +711,3 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
} }
} }
} }
unsafe extern "C" fn media_configure_trampoline<P, F: Fn(&P, &RTSPMedia) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, object: *mut gst_rtsp_server_sys::GstRTSPMedia, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn media_constructed_trampoline<P, F: Fn(&P, &RTSPMedia) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, object: *mut gst_rtsp_server_sys::GstRTSPMedia, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn notify_bind_mcast_address_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_buffer_size_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_clock_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_eos_shutdown_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_launch_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_max_mcast_ttl_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_profiles_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_protocols_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_shared_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_stop_on_disconnect_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_suspend_mode_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_transport_mode_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactory, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactory> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
}

24
gstreamer-rtsp-server/src/auto/rtsp_media_factory_uri.rs
View file

@ -87,6 +87,12 @@ impl<O: IsA<RTSPMediaFactoryURI>> RTSPMediaFactoryURIExt for O {
} }
fn connect_property_uri_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_uri_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_uri_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactoryURI, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactoryURI>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactoryURI::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::uri\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::uri\0".as_ptr() as *const _,
@ -95,6 +101,12 @@ impl<O: IsA<RTSPMediaFactoryURI>> RTSPMediaFactoryURIExt for O {
} }
fn connect_property_use_gstpay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_use_gstpay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_use_gstpay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactoryURI, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactoryURI>
{
let f: &F = &*(f as *const F);
f(&RTSPMediaFactoryURI::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::use-gstpay\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::use-gstpay\0".as_ptr() as *const _,
@ -102,15 +114,3 @@ impl<O: IsA<RTSPMediaFactoryURI>> RTSPMediaFactoryURIExt for O {
} }
} }
} }
unsafe extern "C" fn notify_uri_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactoryURI, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactoryURI> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactoryURI::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_use_gstpay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPMediaFactoryURI, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPMediaFactoryURI> {
let f: &F = &*(f as *const F);
f(&RTSPMediaFactoryURI::from_glib_borrow(this).unsafe_cast())
}

84
gstreamer-rtsp-server/src/auto/rtsp_server.rs
View file

@ -246,6 +246,12 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
} }
fn connect_client_connected<F: Fn(&Self, &RTSPClient) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_client_connected<F: Fn(&Self, &RTSPClient) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn client_connected_trampoline<P, F: Fn(&P, &RTSPClient) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, object: *mut gst_rtsp_server_sys::GstRTSPClient, f: glib_sys::gpointer)
where P: IsA<RTSPServer>
{
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"client-connected\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"client-connected\0".as_ptr() as *const _,
@ -254,6 +260,12 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
} }
fn connect_property_address_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_address_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_address_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer>
{
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::address\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::address\0".as_ptr() as *const _,
@ -262,6 +274,12 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
} }
fn connect_property_backlog_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_backlog_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_backlog_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer>
{
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::backlog\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::backlog\0".as_ptr() as *const _,
@ -270,6 +288,12 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
} }
fn connect_property_bound_port_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_bound_port_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_bound_port_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer>
{
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::bound-port\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::bound-port\0".as_ptr() as *const _,
@ -278,6 +302,12 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
} }
fn connect_property_mount_points_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mount_points_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mount_points_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer>
{
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mount-points\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::mount-points\0".as_ptr() as *const _,
@ -286,6 +316,12 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
} }
fn connect_property_service_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_service_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_service_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer>
{
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::service\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::service\0".as_ptr() as *const _,
@ -294,6 +330,12 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
} }
fn connect_property_session_pool_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_session_pool_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_session_pool_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer>
{
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::session-pool\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::session-pool\0".as_ptr() as *const _,
@ -301,45 +343,3 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
} }
} }
} }
unsafe extern "C" fn client_connected_trampoline<P, F: Fn(&P, &RTSPClient) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, object: *mut gst_rtsp_server_sys::GstRTSPClient, f: glib_sys::gpointer)
where P: IsA<RTSPServer> {
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn notify_address_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer> {
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_backlog_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer> {
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_bound_port_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer> {
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_mount_points_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer> {
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_service_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer> {
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_session_pool_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPServer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPServer> {
let f: &F = &*(f as *const F);
f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
}

24
gstreamer-rtsp-server/src/auto/rtsp_session.rs
View file

@ -200,6 +200,12 @@ impl<O: IsA<RTSPSession>> RTSPSessionExt for O {
} }
fn connect_property_timeout_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_timeout_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPSession, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPSession>
{
let f: &F = &*(f as *const F);
f(&RTSPSession::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::timeout\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::timeout\0".as_ptr() as *const _,
@ -208,6 +214,12 @@ impl<O: IsA<RTSPSession>> RTSPSessionExt for O {
} }
fn connect_property_timeout_always_visible_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_timeout_always_visible_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_timeout_always_visible_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPSession, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPSession>
{
let f: &F = &*(f as *const F);
f(&RTSPSession::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::timeout-always-visible\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::timeout-always-visible\0".as_ptr() as *const _,
@ -215,15 +227,3 @@ impl<O: IsA<RTSPSession>> RTSPSessionExt for O {
} }
} }
} }
unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPSession, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPSession> {
let f: &F = &*(f as *const F);
f(&RTSPSession::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_timeout_always_visible_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPSession, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPSession> {
let f: &F = &*(f as *const F);
f(&RTSPSession::from_glib_borrow(this).unsafe_cast())
}

24
gstreamer-rtsp-server/src/auto/rtsp_session_pool.rs
View file

@ -129,6 +129,12 @@ impl<O: IsA<RTSPSessionPool>> RTSPSessionPoolExt for O {
} }
fn connect_session_removed<F: Fn(&Self, &RTSPSession) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_session_removed<F: Fn(&Self, &RTSPSession) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn session_removed_trampoline<P, F: Fn(&P, &RTSPSession) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPSessionPool, object: *mut gst_rtsp_server_sys::GstRTSPSession, f: glib_sys::gpointer)
where P: IsA<RTSPSessionPool>
{
let f: &F = &*(f as *const F);
f(&RTSPSessionPool::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"session-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"session-removed\0".as_ptr() as *const _,
@ -137,6 +143,12 @@ impl<O: IsA<RTSPSessionPool>> RTSPSessionPoolExt for O {
} }
fn connect_property_max_sessions_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_sessions_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_sessions_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPSessionPool, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPSessionPool>
{
let f: &F = &*(f as *const F);
f(&RTSPSessionPool::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-sessions\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-sessions\0".as_ptr() as *const _,
@ -144,15 +156,3 @@ impl<O: IsA<RTSPSessionPool>> RTSPSessionPoolExt for O {
} }
} }
} }
unsafe extern "C" fn session_removed_trampoline<P, F: Fn(&P, &RTSPSession) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPSessionPool, object: *mut gst_rtsp_server_sys::GstRTSPSession, f: glib_sys::gpointer)
where P: IsA<RTSPSessionPool> {
let f: &F = &*(f as *const F);
f(&RTSPSessionPool::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn notify_max_sessions_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPSessionPool, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPSessionPool> {
let f: &F = &*(f as *const F);
f(&RTSPSessionPool::from_glib_borrow(this).unsafe_cast())
}

72
gstreamer-rtsp-server/src/auto/rtsp_stream.rs
View file

@ -741,6 +741,12 @@ impl<O: IsA<RTSPStream>> RTSPStreamExt for O {
} }
fn connect_new_rtcp_encoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_new_rtcp_encoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn new_rtcp_encoder_trampoline<P, F: Fn(&P, &gst::Element) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, object: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<RTSPStream>
{
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"new-rtcp-encoder\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"new-rtcp-encoder\0".as_ptr() as *const _,
@ -749,6 +755,12 @@ impl<O: IsA<RTSPStream>> RTSPStreamExt for O {
} }
fn connect_new_rtp_encoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_new_rtp_encoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn new_rtp_encoder_trampoline<P, F: Fn(&P, &gst::Element) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, object: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<RTSPStream>
{
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"new-rtp-encoder\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"new-rtp-encoder\0".as_ptr() as *const _,
@ -757,6 +769,12 @@ impl<O: IsA<RTSPStream>> RTSPStreamExt for O {
} }
fn connect_new_rtp_rtcp_decoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_new_rtp_rtcp_decoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn new_rtp_rtcp_decoder_trampoline<P, F: Fn(&P, &gst::Element) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, object: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<RTSPStream>
{
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"new-rtp-rtcp-decoder\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"new-rtp-rtcp-decoder\0".as_ptr() as *const _,
@ -765,6 +783,12 @@ impl<O: IsA<RTSPStream>> RTSPStreamExt for O {
} }
fn connect_property_control_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_control_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_control_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPStream>
{
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::control\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::control\0".as_ptr() as *const _,
@ -773,6 +797,12 @@ impl<O: IsA<RTSPStream>> RTSPStreamExt for O {
} }
fn connect_property_profiles_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_profiles_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_profiles_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPStream>
{
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::profiles\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::profiles\0".as_ptr() as *const _,
@ -781,6 +811,12 @@ impl<O: IsA<RTSPStream>> RTSPStreamExt for O {
} }
fn connect_property_protocols_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_protocols_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_protocols_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPStream>
{
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::protocols\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::protocols\0".as_ptr() as *const _,
@ -788,39 +824,3 @@ impl<O: IsA<RTSPStream>> RTSPStreamExt for O {
} }
} }
} }
unsafe extern "C" fn new_rtcp_encoder_trampoline<P, F: Fn(&P, &gst::Element) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, object: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<RTSPStream> {
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn new_rtp_encoder_trampoline<P, F: Fn(&P, &gst::Element) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, object: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<RTSPStream> {
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn new_rtp_rtcp_decoder_trampoline<P, F: Fn(&P, &gst::Element) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, object: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<RTSPStream> {
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
}
unsafe extern "C" fn notify_control_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPStream> {
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_profiles_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPStream> {
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_protocols_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPStream> {
let f: &F = &*(f as *const F);
f(&RTSPStream::from_glib_borrow(this).unsafe_cast())
}

12
gstreamer-rtsp-server/src/auto/rtsp_thread_pool.rs
View file

@ -75,6 +75,12 @@ impl<O: IsA<RTSPThreadPool>> RTSPThreadPoolExt for O {
} }
fn connect_property_max_threads_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_threads_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_max_threads_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPThreadPool, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPThreadPool>
{
let f: &F = &*(f as *const F);
f(&RTSPThreadPool::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-threads\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::max-threads\0".as_ptr() as *const _,
@ -82,9 +88,3 @@ impl<O: IsA<RTSPThreadPool>> RTSPThreadPoolExt for O {
} }
} }
} }
unsafe extern "C" fn notify_max_threads_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_rtsp_server_sys::GstRTSPThreadPool, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<RTSPThreadPool> {
let f: &F = &*(f as *const F);
f(&RTSPThreadPool::from_glib_borrow(this).unsafe_cast())
}

2
gstreamer-rtsp-server/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

2
gstreamer-rtsp/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

2
gstreamer-sdp/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

2
gstreamer-video/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 6d4ca01) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

12
gstreamer-video/src/auto/video_encoder.rs
View file

@ -131,6 +131,12 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExt for O {
} }
fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_video_sys::GstVideoEncoder, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<VideoEncoder>
{
let f: &F = &*(f as *const F);
f(&VideoEncoder::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::qos\0".as_ptr() as *const _,
@ -138,9 +144,3 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExt for O {
} }
} }
} }
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_video_sys::GstVideoEncoder, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<VideoEncoder> {
let f: &F = &*(f as *const F);
f(&VideoEncoder::from_glib_borrow(this).unsafe_cast())
}

2
gstreamer-webrtc/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 58cffd4) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)

47
gstreamer-webrtc/src/auto/web_rtcdtls_transport.rs
View file

@ -7,7 +7,7 @@ use WebRTCICETransport;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -108,6 +108,10 @@ impl WebRTCDTLSTransport {
} }
pub fn connect_property_certificate_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_certificate_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_certificate_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::certificate\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::certificate\0".as_ptr() as *const _,
@ -116,6 +120,10 @@ impl WebRTCDTLSTransport {
} }
pub fn connect_property_client_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_client_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_client_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::client\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::client\0".as_ptr() as *const _,
@ -124,6 +132,10 @@ impl WebRTCDTLSTransport {
} }
pub fn connect_property_remote_certificate_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_remote_certificate_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_remote_certificate_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::remote-certificate\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::remote-certificate\0".as_ptr() as *const _,
@ -132,6 +144,10 @@ impl WebRTCDTLSTransport {
} }
pub fn connect_property_state_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_state_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_state_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::state\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::state\0".as_ptr() as *const _,
@ -140,6 +156,10 @@ impl WebRTCDTLSTransport {
} }
pub fn connect_property_transport_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_transport_notify<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_transport_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::transport\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::transport\0".as_ptr() as *const _,
@ -150,28 +170,3 @@ impl WebRTCDTLSTransport {
unsafe impl Send for WebRTCDTLSTransport {} unsafe impl Send for WebRTCDTLSTransport {}
unsafe impl Sync for WebRTCDTLSTransport {} unsafe impl Sync for WebRTCDTLSTransport {}
unsafe extern "C" fn notify_certificate_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_client_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_remote_certificate_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_state_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_transport_trampoline<F: Fn(&WebRTCDTLSTransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCDTLSTransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

38
gstreamer-webrtc/src/auto/web_rtcice_transport.rs
View file

@ -8,7 +8,7 @@ use WebRTCICEGatheringState;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -77,6 +77,10 @@ impl WebRTCICETransport {
} }
pub fn connect_on_new_candidate<F: Fn(&WebRTCICETransport, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_on_new_candidate<F: Fn(&WebRTCICETransport, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn on_new_candidate_trampoline<F: Fn(&WebRTCICETransport, &str) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCICETransport, object: *mut libc::c_char, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &GString::from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"on-new-candidate\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"on-new-candidate\0".as_ptr() as *const _,
@ -85,6 +89,10 @@ impl WebRTCICETransport {
} }
pub fn connect_on_selected_candidate_pair_change<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_on_selected_candidate_pair_change<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn on_selected_candidate_pair_change_trampoline<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCICETransport, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"on-selected-candidate-pair-change\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"on-selected-candidate-pair-change\0".as_ptr() as *const _,
@ -93,6 +101,10 @@ impl WebRTCICETransport {
} }
pub fn connect_property_gathering_state_notify<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_gathering_state_notify<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_gathering_state_trampoline<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCICETransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::gathering-state\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::gathering-state\0".as_ptr() as *const _,
@ -101,6 +113,10 @@ impl WebRTCICETransport {
} }
pub fn connect_property_state_notify<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_state_notify<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_state_trampoline<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCICETransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::state\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::state\0".as_ptr() as *const _,
@ -111,23 +127,3 @@ impl WebRTCICETransport {
unsafe impl Send for WebRTCICETransport {} unsafe impl Send for WebRTCICETransport {}
unsafe impl Sync for WebRTCICETransport {} unsafe impl Sync for WebRTCICETransport {}
unsafe extern "C" fn on_new_candidate_trampoline<F: Fn(&WebRTCICETransport, &str) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCICETransport, object: *mut libc::c_char, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &GString::from_glib_borrow(object))
}
unsafe extern "C" fn on_selected_candidate_pair_change_trampoline<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCICETransport, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_gathering_state_trampoline<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCICETransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_state_trampoline<F: Fn(&WebRTCICETransport) + Send + Sync + 'static>(this: *mut gst_web_rtc_sys::GstWebRTCICETransport, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

2
gstreamer-webrtc/src/auto/web_rtcrtp_transceiver.rs
View file

@ -6,7 +6,7 @@ use WebRTCRTPReceiver;
use WebRTCRTPSender; use WebRTCRTPSender;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::translate::*; use glib::translate::*;
use gobject_sys; use gobject_sys;
use gst_web_rtc_sys; use gst_web_rtc_sys;

4
gstreamer/src/auto/allocator.rs
View file

@ -37,7 +37,7 @@ unsafe impl Sync for Allocator {}
pub const NONE_ALLOCATOR: Option<&Allocator> = None; pub const NONE_ALLOCATOR: Option<&Allocator> = None;
pub trait AllocatorExt: 'static { pub trait AllocatorExt: 'static {
//fn alloc(&self, size: usize, params: Option<&mut AllocationParams>) -> /*Ignored*/Option<Memory>; //fn alloc(&self, size: usize, params: /*Ignored*/Option<&mut AllocationParams>) -> /*Ignored*/Option<Memory>;
//fn free(&self, memory: /*Ignored*/&mut Memory); //fn free(&self, memory: /*Ignored*/&mut Memory);
@ -45,7 +45,7 @@ pub trait AllocatorExt: 'static {
} }
impl<O: IsA<Allocator>> AllocatorExt for O { impl<O: IsA<Allocator>> AllocatorExt for O {
//fn alloc(&self, size: usize, params: Option<&mut AllocationParams>) -> /*Ignored*/Option<Memory> { //fn alloc(&self, size: usize, params: /*Ignored*/Option<&mut AllocationParams>) -> /*Ignored*/Option<Memory> {
// unsafe { TODO: call gst_sys:gst_allocator_alloc() } // unsafe { TODO: call gst_sys:gst_allocator_alloc() }
//} //}

74
gstreamer/src/auto/bin.rs
View file

@ -232,6 +232,12 @@ impl<O: IsA<Bin>> GstBinExt for O {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
fn connect_deep_element_added<F: Fn(&Self, &Bin, &Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_deep_element_added<F: Fn(&Self, &Bin, &Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn deep_element_added_trampoline<P, F: Fn(&P, &Bin, &Element) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, sub_bin: *mut gst_sys::GstBin, element: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Bin>
{
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(sub_bin), &from_glib_borrow(element))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"deep-element-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"deep-element-added\0".as_ptr() as *const _,
@ -241,6 +247,12 @@ impl<O: IsA<Bin>> GstBinExt for O {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
fn connect_deep_element_removed<F: Fn(&Self, &Bin, &Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_deep_element_removed<F: Fn(&Self, &Bin, &Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn deep_element_removed_trampoline<P, F: Fn(&P, &Bin, &Element) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, sub_bin: *mut gst_sys::GstBin, element: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Bin>
{
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(sub_bin), &from_glib_borrow(element))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"deep-element-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"deep-element-removed\0".as_ptr() as *const _,
@ -249,6 +261,12 @@ impl<O: IsA<Bin>> GstBinExt for O {
} }
fn connect_element_added<F: Fn(&Self, &Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_element_added<F: Fn(&Self, &Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn element_added_trampoline<P, F: Fn(&P, &Element) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, element: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Bin>
{
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"element-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"element-added\0".as_ptr() as *const _,
@ -257,6 +275,12 @@ impl<O: IsA<Bin>> GstBinExt for O {
} }
fn connect_element_removed<F: Fn(&Self, &Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_element_removed<F: Fn(&Self, &Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn element_removed_trampoline<P, F: Fn(&P, &Element) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, element: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Bin>
{
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"element-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"element-removed\0".as_ptr() as *const _,
@ -265,6 +289,12 @@ impl<O: IsA<Bin>> GstBinExt for O {
} }
fn connect_property_async_handling_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_async_handling_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_async_handling_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Bin>
{
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::async-handling\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::async-handling\0".as_ptr() as *const _,
@ -273,6 +303,12 @@ impl<O: IsA<Bin>> GstBinExt for O {
} }
fn connect_property_message_forward_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_message_forward_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_message_forward_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Bin>
{
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::message-forward\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::message-forward\0".as_ptr() as *const _,
@ -280,41 +316,3 @@ impl<O: IsA<Bin>> GstBinExt for O {
} }
} }
} }
#[cfg(any(feature = "v1_10", feature = "dox"))]
unsafe extern "C" fn deep_element_added_trampoline<P, F: Fn(&P, &Bin, &Element) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, sub_bin: *mut gst_sys::GstBin, element: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Bin> {
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(sub_bin), &from_glib_borrow(element))
}
#[cfg(any(feature = "v1_10", feature = "dox"))]
unsafe extern "C" fn deep_element_removed_trampoline<P, F: Fn(&P, &Bin, &Element) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, sub_bin: *mut gst_sys::GstBin, element: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Bin> {
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(sub_bin), &from_glib_borrow(element))
}
unsafe extern "C" fn element_added_trampoline<P, F: Fn(&P, &Element) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, element: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Bin> {
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element))
}
unsafe extern "C" fn element_removed_trampoline<P, F: Fn(&P, &Element) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, element: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Bin> {
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element))
}
unsafe extern "C" fn notify_async_handling_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Bin> {
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_message_forward_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstBin, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Bin> {
let f: &F = &*(f as *const F);
f(&Bin::from_glib_borrow(this).unsafe_cast())
}

20
gstreamer/src/auto/bus.rs
View file

@ -6,7 +6,7 @@ use ClockTime;
use Message; use Message;
use Object; use Object;
use glib; use glib;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -111,6 +111,10 @@ impl Bus {
} }
pub fn connect_message<F: Fn(&Bus, &Message) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_message<F: Fn(&Bus, &Message) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn message_trampoline<F: Fn(&Bus, &Message) + Send + 'static>(this: *mut gst_sys::GstBus, message: *mut gst_sys::GstMessage, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(message))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"message\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"message\0".as_ptr() as *const _,
@ -119,6 +123,10 @@ impl Bus {
} }
pub fn connect_sync_message<F: Fn(&Bus, &Message) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_sync_message<F: Fn(&Bus, &Message) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn sync_message_trampoline<F: Fn(&Bus, &Message) + Send + Sync + 'static>(this: *mut gst_sys::GstBus, message: *mut gst_sys::GstMessage, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(message))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"sync-message\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"sync-message\0".as_ptr() as *const _,
@ -135,13 +143,3 @@ impl Default for Bus {
unsafe impl Send for Bus {} unsafe impl Send for Bus {}
unsafe impl Sync for Bus {} unsafe impl Sync for Bus {}
unsafe extern "C" fn message_trampoline<F: Fn(&Bus, &Message) + Send + 'static>(this: *mut gst_sys::GstBus, message: *mut gst_sys::GstMessage, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(message))
}
unsafe extern "C" fn sync_message_trampoline<F: Fn(&Bus, &Message) + Send + Sync + 'static>(this: *mut gst_sys::GstBus, message: *mut gst_sys::GstMessage, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(message))
}

24
gstreamer/src/auto/child_proxy.rs
View file

@ -119,6 +119,12 @@ impl<O: IsA<ChildProxy>> ChildProxyExt for O {
//} //}
fn connect_child_added<F: Fn(&Self, &glib::Object, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_child_added<F: Fn(&Self, &glib::Object, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn child_added_trampoline<P, F: Fn(&P, &glib::Object, &str) + Send + Sync + 'static>(this: *mut gst_sys::GstChildProxy, object: *mut gobject_sys::GObject, name: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<ChildProxy>
{
let f: &F = &*(f as *const F);
f(&ChildProxy::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object), &GString::from_glib_borrow(name))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"child-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"child-added\0".as_ptr() as *const _,
@ -127,6 +133,12 @@ impl<O: IsA<ChildProxy>> ChildProxyExt for O {
} }
fn connect_child_removed<F: Fn(&Self, &glib::Object, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_child_removed<F: Fn(&Self, &glib::Object, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn child_removed_trampoline<P, F: Fn(&P, &glib::Object, &str) + Send + Sync + 'static>(this: *mut gst_sys::GstChildProxy, object: *mut gobject_sys::GObject, name: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<ChildProxy>
{
let f: &F = &*(f as *const F);
f(&ChildProxy::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object), &GString::from_glib_borrow(name))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"child-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"child-removed\0".as_ptr() as *const _,
@ -134,15 +146,3 @@ impl<O: IsA<ChildProxy>> ChildProxyExt for O {
} }
} }
} }
unsafe extern "C" fn child_added_trampoline<P, F: Fn(&P, &glib::Object, &str) + Send + Sync + 'static>(this: *mut gst_sys::GstChildProxy, object: *mut gobject_sys::GObject, name: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<ChildProxy> {
let f: &F = &*(f as *const F);
f(&ChildProxy::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object), &GString::from_glib_borrow(name))
}
unsafe extern "C" fn child_removed_trampoline<P, F: Fn(&P, &glib::Object, &str) + Send + Sync + 'static>(this: *mut gst_sys::GstChildProxy, object: *mut gobject_sys::GObject, name: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<ChildProxy> {
let f: &F = &*(f as *const F);
f(&ChildProxy::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object), &GString::from_glib_borrow(name))
}

48
gstreamer/src/auto/clock.rs
View file

@ -293,6 +293,12 @@ impl<O: IsA<Clock>> ClockExt for O {
} }
fn connect_synced<F: Fn(&Self, bool) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_synced<F: Fn(&Self, bool) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn synced_trampoline<P, F: Fn(&P, bool) + Send + Sync + 'static>(this: *mut gst_sys::GstClock, synced: glib_sys::gboolean, f: glib_sys::gpointer)
where P: IsA<Clock>
{
let f: &F = &*(f as *const F);
f(&Clock::from_glib_borrow(this).unsafe_cast(), from_glib(synced))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"synced\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"synced\0".as_ptr() as *const _,
@ -301,6 +307,12 @@ impl<O: IsA<Clock>> ClockExt for O {
} }
fn connect_property_timeout_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_timeout_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clock>
{
let f: &F = &*(f as *const F);
f(&Clock::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::timeout\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::timeout\0".as_ptr() as *const _,
@ -309,6 +321,12 @@ impl<O: IsA<Clock>> ClockExt for O {
} }
fn connect_property_window_size_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_window_size_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_window_size_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clock>
{
let f: &F = &*(f as *const F);
f(&Clock::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::window-size\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::window-size\0".as_ptr() as *const _,
@ -317,6 +335,12 @@ impl<O: IsA<Clock>> ClockExt for O {
} }
fn connect_property_window_threshold_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_window_threshold_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_window_threshold_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clock>
{
let f: &F = &*(f as *const F);
f(&Clock::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::window-threshold\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::window-threshold\0".as_ptr() as *const _,
@ -324,27 +348,3 @@ impl<O: IsA<Clock>> ClockExt for O {
} }
} }
} }
unsafe extern "C" fn synced_trampoline<P, F: Fn(&P, bool) + Send + Sync + 'static>(this: *mut gst_sys::GstClock, synced: glib_sys::gboolean, f: glib_sys::gpointer)
where P: IsA<Clock> {
let f: &F = &*(f as *const F);
f(&Clock::from_glib_borrow(this).unsafe_cast(), from_glib(synced))
}
unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clock> {
let f: &F = &*(f as *const F);
f(&Clock::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_window_size_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clock> {
let f: &F = &*(f as *const F);
f(&Clock::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_window_threshold_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Clock> {
let f: &F = &*(f as *const F);
f(&Clock::from_glib_borrow(this).unsafe_cast())
}

12
gstreamer/src/auto/device.rs
View file

@ -101,6 +101,12 @@ impl<O: IsA<Device>> DeviceExt for O {
} }
fn connect_removed<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_removed<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn removed_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstDevice, f: glib_sys::gpointer)
where P: IsA<Device>
{
let f: &F = &*(f as *const F);
f(&Device::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"removed\0".as_ptr() as *const _,
@ -108,9 +114,3 @@ impl<O: IsA<Device>> DeviceExt for O {
} }
} }
} }
unsafe extern "C" fn removed_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstDevice, f: glib_sys::gpointer)
where P: IsA<Device> {
let f: &F = &*(f as *const F);
f(&Device::from_glib_borrow(this).unsafe_cast())
}

12
gstreamer/src/auto/device_monitor.rs
View file

@ -113,6 +113,12 @@ impl<O: IsA<DeviceMonitor>> DeviceMonitorExt for O {
} }
fn connect_property_show_all_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_show_all_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_show_all_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstDeviceMonitor, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<DeviceMonitor>
{
let f: &F = &*(f as *const F);
f(&DeviceMonitor::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::show-all\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::show-all\0".as_ptr() as *const _,
@ -120,9 +126,3 @@ impl<O: IsA<DeviceMonitor>> DeviceMonitorExt for O {
} }
} }
} }
unsafe extern "C" fn notify_show_all_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstDeviceMonitor, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<DeviceMonitor> {
let f: &F = &*(f as *const F);
f(&DeviceMonitor::from_glib_borrow(this).unsafe_cast())
}

24
gstreamer/src/auto/device_provider.rs
View file

@ -138,6 +138,12 @@ impl<O: IsA<DeviceProvider>> DeviceProviderExt for O {
} }
fn connect_provider_hidden<F: Fn(&Self, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_provider_hidden<F: Fn(&Self, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn provider_hidden_trampoline<P, F: Fn(&P, &str) + Send + Sync + 'static>(this: *mut gst_sys::GstDeviceProvider, object: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<DeviceProvider>
{
let f: &F = &*(f as *const F);
f(&DeviceProvider::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"provider-hidden\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"provider-hidden\0".as_ptr() as *const _,
@ -146,6 +152,12 @@ impl<O: IsA<DeviceProvider>> DeviceProviderExt for O {
} }
fn connect_provider_unhidden<F: Fn(&Self, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_provider_unhidden<F: Fn(&Self, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn provider_unhidden_trampoline<P, F: Fn(&P, &str) + Send + Sync + 'static>(this: *mut gst_sys::GstDeviceProvider, object: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<DeviceProvider>
{
let f: &F = &*(f as *const F);
f(&DeviceProvider::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(object))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"provider-unhidden\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"provider-unhidden\0".as_ptr() as *const _,
@ -153,15 +165,3 @@ impl<O: IsA<DeviceProvider>> DeviceProviderExt for O {
} }
} }
} }
unsafe extern "C" fn provider_hidden_trampoline<P, F: Fn(&P, &str) + Send + Sync + 'static>(this: *mut gst_sys::GstDeviceProvider, object: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<DeviceProvider> {
let f: &F = &*(f as *const F);
f(&DeviceProvider::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(object))
}
unsafe extern "C" fn provider_unhidden_trampoline<P, F: Fn(&P, &str) + Send + Sync + 'static>(this: *mut gst_sys::GstDeviceProvider, object: *mut libc::c_char, f: glib_sys::gpointer)
where P: IsA<DeviceProvider> {
let f: &F = &*(f as *const F);
f(&DeviceProvider::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(object))
}

36
gstreamer/src/auto/element.rs
View file

@ -453,6 +453,12 @@ impl<O: IsA<Element>> ElementExt for O {
} }
fn connect_no_more_pads<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_no_more_pads<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn no_more_pads_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Element>
{
let f: &F = &*(f as *const F);
f(&Element::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"no-more-pads\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"no-more-pads\0".as_ptr() as *const _,
@ -461,6 +467,12 @@ impl<O: IsA<Element>> ElementExt for O {
} }
fn connect_pad_added<F: Fn(&Self, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pad_added<F: Fn(&Self, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pad_added_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstElement, new_pad: *mut gst_sys::GstPad, f: glib_sys::gpointer)
where P: IsA<Element>
{
let f: &F = &*(f as *const F);
f(&Element::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(new_pad))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pad-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pad-added\0".as_ptr() as *const _,
@ -469,6 +481,12 @@ impl<O: IsA<Element>> ElementExt for O {
} }
fn connect_pad_removed<F: Fn(&Self, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_pad_removed<F: Fn(&Self, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pad_removed_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstElement, old_pad: *mut gst_sys::GstPad, f: glib_sys::gpointer)
where P: IsA<Element>
{
let f: &F = &*(f as *const F);
f(&Element::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(old_pad))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pad-removed\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pad-removed\0".as_ptr() as *const _,
@ -476,21 +494,3 @@ impl<O: IsA<Element>> ElementExt for O {
} }
} }
} }
unsafe extern "C" fn no_more_pads_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstElement, f: glib_sys::gpointer)
where P: IsA<Element> {
let f: &F = &*(f as *const F);
f(&Element::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn pad_added_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstElement, new_pad: *mut gst_sys::GstPad, f: glib_sys::gpointer)
where P: IsA<Element> {
let f: &F = &*(f as *const F);
f(&Element::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(new_pad))
}
unsafe extern "C" fn pad_removed_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstElement, old_pad: *mut gst_sys::GstPad, f: glib_sys::gpointer)
where P: IsA<Element> {
let f: &F = &*(f as *const F);
f(&Element::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(old_pad))
}

24
gstreamer/src/auto/object.rs
View file

@ -236,6 +236,12 @@ impl<O: IsA<Object>> GstObjectExt for O {
//} //}
fn connect_property_name_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_name_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_name_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstObject, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Object>
{
let f: &F = &*(f as *const F);
f(&Object::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::name\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::name\0".as_ptr() as *const _,
@ -244,6 +250,12 @@ impl<O: IsA<Object>> GstObjectExt for O {
} }
fn connect_property_parent_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_parent_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_parent_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstObject, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Object>
{
let f: &F = &*(f as *const F);
f(&Object::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::parent\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::parent\0".as_ptr() as *const _,
@ -251,15 +263,3 @@ impl<O: IsA<Object>> GstObjectExt for O {
} }
} }
} }
unsafe extern "C" fn notify_name_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstObject, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Object> {
let f: &F = &*(f as *const F);
f(&Object::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_parent_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstObject, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Object> {
let f: &F = &*(f as *const F);
f(&Object::from_glib_borrow(this).unsafe_cast())
}

60
gstreamer/src/auto/pad.rs
View file

@ -443,6 +443,12 @@ impl<O: IsA<Pad>> PadExt for O {
} }
fn connect_linked<F: Fn(&Self, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_linked<F: Fn(&Self, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn linked_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, peer: *mut gst_sys::GstPad, f: glib_sys::gpointer)
where P: IsA<Pad>
{
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(peer))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"linked\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"linked\0".as_ptr() as *const _,
@ -451,6 +457,12 @@ impl<O: IsA<Pad>> PadExt for O {
} }
fn connect_unlinked<F: Fn(&Self, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_unlinked<F: Fn(&Self, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn unlinked_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, peer: *mut gst_sys::GstPad, f: glib_sys::gpointer)
where P: IsA<Pad>
{
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(peer))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"unlinked\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"unlinked\0".as_ptr() as *const _,
@ -459,6 +471,12 @@ impl<O: IsA<Pad>> PadExt for O {
} }
fn connect_property_caps_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_caps_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_caps_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pad>
{
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _,
@ -467,6 +485,12 @@ impl<O: IsA<Pad>> PadExt for O {
} }
fn connect_property_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_offset_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pad>
{
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::offset\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::offset\0".as_ptr() as *const _,
@ -475,6 +499,12 @@ impl<O: IsA<Pad>> PadExt for O {
} }
fn connect_property_template_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_template_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_template_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pad>
{
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::template\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::template\0".as_ptr() as *const _,
@ -482,33 +512,3 @@ impl<O: IsA<Pad>> PadExt for O {
} }
} }
} }
unsafe extern "C" fn linked_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, peer: *mut gst_sys::GstPad, f: glib_sys::gpointer)
where P: IsA<Pad> {
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(peer))
}
unsafe extern "C" fn unlinked_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, peer: *mut gst_sys::GstPad, f: glib_sys::gpointer)
where P: IsA<Pad> {
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(peer))
}
unsafe extern "C" fn notify_caps_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pad> {
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_offset_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pad> {
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_template_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pad> {
let f: &F = &*(f as *const F);
f(&Pad::from_glib_borrow(this).unsafe_cast())
}

11
gstreamer/src/auto/pad_template.rs
View file

@ -13,7 +13,7 @@ use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::IsA; use glib::object::IsA;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -93,6 +93,10 @@ impl PadTemplate {
} }
pub fn connect_pad_created<F: Fn(&PadTemplate, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_pad_created<F: Fn(&PadTemplate, &Pad) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn pad_created_trampoline<F: Fn(&PadTemplate, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstPadTemplate, pad: *mut gst_sys::GstPad, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(pad))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"pad-created\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"pad-created\0".as_ptr() as *const _,
@ -103,8 +107,3 @@ impl PadTemplate {
unsafe impl Send for PadTemplate {} unsafe impl Send for PadTemplate {}
unsafe impl Sync for PadTemplate {} unsafe impl Sync for PadTemplate {}
unsafe extern "C" fn pad_created_trampoline<F: Fn(&PadTemplate, &Pad) + Send + Sync + 'static>(this: *mut gst_sys::GstPadTemplate, pad: *mut gst_sys::GstPad, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(pad))
}

36
gstreamer/src/auto/pipeline.rs
View file

@ -122,6 +122,12 @@ impl<O: IsA<Pipeline>> PipelineExt for O {
} }
fn connect_property_auto_flush_bus_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_auto_flush_bus_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_auto_flush_bus_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::auto-flush-bus\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::auto-flush-bus\0".as_ptr() as *const _,
@ -130,6 +136,12 @@ impl<O: IsA<Pipeline>> PipelineExt for O {
} }
fn connect_property_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_delay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::delay\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::delay\0".as_ptr() as *const _,
@ -138,6 +150,12 @@ impl<O: IsA<Pipeline>> PipelineExt for O {
} }
fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline>
{
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _,
@ -145,21 +163,3 @@ impl<O: IsA<Pipeline>> PipelineExt for O {
} }
} }
} }
unsafe extern "C" fn notify_auto_flush_bus_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_delay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<Pipeline> {
let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast())
}

20
gstreamer/src/auto/registry.rs
View file

@ -7,7 +7,7 @@ use Plugin;
use PluginFeature; use PluginFeature;
use glib; use glib;
use glib::object::IsA; use glib::object::IsA;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -148,6 +148,10 @@ impl Registry {
} }
pub fn connect_feature_added<F: Fn(&Registry, &PluginFeature) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_feature_added<F: Fn(&Registry, &PluginFeature) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn feature_added_trampoline<F: Fn(&Registry, &PluginFeature) + Send + Sync + 'static>(this: *mut gst_sys::GstRegistry, feature: *mut gst_sys::GstPluginFeature, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(feature))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"feature-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"feature-added\0".as_ptr() as *const _,
@ -156,6 +160,10 @@ impl Registry {
} }
pub fn connect_plugin_added<F: Fn(&Registry, &Plugin) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_plugin_added<F: Fn(&Registry, &Plugin) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn plugin_added_trampoline<F: Fn(&Registry, &Plugin) + Send + Sync + 'static>(this: *mut gst_sys::GstRegistry, plugin: *mut gst_sys::GstPlugin, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(plugin))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"plugin-added\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"plugin-added\0".as_ptr() as *const _,
@ -166,13 +174,3 @@ impl Registry {
unsafe impl Send for Registry {} unsafe impl Send for Registry {}
unsafe impl Sync for Registry {} unsafe impl Sync for Registry {}
unsafe extern "C" fn feature_added_trampoline<F: Fn(&Registry, &PluginFeature) + Send + Sync + 'static>(this: *mut gst_sys::GstRegistry, feature: *mut gst_sys::GstPluginFeature, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(feature))
}
unsafe extern "C" fn plugin_added_trampoline<F: Fn(&Registry, &Plugin) + Send + Sync + 'static>(this: *mut gst_sys::GstRegistry, plugin: *mut gst_sys::GstPlugin, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(plugin))
}

38
gstreamer/src/auto/stream.rs
View file

@ -10,7 +10,7 @@ use TagList;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -157,6 +157,10 @@ impl Stream {
} }
pub fn connect_property_caps_notify<F: Fn(&Stream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_caps_notify<F: Fn(&Stream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&Stream) + Send + Sync + 'static>(this: *mut gst_sys::GstStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _,
@ -165,6 +169,10 @@ impl Stream {
} }
pub fn connect_property_stream_flags_notify<F: Fn(&Stream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_stream_flags_notify<F: Fn(&Stream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_stream_flags_trampoline<F: Fn(&Stream) + Send + Sync + 'static>(this: *mut gst_sys::GstStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::stream-flags\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::stream-flags\0".as_ptr() as *const _,
@ -173,6 +181,10 @@ impl Stream {
} }
pub fn connect_property_stream_type_notify<F: Fn(&Stream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_stream_type_notify<F: Fn(&Stream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_stream_type_trampoline<F: Fn(&Stream) + Send + Sync + 'static>(this: *mut gst_sys::GstStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::stream-type\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::stream-type\0".as_ptr() as *const _,
@ -181,6 +193,10 @@ impl Stream {
} }
pub fn connect_property_tags_notify<F: Fn(&Stream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_tags_notify<F: Fn(&Stream) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_tags_trampoline<F: Fn(&Stream) + Send + Sync + 'static>(this: *mut gst_sys::GstStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::tags\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::tags\0".as_ptr() as *const _,
@ -191,23 +207,3 @@ impl Stream {
unsafe impl Send for Stream {} unsafe impl Send for Stream {}
unsafe impl Sync for Stream {} unsafe impl Sync for Stream {}
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&Stream) + Send + Sync + 'static>(this: *mut gst_sys::GstStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_stream_flags_trampoline<F: Fn(&Stream) + Send + Sync + 'static>(this: *mut gst_sys::GstStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_stream_type_trampoline<F: Fn(&Stream) + Send + Sync + 'static>(this: *mut gst_sys::GstStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe extern "C" fn notify_tags_trampoline<F: Fn(&Stream) + Send + Sync + 'static>(this: *mut gst_sys::GstStream, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

11
gstreamer/src/auto/stream_collection.rs
View file

@ -8,7 +8,7 @@ use Stream;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId; use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::translate::*; use glib::translate::*;
@ -67,6 +67,10 @@ impl StreamCollection {
//} //}
pub fn connect_property_upstream_id_notify<F: Fn(&StreamCollection) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_upstream_id_notify<F: Fn(&StreamCollection) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_upstream_id_trampoline<F: Fn(&StreamCollection) + Send + Sync + 'static>(this: *mut gst_sys::GstStreamCollection, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::upstream-id\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::upstream-id\0".as_ptr() as *const _,
@ -77,8 +81,3 @@ impl StreamCollection {
unsafe impl Send for StreamCollection {} unsafe impl Send for StreamCollection {}
unsafe impl Sync for StreamCollection {} unsafe impl Sync for StreamCollection {}
unsafe extern "C" fn notify_upstream_id_trampoline<F: Fn(&StreamCollection) + Send + Sync + 'static>(this: *mut gst_sys::GstStreamCollection, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}

12
gstreamer/src/auto/system_clock.rs
View file

@ -71,6 +71,12 @@ impl<O: IsA<SystemClock>> SystemClockExt for O {
} }
fn connect_property_clock_type_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_clock_type_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_clock_type_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstSystemClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<SystemClock>
{
let f: &F = &*(f as *const F);
f(&SystemClock::from_glib_borrow(this).unsafe_cast())
}
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::clock-type\0".as_ptr() as *const _, connect_raw(self.as_ptr() as *mut _, b"notify::clock-type\0".as_ptr() as *const _,
@ -78,9 +84,3 @@ impl<O: IsA<SystemClock>> SystemClockExt for O {
} }
} }
} }
unsafe extern "C" fn notify_clock_type_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_sys::GstSystemClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer)
where P: IsA<SystemClock> {
let f: &F = &*(f as *const F);
f(&SystemClock::from_glib_borrow(this).unsafe_cast())
}

2
gstreamer/src/auto/versions.txt
View file

@ -1,2 +1,2 @@
Generated by gir (https://github.com/gtk-rs/gir @ 7dc9574) Generated by gir (https://github.com/gtk-rs/gir @ e586ff8)
from gir-files (https://github.com/gtk-rs/gir-files @ ???) from gir-files (https://github.com/gtk-rs/gir-files @ ???)