diff --git a/gstreamer-app/src/auto/app_sink.rs b/gstreamer-app/src/auto/app_sink.rs
index 821fb3a1f..184f36ed5 100644
--- a/gstreamer-app/src/auto/app_sink.rs
+++ b/gstreamer-app/src/auto/app_sink.rs
@@ -4,7 +4,7 @@
 
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 use glib::translate::*;
@@ -158,6 +158,10 @@ impl AppSink {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-app/src/auto/app_src.rs b/gstreamer-app/src/auto/app_src.rs
index 5518d7790..1b4a0fa11 100644
--- a/gstreamer-app/src/auto/app_src.rs
+++ b/gstreamer-app/src/auto/app_src.rs
@@ -5,7 +5,7 @@
 use AppStreamType;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 use glib::translate::*;
@@ -210,6 +210,10 @@ impl AppSrc {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-app/src/auto/versions.txt b/gstreamer-app/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-app/src/auto/versions.txt
+++ b/gstreamer-app/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-audio/src/auto/stream_volume.rs b/gstreamer-audio/src/auto/stream_volume.rs
index b7aa1030b..a89adc1df 100644
--- a/gstreamer-audio/src/auto/stream_volume.rs
+++ b/gstreamer-audio/src/auto/stream_volume.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-audio/src/auto/versions.txt b/gstreamer-audio/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-audio/src/auto/versions.txt
+++ b/gstreamer-audio/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-base/src/auto/aggregator.rs b/gstreamer-base/src/auto/aggregator.rs
index 2b9388665..dd7e963e6 100644
--- a/gstreamer-base/src/auto/aggregator.rs
+++ b/gstreamer-base/src/auto/aggregator.rs
@@ -115,6 +115,12 @@ impl<O: IsA<Aggregator>> AggregatorExt for O {
 
     #[cfg(any(feature = "v1_14", feature = "dox"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-base/src/auto/aggregator_pad.rs b/gstreamer-base/src/auto/aggregator_pad.rs
index 89cbbd4b6..2caac8f28 100644
--- a/gstreamer-base/src/auto/aggregator_pad.rs
+++ b/gstreamer-base/src/auto/aggregator_pad.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-base/src/auto/base_parse.rs b/gstreamer-base/src/auto/base_parse.rs
index 1b463e2f7..5f1505409 100644
--- a/gstreamer-base/src/auto/base_parse.rs
+++ b/gstreamer-base/src/auto/base_parse.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-base/src/auto/base_sink.rs b/gstreamer-base/src/auto/base_sink.rs
index 6b99fcfdb..5c63cd23f 100644
--- a/gstreamer-base/src/auto/base_sink.rs
+++ b/gstreamer-base/src/auto/base_sink.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-base/src/auto/base_src.rs b/gstreamer-base/src/auto/base_src.rs
index b89d28b59..07fc50ea1 100644
--- a/gstreamer-base/src/auto/base_src.rs
+++ b/gstreamer-base/src/auto/base_src.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-base/src/auto/base_transform.rs b/gstreamer-base/src/auto/base_transform.rs
index 1e98e086b..d85f9982f 100644
--- a/gstreamer-base/src/auto/base_transform.rs
+++ b/gstreamer-base/src/auto/base_transform.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-base/src/auto/versions.txt b/gstreamer-base/src/auto/versions.txt
index d07525712..479278448 100644
--- a/gstreamer-base/src/auto/versions.txt
+++ b/gstreamer-base/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-check/src/auto/test_clock.rs b/gstreamer-check/src/auto/test_clock.rs
index d550450d7..be038d0c5 100644
--- a/gstreamer-check/src/auto/test_clock.rs
+++ b/gstreamer-check/src/auto/test_clock.rs
@@ -5,7 +5,7 @@
 use glib::StaticType;
 use glib::Value;
 use glib::object::Cast;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-check/src/auto/versions.txt b/gstreamer-check/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-check/src/auto/versions.txt
+++ b/gstreamer-check/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-editing-services/src/auto/asset.rs b/gstreamer-editing-services/src/auto/asset.rs
index 3c2ab60ae..bdd95fa69 100644
--- a/gstreamer-editing-services/src/auto/asset.rs
+++ b/gstreamer-editing-services/src/auto/asset.rs
@@ -5,7 +5,7 @@
 use Error;
 use Extractable;
 #[cfg(feature = "futures")]
-use futures_core;
+use futures::future;
 use ges_sys;
 use gio;
 use gio_sys;
@@ -65,7 +65,7 @@ impl Asset {
     }
 
     #[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 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/clip.rs b/gstreamer-editing-services/src/auto/clip.rs
index 911fee06a..f172e2689 100644
--- a/gstreamer-editing-services/src/auto/clip.rs
+++ b/gstreamer-editing-services/src/auto/clip.rs
@@ -144,6 +144,12 @@ impl<O: IsA<Clip>> ClipExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/container.rs b/gstreamer-editing-services/src/auto/container.rs
index 5b0d758f7..4b4f955ed 100644
--- a/gstreamer-editing-services/src/auto/container.rs
+++ b/gstreamer-editing-services/src/auto/container.rs
@@ -100,6 +100,12 @@ impl<O: IsA<Container>> GESContainerExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/group.rs b/gstreamer-editing-services/src/auto/group.rs
index c65294077..31c6b74c9 100644
--- a/gstreamer-editing-services/src/auto/group.rs
+++ b/gstreamer-editing-services/src/auto/group.rs
@@ -147,6 +147,12 @@ impl<O: IsA<Group>> GroupExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/layer.rs b/gstreamer-editing-services/src/auto/layer.rs
index 1bff63522..b5dc14bb6 100644
--- a/gstreamer-editing-services/src/auto/layer.rs
+++ b/gstreamer-editing-services/src/auto/layer.rs
@@ -162,6 +162,12 @@ impl<O: IsA<Layer>> LayerExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/pipeline.rs b/gstreamer-editing-services/src/auto/pipeline.rs
index 8ac838f27..0d948d23a 100644
--- a/gstreamer-editing-services/src/auto/pipeline.rs
+++ b/gstreamer-editing-services/src/auto/pipeline.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/project.rs b/gstreamer-editing-services/src/auto/project.rs
index ba532333c..99ffde515 100644
--- a/gstreamer-editing-services/src/auto/project.rs
+++ b/gstreamer-editing-services/src/auto/project.rs
@@ -157,6 +157,12 @@ impl<O: IsA<Project>> ProjectExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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()
-}
diff --git a/gstreamer-editing-services/src/auto/timeline.rs b/gstreamer-editing-services/src/auto/timeline.rs
index 4d364fd6a..60de84345 100644
--- a/gstreamer-editing-services/src/auto/timeline.rs
+++ b/gstreamer-editing-services/src/auto/timeline.rs
@@ -290,6 +290,12 @@ impl<O: IsA<Timeline>> TimelineExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/timeline_element.rs b/gstreamer-editing-services/src/auto/timeline_element.rs
index 8cce1a80e..c5d108756 100644
--- a/gstreamer-editing-services/src/auto/timeline_element.rs
+++ b/gstreamer-editing-services/src/auto/timeline_element.rs
@@ -375,6 +375,12 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
     //}
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/track.rs b/gstreamer-editing-services/src/auto/track.rs
index fc53112a2..342cfe57b 100644
--- a/gstreamer-editing-services/src/auto/track.rs
+++ b/gstreamer-editing-services/src/auto/track.rs
@@ -179,6 +179,12 @@ impl<O: IsA<Track>> GESTrackExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/track_element.rs b/gstreamer-editing-services/src/auto/track_element.rs
index ec4dbc35c..e4376bf02 100644
--- a/gstreamer-editing-services/src/auto/track_element.rs
+++ b/gstreamer-editing-services/src/auto/track_element.rs
@@ -179,6 +179,12 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
     //}
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/uri_clip.rs b/gstreamer-editing-services/src/auto/uri_clip.rs
index 8ad1e344d..6f04ae4b0 100644
--- a/gstreamer-editing-services/src/auto/uri_clip.rs
+++ b/gstreamer-editing-services/src/auto/uri_clip.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/uri_clip_asset.rs b/gstreamer-editing-services/src/auto/uri_clip_asset.rs
index b42c635c8..77cc29735 100644
--- a/gstreamer-editing-services/src/auto/uri_clip_asset.rs
+++ b/gstreamer-editing-services/src/auto/uri_clip_asset.rs
@@ -95,6 +95,12 @@ impl<O: IsA<UriClipAsset>> UriClipAssetExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-editing-services/src/auto/versions.txt b/gstreamer-editing-services/src/auto/versions.txt
index 81fb66a67..479278448 100644
--- a/gstreamer-editing-services/src/auto/versions.txt
+++ b/gstreamer-editing-services/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-gl/src/auto/gl_base_filter.rs b/gstreamer-gl/src/auto/gl_base_filter.rs
index 372ced618..dce87097e 100644
--- a/gstreamer-gl/src/auto/gl_base_filter.rs
+++ b/gstreamer-gl/src/auto/gl_base_filter.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-gl/src/auto/gl_display.rs b/gstreamer-gl/src/auto/gl_display.rs
index 1caefbee6..4064a7896 100644
--- a/gstreamer-gl/src/auto/gl_display.rs
+++ b/gstreamer-gl/src/auto/gl_display.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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()
-}
diff --git a/gstreamer-gl/src/auto/gl_overlay_compositor.rs b/gstreamer-gl/src/auto/gl_overlay_compositor.rs
index 122fa9774..059300030 100644
--- a/gstreamer-gl/src/auto/gl_overlay_compositor.rs
+++ b/gstreamer-gl/src/auto/gl_overlay_compositor.rs
@@ -9,7 +9,7 @@ use glib::StaticType;
 use glib::Value;
 use glib::object::IsA;
 #[cfg(any(feature = "v1_16", feature = "dox"))]
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 #[cfg(any(feature = "v1_16", feature = "dox"))]
 use glib::signal::SignalHandlerId;
 #[cfg(any(feature = "v1_16", feature = "dox"))]
@@ -79,6 +79,10 @@ impl GLOverlayCompositor {
 
     #[cfg(any(feature = "v1_16", feature = "dox"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-gl/src/auto/gl_shader.rs b/gstreamer-gl/src/auto/gl_shader.rs
index e92970ab0..810114bce 100644
--- a/gstreamer-gl/src/auto/gl_shader.rs
+++ b/gstreamer-gl/src/auto/gl_shader.rs
@@ -15,7 +15,7 @@ use glib::GString;
 use glib::StaticType;
 use glib::Value;
 use glib::object::IsA;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-gl/src/auto/gl_view_convert.rs b/gstreamer-gl/src/auto/gl_view_convert.rs
index e786727fb..990817fbf 100644
--- a/gstreamer-gl/src/auto/gl_view_convert.rs
+++ b/gstreamer-gl/src/auto/gl_view_convert.rs
@@ -8,7 +8,7 @@ use glib;
 use glib::StaticType;
 use glib::Value;
 use glib::object::IsA;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-gl/src/auto/gl_window.rs b/gstreamer-gl/src/auto/gl_window.rs
index 6ba304f9b..3deddab30 100644
--- a/gstreamer-gl/src/auto/gl_window.rs
+++ b/gstreamer-gl/src/auto/gl_window.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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)
-}
diff --git a/gstreamer-gl/src/auto/versions.txt b/gstreamer-gl/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-gl/src/auto/versions.txt
+++ b/gstreamer-gl/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-net/src/auto/net_client_clock.rs b/gstreamer-net/src/auto/net_client_clock.rs
index aa729cba2..f133226f3 100644
--- a/gstreamer-net/src/auto/net_client_clock.rs
+++ b/gstreamer-net/src/auto/net_client_clock.rs
@@ -5,7 +5,7 @@
 use glib::GString;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-net/src/auto/net_time_provider.rs b/gstreamer-net/src/auto/net_time_provider.rs
