diff --git a/gstreamer-audio/src/subclass/audio_decoder.rs b/gstreamer-audio/src/subclass/audio_decoder.rs
index cb0d03bc7..243f58820 100644
--- a/gstreamer-audio/src/subclass/audio_decoder.rs
+++ b/gstreamer-audio/src/subclass/audio_decoder.rs
@@ -10,9 +10,9 @@ use glib_sys;
 use gst_audio_sys;
 use gst_sys;
 
+use glib::subclass::prelude::*;
 use glib::translate::*;
 
-use glib::subclass::prelude::*;
 use gst;
 use gst::subclass::prelude::*;
 use gst_base;
@@ -25,33 +25,29 @@ use crate::prelude::*;
 use AudioDecoder;
 
 pub trait AudioDecoderImpl: AudioDecoderImplExt + ElementImpl {
-    fn open(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
+    fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         self.parent_open(element)
     }
 
-    fn close(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
+    fn close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         self.parent_close(element)
     }
 
-    fn start(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
+    fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         self.parent_start(element)
     }
 
-    fn stop(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         self.parent_stop(element)
     }
 
-    fn set_format(
-        &self,
-        element: &AudioDecoder,
-        caps: &gst::Caps,
-    ) -> Result<(), gst::LoggableError> {
+    fn set_format(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
         self.parent_set_format(element, caps)
     }
 
     fn parse(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         adapter: &gst_base::Adapter,
     ) -> Result<(u32, u32), gst::FlowError> {
         self.parent_parse(element, adapter)
@@ -59,7 +55,7 @@ pub trait AudioDecoderImpl: AudioDecoderImplExt + ElementImpl {
 
     fn handle_frame(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         buffer: Option<&gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         self.parent_handle_frame(element, buffer)
@@ -67,43 +63,43 @@ pub trait AudioDecoderImpl: AudioDecoderImplExt + ElementImpl {
 
     fn pre_push(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         buffer: gst::Buffer,
     ) -> Result<Option<gst::Buffer>, gst::FlowError> {
         self.parent_pre_push(element, buffer)
     }
 
-    fn flush(&self, element: &AudioDecoder, hard: bool) {
+    fn flush(&self, element: &Self::Type, hard: bool) {
         self.parent_flush(element, hard)
     }
 
-    fn negotiate(&self, element: &AudioDecoder) -> Result<(), gst::LoggableError> {
+    fn negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> {
         self.parent_negotiate(element)
     }
 
-    fn get_caps(&self, element: &AudioDecoder, filter: Option<&gst::Caps>) -> gst::Caps {
+    fn get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps {
         self.parent_get_caps(element, filter)
     }
 
-    fn sink_event(&self, element: &AudioDecoder, event: gst::Event) -> bool {
+    fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         self.parent_sink_event(element, event)
     }
 
-    fn sink_query(&self, element: &AudioDecoder, query: &mut gst::QueryRef) -> bool {
+    fn sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
         self.parent_sink_query(element, query)
     }
 
-    fn src_event(&self, element: &AudioDecoder, event: gst::Event) -> bool {
+    fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         self.parent_src_event(element, event)
     }
 
-    fn src_query(&self, element: &AudioDecoder, query: &mut gst::QueryRef) -> bool {
+    fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
         self.parent_src_query(element, query)
     }
 
     fn propose_allocation(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage> {
         self.parent_propose_allocation(element, query)
@@ -111,75 +107,75 @@ pub trait AudioDecoderImpl: AudioDecoderImplExt + ElementImpl {
 
     fn decide_allocation(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage> {
         self.parent_decide_allocation(element, query)
     }
 }
 
-pub trait AudioDecoderImplExt {
-    fn parent_open(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage>;
+pub trait AudioDecoderImplExt: ObjectSubclass {
+    fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
 
-    fn parent_close(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage>;
+    fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
 
-    fn parent_start(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage>;
+    fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
 
-    fn parent_stop(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage>;
+    fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
 
     fn parent_set_format(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         caps: &gst::Caps,
     ) -> Result<(), gst::LoggableError>;
 
     fn parent_parse(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         adapter: &gst_base::Adapter,
     ) -> Result<(u32, u32), gst::FlowError>;
 
     fn parent_handle_frame(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         buffer: Option<&gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError>;
 
     fn parent_pre_push(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         buffer: gst::Buffer,
     ) -> Result<Option<gst::Buffer>, gst::FlowError>;
 
-    fn parent_flush(&self, element: &AudioDecoder, hard: bool);
+    fn parent_flush(&self, element: &Self::Type, hard: bool);
 
-    fn parent_negotiate(&self, element: &AudioDecoder) -> Result<(), gst::LoggableError>;
+    fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>;
 
-    fn parent_get_caps(&self, element: &AudioDecoder, filter: Option<&gst::Caps>) -> gst::Caps;
+    fn parent_get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps;
 
-    fn parent_sink_event(&self, element: &AudioDecoder, event: gst::Event) -> bool;
+    fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool;
 
-    fn parent_sink_query(&self, element: &AudioDecoder, query: &mut gst::QueryRef) -> bool;
+    fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool;
 
-    fn parent_src_event(&self, element: &AudioDecoder, event: gst::Event) -> bool;
+    fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool;
 
-    fn parent_src_query(&self, element: &AudioDecoder, query: &mut gst::QueryRef) -> bool;
+    fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool;
 
     fn parent_propose_allocation(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage>;
 
     fn parent_decide_allocation(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage>;
 }
 
 impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
-    fn parent_open(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
+    fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -187,7 +183,11 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             (*parent_class)
                 .open
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0)) {
+                    if from_glib(f(element
+                        .unsafe_cast_ref::<AudioDecoder>()
+                        .to_glib_none()
+                        .0))
+                    {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -200,7 +200,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
         }
     }
 
-    fn parent_close(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
+    fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -208,7 +208,11 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             (*parent_class)
                 .close
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0)) {
+                    if from_glib(f(element
+                        .unsafe_cast_ref::<AudioDecoder>()
+                        .to_glib_none()
+                        .0))
+                    {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -221,7 +225,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
         }
     }
 
-    fn parent_start(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
+    fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -229,7 +233,11 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             (*parent_class)
                 .start
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0)) {
+                    if from_glib(f(element
+                        .unsafe_cast_ref::<AudioDecoder>()
+                        .to_glib_none()
+                        .0))
+                    {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -242,7 +250,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
         }
     }
 
-    fn parent_stop(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
+    fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -250,7 +258,11 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             (*parent_class)
                 .stop
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0)) {
+                    if from_glib(f(element
+                        .unsafe_cast_ref::<AudioDecoder>()
+                        .to_glib_none()
+                        .0))
+                    {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -265,7 +277,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
 
     fn parent_set_format(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         caps: &gst::Caps,
     ) -> Result<(), gst::LoggableError> {
         unsafe {
@@ -276,7 +288,10 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
                 .set_format
                 .map(|f| {
                     gst_result_from_gboolean!(
-                        f(element.to_glib_none().0, caps.to_glib_none().0),
+                        f(
+                            element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                            caps.to_glib_none().0
+                        ),
                         gst::CAT_RUST,
                         "parent function `set_format` failed"
                     )
@@ -287,7 +302,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
 
     fn parent_parse(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         adapter: &gst_base::Adapter,
     ) -> Result<(u32, u32), gst::FlowError> {
         unsafe {
@@ -300,7 +315,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
                     let mut offset = mem::MaybeUninit::uninit();
                     let mut len = mem::MaybeUninit::uninit();
                     match gst::FlowReturn::from_glib(f(
-                        element.to_glib_none().0,
+                        element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
                         adapter.to_glib_none().0,
                         offset.as_mut_ptr(),
                         len.as_mut_ptr(),
@@ -323,7 +338,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
 
     fn parent_handle_frame(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         buffer: Option<&gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         unsafe {
@@ -334,7 +349,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
                 .handle_frame
                 .map(|f| {
                     gst::FlowReturn::from_glib(f(
-                        element.to_glib_none().0,
+                        element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
                         buffer
                             .map(|buffer| buffer.as_mut_ptr() as *mut *mut gst_sys::GstBuffer)
                             .unwrap_or(ptr::null_mut()),
@@ -347,7 +362,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
 
     fn parent_pre_push(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         buffer: gst::Buffer,
     ) -> Result<Option<gst::Buffer>, gst::FlowError> {
         unsafe {
@@ -356,8 +371,11 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
                 data.as_ref().get_parent_class() as *mut gst_audio_sys::GstAudioDecoderClass;
             if let Some(f) = (*parent_class).pre_push {
                 let mut buffer = buffer.into_ptr();
-                match gst::FlowReturn::from_glib(f(element.to_glib_none().0, &mut buffer))
-                    .into_result()
+                match gst::FlowReturn::from_glib(f(
+                    element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                    &mut buffer,
+                ))
+                .into_result()
                 {
                     Ok(_) => Ok(from_glib_full(buffer)),
                     Err(err) => Err(err),
@@ -368,19 +386,24 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
         }
     }
 
-    fn parent_flush(&self, element: &AudioDecoder, hard: bool) {
+    fn parent_flush(&self, element: &Self::Type, hard: bool) {
         unsafe {
             let data = T::type_data();
             let parent_class =
                 data.as_ref().get_parent_class() as *mut gst_audio_sys::GstAudioDecoderClass;
             (*parent_class)
                 .flush
-                .map(|f| f(element.to_glib_none().0, hard.to_glib()))
+                .map(|f| {
+                    f(
+                        element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                        hard.to_glib(),
+                    )
+                })
                 .unwrap_or(())
         }
     }
 
-    fn parent_negotiate(&self, element: &AudioDecoder) -> Result<(), gst::LoggableError> {
+    fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -389,7 +412,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
                 .negotiate
                 .map(|f| {
                     gst_result_from_gboolean!(
-                        f(element.to_glib_none().0),
+                        f(element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0),
                         gst::CAT_RUST,
                         "Parent function `negotiate` failed"
                     )
@@ -398,19 +421,28 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
         }
     }
 
-    fn parent_get_caps(&self, element: &AudioDecoder, filter: Option<&gst::Caps>) -> gst::Caps {
+    fn parent_get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps {
         unsafe {
             let data = T::type_data();
             let parent_class =
                 data.as_ref().get_parent_class() as *mut gst_audio_sys::GstAudioDecoderClass;
             (*parent_class)
                 .getcaps
-                .map(|f| from_glib_full(f(element.to_glib_none().0, filter.to_glib_none().0)))
-                .unwrap_or_else(|| element.proxy_getcaps(None, filter))
+                .map(|f| {
+                    from_glib_full(f(
+                        element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                        filter.to_glib_none().0,
+                    ))
+                })
+                .unwrap_or_else(|| {
+                    element
+                        .unsafe_cast_ref::<AudioDecoder>()
+                        .proxy_getcaps(None, filter)
+                })
         }
     }
 
-    fn parent_sink_event(&self, element: &AudioDecoder, event: gst::Event) -> bool {
+    fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -418,11 +450,14 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             let f = (*parent_class)
                 .sink_event
                 .expect("Missing parent function `sink_event`");
-            from_glib(f(element.to_glib_none().0, event.into_ptr()))
+            from_glib(f(
+                element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                event.into_ptr(),
+            ))
         }
     }
 
-    fn parent_sink_query(&self, element: &AudioDecoder, query: &mut gst::QueryRef) -> bool {
+    fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -430,11 +465,14 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             let f = (*parent_class)
                 .sink_query
                 .expect("Missing parent function `sink_query`");
-            from_glib(f(element.to_glib_none().0, query.as_mut_ptr()))
+            from_glib(f(
+                element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                query.as_mut_ptr(),
+            ))
         }
     }
 
-    fn parent_src_event(&self, element: &AudioDecoder, event: gst::Event) -> bool {
+    fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -442,11 +480,14 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             let f = (*parent_class)
                 .src_event
                 .expect("Missing parent function `src_event`");
-            from_glib(f(element.to_glib_none().0, event.into_ptr()))
+            from_glib(f(
+                element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                event.into_ptr(),
+            ))
         }
     }
 
-    fn parent_src_query(&self, element: &AudioDecoder, query: &mut gst::QueryRef) -> bool {
+    fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -454,13 +495,16 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             let f = (*parent_class)
                 .src_query
                 .expect("Missing parent function `src_query`");
-            from_glib(f(element.to_glib_none().0, query.as_mut_ptr()))
+            from_glib(f(
+                element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                query.as_mut_ptr(),
+            ))
         }
     }
 
     fn parent_propose_allocation(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage> {
         unsafe {
@@ -470,7 +514,10 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             (*parent_class)
                 .propose_allocation
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0, query.as_mut_ptr())) {
+                    if from_glib(f(
+                        element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                        query.as_mut_ptr(),
+                    )) {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -485,7 +532,7 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
 
     fn parent_decide_allocation(
         &self,
-        element: &AudioDecoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage> {
         unsafe {
@@ -495,7 +542,10 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
             (*parent_class)
                 .decide_allocation
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0, query.as_mut_ptr())) {
+                    if from_glib(f(
+                        element.unsafe_cast_ref::<AudioDecoder>().to_glib_none().0,
+                        query.as_mut_ptr(),
+                    )) {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -547,7 +597,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.open(&wrap) {
+        match imp.open(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -569,7 +619,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.close(&wrap) {
+        match imp.close(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -591,7 +641,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.start(&wrap) {
+        match imp.start(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -613,7 +663,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.stop(&wrap) {
+        match imp.stop(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -636,7 +686,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.set_format(&wrap, &from_glib_borrow(caps)) {
+        match imp.set_format(wrap.unsafe_cast_ref(), &from_glib_borrow(caps)) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -661,7 +711,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
-        match imp.parse(&wrap, &from_glib_borrow(adapter)) {
+        match imp.parse(wrap.unsafe_cast_ref(), &from_glib_borrow(adapter)) {
             Ok((new_offset, new_len)) => {
                 assert!(new_offset <= std::i32::MAX as u32);
                 assert!(new_len <= std::i32::MAX as u32);
@@ -691,7 +741,7 @@ where
 
     gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
         imp.handle_frame(
-            &wrap,
+            wrap.unsafe_cast_ref(),
             Option::<gst::Buffer>::from_glib_none(buffer).as_ref(),
         )
         .into()
@@ -711,7 +761,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
-        match imp.pre_push(&wrap, from_glib_full(*buffer)) {
+        match imp.pre_push(wrap.unsafe_cast_ref(), from_glib_full(*buffer)) {
             Ok(Some(new_buffer)) => {
                 *buffer = new_buffer.into_ptr();
                 Ok(gst::FlowSuccess::Ok)
@@ -738,7 +788,7 @@ unsafe extern "C" fn audio_decoder_flush<T: AudioDecoderImpl>(
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), (), {
-        AudioDecoderImpl::flush(imp, &wrap, from_glib(hard))
+        AudioDecoderImpl::flush(imp, wrap.unsafe_cast_ref(), from_glib(hard))
     })
 }
 
@@ -753,7 +803,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.negotiate(&wrap) {
+        match imp.negotiate(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -778,7 +828,7 @@ where
     gst_panic_to_error!(&wrap, &instance.panicked(), gst::Caps::new_empty(), {
         AudioDecoderImpl::get_caps(
             imp,
-            &wrap,
+            wrap.unsafe_cast_ref(),
             Option::<gst::Caps>::from_glib_borrow(filter)
                 .as_ref()
                 .as_ref(),
@@ -799,7 +849,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        imp.sink_event(&wrap, from_glib_full(event))
+        imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
     })
     .to_glib()
 }
@@ -816,7 +866,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        imp.sink_query(&wrap, gst::QueryRef::from_mut_ptr(query))
+        imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
     })
     .to_glib()
 }
@@ -833,7 +883,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        imp.src_event(&wrap, from_glib_full(event))
+        imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
     })
     .to_glib()
 }
@@ -850,7 +900,7 @@ where
     let wrap: Borrowed<AudioDecoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        imp.src_query(&wrap, gst::QueryRef::from_mut_ptr(query))
+        imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
     })
     .to_glib()
 }
@@ -868,7 +918,7 @@ where
     let query = gst::QueryRef::from_mut_ptr(query);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.propose_allocation(&wrap, query) {
+        match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -892,7 +942,7 @@ where
     let query = gst::QueryRef::from_mut_ptr(query);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.decide_allocation(&wrap, query) {
+        match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
diff --git a/gstreamer-audio/src/subclass/audio_encoder.rs b/gstreamer-audio/src/subclass/audio_encoder.rs
index 88a196fbf..501abf999 100644
--- a/gstreamer-audio/src/subclass/audio_encoder.rs
+++ b/gstreamer-audio/src/subclass/audio_encoder.rs
@@ -10,9 +10,9 @@ use glib_sys;
 use gst_audio_sys;
 use gst_sys;
 
+use glib::subclass::prelude::*;
 use glib::translate::*;
 
-use glib::subclass::prelude::*;
 use gst;
 use gst::subclass::prelude::*;
 
@@ -24,33 +24,29 @@ use AudioEncoder;
 use AudioInfo;
 
 pub trait AudioEncoderImpl: AudioEncoderImplExt + ElementImpl {
-    fn open(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage> {
+    fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         self.parent_open(element)
     }
 
-    fn close(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage> {
+    fn close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         self.parent_close(element)
     }
 
-    fn start(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage> {
+    fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         self.parent_start(element)
     }
 
-    fn stop(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         self.parent_stop(element)
     }
 
-    fn set_format(
-        &self,
-        element: &AudioEncoder,
-        info: &AudioInfo,
-    ) -> Result<(), gst::LoggableError> {
+    fn set_format(&self, element: &Self::Type, info: &AudioInfo) -> Result<(), gst::LoggableError> {
         self.parent_set_format(element, info)
     }
 
     fn handle_frame(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         buffer: Option<&gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         self.parent_handle_frame(element, buffer)
@@ -58,43 +54,43 @@ pub trait AudioEncoderImpl: AudioEncoderImplExt + ElementImpl {
 
     fn pre_push(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         buffer: gst::Buffer,
     ) -> Result<Option<gst::Buffer>, gst::FlowError> {
         self.parent_pre_push(element, buffer)
     }
 
-    fn flush(&self, element: &AudioEncoder) {
+    fn flush(&self, element: &Self::Type) {
         self.parent_flush(element)
     }
 
-    fn negotiate(&self, element: &AudioEncoder) -> Result<(), gst::LoggableError> {
+    fn negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> {
         self.parent_negotiate(element)
     }
 
-    fn get_caps(&self, element: &AudioEncoder, filter: Option<&gst::Caps>) -> gst::Caps {
+    fn get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps {
         self.parent_get_caps(element, filter)
     }
 
-    fn sink_event(&self, element: &AudioEncoder, event: gst::Event) -> bool {
+    fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         self.parent_sink_event(element, event)
     }
 
-    fn sink_query(&self, element: &AudioEncoder, query: &mut gst::QueryRef) -> bool {
+    fn sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
         self.parent_sink_query(element, query)
     }
 
-    fn src_event(&self, element: &AudioEncoder, event: gst::Event) -> bool {
+    fn src_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         self.parent_src_event(element, event)
     }
 
-    fn src_query(&self, element: &AudioEncoder, query: &mut gst::QueryRef) -> bool {
+    fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
         self.parent_src_query(element, query)
     }
 
     fn propose_allocation(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage> {
         self.parent_propose_allocation(element, query)
@@ -102,69 +98,69 @@ pub trait AudioEncoderImpl: AudioEncoderImplExt + ElementImpl {
 
     fn decide_allocation(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage> {
         self.parent_decide_allocation(element, query)
     }
 }
 
-pub trait AudioEncoderImplExt {
-    fn parent_open(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage>;
+pub trait AudioEncoderImplExt: ObjectSubclass {
+    fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
 
-    fn parent_close(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage>;
+    fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
 
-    fn parent_start(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage>;
+    fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
 
-    fn parent_stop(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage>;
+    fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage>;
 
     fn parent_set_format(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         info: &AudioInfo,
     ) -> Result<(), gst::LoggableError>;
 
     fn parent_handle_frame(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         buffer: Option<&gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError>;
 
     fn parent_pre_push(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         buffer: gst::Buffer,
     ) -> Result<Option<gst::Buffer>, gst::FlowError>;
 
-    fn parent_flush(&self, element: &AudioEncoder);
+    fn parent_flush(&self, element: &Self::Type);
 
-    fn parent_negotiate(&self, element: &AudioEncoder) -> Result<(), gst::LoggableError>;
+    fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError>;
 
-    fn parent_get_caps(&self, element: &AudioEncoder, filter: Option<&gst::Caps>) -> gst::Caps;
+    fn parent_get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps;
 
-    fn parent_sink_event(&self, element: &AudioEncoder, event: gst::Event) -> bool;
+    fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool;
 
-    fn parent_sink_query(&self, element: &AudioEncoder, query: &mut gst::QueryRef) -> bool;
+    fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool;
 
-    fn parent_src_event(&self, element: &AudioEncoder, event: gst::Event) -> bool;
+    fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool;
 
-    fn parent_src_query(&self, element: &AudioEncoder, query: &mut gst::QueryRef) -> bool;
+    fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool;
 
     fn parent_propose_allocation(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage>;
 
     fn parent_decide_allocation(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage>;
 }
 
 impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
-    fn parent_open(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage> {
+    fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -172,7 +168,11 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             (*parent_class)
                 .open
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0)) {
+                    if from_glib(f(element
+                        .unsafe_cast_ref::<AudioEncoder>()
+                        .to_glib_none()
+                        .0))
+                    {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -185,7 +185,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
         }
     }
 
-    fn parent_close(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage> {
+    fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -193,7 +193,11 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             (*parent_class)
                 .close
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0)) {
+                    if from_glib(f(element
+                        .unsafe_cast_ref::<AudioEncoder>()
+                        .to_glib_none()
+                        .0))
+                    {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -206,7 +210,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
         }
     }
 
-    fn parent_start(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage> {
+    fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -214,7 +218,11 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             (*parent_class)
                 .start
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0)) {
+                    if from_glib(f(element
+                        .unsafe_cast_ref::<AudioEncoder>()
+                        .to_glib_none()
+                        .0))
+                    {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -227,7 +235,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
         }
     }
 
-    fn parent_stop(&self, element: &AudioEncoder) -> Result<(), gst::ErrorMessage> {
+    fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -235,7 +243,11 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             (*parent_class)
                 .stop
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0)) {
+                    if from_glib(f(element
+                        .unsafe_cast_ref::<AudioEncoder>()
+                        .to_glib_none()
+                        .0))
+                    {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -250,7 +262,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
 
     fn parent_set_format(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         info: &AudioInfo,
     ) -> Result<(), gst::LoggableError> {
         unsafe {
@@ -261,7 +273,10 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
                 .set_format
                 .map(|f| {
                     gst_result_from_gboolean!(
-                        f(element.to_glib_none().0, info.to_glib_none().0 as *mut _),
+                        f(
+                            element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                            info.to_glib_none().0 as *mut _
+                        ),
                         gst::CAT_RUST,
                         "parent function `set_format` failed"
                     )
@@ -272,7 +287,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
 
     fn parent_handle_frame(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         buffer: Option<&gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         unsafe {
@@ -283,7 +298,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
                 .handle_frame
                 .map(|f| {
                     gst::FlowReturn::from_glib(f(
-                        element.to_glib_none().0,
+                        element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
                         buffer
                             .map(|buffer| buffer.as_mut_ptr() as *mut *mut gst_sys::GstBuffer)
                             .unwrap_or(ptr::null_mut()),
@@ -296,7 +311,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
 
     fn parent_pre_push(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         buffer: gst::Buffer,
     ) -> Result<Option<gst::Buffer>, gst::FlowError> {
         unsafe {
@@ -305,8 +320,11 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
                 data.as_ref().get_parent_class() as *mut gst_audio_sys::GstAudioEncoderClass;
             if let Some(f) = (*parent_class).pre_push {
                 let mut buffer = buffer.into_ptr();
-                match gst::FlowReturn::from_glib(f(element.to_glib_none().0, &mut buffer))
-                    .into_result()
+                match gst::FlowReturn::from_glib(f(
+                    element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                    &mut buffer,
+                ))
+                .into_result()
                 {
                     Ok(_) => Ok(from_glib_full(buffer)),
                     Err(err) => Err(err),
@@ -317,19 +335,19 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
         }
     }
 
-    fn parent_flush(&self, element: &AudioEncoder) {
+    fn parent_flush(&self, element: &Self::Type) {
         unsafe {
             let data = T::type_data();
             let parent_class =
                 data.as_ref().get_parent_class() as *mut gst_audio_sys::GstAudioEncoderClass;
             (*parent_class)
                 .flush
-                .map(|f| f(element.to_glib_none().0))
+                .map(|f| f(element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0))
                 .unwrap_or(())
         }
     }
 
-    fn parent_negotiate(&self, element: &AudioEncoder) -> Result<(), gst::LoggableError> {
+    fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -338,7 +356,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
                 .negotiate
                 .map(|f| {
                     gst_result_from_gboolean!(
-                        f(element.to_glib_none().0),
+                        f(element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0),
                         gst::CAT_RUST,
                         "Parent function `negotiate` failed"
                     )
@@ -347,19 +365,28 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
         }
     }
 
-    fn parent_get_caps(&self, element: &AudioEncoder, filter: Option<&gst::Caps>) -> gst::Caps {
+    fn parent_get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps {
         unsafe {
             let data = T::type_data();
             let parent_class =
                 data.as_ref().get_parent_class() as *mut gst_audio_sys::GstAudioEncoderClass;
             (*parent_class)
                 .getcaps
-                .map(|f| from_glib_full(f(element.to_glib_none().0, filter.to_glib_none().0)))
-                .unwrap_or_else(|| element.proxy_getcaps(None, filter))
+                .map(|f| {
+                    from_glib_full(f(
+                        element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                        filter.to_glib_none().0,
+                    ))
+                })
+                .unwrap_or_else(|| {
+                    element
+                        .unsafe_cast_ref::<AudioEncoder>()
+                        .proxy_getcaps(None, filter)
+                })
         }
     }
 
-    fn parent_sink_event(&self, element: &AudioEncoder, event: gst::Event) -> bool {
+    fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -367,11 +394,14 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             let f = (*parent_class)
                 .sink_event
                 .expect("Missing parent function `sink_event`");
-            from_glib(f(element.to_glib_none().0, event.into_ptr()))
+            from_glib(f(
+                element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                event.into_ptr(),
+            ))
         }
     }
 
-    fn parent_sink_query(&self, element: &AudioEncoder, query: &mut gst::QueryRef) -> bool {
+    fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -379,11 +409,14 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             let f = (*parent_class)
                 .sink_query
                 .expect("Missing parent function `sink_query`");
-            from_glib(f(element.to_glib_none().0, query.as_mut_ptr()))
+            from_glib(f(
+                element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                query.as_mut_ptr(),
+            ))
         }
     }
 
-    fn parent_src_event(&self, element: &AudioEncoder, event: gst::Event) -> bool {
+    fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -391,11 +424,14 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             let f = (*parent_class)
                 .src_event
                 .expect("Missing parent function `src_event`");
-            from_glib(f(element.to_glib_none().0, event.into_ptr()))
+            from_glib(f(
+                element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                event.into_ptr(),
+            ))
         }
     }
 
-    fn parent_src_query(&self, element: &AudioEncoder, query: &mut gst::QueryRef) -> bool {
+    fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -403,13 +439,16 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             let f = (*parent_class)
                 .src_query
                 .expect("Missing parent function `src_query`");
-            from_glib(f(element.to_glib_none().0, query.as_mut_ptr()))
+            from_glib(f(
+                element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                query.as_mut_ptr(),
+            ))
         }
     }
 
     fn parent_propose_allocation(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage> {
         unsafe {
@@ -419,7 +458,10 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             (*parent_class)
                 .propose_allocation
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0, query.as_mut_ptr())) {
+                    if from_glib(f(
+                        element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                        query.as_mut_ptr(),
+                    )) {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -434,7 +476,7 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
 
     fn parent_decide_allocation(
         &self,
-        element: &AudioEncoder,
+        element: &Self::Type,
         query: &mut gst::QueryRef,
     ) -> Result<(), gst::ErrorMessage> {
         unsafe {
@@ -444,7 +486,10 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
             (*parent_class)
                 .decide_allocation
                 .map(|f| {
-                    if from_glib(f(element.to_glib_none().0, query.as_mut_ptr())) {
+                    if from_glib(f(
+                        element.unsafe_cast_ref::<AudioEncoder>().to_glib_none().0,
+                        query.as_mut_ptr(),
+                    )) {
                         Ok(())
                     } else {
                         Err(gst_error_msg!(
@@ -495,7 +540,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.open(&wrap) {
+        match imp.open(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -517,7 +562,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.close(&wrap) {
+        match imp.close(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -539,7 +584,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.start(&wrap) {
+        match imp.start(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -561,7 +606,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.stop(&wrap) {
+        match imp.stop(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -584,7 +629,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.set_format(&wrap, &from_glib_none(info)) {
+        match imp.set_format(wrap.unsafe_cast_ref(), &from_glib_none(info)) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -610,7 +655,7 @@ where
 
     gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
         imp.handle_frame(
-            &wrap,
+            wrap.unsafe_cast_ref(),
             Option::<gst::Buffer>::from_glib_none(buffer).as_ref(),
         )
         .into()
@@ -630,7 +675,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
-        match imp.pre_push(&wrap, from_glib_full(*buffer)) {
+        match imp.pre_push(wrap.unsafe_cast_ref(), from_glib_full(*buffer)) {
             Ok(Some(new_buffer)) => {
                 *buffer = new_buffer.into_ptr();
                 Ok(gst::FlowSuccess::Ok)
@@ -656,7 +701,7 @@ unsafe extern "C" fn audio_encoder_flush<T: AudioEncoderImpl>(
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), (), {
-        AudioEncoderImpl::flush(imp, &wrap)
+        AudioEncoderImpl::flush(imp, wrap.unsafe_cast_ref())
     })
 }
 
@@ -671,7 +716,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.negotiate(&wrap) {
+        match imp.negotiate(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -696,7 +741,7 @@ where
     gst_panic_to_error!(&wrap, &instance.panicked(), gst::Caps::new_empty(), {
         AudioEncoderImpl::get_caps(
             imp,
-            &wrap,
+            wrap.unsafe_cast_ref(),
             Option::<gst::Caps>::from_glib_borrow(filter)
                 .as_ref()
                 .as_ref(),
@@ -717,7 +762,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        imp.sink_event(&wrap, from_glib_full(event))
+        imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
     })
     .to_glib()
 }
@@ -734,7 +779,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        imp.sink_query(&wrap, gst::QueryRef::from_mut_ptr(query))
+        imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
     })
     .to_glib()
 }
@@ -751,7 +796,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        imp.src_event(&wrap, from_glib_full(event))
+        imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
     })
     .to_glib()
 }
@@ -768,7 +813,7 @@ where
     let wrap: Borrowed<AudioEncoder> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        imp.src_query(&wrap, gst::QueryRef::from_mut_ptr(query))
+        imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
     })
     .to_glib()
 }
@@ -786,7 +831,7 @@ where
     let query = gst::QueryRef::from_mut_ptr(query);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.propose_allocation(&wrap, query) {
+        match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
@@ -810,7 +855,7 @@ where
     let query = gst::QueryRef::from_mut_ptr(query);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.decide_allocation(&wrap, query) {
+        match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
             Ok(()) => true,
             Err(err) => {
                 wrap.post_error_message(err);
diff --git a/gstreamer-audio/src/subclass/audio_sink.rs b/gstreamer-audio/src/subclass/audio_sink.rs
index 0f260895a..2ec43011e 100644
--- a/gstreamer-audio/src/subclass/audio_sink.rs
+++ b/gstreamer-audio/src/subclass/audio_sink.rs
@@ -1,9 +1,10 @@
 use glib_sys;
 use gst_audio_sys;
 
+use glib::prelude::*;
+use glib::subclass::prelude::*;
 use glib::translate::*;
 
-use glib::subclass::prelude::*;
 use gst::subclass::prelude::*;
 use gst::LoggableError;
 use gst_base::subclass::prelude::*;
@@ -12,55 +13,55 @@ use AudioRingBufferSpec;
 use AudioSink;
 
 pub trait AudioSinkImpl: AudioSinkImplExt + BaseSinkImpl {
-    fn close(&self, sink: &AudioSink) -> Result<(), LoggableError> {
+    fn close(&self, sink: &Self::Type) -> Result<(), LoggableError> {
         self.parent_close(sink)
     }
 
-    fn delay(&self, sink: &AudioSink) -> u32 {
+    fn delay(&self, sink: &Self::Type) -> u32 {
         self.parent_delay(sink)
     }
 
-    fn open(&self, sink: &AudioSink) -> Result<(), LoggableError> {
+    fn open(&self, sink: &Self::Type) -> Result<(), LoggableError> {
         self.parent_open(sink)
     }
 
     fn prepare(
         &self,
-        sink: &AudioSink,
+        sink: &Self::Type,
         spec: &mut AudioRingBufferSpec,
     ) -> Result<(), LoggableError> {
         AudioSinkImplExt::parent_prepare(self, sink, spec)
     }
 
-    fn unprepare(&self, sink: &AudioSink) -> Result<(), LoggableError> {
+    fn unprepare(&self, sink: &Self::Type) -> Result<(), LoggableError> {
         self.parent_unprepare(sink)
     }
 
-    fn write(&self, sink: &AudioSink, audio_data: &[u8]) -> Result<i32, LoggableError> {
+    fn write(&self, sink: &Self::Type, audio_data: &[u8]) -> Result<i32, LoggableError> {
         self.parent_write(sink, audio_data)
     }
 
-    fn reset(&self, sink: &AudioSink) {
+    fn reset(&self, sink: &Self::Type) {
         self.parent_reset(sink)
     }
 }
 
-pub trait AudioSinkImplExt {
-    fn parent_close(&self, sink: &AudioSink) -> Result<(), LoggableError>;
-    fn parent_delay(&self, sink: &AudioSink) -> u32;
-    fn parent_open(&self, sink: &AudioSink) -> Result<(), LoggableError>;
+pub trait AudioSinkImplExt: ObjectSubclass {
+    fn parent_close(&self, sink: &Self::Type) -> Result<(), LoggableError>;
+    fn parent_delay(&self, sink: &Self::Type) -> u32;
+    fn parent_open(&self, sink: &Self::Type) -> Result<(), LoggableError>;
     fn parent_prepare(
         &self,
-        sink: &AudioSink,
+        sink: &Self::Type,
         spec: &mut AudioRingBufferSpec,
     ) -> Result<(), LoggableError>;
-    fn parent_unprepare(&self, sink: &AudioSink) -> Result<(), LoggableError>;
-    fn parent_write(&self, sink: &AudioSink, audio_data: &[u8]) -> Result<i32, LoggableError>;
-    fn parent_reset(&self, sink: &AudioSink);
+    fn parent_unprepare(&self, sink: &Self::Type) -> Result<(), LoggableError>;
+    fn parent_write(&self, sink: &Self::Type, audio_data: &[u8]) -> Result<i32, LoggableError>;
+    fn parent_reset(&self, sink: &Self::Type);
 }
 
 impl<T: AudioSinkImpl> AudioSinkImplExt for T {
-    fn parent_close(&self, sink: &AudioSink) -> Result<(), LoggableError> {
+    fn parent_close(&self, sink: &Self::Type) -> Result<(), LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -70,14 +71,14 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
                 Some(f) => f,
             };
             gst_result_from_gboolean!(
-                f(sink.to_glib_none().0),
+                f(sink.unsafe_cast_ref::<AudioSink>().to_glib_none().0),
                 gst::CAT_RUST,
                 "Failed to close element using the parent function"
             )
         }
     }
 
-    fn parent_delay(&self, sink: &AudioSink) -> u32 {
+    fn parent_delay(&self, sink: &Self::Type) -> u32 {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -86,11 +87,11 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
                 Some(f) => f,
                 None => return 0,
             };
-            f(sink.to_glib_none().0)
+            f(sink.unsafe_cast_ref::<AudioSink>().to_glib_none().0)
         }
     }
 
-    fn parent_open(&self, sink: &AudioSink) -> Result<(), LoggableError> {
+    fn parent_open(&self, sink: &Self::Type) -> Result<(), LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -100,7 +101,7 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
                 None => return Ok(()),
             };
             gst_result_from_gboolean!(
-                f(sink.to_glib_none().0),
+                f(sink.unsafe_cast_ref::<AudioSink>().to_glib_none().0),
                 gst::CAT_RUST,
                 "Failed to open element using the parent function"
             )
@@ -109,7 +110,7 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
 
     fn parent_prepare(
         &self,
-        sink: &AudioSink,
+        sink: &Self::Type,
         spec: &mut AudioRingBufferSpec,
     ) -> Result<(), LoggableError> {
         unsafe {
@@ -121,14 +122,17 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
                 None => return Ok(()),
             };
             gst_result_from_gboolean!(
-                f(sink.to_glib_none().0, &mut spec.0),
+                f(
+                    sink.unsafe_cast_ref::<AudioSink>().to_glib_none().0,
+                    &mut spec.0
+                ),
                 gst::CAT_RUST,
                 "Failed to prepare element using the parent function"
             )
         }
     }
 
-    fn parent_unprepare(&self, sink: &AudioSink) -> Result<(), LoggableError> {
+    fn parent_unprepare(&self, sink: &Self::Type) -> Result<(), LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -143,14 +147,14 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
                 }
             };
             gst_result_from_gboolean!(
-                f(sink.to_glib_none().0),
+                f(sink.unsafe_cast_ref::<AudioSink>().to_glib_none().0),
                 gst::CAT_RUST,
                 "Failed to unprepare element using the parent function"
             )
         }
     }
 
-    fn parent_write(&self, sink: &AudioSink, buffer: &[u8]) -> Result<i32, LoggableError> {
+    fn parent_write(&self, sink: &Self::Type, buffer: &[u8]) -> Result<i32, LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -160,7 +164,11 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
                 None => return Ok(-1),
             };
             let buffer_ptr = buffer.as_ptr() as *const _ as *mut _;
-            let ret = f(sink.to_glib_none().0, buffer_ptr, buffer.len() as u32);
+            let ret = f(
+                sink.unsafe_cast_ref::<AudioSink>().to_glib_none().0,
+                buffer_ptr,
+                buffer.len() as u32,
+            );
             if ret > 0 {
                 Ok(ret)
             } else {
@@ -172,13 +180,13 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
         }
     }
 
-    fn parent_reset(&self, sink: &AudioSink) {
+    fn parent_reset(&self, sink: &Self::Type) {
         unsafe {
             let data = T::type_data();
             let parent_class =
                 data.as_ref().get_parent_class() as *mut gst_audio_sys::GstAudioSinkClass;
             if let Some(f) = (*parent_class).reset {
-                f(sink.to_glib_none().0)
+                f(sink.unsafe_cast_ref::<AudioSink>().to_glib_none().0)
             }
         }
     }
@@ -212,7 +220,7 @@ where
     let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.close(&wrap) {
+        match imp.close(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -231,7 +239,9 @@ where
     let imp = instance.get_impl();
     let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
 
-    gst_panic_to_error!(&wrap, &instance.panicked(), 0, { imp.delay(&wrap) })
+    gst_panic_to_error!(&wrap, &instance.panicked(), 0, {
+        imp.delay(wrap.unsafe_cast_ref())
+    })
 }
 
 unsafe extern "C" fn audiosink_open<T: AudioSinkImpl>(
@@ -245,7 +255,7 @@ where
     let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.open(&wrap) {
+        match imp.open(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -270,7 +280,7 @@ where
     let spec = &mut *(spec as *mut AudioRingBufferSpec);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match AudioSinkImpl::prepare(imp, &wrap, spec) {
+        match AudioSinkImpl::prepare(imp, wrap.unsafe_cast_ref(), spec) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -292,7 +302,7 @@ where
     let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.unprepare(&wrap) {
+        match imp.unprepare(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -317,7 +327,7 @@ where
     let data_slice = std::slice::from_raw_parts(data as *const u8, length as usize);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), -1, {
-        imp.write(&wrap, data_slice).unwrap_or(-1)
+        imp.write(wrap.unsafe_cast_ref(), data_slice).unwrap_or(-1)
     })
 }
 
@@ -330,6 +340,6 @@ where
     let wrap: Borrowed<AudioSink> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), (), {
-        imp.reset(&wrap);
+        imp.reset(wrap.unsafe_cast_ref());
     });
 }
diff --git a/gstreamer-audio/src/subclass/audio_src.rs b/gstreamer-audio/src/subclass/audio_src.rs
index 0bc6d4646..1938d8d4c 100644
--- a/gstreamer-audio/src/subclass/audio_src.rs
+++ b/gstreamer-audio/src/subclass/audio_src.rs
@@ -3,9 +3,10 @@ use gst_audio_sys;
 
 use std::mem;
 
+use glib::prelude::*;
+use glib::subclass::prelude::*;
 use glib::translate::*;
 
-use glib::subclass::prelude::*;
 use gst::subclass::prelude::*;
 use gst::LoggableError;
 use gst_base::subclass::prelude::*;
@@ -14,59 +15,63 @@ use AudioRingBufferSpec;
 use AudioSrc;
 
 pub trait AudioSrcImpl: AudioSrcImplExt + BaseSrcImpl {
-    fn close(&self, src: &AudioSrc) -> Result<(), LoggableError> {
+    fn close(&self, src: &Self::Type) -> Result<(), LoggableError> {
         self.parent_close(src)
     }
 
-    fn delay(&self, src: &AudioSrc) -> u32 {
+    fn delay(&self, src: &Self::Type) -> u32 {
         self.parent_delay(src)
     }
 
-    fn open(&self, src: &AudioSrc) -> Result<(), LoggableError> {
+    fn open(&self, src: &Self::Type) -> Result<(), LoggableError> {
         self.parent_open(src)
     }
 
-    fn prepare(&self, src: &AudioSrc, spec: &mut AudioRingBufferSpec) -> Result<(), LoggableError> {
+    fn prepare(
+        &self,
+        src: &Self::Type,
+        spec: &mut AudioRingBufferSpec,
+    ) -> Result<(), LoggableError> {
         AudioSrcImplExt::parent_prepare(self, src, spec)
     }
 
-    fn unprepare(&self, src: &AudioSrc) -> Result<(), LoggableError> {
+    fn unprepare(&self, src: &Self::Type) -> Result<(), LoggableError> {
         self.parent_unprepare(src)
     }
 
     fn read(
         &self,
-        src: &AudioSrc,
+        src: &Self::Type,
         audio_data: &mut [u8],
     ) -> Result<(u32, gst::ClockTime), LoggableError> {
         self.parent_read(src, audio_data)
     }
 
-    fn reset(&self, src: &AudioSrc) {
+    fn reset(&self, src: &Self::Type) {
         self.parent_reset(src)
     }
 }
 
-pub trait AudioSrcImplExt {
-    fn parent_close(&self, src: &AudioSrc) -> Result<(), LoggableError>;
-    fn parent_delay(&self, src: &AudioSrc) -> u32;
-    fn parent_open(&self, src: &AudioSrc) -> Result<(), LoggableError>;
+pub trait AudioSrcImplExt: ObjectSubclass {
+    fn parent_close(&self, src: &Self::Type) -> Result<(), LoggableError>;
+    fn parent_delay(&self, src: &Self::Type) -> u32;
+    fn parent_open(&self, src: &Self::Type) -> Result<(), LoggableError>;
     fn parent_prepare(
         &self,
-        src: &AudioSrc,
+        src: &Self::Type,
         spec: &mut AudioRingBufferSpec,
     ) -> Result<(), LoggableError>;
-    fn parent_unprepare(&self, src: &AudioSrc) -> Result<(), LoggableError>;
+    fn parent_unprepare(&self, src: &Self::Type) -> Result<(), LoggableError>;
     fn parent_read(
         &self,
-        src: &AudioSrc,
+        src: &Self::Type,
         audio_data: &mut [u8],
     ) -> Result<(u32, gst::ClockTime), LoggableError>;
-    fn parent_reset(&self, src: &AudioSrc);
+    fn parent_reset(&self, src: &Self::Type);
 }
 
 impl<T: AudioSrcImpl> AudioSrcImplExt for T {
-    fn parent_close(&self, src: &AudioSrc) -> Result<(), LoggableError> {
+    fn parent_close(&self, src: &Self::Type) -> Result<(), LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -76,14 +81,14 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
                 Some(f) => f,
             };
             gst_result_from_gboolean!(
-                f(src.to_glib_none().0),
+                f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0),
                 gst::CAT_RUST,
                 "Failed to close element using the parent function"
             )
         }
     }
 
-    fn parent_delay(&self, src: &AudioSrc) -> u32 {
+    fn parent_delay(&self, src: &Self::Type) -> u32 {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -92,11 +97,11 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
                 Some(f) => f,
                 None => return 0,
             };
-            f(src.to_glib_none().0)
+            f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0)
         }
     }
 
-    fn parent_open(&self, src: &AudioSrc) -> Result<(), LoggableError> {
+    fn parent_open(&self, src: &Self::Type) -> Result<(), LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -106,7 +111,7 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
                 None => return Ok(()),
             };
             gst_result_from_gboolean!(
-                f(src.to_glib_none().0),
+                f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0),
                 gst::CAT_RUST,
                 "Failed to open element using the parent function"
             )
@@ -115,7 +120,7 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
 
     fn parent_prepare(
         &self,
-        src: &AudioSrc,
+        src: &Self::Type,
         spec: &mut AudioRingBufferSpec,
     ) -> Result<(), LoggableError> {
         unsafe {
@@ -127,14 +132,17 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
                 None => return Ok(()),
             };
             gst_result_from_gboolean!(
-                f(src.to_glib_none().0, &mut spec.0),
+                f(
+                    src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0,
+                    &mut spec.0
+                ),
                 gst::CAT_RUST,
                 "Failed to prepare element using the parent function"
             )
         }
     }
 
-    fn parent_unprepare(&self, src: &AudioSrc) -> Result<(), LoggableError> {
+    fn parent_unprepare(&self, src: &Self::Type) -> Result<(), LoggableError> {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -149,7 +157,7 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
                 }
             };
             gst_result_from_gboolean!(
-                f(src.to_glib_none().0),
+                f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0),
                 gst::CAT_RUST,
                 "Failed to unprepare element using the parent function"
             )
@@ -158,7 +166,7 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
 
     fn parent_read(
         &self,
-        src: &AudioSrc,
+        src: &Self::Type,
         buffer: &mut [u8],
     ) -> Result<(u32, gst::ClockTime), LoggableError> {
         unsafe {
@@ -172,7 +180,7 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
             let buffer_ptr = buffer.as_mut_ptr() as *mut _;
             let mut timestamp = mem::MaybeUninit::uninit();
             let ret = f(
-                src.to_glib_none().0,
+                src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0,
                 buffer_ptr,
                 buffer.len() as u32,
                 timestamp.as_mut_ptr(),
@@ -188,13 +196,13 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
         }
     }
 
-    fn parent_reset(&self, src: &AudioSrc) {
+    fn parent_reset(&self, src: &Self::Type) {
         unsafe {
             let data = T::type_data();
             let parent_class =
                 data.as_ref().get_parent_class() as *mut gst_audio_sys::GstAudioSrcClass;
             if let Some(f) = (*parent_class).reset {
-                f(src.to_glib_none().0)
+                f(src.unsafe_cast_ref::<AudioSrc>().to_glib_none().0)
             }
         }
     }
@@ -228,7 +236,7 @@ where
     let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.close(&wrap) {
+        match imp.close(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -247,7 +255,9 @@ where
     let imp = instance.get_impl();
     let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
 
-    gst_panic_to_error!(&wrap, &instance.panicked(), 0, { imp.delay(&wrap) })
+    gst_panic_to_error!(&wrap, &instance.panicked(), 0, {
+        imp.delay(wrap.unsafe_cast_ref())
+    })
 }
 
 unsafe extern "C" fn audiosrc_open<T: AudioSrcImpl>(
@@ -261,7 +271,7 @@ where
     let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.open(&wrap) {
+        match imp.open(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -286,7 +296,7 @@ where
     let spec = &mut *(spec as *mut AudioRingBufferSpec);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match AudioSrcImpl::prepare(imp, &wrap, spec) {
+        match AudioSrcImpl::prepare(imp, wrap.unsafe_cast_ref(), spec) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -308,7 +318,7 @@ where
     let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), false, {
-        match imp.unprepare(&wrap) {
+        match imp.unprepare(wrap.unsafe_cast_ref()) {
             Ok(()) => true,
             Err(err) => {
                 err.log_with_object(&*wrap);
@@ -335,7 +345,7 @@ where
 
     gst_panic_to_error!(&wrap, &instance.panicked(), 0, {
         let (res, timestamp_res) = imp
-            .read(&wrap, data_slice)
+            .read(wrap.unsafe_cast_ref(), data_slice)
             .unwrap_or((0, gst::CLOCK_TIME_NONE));
         *timestamp = timestamp_res.to_glib();
 
@@ -352,6 +362,6 @@ where
     let wrap: Borrowed<AudioSrc> = from_glib_borrow(ptr);
 
     gst_panic_to_error!(&wrap, &instance.panicked(), (), {
-        imp.reset(&wrap);
+        imp.reset(wrap.unsafe_cast_ref());
     });
 }