Regenerate everything with latest gir

gstreamer-app/src/auto/app_sink.rs

@@ -227,41 +227,41 @@ unsafe impl Send for AppSink {}
 unsafe impl Sync for AppSink {}
 
 unsafe extern "C" fn eos_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut ffi::GstAppSink, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-app/src/auto/app_src.rs

@@ -343,81 +343,81 @@ 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 ffi::GstAppSrc, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, length: libc::c_uint, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, offset: u64, f: glib_ffi::gpointer) -> glib_ffi::gboolean {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstAppSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-app/src/auto/versions.txt

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

gstreamer-audio/src/auto/stream_volume.rs

@@ -93,12 +93,12 @@ impl<O: IsA<StreamVolume>> StreamVolumeExt for O {
 
 unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstStreamVolume, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<StreamVolume> {
-    let f: &F = transmute(f);
+    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 ffi::GstStreamVolume, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<StreamVolume> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&StreamVolume::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-audio/src/auto/versions.txt

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

gstreamer-base/src/auto/aggregator.rs

@@ -124,12 +124,12 @@ 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 ffi::GstAggregator, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Aggregator> {
-    let f: &F = transmute(f);
+    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 ffi::GstAggregator, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Aggregator> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Aggregator::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-base/src/auto/base_sink.rs

@@ -425,66 +425,66 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
 
 unsafe extern "C" fn notify_async_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSink> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&BaseSink::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-base/src/auto/base_src.rs

@@ -243,24 +243,24 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
 
 unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstBaseSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSrc> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSrc> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSrc> {
-    let f: &F = transmute(f);
+    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 ffi::GstBaseSrc, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseSrc> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-base/src/auto/base_transform.rs

@@ -174,6 +174,6 @@ impl<O: IsA<BaseTransform>> BaseTransformExt for O {
 
 unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstBaseTransform, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<BaseTransform> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&BaseTransform::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-base/src/auto/versions.txt

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

gstreamer-check/src/auto/test_clock.rs

@@ -45,12 +45,9 @@ impl TestClock {
         }
     }
 
-    pub fn crank(&self) -> Result<(), glib::BoolError> {
+    pub fn crank(&self) -> bool {
         unsafe {
-            glib_result_from_gboolean!(
+            from_glib(ffi::gst_test_clock_crank(self.to_glib_none().0))
-                ffi::gst_test_clock_crank(self.to_glib_none().0),
-                "Failed to crank"
-            )
         }
     }
 
@@ -147,6 +144,6 @@ 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 ffi::GstTestClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-check/src/auto/versions.txt

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

gstreamer-editing-services/src/auto/asset.rs

@@ -200,12 +200,12 @@ impl<O: IsA<Asset>> AssetExt for O {
 
 unsafe extern "C" fn notify_proxy_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESAsset, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Asset> {
-    let f: &F = transmute(f);
+    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 ffi::GESAsset, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Asset> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Asset::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/clip.rs

@@ -164,12 +164,12 @@ impl<O: IsA<Clip>> ClipExt for O {
 
 unsafe extern "C" fn notify_layer_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESClip, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Clip> {
-    let f: &F = transmute(f);
+    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 ffi::GESClip, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Clip> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Clip::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/container.rs

@@ -126,18 +126,18 @@ impl<O: IsA<Container>> GESContainerExt for O {
 
 unsafe extern "C" fn child_added_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(this: *mut ffi::GESContainer, element: *mut ffi::GESTimelineElement, f: glib_ffi::gpointer)
 where P: IsA<Container> {
-    let f: &F = transmute(f);
+    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 ffi::GESContainer, element: *mut ffi::GESTimelineElement, f: glib_ffi::gpointer)
 where P: IsA<Container> {
-    let f: &F = transmute(f);
+    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 ffi::GESContainer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Container> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Container::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/group.rs

@@ -189,30 +189,30 @@ impl<O: IsA<Group>> GroupExt for O {
 
 unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESGroup, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Group> {
-    let f: &F = transmute(f);
+    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 ffi::GESGroup, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Group> {
-    let f: &F = transmute(f);
+    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 ffi::GESGroup, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Group> {
-    let f: &F = transmute(f);
+    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 ffi::GESGroup, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Group> {
-    let f: &F = transmute(f);
+    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 ffi::GESGroup, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Group> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Group::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/layer.rs

@@ -196,24 +196,24 @@ impl<O: IsA<Layer>> LayerExt for O {
 
 unsafe extern "C" fn clip_added_trampoline<P, F: Fn(&P, &Clip) + 'static>(this: *mut ffi::GESLayer, clip: *mut ffi::GESClip, f: glib_ffi::gpointer)
 where P: IsA<Layer> {
-    let f: &F = transmute(f);
+    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 ffi::GESLayer, clip: *mut ffi::GESClip, f: glib_ffi::gpointer)
 where P: IsA<Layer> {
-    let f: &F = transmute(f);
+    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 ffi::GESLayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Layer> {
-    let f: &F = transmute(f);
+    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 ffi::GESLayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Layer> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Layer::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/pipeline.rs

@@ -285,36 +285,36 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
 
 unsafe extern "C" fn notify_audio_filter_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Pipeline::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/project.rs

@@ -211,36 +211,36 @@ impl<O: IsA<Project>> ProjectExt for O {
 
 unsafe extern "C" fn asset_added_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ffi::GESProject, asset: *mut ffi::GESAsset, f: glib_ffi::gpointer)
 where P: IsA<Project> {
-    let f: &F = transmute(f);
+    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 ffi::GESProject, asset: *mut ffi::GESAsset, f: glib_ffi::gpointer)
 where P: IsA<Project> {
-    let f: &F = transmute(f);
+    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 ffi::GESProject, asset: *mut ffi::GESAsset, f: glib_ffi::gpointer)
 where P: IsA<Project> {
-    let f: &F = transmute(f);
+    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 ffi::GESProject, error: *mut glib_ffi::GError, id: *mut libc::c_char, extractable_type: glib_ffi::GType, f: glib_ffi::gpointer)
 where P: IsA<Project> {
-    let f: &F = transmute(f);
+    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 ffi::GESProject, timeline: *mut ffi::GESTimeline, f: glib_ffi::gpointer)
 where P: IsA<Project> {
-    let f: &F = transmute(f);
+    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 ffi::GESProject, error: *mut glib_ffi::GError, wrong_asset: *mut ffi::GESAsset, f: glib_ffi::gpointer) -> *mut libc::c_char
 where P: IsA<Project> {
-    let f: &F = transmute(f);
+    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()
 }

gstreamer-editing-services/src/auto/timeline.rs

@@ -389,66 +389,66 @@ impl<O: IsA<Timeline>> TimelineExt for O {
 
 unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESTimeline, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimeline, group: *mut ffi::GESGroup, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimeline, layer: *mut ffi::GESLayer, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimeline, layer: *mut ffi::GESLayer, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimeline, object: *mut ffi::GESTrackElement, p0: *mut ffi::GESTrackElement, p1: u64, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object), &from_glib_borrow(p0), p1)
 }
 
 unsafe extern "C" fn snapping_started_trampoline<P, F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static>(this: *mut ffi::GESTimeline, object: *mut ffi::GESTrackElement, p0: *mut ffi::GESTrackElement, p1: u64, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object), &from_glib_borrow(p0), p1)
 }
 
 unsafe extern "C" fn track_added_trampoline<P, F: Fn(&P, &Track) + 'static>(this: *mut ffi::GESTimeline, track: *mut ffi::GESTrack, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimeline, track: *mut ffi::GESTrack, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Timeline> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Timeline::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/timeline_element.rs

@@ -442,54 +442,54 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
 
 unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTimelineElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TimelineElement> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/track.rs

@@ -229,36 +229,36 @@ impl<O: IsA<Track>> GESTrackExt for O {
 
 unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESTrack, f: glib_ffi::gpointer)
 where P: IsA<Track> {
-    let f: &F = transmute(f);
+    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 ffi::GESTrack, effect: *mut ffi::GESTrackElement, f: glib_ffi::gpointer)
 where P: IsA<Track> {
-    let f: &F = transmute(f);
+    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 ffi::GESTrack, effect: *mut ffi::GESTrackElement, f: glib_ffi::gpointer)
 where P: IsA<Track> {
-    let f: &F = transmute(f);
+    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 ffi::GESTrack, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Track> {
-    let f: &F = transmute(f);
+    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 ffi::GESTrack, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Track> {
-    let f: &F = transmute(f);
+    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 ffi::GESTrack, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Track> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Track::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/track_element.rs

@@ -205,18 +205,18 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
 
 unsafe extern "C" fn notify_active_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESTrackElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TrackElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTrackElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TrackElement> {
-    let f: &F = transmute(f);
+    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 ffi::GESTrackElement, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<TrackElement> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&TrackElement::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/uri_clip.rs

@@ -135,18 +135,18 @@ impl<O: IsA<UriClip>> UriClipExt for O {
 
 unsafe extern "C" fn notify_is_image_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESUriClip, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<UriClip> {
-    let f: &F = transmute(f);
+    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 ffi::GESUriClip, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<UriClip> {
-    let f: &F = transmute(f);
+    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 ffi::GESUriClip, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<UriClip> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&UriClip::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/uri_clip_asset.rs

@@ -101,6 +101,6 @@ impl<O: IsA<UriClipAsset>> UriClipAssetExt for O {
 
 unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GESUriClipAsset, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<UriClipAsset> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&UriClipAsset::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-editing-services/src/auto/versions.txt

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

gstreamer-gl/src/auto/gl_base_filter.rs

@@ -56,6 +56,6 @@ impl<O: IsA<GLBaseFilter>> GLBaseFilterExt for O {
 
 unsafe extern "C" fn notify_context_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstGLBaseFilter, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<GLBaseFilter> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&GLBaseFilter::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-gl/src/auto/gl_display.rs

@@ -131,6 +131,6 @@ 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 ffi::GstGLDisplay, context: *mut ffi::GstGLContext, f: glib_ffi::gpointer) -> *mut ffi::GstGLContext
 where P: IsA<GLDisplay> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&GLDisplay::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(context)).to_glib_full()
 }

gstreamer-gl/src/auto/gl_framebuffer.rs

@@ -43,7 +43,7 @@ pub trait GLFramebufferExt: 'static {
 
     fn bind(&self);
 
-    //fn draw_to_texture(&self, mem: /*Ignored*/&mut GLMemory, func: /*Unimplemented*/Fn(/*Unimplemented*/Fundamental: Pointer) -> bool, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> bool;
+    //fn draw_to_texture(&self, mem: /*Ignored*/&mut GLMemory, func: /*Unimplemented*/FnMut(/*Unimplemented*/Fundamental: Pointer) -> bool, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> bool;
 
     fn get_effective_dimensions(&self) -> (u32, u32);
 
@@ -61,7 +61,7 @@ impl<O: IsA<GLFramebuffer>> GLFramebufferExt for O {
         }
     }
 
-    //fn draw_to_texture(&self, mem: /*Ignored*/&mut GLMemory, func: /*Unimplemented*/Fn(/*Unimplemented*/Fundamental: Pointer) -> bool, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> bool {
+    //fn draw_to_texture(&self, mem: /*Ignored*/&mut GLMemory, func: /*Unimplemented*/FnMut(/*Unimplemented*/Fundamental: Pointer) -> bool, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> bool {
     //    unsafe { TODO: call ffi::gst_gl_framebuffer_draw_to_texture() }
     //}
 

gstreamer-gl/src/auto/gl_shader.rs

@@ -267,6 +267,6 @@ 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 ffi::GstGLShader, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-gl/src/auto/gl_view_convert.rs

@@ -187,26 +187,26 @@ 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 ffi::GstGLViewConvert, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstGLViewConvert, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstGLViewConvert, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstGLViewConvert, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstGLViewConvert, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-gl/src/auto/gl_window.rs

@@ -174,12 +174,12 @@ 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 ffi::GstGLWindow, id: *mut libc::c_char, key: *mut libc::c_char, f: glib_ffi::gpointer)
 where P: IsA<GLWindow> {
-    let f: &F = transmute(f);
+    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 ffi::GstGLWindow, id: *mut libc::c_char, button: libc::c_int, x: libc::c_double, y: libc::c_double, f: glib_ffi::gpointer)
 where P: IsA<GLWindow> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&GLWindow::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(id), button, x, y)
 }

gstreamer-gl/src/auto/versions.txt

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

gstreamer-net/src/auto/net_client_clock.rs

@@ -189,36 +189,36 @@ 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 ffi::GstNetClientClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstNetClientClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstNetClientClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstNetClientClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstNetClientClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstNetClientClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstNetClientClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-net/src/auto/net_time_provider.rs

@@ -98,11 +98,11 @@ 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 ffi::GstNetTimeProvider, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstNetTimeProvider, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-net/src/auto/ptp_clock.rs

@@ -85,16 +85,16 @@ 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 ffi::GstPtpClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPtpClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPtpClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-net/src/auto/versions.txt

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

gstreamer-pbutils/src/auto/discoverer.rs

@@ -98,21 +98,21 @@ 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 ffi::GstDiscoverer, info: *mut ffi::GstDiscovererInfo, error: *mut glib_ffi::GError, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this), &from_glib_borrow(info), &from_glib_borrow(error))
 }
 
 unsafe extern "C" fn finished_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut ffi::GstDiscoverer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstDiscoverer, source: *mut gst_ffi::GstElement, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstDiscoverer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-pbutils/src/auto/versions.txt

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

gstreamer-player/src/auto/player.rs

@@ -555,126 +555,126 @@ unsafe impl Send for Player {}
 unsafe impl Sync for Player {}
 
 unsafe extern "C" fn buffering_trampoline<F: Fn(&Player, i32) + Send + 'static>(this: *mut ffi::GstPlayer, object: libc::c_int, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, object: *mut glib_ffi::GError, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, object: *mut ffi::GstPlayerMediaInfo, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, object: ffi::GstPlayerState, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, object: *mut libc::c_char, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, object: libc::c_int, p0: libc::c_int, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, object: *mut glib_ffi::GError, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-player/src/auto/player_video_overlay_video_renderer.rs

@@ -102,11 +102,11 @@ 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 ffi::GstPlayerVideoOverlayVideoRenderer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstPlayerVideoOverlayVideoRenderer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-player/src/auto/versions.txt

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

gstreamer-rtsp-server/src/auto/rtsp_auth.rs

@@ -191,6 +191,6 @@ 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 ffi::GstRTSPAuth, connection: *mut gio_ffi::GTlsConnection, peer_cert: *mut gio_ffi::GTlsCertificate, errors: gio_ffi::GTlsCertificateFlags, f: glib_ffi::gpointer) -> glib_ffi::gboolean
 where P: IsA<RTSPAuth> {
-    let f: &F = transmute(f);
+    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()
 }

gstreamer-rtsp-server/src/auto/rtsp_client.rs

@@ -70,7 +70,7 @@ pub trait RTSPClientExt: 'static {
 
     //fn send_message<'a, P: IsA<RTSPSession> + 'a, Q: Into<Option<&'a P>>>(&self, session: Q, message: /*Ignored*/&mut gst_rtsp::RTSPMessage) -> gst_rtsp::RTSPResult;
 
-    //fn session_filter(&self, func: /*Unimplemented*/Fn(&RTSPClient, &RTSPSession) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSession>;
+    //fn session_filter(&self, func: /*Unimplemented*/FnMut(&RTSPClient, &RTSPSession) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSession>;
 
     fn set_auth<'a, P: IsA<RTSPAuth> + 'a, Q: Into<Option<&'a P>>>(&self, auth: Q);
 
@@ -198,7 +198,7 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
     //    unsafe { TODO: call ffi::gst_rtsp_client_send_message() }
     //}
 
-    //fn session_filter(&self, func: /*Unimplemented*/Fn(&RTSPClient, &RTSPSession) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSession> {
+    //fn session_filter(&self, func: /*Unimplemented*/FnMut(&RTSPClient, &RTSPSession) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSession> {
     //    unsafe { TODO: call ffi::gst_rtsp_client_session_filter() }
     //}
 
@@ -481,166 +481,166 @@ impl<O: IsA<RTSPClient>> RTSPClientExt for O {
 
 unsafe extern "C" fn announce_request_trampoline<P, F: Fn(&P, &RTSPContext) + Send + Sync + 'static>(this: *mut ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, object: *mut ffi::GstRTSPSession, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer) -> gst_rtsp_ffi::GstRTSPStatusCode
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, ctx: *mut ffi::GstRTSPContext, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPClient, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPClient> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPClient::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/rtsp_media.rs

@@ -719,108 +719,108 @@ impl<O: IsA<RTSPMedia>> RTSPMediaExt for O {
 
 unsafe extern "C" fn new_state_trampoline<P, F: Fn(&P, i32) + Send + Sync + 'static>(this: *mut ffi::GstRTSPMedia, object: libc::c_int, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, object: *mut ffi::GstRTSPStream, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, object: *mut ffi::GstRTSPStream, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, object: libc::c_int, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMedia, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMedia> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPMedia::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/rtsp_media_factory.rs

@@ -511,78 +511,78 @@ impl<O: IsA<RTSPMediaFactory>> RTSPMediaFactoryExt for O {
 
 unsafe extern "C" fn media_configure_trampoline<P, F: Fn(&P, &RTSPMedia) + Send + Sync + 'static>(this: *mut ffi::GstRTSPMediaFactory, object: *mut ffi::GstRTSPMedia, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, object: *mut ffi::GstRTSPMedia, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object))
 }
 
 unsafe extern "C" fn notify_buffer_size_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactory, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactory> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPMediaFactory::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/rtsp_media_factory_uri.rs

@@ -105,12 +105,12 @@ impl<O: IsA<RTSPMediaFactoryURI>> RTSPMediaFactoryURIExt for O {
 
 unsafe extern "C" fn notify_uri_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstRTSPMediaFactoryURI, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactoryURI> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPMediaFactoryURI, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPMediaFactoryURI> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPMediaFactoryURI::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/rtsp_server.rs

@@ -58,7 +58,7 @@ unsafe impl Sync for RTSPServer {}
 pub const NONE_RTSP_SERVER: Option<&RTSPServer> = None;
 
 pub trait RTSPServerExt: 'static {
-    //fn client_filter(&self, func: /*Unimplemented*/Fn(&RTSPServer, &RTSPClient) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPClient>;
+    //fn client_filter(&self, func: /*Unimplemented*/FnMut(&RTSPServer, &RTSPClient) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPClient>;
 
     fn create_socket<'a, P: IsA<gio::Cancellable> + 'a, Q: Into<Option<&'a P>>>(&self, cancellable: Q) -> Result<gio::Socket, Error>;
 
@@ -112,7 +112,7 @@ pub trait RTSPServerExt: 'static {
 }
 
 impl<O: IsA<RTSPServer>> RTSPServerExt for O {
-    //fn client_filter(&self, func: /*Unimplemented*/Fn(&RTSPServer, &RTSPClient) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPClient> {
+    //fn client_filter(&self, func: /*Unimplemented*/FnMut(&RTSPServer, &RTSPClient) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPClient> {
     //    unsafe { TODO: call ffi::gst_rtsp_server_client_filter() }
     //}
 
@@ -294,42 +294,42 @@ impl<O: IsA<RTSPServer>> RTSPServerExt for O {
 
 unsafe extern "C" fn client_connected_trampoline<P, F: Fn(&P, &RTSPClient) + Send + Sync + 'static>(this: *mut ffi::GstRTSPServer, object: *mut ffi::GstRTSPClient, f: glib_ffi::gpointer)
 where P: IsA<RTSPServer> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPServer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPServer> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPServer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPServer> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPServer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPServer> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPServer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPServer> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPServer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPServer> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPServer, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPServer> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPServer::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/rtsp_session.rs

@@ -44,7 +44,7 @@ pub const NONE_RTSP_SESSION: Option<&RTSPSession> = None;
 pub trait RTSPSessionExt: 'static {
     fn allow_expire(&self);
 
-    //fn filter(&self, func: /*Unimplemented*/Fn(&RTSPSession, &RTSPSessionMedia) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSessionMedia>;
+    //fn filter(&self, func: /*Unimplemented*/FnMut(&RTSPSession, &RTSPSessionMedia) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSessionMedia>;
 
     fn get_header(&self) -> Option<GString>;
 
@@ -88,7 +88,7 @@ impl<O: IsA<RTSPSession>> RTSPSessionExt for O {
         }
     }
 
-    //fn filter(&self, func: /*Unimplemented*/Fn(&RTSPSession, &RTSPSessionMedia) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSessionMedia> {
+    //fn filter(&self, func: /*Unimplemented*/FnMut(&RTSPSession, &RTSPSessionMedia) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSessionMedia> {
     //    unsafe { TODO: call ffi::gst_rtsp_session_filter() }
     //}
 
@@ -201,12 +201,12 @@ impl<O: IsA<RTSPSession>> RTSPSessionExt for O {
 
 unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstRTSPSession, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPSession> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPSession, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPSession> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPSession::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/rtsp_session_pool.rs

@@ -47,7 +47,7 @@ pub trait RTSPSessionPoolExt: 'static {
 
     fn create(&self) -> Option<RTSPSession>;
 
-    //fn filter(&self, func: /*Unimplemented*/Fn(&RTSPSessionPool, &RTSPSession) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSession>;
+    //fn filter(&self, func: /*Unimplemented*/FnMut(&RTSPSessionPool, &RTSPSession) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSession>;
 
     fn find(&self, sessionid: &str) -> Option<RTSPSession>;
 
@@ -77,7 +77,7 @@ impl<O: IsA<RTSPSessionPool>> RTSPSessionPoolExt for O {
         }
     }
 
-    //fn filter(&self, func: /*Unimplemented*/Fn(&RTSPSessionPool, &RTSPSession) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSession> {
+    //fn filter(&self, func: /*Unimplemented*/FnMut(&RTSPSessionPool, &RTSPSession) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPSession> {
     //    unsafe { TODO: call ffi::gst_rtsp_session_pool_filter() }
     //}
 
@@ -130,12 +130,12 @@ impl<O: IsA<RTSPSessionPool>> RTSPSessionPoolExt for O {
 
 unsafe extern "C" fn session_removed_trampoline<P, F: Fn(&P, &RTSPSession) + Send + Sync + 'static>(this: *mut ffi::GstRTSPSessionPool, object: *mut ffi::GstRTSPSession, f: glib_ffi::gpointer)
 where P: IsA<RTSPSessionPool> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPSessionPool, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPSessionPool> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPSessionPool::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/rtsp_stream.rs

@@ -164,7 +164,7 @@ pub trait RTSPStreamExt: 'static {
 
     fn set_seqnum_offset(&self, seqnum: u16);
 
-    //fn transport_filter(&self, func: /*Unimplemented*/Fn(&RTSPStream, &RTSPStreamTransport) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPStreamTransport>;
+    //fn transport_filter(&self, func: /*Unimplemented*/FnMut(&RTSPStream, &RTSPStreamTransport) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPStreamTransport>;
 
     fn unblock_linked(&self) -> Result<(), glib::error::BoolError>;
 
@@ -539,7 +539,7 @@ impl<O: IsA<RTSPStream>> RTSPStreamExt for O {
         }
     }
 
-    //fn transport_filter(&self, func: /*Unimplemented*/Fn(&RTSPStream, &RTSPStreamTransport) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPStreamTransport> {
+    //fn transport_filter(&self, func: /*Unimplemented*/FnMut(&RTSPStream, &RTSPStreamTransport) -> /*Ignored*/RTSPFilterResult, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Vec<RTSPStreamTransport> {
     //    unsafe { TODO: call ffi::gst_rtsp_stream_transport_filter() }
     //}
 
@@ -599,30 +599,30 @@ 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 ffi::GstRTSPStream, object: *mut gst_ffi::GstElement, f: glib_ffi::gpointer)
 where P: IsA<RTSPStream> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPStream, object: *mut gst_ffi::GstElement, f: glib_ffi::gpointer)
 where P: IsA<RTSPStream> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPStream, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPStream> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPStream, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPStream> {
-    let f: &F = transmute(f);
+    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 ffi::GstRTSPStream, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPStream> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPStream::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/rtsp_thread_pool.rs

@@ -85,6 +85,6 @@ impl<O: IsA<RTSPThreadPool>> RTSPThreadPoolExt for O {
 
 unsafe extern "C" fn notify_max_threads_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstRTSPThreadPool, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<RTSPThreadPool> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&RTSPThreadPool::from_glib_borrow(this).unsafe_cast())
 }

gstreamer-rtsp-server/src/auto/versions.txt

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

gstreamer-rtsp/src/auto/versions.txt

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

gstreamer-sdp/src/auto/versions.txt

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

gstreamer-video/src/auto/versions.txt

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

gstreamer-webrtc/src/auto/versions.txt

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

gstreamer-webrtc/src/auto/web_rtcdtls_transport.rs

@@ -153,26 +153,26 @@ 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 ffi::GstWebRTCDTLSTransport, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstWebRTCDTLSTransport, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstWebRTCDTLSTransport, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstWebRTCDTLSTransport, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstWebRTCDTLSTransport, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer-webrtc/src/auto/web_rtcice_transport.rs

@@ -113,21 +113,21 @@ 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 ffi::GstWebRTCICETransport, object: *mut libc::c_char, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstWebRTCICETransport, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstWebRTCICETransport, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstWebRTCICETransport, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer/src/auto/bin.rs

@@ -285,37 +285,37 @@ 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 ffi::GstBin, sub_bin: *mut ffi::GstBin, element: *mut ffi::GstElement, f: glib_ffi::gpointer)
 where P: IsA<Bin> {
-    let f: &F = transmute(f);
+    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 ffi::GstBin, sub_bin: *mut ffi::GstBin, element: *mut ffi::GstElement, f: glib_ffi::gpointer)
 where P: IsA<Bin> {
-    let f: &F = transmute(f);
+    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 ffi::GstBin, element: *mut ffi::GstElement, f: glib_ffi::gpointer)
 where P: IsA<Bin> {
-    let f: &F = transmute(f);
+    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 ffi::GstBin, element: *mut ffi::GstElement, f: glib_ffi::gpointer)
 where P: IsA<Bin> {
-    let f: &F = transmute(f);
+    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 ffi::GstBin, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Bin> {
-    let f: &F = transmute(f);
+    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 ffi::GstBin, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Bin> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Bin::from_glib_borrow(this).unsafe_cast())
 }

gstreamer/src/auto/bus.rs

@@ -137,11 +137,11 @@ unsafe impl Send for Bus {}
 unsafe impl Sync for Bus {}
 
 unsafe extern "C" fn message_trampoline<F: Fn(&Bus, &Message) + Send + 'static>(this: *mut ffi::GstBus, message: *mut ffi::GstMessage, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstBus, message: *mut ffi::GstMessage, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this), &from_glib_borrow(message))
 }

gstreamer/src/auto/child_proxy.rs

@@ -137,12 +137,12 @@ 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 ffi::GstChildProxy, object: *mut gobject_ffi::GObject, name: *mut libc::c_char, f: glib_ffi::gpointer)
 where P: IsA<ChildProxy> {
-    let f: &F = transmute(f);
+    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 ffi::GstChildProxy, object: *mut gobject_ffi::GObject, name: *mut libc::c_char, f: glib_ffi::gpointer)
 where P: IsA<ChildProxy> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&ChildProxy::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object), &GString::from_glib_borrow(name))
 }

gstreamer/src/auto/clock.rs

@@ -318,24 +318,24 @@ impl<O: IsA<Clock>> ClockExt for O {
 
 unsafe extern "C" fn synced_trampoline<P, F: Fn(&P, bool) + Send + Sync + 'static>(this: *mut ffi::GstClock, synced: glib_ffi::gboolean, f: glib_ffi::gpointer)
 where P: IsA<Clock> {
-    let f: &F = transmute(f);
+    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 ffi::GstClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Clock> {
-    let f: &F = transmute(f);
+    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 ffi::GstClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Clock> {
-    let f: &F = transmute(f);
+    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 ffi::GstClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Clock> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Clock::from_glib_borrow(this).unsafe_cast())
 }

gstreamer/src/auto/device.rs

@@ -112,6 +112,6 @@ impl<O: IsA<Device>> DeviceExt for O {
 
 unsafe extern "C" fn removed_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstDevice, f: glib_ffi::gpointer)
 where P: IsA<Device> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Device::from_glib_borrow(this).unsafe_cast())
 }

gstreamer/src/auto/device_monitor.rs

@@ -123,6 +123,6 @@ impl<O: IsA<DeviceMonitor>> DeviceMonitorExt for O {
 
 unsafe extern "C" fn notify_show_all_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstDeviceMonitor, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<DeviceMonitor> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&DeviceMonitor::from_glib_borrow(this).unsafe_cast())
 }

gstreamer/src/auto/device_provider.rs

@@ -157,12 +157,12 @@ impl<O: IsA<DeviceProvider>> DeviceProviderExt for O {
 
 unsafe extern "C" fn provider_hidden_trampoline<P, F: Fn(&P, &str) + Send + Sync + 'static>(this: *mut ffi::GstDeviceProvider, object: *mut libc::c_char, f: glib_ffi::gpointer)
 where P: IsA<DeviceProvider> {
-    let f: &F = transmute(f);
+    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 ffi::GstDeviceProvider, object: *mut libc::c_char, f: glib_ffi::gpointer)
 where P: IsA<DeviceProvider> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&DeviceProvider::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(object))
 }

gstreamer/src/auto/element.rs

@@ -502,18 +502,18 @@ impl<O: IsA<Element>> ElementExt for O {
 
 unsafe extern "C" fn no_more_pads_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstElement, f: glib_ffi::gpointer)
 where P: IsA<Element> {
-    let f: &F = transmute(f);
+    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 ffi::GstElement, new_pad: *mut ffi::GstPad, f: glib_ffi::gpointer)
 where P: IsA<Element> {
-    let f: &F = transmute(f);
+    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 ffi::GstElement, old_pad: *mut ffi::GstPad, f: glib_ffi::gpointer)
 where P: IsA<Element> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Element::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(old_pad))
 }

gstreamer/src/auto/object.rs

@@ -255,12 +255,12 @@ impl<O: IsA<Object>> GstObjectExt for O {
 
 unsafe extern "C" fn notify_name_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstObject, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Object> {
-    let f: &F = transmute(f);
+    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 ffi::GstObject, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Object> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Object::from_glib_borrow(this).unsafe_cast())
 }

gstreamer/src/auto/pad.rs

@@ -490,30 +490,30 @@ impl<O: IsA<Pad>> PadExt for O {
 
 unsafe extern "C" fn linked_trampoline<P, F: Fn(&P, &Pad) + Send + Sync + 'static>(this: *mut ffi::GstPad, peer: *mut ffi::GstPad, f: glib_ffi::gpointer)
 where P: IsA<Pad> {
-    let f: &F = transmute(f);
+    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 ffi::GstPad, peer: *mut ffi::GstPad, f: glib_ffi::gpointer)
 where P: IsA<Pad> {
-    let f: &F = transmute(f);
+    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 ffi::GstPad, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pad> {
-    let f: &F = transmute(f);
+    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 ffi::GstPad, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pad> {
-    let f: &F = transmute(f);
+    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 ffi::GstPad, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pad> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Pad::from_glib_borrow(this).unsafe_cast())
 }

gstreamer/src/auto/pad_template.rs

@@ -105,6 +105,6 @@ 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 ffi::GstPadTemplate, pad: *mut ffi::GstPad, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this), &from_glib_borrow(pad))
 }

gstreamer/src/auto/pipeline.rs

@@ -150,18 +150,18 @@ 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 ffi::GstPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    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 ffi::GstPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    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 ffi::GstPipeline, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<Pipeline> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&Pipeline::from_glib_borrow(this).unsafe_cast())
 }

gstreamer/src/auto/registry.rs

@@ -168,11 +168,11 @@ 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 ffi::GstRegistry, feature: *mut ffi::GstPluginFeature, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstRegistry, plugin: *mut ffi::GstPlugin, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this), &from_glib_borrow(plugin))
 }

gstreamer/src/auto/stream.rs

@@ -195,21 +195,21 @@ 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 ffi::GstStream, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstStream, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstStream, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    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 ffi::GstStream, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer/src/auto/stream_collection.rs

@@ -80,6 +80,6 @@ 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 ffi::GstStreamCollection, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&from_glib_borrow(this))
 }

gstreamer/src/auto/system_clock.rs

@@ -82,6 +82,6 @@ impl<O: IsA<SystemClock>> SystemClockExt for O {
 
 unsafe extern "C" fn notify_clock_type_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut ffi::GstSystemClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
 where P: IsA<SystemClock> {
-    let f: &F = transmute(f);
+    let f: &F = &*(f as *const F);
     f(&SystemClock::from_glib_borrow(this).unsafe_cast())
 }

gstreamer/src/auto/versions.txt

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