index bb496d569..7a2480311 100644
--- a/gstreamer-net/src/auto/net_time_provider.rs
+++ b/gstreamer-net/src/auto/net_time_provider.rs
@@ -5,7 +5,7 @@
 use glib::GString;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-net/src/auto/ptp_clock.rs b/gstreamer-net/src/auto/ptp_clock.rs
index f99d79b47..5f697ff93 100644
--- a/gstreamer-net/src/auto/ptp_clock.rs
+++ b/gstreamer-net/src/auto/ptp_clock.rs
@@ -4,7 +4,7 @@
 
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-net/src/auto/versions.txt b/gstreamer-net/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-net/src/auto/versions.txt
+++ b/gstreamer-net/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-pbutils/src/auto/discoverer.rs b/gstreamer-pbutils/src/auto/discoverer.rs
index 4771f74e0..ce6f53cb6 100644
--- a/gstreamer-pbutils/src/auto/discoverer.rs
+++ b/gstreamer-pbutils/src/auto/discoverer.rs
@@ -9,7 +9,7 @@ use glib;
 use glib::StaticType;
 #[cfg(any(feature = "v1_16", feature = "dox"))]
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-pbutils/src/auto/encoding_container_profile.rs b/gstreamer-pbutils/src/auto/encoding_container_profile.rs
index 2e8e8c4ab..e202edcd6 100644
--- a/gstreamer-pbutils/src/auto/encoding_container_profile.rs
+++ b/gstreamer-pbutils/src/auto/encoding_container_profile.rs
@@ -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 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))
-        }
-    }
-}
diff --git a/gstreamer-pbutils/src/auto/mod.rs b/gstreamer-pbutils/src/auto/mod.rs
index 5207dd444..b1af084b2 100644
--- a/gstreamer-pbutils/src/auto/mod.rs
+++ b/gstreamer-pbutils/src/auto/mod.rs
@@ -28,8 +28,7 @@ mod encoding_audio_profile;
 pub use self::encoding_audio_profile::{EncodingAudioProfile, EncodingAudioProfileClass};
 
 mod encoding_container_profile;
-pub use self::encoding_container_profile::{EncodingContainerProfile, EncodingContainerProfileClass, NONE_ENCODING_CONTAINER_PROFILE};
-pub use self::encoding_container_profile::EncodingContainerProfileExt;
+pub use self::encoding_container_profile::{EncodingContainerProfile, EncodingContainerProfileClass};
 
 mod encoding_profile;
 pub use self::encoding_profile::{EncodingProfile, EncodingProfileClass, NONE_ENCODING_PROFILE};
@@ -52,6 +51,5 @@ pub mod functions;
 #[doc(hidden)]
 pub mod traits {
     pub use super::DiscovererStreamInfoExt;
-    pub use super::EncodingContainerProfileExt;
     pub use super::EncodingProfileExt;
 }
diff --git a/gstreamer-pbutils/src/auto/versions.txt b/gstreamer-pbutils/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-pbutils/src/auto/versions.txt
+++ b/gstreamer-pbutils/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-player/src/auto/player.rs b/gstreamer-player/src/auto/player.rs
index b606f3d6e..c69e7d4f4 100644
--- a/gstreamer-player/src/auto/player.rs
+++ b/gstreamer-player/src/auto/player.rs
@@ -15,7 +15,7 @@ use glib;
 use glib::GString;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 use glib::translate::*;
@@ -362,6 +362,10 @@ impl Player {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-player/src/auto/player_gmain_context_signal_dispatcher.rs b/gstreamer-player/src/auto/player_gmain_context_signal_dispatcher.rs
index e2dbf9afb..028439c25 100644
--- a/gstreamer-player/src/auto/player_gmain_context_signal_dispatcher.rs
+++ b/gstreamer-player/src/auto/player_gmain_context_signal_dispatcher.rs
@@ -6,7 +6,7 @@ use PlayerSignalDispatcher;
 use glib;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::translate::*;
 use gobject_sys;
 use gst_player_sys;
diff --git a/gstreamer-player/src/auto/player_video_overlay_video_renderer.rs b/gstreamer-player/src/auto/player_video_overlay_video_renderer.rs
index f3e5cc8b1..afe1dc4e6 100644
--- a/gstreamer-player/src/auto/player_video_overlay_video_renderer.rs
+++ b/gstreamer-player/src/auto/player_video_overlay_video_renderer.rs
@@ -5,7 +5,7 @@
 use PlayerVideoRenderer;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-player/src/auto/versions.txt b/gstreamer-player/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-player/src/auto/versions.txt
+++ b/gstreamer-player/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_auth.rs b/gstreamer-rtsp-server/src/auto/rtsp_auth.rs
index 289122dc9..7c215d6da 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_auth.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_auth.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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()
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_client.rs b/gstreamer-rtsp-server/src/auto/rtsp_client.rs
index 914eb266e..359520a26 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_client.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_client.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_media.rs b/gstreamer-rtsp-server/src/auto/rtsp_media.rs
index a94cc39ab..bfacc38cf 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_media.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_media.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_media_factory.rs b/gstreamer-rtsp-server/src/auto/rtsp_media_factory.rs
index 11f70b4db..5ecc6d27c 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_media_factory.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_media_factory.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_media_factory_uri.rs b/gstreamer-rtsp-server/src/auto/rtsp_media_factory_uri.rs
index 752acfcba..769e3731a 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_media_factory_uri.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_media_factory_uri.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_server.rs b/gstreamer-rtsp-server/src/auto/rtsp_server.rs
index 8e0c45e75..8c6073ea6 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_server.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_server.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_session.rs b/gstreamer-rtsp-server/src/auto/rtsp_session.rs
index 6d36d7c67..0403b2825 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_session.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_session.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_session_pool.rs b/gstreamer-rtsp-server/src/auto/rtsp_session_pool.rs
index 308a966f8..d7e7dec9d 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_session_pool.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_session_pool.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_stream.rs b/gstreamer-rtsp-server/src/auto/rtsp_stream.rs
index 3d84e1ae1..b3201bb55 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_stream.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_stream.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/rtsp_thread_pool.rs b/gstreamer-rtsp-server/src/auto/rtsp_thread_pool.rs
index 4a1fcdcbc..bf80eb2f8 100644
--- a/gstreamer-rtsp-server/src/auto/rtsp_thread_pool.rs
+++ b/gstreamer-rtsp-server/src/auto/rtsp_thread_pool.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-rtsp-server/src/auto/versions.txt b/gstreamer-rtsp-server/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-rtsp-server/src/auto/versions.txt
+++ b/gstreamer-rtsp-server/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-rtsp/src/auto/versions.txt b/gstreamer-rtsp/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-rtsp/src/auto/versions.txt
+++ b/gstreamer-rtsp/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-sdp/src/auto/versions.txt b/gstreamer-sdp/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-sdp/src/auto/versions.txt
+++ b/gstreamer-sdp/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-video/src/auto/versions.txt b/gstreamer-video/src/auto/versions.txt
index ef8c963e8..479278448 100644
--- a/gstreamer-video/src/auto/versions.txt
+++ b/gstreamer-video/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-video/src/auto/video_encoder.rs b/gstreamer-video/src/auto/video_encoder.rs
index f44130ac6..0923a32b1 100644
--- a/gstreamer-video/src/auto/video_encoder.rs
+++ b/gstreamer-video/src/auto/video_encoder.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer-webrtc/src/auto/versions.txt b/gstreamer-webrtc/src/auto/versions.txt
index a9e0ccc5d..479278448 100644
--- a/gstreamer-webrtc/src/auto/versions.txt
+++ b/gstreamer-webrtc/src/auto/versions.txt
@@ -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 @ ???)
diff --git a/gstreamer-webrtc/src/auto/web_rtcdtls_transport.rs b/gstreamer-webrtc/src/auto/web_rtcdtls_transport.rs
index c9503a4bb..4381437b2 100644
--- a/gstreamer-webrtc/src/auto/web_rtcdtls_transport.rs
+++ b/gstreamer-webrtc/src/auto/web_rtcdtls_transport.rs
@@ -7,7 +7,7 @@ use WebRTCICETransport;
 use glib::GString;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-webrtc/src/auto/web_rtcice_transport.rs b/gstreamer-webrtc/src/auto/web_rtcice_transport.rs
index 6ec3497a6..37c741851 100644
--- a/gstreamer-webrtc/src/auto/web_rtcice_transport.rs
+++ b/gstreamer-webrtc/src/auto/web_rtcice_transport.rs
@@ -8,7 +8,7 @@ use WebRTCICEGatheringState;
 use glib::GString;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             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 _,
@@ -93,6 +101,10 @@ impl WebRTCICETransport {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer-webrtc/src/auto/web_rtcrtp_transceiver.rs b/gstreamer-webrtc/src/auto/web_rtcrtp_transceiver.rs
index ed9da1625..a7772c767 100644
--- a/gstreamer-webrtc/src/auto/web_rtcrtp_transceiver.rs
+++ b/gstreamer-webrtc/src/auto/web_rtcrtp_transceiver.rs
@@ -6,7 +6,7 @@ use WebRTCRTPReceiver;
 use WebRTCRTPSender;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::translate::*;
 use gobject_sys;
 use gst_web_rtc_sys;
diff --git a/gstreamer/src/auto/allocator.rs b/gstreamer/src/auto/allocator.rs
index 6f1a5c6f5..3a204748b 100644
--- a/gstreamer/src/auto/allocator.rs
+++ b/gstreamer/src/auto/allocator.rs
@@ -37,7 +37,7 @@ unsafe impl Sync for Allocator {}
 pub const NONE_ALLOCATOR: Option<&Allocator> = None;
 
 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);
 
@@ -45,7 +45,7 @@ pub trait AllocatorExt: 'static {
 }
 
 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() }
     //}
 
diff --git a/gstreamer/src/auto/bin.rs b/gstreamer/src/auto/bin.rs
index 43e304fd1..d804147a0 100644
--- a/gstreamer/src/auto/bin.rs
+++ b/gstreamer/src/auto/bin.rs
@@ -232,6 +232,12 @@ impl<O: IsA<Bin>> GstBinExt for O {
 
     #[cfg(any(feature = "v1_10", feature = "dox"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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"))]
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer/src/auto/bus.rs b/gstreamer/src/auto/bus.rs
index 00bbefa0c..44439b988 100644
--- a/gstreamer/src/auto/bus.rs
+++ b/gstreamer/src/auto/bus.rs
@@ -6,7 +6,7 @@ use ClockTime;
 use Message;
 use Object;
 use glib;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 use glib::translate::*;
@@ -111,6 +111,10 @@ impl Bus {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer/src/auto/child_proxy.rs b/gstreamer/src/auto/child_proxy.rs
index 8f3d5ea8b..0e7399f5d 100644
--- a/gstreamer/src/auto/child_proxy.rs
+++ b/gstreamer/src/auto/child_proxy.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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))
-}
diff --git a/gstreamer/src/auto/clock.rs b/gstreamer/src/auto/clock.rs
index d48d586d7..e7945103d 100644
--- a/gstreamer/src/auto/clock.rs
+++ b/gstreamer/src/auto/clock.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer/src/auto/device.rs b/gstreamer/src/auto/device.rs
index a4a2d22df..0d54740c4 100644
--- a/gstreamer/src/auto/device.rs
+++ b/gstreamer/src/auto/device.rs
@@ -101,6 +101,12 @@ impl<O: IsA<Device>> DeviceExt for O {
     }
 
     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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer/src/auto/device_monitor.rs b/gstreamer/src/auto/device_monitor.rs
index f098fb384..3a57f5044 100644
--- a/gstreamer/src/auto/device_monitor.rs
+++ b/gstreamer/src/auto/device_monitor.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer/src/auto/device_provider.rs b/gstreamer/src/auto/device_provider.rs
index fe604c7c8..d25247530 100644
--- a/gstreamer/src/auto/device_provider.rs
+++ b/gstreamer/src/auto/device_provider.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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))
-}
diff --git a/gstreamer/src/auto/element.rs b/gstreamer/src/auto/element.rs
index 53ed21549..e44db0c06 100644
--- a/gstreamer/src/auto/element.rs
+++ b/gstreamer/src/auto/element.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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))
-}
diff --git a/gstreamer/src/auto/object.rs b/gstreamer/src/auto/object.rs
index d73e9e0d6..e521fec6b 100644
--- a/gstreamer/src/auto/object.rs
+++ b/gstreamer/src/auto/object.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer/src/auto/pad.rs b/gstreamer/src/auto/pad.rs
index 5723e9b4d..dc9e0bd36 100644
--- a/gstreamer/src/auto/pad.rs
+++ b/gstreamer/src/auto/pad.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer/src/auto/pad_template.rs b/gstreamer/src/auto/pad_template.rs
index b3aa9f3fb..6585c4681 100644
--- a/gstreamer/src/auto/pad_template.rs
+++ b/gstreamer/src/auto/pad_template.rs
@@ -13,7 +13,7 @@ use glib::GString;
 use glib::StaticType;
 use glib::Value;
 use glib::object::IsA;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer/src/auto/pipeline.rs b/gstreamer/src/auto/pipeline.rs
index f5e0a0919..71af1adb4 100644
--- a/gstreamer/src/auto/pipeline.rs
+++ b/gstreamer/src/auto/pipeline.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer/src/auto/registry.rs b/gstreamer/src/auto/registry.rs
index b9ab64ad4..bb03cbe27 100644
--- a/gstreamer/src/auto/registry.rs
+++ b/gstreamer/src/auto/registry.rs
@@ -7,7 +7,7 @@ use Plugin;
 use PluginFeature;
 use glib;
 use glib::object::IsA;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer/src/auto/stream.rs b/gstreamer/src/auto/stream.rs
index fa6499e29..f4dce8de0 100644
--- a/gstreamer/src/auto/stream.rs
+++ b/gstreamer/src/auto/stream.rs
@@ -10,7 +10,7 @@ use TagList;
 use glib::GString;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer/src/auto/stream_collection.rs b/gstreamer/src/auto/stream_collection.rs
index 0d01384ce..1adef034c 100644
--- a/gstreamer/src/auto/stream_collection.rs
+++ b/gstreamer/src/auto/stream_collection.rs
@@ -8,7 +8,7 @@ use Stream;
 use glib::GString;
 use glib::StaticType;
 use glib::Value;
-use glib::object::ObjectType;
+use glib::object::ObjectType as ObjectType_;
 use glib::signal::SignalHandlerId;
 use glib::signal::connect_raw;
 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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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 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))
-}
diff --git a/gstreamer/src/auto/system_clock.rs b/gstreamer/src/auto/system_clock.rs
index 1c2cee3c0..5f2323242 100644
--- a/gstreamer/src/auto/system_clock.rs
+++ b/gstreamer/src/auto/system_clock.rs
@@ -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 {
+        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 {
             let f: Box_<F> = Box_::new(f);
             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())
-}
diff --git a/gstreamer/src/auto/versions.txt b/gstreamer/src/auto/versions.txt
index 90eaf67a0..479278448 100644
--- a/gstreamer/src/auto/versions.txt
+++ b/gstreamer/src/auto/versions.txt
@@ -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 @ ???)