Change *Impl trait methods to only take &self and not Self::Type in addition

29 files changed, 991 insertions, 1456 deletions

diff --git a/video/cdg/src/cdgdec/imp.rs b/video/cdg/src/cdgdec/imp.rs
index 5e4f3cc3..469c0976 100644
--- a/video/cdg/src/cdgdec/imp.rs
+++ b/video/cdg/src/cdgdec/imp.rs
@@ -88,39 +88,39 @@ impl ElementImpl for CdgDec {
 }
 
 impl VideoDecoderImpl for CdgDec {
-    fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn start(&self) -> Result<(), gst::ErrorMessage> {
         let mut out_info = self.output_info.lock().unwrap();
         *out_info = None;
 
-        self.parent_start(element)
+        self.parent_start()
     }
 
-    fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         {
             let mut cdg_inter = self.cdg_inter.lock().unwrap();
             cdg_inter.reset(true);
         }
-        self.parent_stop(element)
+        self.parent_stop()
     }
 
     fn handle_frame(
         &self,
-        element: &Self::Type,
         mut frame: gst_video::VideoCodecFrame,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         {
             let mut out_info = self.output_info.lock().unwrap();
             if out_info.is_none() {
-                let output_state = element.set_output_state(
+                let instance = self.instance();
+                let output_state = instance.set_output_state(
                     gst_video::VideoFormat::Rgba,
                     CDG_WIDTH,
                     CDG_HEIGHT,
                     None,
                 )?;
 
-                element.negotiate(output_state)?;
+                instance.negotiate(output_state)?;
 
-                let out_state = element.output_state().unwrap();
+                let out_state = instance.output_state().unwrap();
                 *out_info = Some(out_state.info());
             }
         }
@@ -128,8 +128,8 @@ impl VideoDecoderImpl for CdgDec {
         let cmd = {
             let input = frame.input_buffer().unwrap();
             let map = input.map_readable().map_err(|_| {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::CoreError::Failed,
                     ["Failed to map input buffer readable"]
                 );
@@ -144,7 +144,7 @@ impl VideoDecoderImpl for CdgDec {
             Some(cmd) => cmd,
             None => {
                 // Not a CDG command
-                element.release_frame(frame);
+                self.instance().release_frame(frame);
                 return Ok(gst::FlowSuccess::Ok);
             }
         };
@@ -152,7 +152,7 @@ impl VideoDecoderImpl for CdgDec {
         let mut cdg_inter = self.cdg_inter.lock().unwrap();
         cdg_inter.handle_cmd(cmd);
 
-        element.allocate_output_frame(&mut frame, None)?;
+        self.instance().allocate_output_frame(&mut frame, None)?;
         {
             let output = frame.output_buffer_mut().unwrap();
             let info = self.output_info.lock().unwrap();
@@ -160,8 +160,8 @@ impl VideoDecoderImpl for CdgDec {
             let mut out_frame =
                 gst_video::VideoFrameRef::from_buffer_ref_writable(output, info.as_ref().unwrap())
                     .map_err(|_| {
-                        gst::element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::CoreError::Failed,
                             ["Failed to map output buffer writable"]
                         );
@@ -188,19 +188,13 @@ impl VideoDecoderImpl for CdgDec {
             }
         }
 
-        gst::debug!(
-            CAT,
-            obj: element,
-            "Finish frame pts={}",
-            frame.pts().display()
-        );
+        gst::debug!(CAT, imp: self, "Finish frame pts={}", frame.pts().display());
 
-        element.finish_frame(frame)
+        self.instance().finish_frame(frame)
     }
 
     fn decide_allocation(
         &self,
-        element: &Self::Type,
         query: &mut gst::query::Allocation,
     ) -> Result<(), gst::LoggableError> {
         if query
@@ -216,11 +210,11 @@ impl VideoDecoderImpl for CdgDec {
             }
         }
 
-        self.parent_decide_allocation(element, query)
+        self.parent_decide_allocation(query)
     }
 
-    fn flush(&self, element: &Self::Type) -> bool {
-        gst::debug!(CAT, obj: element, "flushing, reset CDG interpreter");
+    fn flush(&self) -> bool {
+        gst::debug!(CAT, imp: self, "flushing, reset CDG interpreter");
 
         let mut cdg_inter = self.cdg_inter.lock().unwrap();
         cdg_inter.reset(false);
diff --git a/video/cdg/src/cdgparse/imp.rs b/video/cdg/src/cdgparse/imp.rs
index d3869d41..8ebf1e00 100644
--- a/video/cdg/src/cdgparse/imp.rs
+++ b/video/cdg/src/cdgparse/imp.rs
@@ -111,16 +111,15 @@ fn time_to_bytes(time: gst::ClockTime) -> Bytes {
 }
 
 impl BaseParseImpl for CdgParse {
-    fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
-        element.set_min_frame_size(CDG_PACKET_SIZE as u32);
+    fn start(&self) -> Result<(), gst::ErrorMessage> {
+        self.instance().set_min_frame_size(CDG_PACKET_SIZE as u32);
 
         /* Set duration */
         let mut query = gst::query::Duration::new(gst::Format::Bytes);
-        let pad = element.src_pad();
-        if pad.query(&mut query) {
+        if self.instance().src_pad().query(&mut query) {
             let size = query.result();
             let bytes: Option<Bytes> = size.try_into().unwrap();
-            element.set_duration(bytes.map(bytes_to_time), 0);
+            self.instance().set_duration(bytes.map(bytes_to_time), 0);
         }
 
         Ok(())
@@ -128,11 +127,9 @@ impl BaseParseImpl for CdgParse {
 
     fn handle_frame(
         &self,
-        element: &Self::Type,
         mut frame: gst_base::BaseParseFrame,
     ) -> Result<(gst::FlowSuccess, u32), gst::FlowError> {
-        let pad = element.src_pad();
-        if pad.current_caps().is_none() {
+        if self.instance().src_pad().current_caps().is_none() {
             // Set src pad caps
             let src_caps = gst::Caps::builder("video/x-cdg")
                 .field("width", CDG_WIDTH as i32)
@@ -141,15 +138,17 @@ impl BaseParseImpl for CdgParse {
                 .field("parsed", true)
                 .build();
 
-            pad.push_event(gst::event::Caps::new(&src_caps));
+            self.instance()
+                .src_pad()
+                .push_event(gst::event::Caps::new(&src_caps));
         }
 
         // Scan for CDG instruction
         let input = frame.buffer().unwrap();
         let skip = {
             let map = input.map_readable().map_err(|_| {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::CoreError::Failed,
                     ["Failed to map input buffer readable"]
                 );
@@ -172,8 +171,8 @@ impl BaseParseImpl for CdgParse {
 
         let (keyframe, header) = {
             let map = input.map_readable().map_err(|_| {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::CoreError::Failed,
                     ["Failed to map input buffer readable"]
                 );
@@ -203,16 +202,16 @@ impl BaseParseImpl for CdgParse {
             buffer.set_flags(gst::BufferFlags::HEADER);
         }
 
-        gst::debug!(CAT, obj: element, "Found frame pts={}", pts);
+        gst::debug!(CAT, imp: self, "Found frame pts={}", pts);
 
-        element.finish_frame(frame, CDG_PACKET_SIZE as u32)?;
+        self.instance()
+            .finish_frame(frame, CDG_PACKET_SIZE as u32)?;
 
         Ok((gst::FlowSuccess::Ok, skip))
     }
 
     fn convert(
         &self,
-        _element: &Self::Type,
         src_val: impl FormattedValue,
         dest_format: gst::Format,
     ) -> Option<gst::GenericFormattedValue> {
diff --git a/video/closedcaption/src/ccdetect/imp.rs b/video/closedcaption/src/ccdetect/imp.rs
index e2b1f615..b6691dd4 100644
--- a/video/closedcaption/src/ccdetect/imp.rs
+++ b/video/closedcaption/src/ccdetect/imp.rs
@@ -72,9 +72,13 @@ struct CCPacketContents {
 }
 
 impl CCDetect {
-    fn detect_cc_data(data: &[u8]) -> Result<CCPacketContents, ParseError> {
+    fn detect_cc_data(&self, data: &[u8]) -> Result<CCPacketContents, ParseError> {
         if data.len() % 3 != 0 {
-            gst::warning!(CAT, "cc_data length is not a multiple of 3, truncating");
+            gst::warning!(
+                CAT,
+                imp: self,
+                "cc_data length is not a multiple of 3, truncating"
+            );
         }
 
         /* logic from ccconverter */
@@ -86,6 +90,7 @@ impl CCDetect {
             let cc_type = triple[0] & 0x03;
             gst::trace!(
                 CAT,
+                imp: self,
                 "triple:{} have ccp:{} 608:{} 708:{} data:{:02x},{:02x},{:02x} cc_valid:{} cc_type:{:02b}",
                 i * 3,
                 started_ccp,
@@ -130,22 +135,21 @@ impl CCDetect {
         })
     }
 
-    fn detect_cdp(data: &[u8]) -> Result<CCPacketContents, ParseError> {
+    fn detect_cdp(&self, data: &[u8]) -> Result<CCPacketContents, ParseError> {
         let data = extract_cdp(data)?;
 
-        Self::detect_cc_data(data)
+        self.detect_cc_data(data)
     }
 
-    fn detect(format: CCFormat, data: &[u8]) -> Result<CCPacketContents, ParseError> {
+    fn detect(&self, format: CCFormat, data: &[u8]) -> Result<CCPacketContents, ParseError> {
         match format {
-            CCFormat::Cc708CcData => Self::detect_cc_data(data),
-            CCFormat::Cc708Cdp => Self::detect_cdp(data),
+            CCFormat::Cc708CcData => self.detect_cc_data(data),
+            CCFormat::Cc708Cdp => self.detect_cdp(data),
         }
     }
 
     fn maybe_update_properties(
         &self,
-        element: &super::CCDetect,
         ts: gst::ClockTime,
         cc_packet: CCPacketContents,
     ) -> Result<(), gst::FlowError> {
@@ -160,6 +164,7 @@ impl CCDetect {
 
             gst::trace!(
                 CAT,
+                imp: self,
                 "packet contains {:?} current settings {:?} and state {:?}",
                 cc_packet,
                 settings,
@@ -193,14 +198,20 @@ impl CCDetect {
                 state.last_cc708_change = Some(ts);
             }
 
-            gst::trace!(CAT, "changed to settings {:?} state {:?}", settings, state);
+            gst::trace!(
+                CAT,
+                imp: self,
+                "changed to settings {:?} state {:?}",
+                settings,
+                state
+            );
         }
 
         if notify_cc608 {
-            element.notify("cc608");
+            self.instance().notify("cc608");
         }
         if notify_cc708 {
-            element.notify("cc708");
+            self.instance().notify("cc708");
         }
 
         Ok(())
@@ -243,13 +254,7 @@ impl ObjectImpl for CCDetect {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "window" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -260,7 +265,7 @@ impl ObjectImpl for CCDetect {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "window" => {
                 let settings = self.settings.lock().unwrap();
@@ -337,14 +342,13 @@ impl BaseTransformImpl for CCDetect {
 
     fn transform_ip_passthrough(
         &self,
-        element: &Self::Type,
         buf: &gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         let map = buf.map_readable().map_err(|_| gst::FlowError::Error)?;
 
         let pts = buf.pts().ok_or_else(|| {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::ResourceError::Read,
                 ["Input buffers must have valid timestamps"]
             );
@@ -357,11 +361,11 @@ impl BaseTransformImpl for CCDetect {
             state.format
         };
 
-        let cc_packet = match Self::detect(format, map.as_slice()) {
+        let cc_packet = match self.detect(format, map.as_slice()) {
             Ok(v) => v,
             Err(e) => {
-                gst::warning!(CAT, "{}", &e.to_string());
-                gst::element_warning!(element, gst::StreamError::Decode, [&e.to_string()]);
+                gst::warning!(CAT, imp: self, "{}", &e.to_string());
+                gst::element_imp_warning!(self, gst::StreamError::Decode, [&e.to_string()]);
                 CCPacketContents {
                     cc608: false,
                     cc708: false,
@@ -369,35 +373,29 @@ impl BaseTransformImpl for CCDetect {
             }
         };
 
-        self.maybe_update_properties(element, pts, cc_packet)
+        self.maybe_update_properties(pts, cc_packet)
             .map_err(|_| gst::FlowError::Error)?;
 
         Ok(gst::FlowSuccess::Ok)
     }
 
-    fn sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
+    fn sink_event(&self, event: gst::Event) -> bool {
         match event.view() {
             gst::event::EventView::Gap(gap) => {
                 let _ = self.maybe_update_properties(
-                    element,
                     gap.get().0,
                     CCPacketContents {
                         cc608: false,
                         cc708: false,
                     },
                 );
-                self.parent_sink_event(element, event)
+                self.parent_sink_event(event)
             }
-            _ => self.parent_sink_event(element, event),
+            _ => self.parent_sink_event(event),
         }
     }
 
-    fn set_caps(
-        &self,
-        _element: &Self::Type,
-        incaps: &gst::Caps,
-        outcaps: &gst::Caps,
-    ) -> Result<(), gst::LoggableError> {
+    fn set_caps(&self, incaps: &gst::Caps, outcaps: &gst::Caps) -> Result<(), gst::LoggableError> {
         if incaps != outcaps {
             return Err(gst::loggable_error!(
                 CAT,
@@ -427,7 +425,7 @@ impl BaseTransformImpl for CCDetect {
         Ok(())
     }
 
-    fn stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         // Drop state
         let _ = self.state.lock().unwrap().take();
 
diff --git a/video/closedcaption/src/cea608overlay/imp.rs b/video/closedcaption/src/cea608overlay/imp.rs
index 4f0fbf44..e52eb690 100644
--- a/video/closedcaption/src/cea608overlay/imp.rs
+++ b/video/closedcaption/src/cea608overlay/imp.rs
@@ -96,17 +96,13 @@ impl Cea608Overlay {
     // https://blogs.gnome.org/mclasen/2019/07/27/more-text-rendering-updates/
     //
     // TODO: switch to the API presented in this post once it's been exposed
-    fn recalculate_layout(
-        &self,
-        element: &super::Cea608Overlay,
-        state: &mut State,
-    ) -> Result<gst::FlowSuccess, gst::FlowError> {
+    fn recalculate_layout(&self, state: &mut State) -> Result<gst::FlowSuccess, gst::FlowError> {
         let video_info = state.video_info.as_ref().unwrap();
         let fontmap = match pangocairo::FontMap::new() {
             Some(fontmap) => Ok(fontmap),
             None => {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::LibraryError::Failed,
                     ["Failed to create pangocairo font map"]
                 );
@@ -116,8 +112,8 @@ impl Cea608Overlay {
         let context = match fontmap.create_context() {
             Some(context) => Ok(context),
             None => {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::LibraryError::Failed,
                     ["Failed to create font map context"]
                 );
@@ -163,7 +159,7 @@ impl Cea608Overlay {
         Ok(gst::FlowSuccess::Ok)
     }
 
-    fn overlay_text(&self, element: &super::Cea608Overlay, text: &str, state: &mut State) {
+    fn overlay_text(&self, text: &str, state: &mut State) {
         let video_info = state.video_info.as_ref().unwrap();
         let layout = state.layout.as_ref().unwrap();
         layout.set_text(text);
@@ -251,7 +247,7 @@ impl Cea608Overlay {
         let buffer = match render_buffer() {
             Some(buffer) => buffer,
             None => {
-                gst::error!(CAT, obj: element, "Failed to render buffer");
+                gst::error!(CAT, imp: self, "Failed to render buffer");
                 state.composition = None;
                 return;
             }
@@ -272,16 +268,12 @@ impl Cea608Overlay {
         };
     }
 
-    fn negotiate(
-        &self,
-        element: &super::Cea608Overlay,
-        state: &mut State,
-    ) -> Result<gst::FlowSuccess, gst::FlowError> {
+    fn negotiate(&self, state: &mut State) -> Result<gst::FlowSuccess, gst::FlowError> {
         let video_info = match state.video_info.as_ref() {
             Some(video_info) => Ok(video_info),
             None => {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::CoreError::Negotiation,
                     ["Element hasn't received valid video caps at negotiation time"]
                 );
@@ -322,14 +314,7 @@ impl Cea608Overlay {
         }
     }
 
-    fn decode_cc_data(
-        &self,
-        pad: &gst::Pad,
-        element: &super::Cea608Overlay,
-        state: &mut State,
-        data: &[u8],
-        pts: gst::ClockTime,
-    ) {
+    fn decode_cc_data(&self, pad: &gst::Pad, state: &mut State, data: &[u8], pts: gst::ClockTime) {
         if data.len() % 3 != 0 {
             gst::warning!(CAT, "cc_data length is not a multiple of 3, truncating");
         }
@@ -342,12 +327,7 @@ impl Cea608Overlay {
                 if cc_type == 0x00 || cc_type == 0x01 {
                     if state.selected_field.is_none() {
                         state.selected_field = Some(cc_type);
-                        gst::info!(
-                            CAT,
-                            obj: element,
-                            "Selected field {} automatically",
-                            cc_type
-                        );
+                        gst::info!(CAT, imp: self, "Selected field {} automatically", cc_type);
                     }
 
                     if Some(cc_type) == state.selected_field {
@@ -368,10 +348,10 @@ impl Cea608Overlay {
                                     }
                                 };
 
-                                self.overlay_text(element, &text, state);
+                                self.overlay_text(&text, state);
                             }
                             Ok(Status::Clear) => {
-                                self.overlay_text(element, "", state);
+                                self.overlay_text("", state);
                             }
                             Ok(Status::Ok) => (),
                             Err(err) => {
@@ -393,14 +373,7 @@ impl Cea608Overlay {
         }
     }
 
-    fn decode_s334_1a(
-        &self,
-        pad: &gst::Pad,
-        element: &super::Cea608Overlay,
-        state: &mut State,
-        data: &[u8],
-        pts: gst::ClockTime,
-    ) {
+    fn decode_s334_1a(&self, pad: &gst::Pad, state: &mut State, data: &[u8], pts: gst::ClockTime) {
         if data.len() % 3 != 0 {
             gst::warning!(CAT, "cc_data length is not a multiple of 3, truncating");
         }
@@ -409,12 +382,7 @@ impl Cea608Overlay {
             let cc_type = triple[0] & 0x01;
             if state.selected_field.is_none() {
                 state.selected_field = Some(cc_type);
-                gst::info!(
-                    CAT,
-                    obj: element,
-                    "Selected field {} automatically",
-                    cc_type
-                );
+                gst::info!(CAT, imp: self, "Selected field {} automatically", cc_type);
             }
 
             if Some(cc_type) == state.selected_field {
@@ -430,7 +398,7 @@ impl Cea608Overlay {
                         }
                     };
 
-                    self.overlay_text(element, &text, state);
+                    self.overlay_text(&text, state);
                 }
 
                 self.reset_timeout(state, pts);
@@ -445,7 +413,6 @@ impl Cea608Overlay {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        element: &super::Cea608Overlay,
         mut buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
@@ -458,28 +425,28 @@ impl Cea608Overlay {
         let mut state = self.state.lock().unwrap();
 
         if self.srcpad.check_reconfigure() {
-            self.negotiate(element, &mut state)?;
+            self.negotiate(&mut state)?;
         }
 
         if state.layout.is_none() {
-            self.recalculate_layout(element, &mut state)?;
+            self.recalculate_layout(&mut state)?;
         }
 
         for meta in buffer.iter_meta::<gst_video::VideoCaptionMeta>() {
             if meta.caption_type() == gst_video::VideoCaptionType::Cea708Cdp {
                 match extract_cdp(meta.data()) {
                     Ok(data) => {
-                        self.decode_cc_data(pad, element, &mut state, data, pts);
+                        self.decode_cc_data(pad, &mut state, data, pts);
                     }
                     Err(e) => {
                         gst::warning!(CAT, "{}", &e.to_string());
-                        gst::element_warning!(element, gst::StreamError::Decode, [&e.to_string()]);
+                        gst::element_imp_warning!(self, gst::StreamError::Decode, [&e.to_string()]);
                     }
                 }
             } else if meta.caption_type() == gst_video::VideoCaptionType::Cea708Raw {
-                self.decode_cc_data(pad, element, &mut state, meta.data(), pts);
+                self.decode_cc_data(pad, &mut state, meta.data(), pts);
             } else if meta.caption_type() == gst_video::VideoCaptionType::Cea608S3341a {
-                self.decode_s334_1a(pad, element, &mut state, meta.data(), pts);
+                self.decode_s334_1a(pad, &mut state, meta.data(), pts);
             } else if meta.caption_type() == gst_video::VideoCaptionType::Cea608Raw {
                 let data = meta.data();
                 assert!(data.len() % 2 == 0);
@@ -500,7 +467,7 @@ impl Cea608Overlay {
                             }
                         };
 
-                        self.overlay_text(element, &text, &mut state);
+                        self.overlay_text(&text, &mut state);
                     }
 
                     self.reset_timeout(&mut state, pts);
@@ -511,7 +478,7 @@ impl Cea608Overlay {
         if let Some(timeout) = self.settings.lock().unwrap().timeout {
             if let Some(interval) = pts.opt_saturating_sub(state.last_cc_pts) {
                 if interval > timeout {
-                    gst::info!(CAT, obj: element, "Reached timeout, clearing overlay");
+                    gst::info!(CAT, imp: self, "Reached timeout, clearing overlay");
                     state.composition.take();
                     state.last_cc_pts.take();
                 }
@@ -539,12 +506,7 @@ impl Cea608Overlay {
         self.srcpad.push(buffer)
     }
 
-    fn sink_event(
-        &self,
-        pad: &gst::Pad,
-        element: &super::Cea608Overlay,
-        event: gst::Event,
-    ) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -553,7 +515,7 @@ impl Cea608Overlay {
                 let mut state = self.state.lock().unwrap();
                 state.video_info = gst_video::VideoInfo::from_caps(c.caps()).ok();
                 self.srcpad.check_reconfigure();
-                match self.negotiate(element, &mut state) {
+                match self.negotiate(&mut state) {
                     Ok(_) => true,
                     Err(_) => {
                         self.srcpad.mark_reconfigure();
@@ -565,9 +527,9 @@ impl Cea608Overlay {
                 let mut state = self.state.lock().unwrap();
                 state.caption_frame = CaptionFrame::default();
                 state.composition = None;
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 }
@@ -585,14 +547,14 @@ impl ObjectSubclass for Cea608Overlay {
                 Cea608Overlay::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |overlay, element| overlay.sink_chain(pad, element, buffer),
+                    |overlay| overlay.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 Cea608Overlay::catch_panic_pad_function(
                     parent,
                     || false,
-                    |overlay, element| overlay.sink_event(pad, element, event),
+                    |overlay| overlay.sink_event(pad, event),
                 )
             })
             .flags(gst::PadFlags::PROXY_CAPS)
@@ -645,13 +607,7 @@ impl ObjectImpl for Cea608Overlay {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "field" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -684,7 +640,7 @@ impl ObjectImpl for Cea608Overlay {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "field" => {
                 let settings = self.settings.lock().unwrap();
@@ -705,9 +661,10 @@ impl ObjectImpl for Cea608Overlay {
             _ => unimplemented!(),
         }
     }
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -760,10 +717,9 @@ impl ElementImpl for Cea608Overlay {
 
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => {
@@ -779,6 +735,6 @@ impl ElementImpl for Cea608Overlay {
             _ => (),
         }
 
-        self.parent_change_state(element, transition)
+        self.parent_change_state(transition)
     }
 }
diff --git a/video/closedcaption/src/cea608tojson/imp.rs b/video/closedcaption/src/cea608tojson/imp.rs
index a9c41aad..633982ae 100644
--- a/video/closedcaption/src/cea608tojson/imp.rs
+++ b/video/closedcaption/src/cea608tojson/imp.rs
@@ -393,7 +393,7 @@ fn eia608_to_text(cc_data: u16) -> String {
 }
 
 fn dump(
-    element: &super::Cea608ToJson,
+    imp: &Cea608ToJson,
     cc_data: u16,
     pts: impl Into<Option<gst::ClockTime>>,
     duration: impl Into<Option<gst::ClockTime>>,
@@ -404,7 +404,7 @@ fn dump(
     if cc_data != 0x8080 {
         gst::debug!(
             CAT,
-            obj: element,
+            imp: imp,
             "{} -> {}: {}",
             pts.display(),
             end.display(),
@@ -413,7 +413,7 @@ fn dump(
     } else {
         gst::trace!(
             CAT,
-            obj: element,
+            imp: imp,
             "{} -> {}: padding",
             pts.display(),
             end.display()
@@ -422,21 +422,17 @@ fn dump(
 }
 
 impl State {
-    fn update_mode(
-        &mut self,
-        element: &super::Cea608ToJson,
-        mode: Cea608Mode,
-    ) -> Option<TimestampedLines> {
+    fn update_mode(&mut self, imp: &Cea608ToJson, mode: Cea608Mode) -> Option<TimestampedLines> {
         if mode.is_rollup() && self.mode == Some(Cea608Mode::PopOn) {
             // https://www.law.cornell.edu/cfr/text/47/79.101 (f)(2)(v)
-            let _ = self.drain(element, true);
+            let _ = self.drain(imp, true);
         }
 
         let ret = if Some(mode) != self.mode {
             if self.mode == Some(Cea608Mode::PopOn) {
-                self.drain_pending(element)
+                self.drain_pending(imp)
             } else {
-                self.drain(element, true)
+                self.drain(imp, true)
             }
         } else {
             None
@@ -459,8 +455,8 @@ impl State {
         ret
     }
 
-    fn drain(&mut self, element: &super::Cea608ToJson, flush: bool) -> Option<TimestampedLines> {
-        gst::log!(CAT, obj: element, "Draining");
+    fn drain(&mut self, imp: &Cea608ToJson, flush: bool) -> Option<TimestampedLines> {
+        gst::log!(CAT, imp: imp, "Draining");
 
         let pts = if self.settings.unbuffered {
             self.current_pts
@@ -533,9 +529,9 @@ impl State {
         }
     }
 
-    fn drain_pending(&mut self, element: &super::Cea608ToJson) -> Option<TimestampedLines> {
+    fn drain_pending(&mut self, imp: &Cea608ToJson) -> Option<TimestampedLines> {
         if let Some(mut pending) = self.pending_lines.take() {
-            gst::log!(CAT, obj: element, "Draining pending");
+            gst::log!(CAT, imp: imp, "Draining pending");
             pending.duration = self
                 .current_pts
                 .opt_add(self.current_duration)
@@ -548,18 +544,14 @@ impl State {
         }
     }
 
-    fn decode_preamble(
-        &mut self,
-        element: &super::Cea608ToJson,
-        cc_data: u16,
-    ) -> Option<TimestampedLines> {
+    fn decode_preamble(&mut self, imp: &Cea608ToJson, cc_data: u16) -> Option<TimestampedLines> {
         let preamble = parse_preamble(cc_data);
 
         if preamble.chan != 0 {
             return None;
         }
 
-        gst::log!(CAT, obj: element, "preamble: {:?}", preamble);
+        gst::log!(CAT, imp: imp, "preamble: {:?}", preamble);
 
         let drain_roll_up = self.cursor.row != preamble.row as u32;
 
@@ -606,7 +598,7 @@ impl State {
                     if self.settings.unbuffered {
                         /* We only need to drain when the roll-up window was relocated */
                         let ret = if drain_roll_up {
-                            self.drain(element, true)
+                            self.drain(imp, true)
                         } else {
                             None
                         };
@@ -620,7 +612,7 @@ impl State {
                         ret
                     // The relocation is potentially destructive, let us drain
                     } else {
-                        let ret = self.drain(element, true);
+                        let ret = self.drain(imp, true);
                         self.rows.insert(self.cursor.row, Row::new(self.cursor.row));
 
                         ret
@@ -638,14 +630,10 @@ impl State {
         }
     }
 
-    fn decode_control(
-        &mut self,
-        element: &super::Cea608ToJson,
-        cc_data: u16,
-    ) -> Option<TimestampedLines> {
+    fn decode_control(&mut self, imp: &Cea608ToJson, cc_data: u16) -> Option<TimestampedLines> {
         let (cmd, chan) = parse_control(cc_data);
 
-        gst::log!(CAT, obj: element, "Command for CC {}", chan);
+        gst::log!(CAT, imp: imp, "Command for CC {}", chan);
 
         if chan != 0 {
             return None;
@@ -653,32 +641,32 @@ impl State {
 
         match cmd {
             ffi::eia608_control_t_eia608_control_resume_direct_captioning => {
-                return self.update_mode(element, Cea608Mode::PaintOn);
+                return self.update_mode(imp, Cea608Mode::PaintOn);
             }
             ffi::eia608_control_t_eia608_control_erase_display_memory => {
                 return match self.mode {
                     Some(Cea608Mode::PopOn) => {
                         self.clear = Some(true);
-                        self.drain_pending(element)
+                        self.drain_pending(imp)
                     }
                     _ => {
-                        let ret = self.drain(element, true);
+                        let ret = self.drain(imp, true);
                         self.clear = Some(true);
                         ret
                     }
                 };
             }
             ffi::eia608_control_t_eia608_control_roll_up_2 => {
-                return self.update_mode(element, Cea608Mode::RollUp2);
+                return self.update_mode(imp, Cea608Mode::RollUp2);
             }
             ffi::eia608_control_t_eia608_control_roll_up_3 => {
-                return self.update_mode(element, Cea608Mode::RollUp3);
+                return self.update_mode(imp, Cea608Mode::RollUp3);
             }
             ffi::eia608_control_t_eia608_control_roll_up_4 => {
-                return self.update_mode(element, Cea608Mode::RollUp4);
+                return self.update_mode(imp, Cea608Mode::RollUp4);
             }
             ffi::eia608_control_t_eia608_control_carriage_return => {
-                gst::log!(CAT, obj: element, "carriage return");
+                gst::log!(CAT, imp: imp, "carriage return");
 
                 if let Some(mode) = self.mode {
                     // https://www.law.cornell.edu/cfr/text/47/79.101 (f)(2)(i) (f)(3)(i)
@@ -704,9 +692,9 @@ impl State {
                             }
 
                             self.rows.insert(self.cursor.row, Row::new(self.cursor.row));
-                            self.drain(element, false)
+                            self.drain(imp, false)
                         } else {
-                            let ret = self.drain(element, true);
+                            let ret = self.drain(imp, true);
                             self.carriage_return = Some(true);
                             ret
                         };
@@ -721,7 +709,7 @@ impl State {
                 }
             }
             ffi::eia608_control_t_eia608_control_resume_caption_loading => {
-                return self.update_mode(element, Cea608Mode::PopOn);
+                return self.update_mode(imp, Cea608Mode::PopOn);
             }
             ffi::eia608_control_t_eia608_control_erase_non_displayed_memory => {
                 if self.mode == Some(Cea608Mode::PopOn) {
@@ -730,13 +718,13 @@ impl State {
             }
             ffi::eia608_control_t_eia608_control_end_of_caption => {
                 // https://www.law.cornell.edu/cfr/text/47/79.101 (f)(2)
-                self.update_mode(element, Cea608Mode::PopOn);
+                self.update_mode(imp, Cea608Mode::PopOn);
                 self.first_pts = self.current_pts;
                 let ret = if self.settings.unbuffered {
-                    self.drain(element, true)
+                    self.drain(imp, true)
                 } else {
-                    let ret = self.drain_pending(element);
-                    self.pending_lines = self.drain(element, true);
+                    let ret = self.drain_pending(imp);
+                    self.pending_lines = self.drain(imp, true);
                     ret
                 };
                 return ret;
@@ -756,14 +744,14 @@ impl State {
             | ffi::eia608_control_t_eia608_control_text_restart
             | ffi::eia608_control_t_eia608_control_text_resume_text_display => {}
             _ => {
-                gst::warning!(CAT, obj: element, "Unknown command {}!", cmd);
+                gst::warning!(CAT, imp: imp, "Unknown command {}!", cmd);
             }
         }
 
         None
     }
 
-    fn decode_text(&mut self, element: &super::Cea608ToJson, cc_data: u16) {
+    fn decode_text(&mut self, imp: &Cea608ToJson, cc_data: u16) {
         let (char1, char2, chan) = eia608_to_utf8(cc_data);
 
         if chan != 0 {
@@ -791,7 +779,7 @@ impl State {
                 row.push(&mut self.cursor, c);
             }
         } else {
-            gst::warning!(CAT, obj: element, "No row to append decoded text to!");
+            gst::warning!(CAT, imp: imp, "No row to append decoded text to!");
         }
     }
 
@@ -807,13 +795,13 @@ impl State {
 
     fn handle_cc_data(
         &mut self,
-        element: &super::Cea608ToJson,
+        imp: &Cea608ToJson,
         pts: Option<gst::ClockTime>,
         duration: Option<gst::ClockTime>,
         cc_data: u16,
     ) -> Option<TimestampedLines> {
         if (is_specialna(cc_data) || is_control(cc_data)) && Some(cc_data) == self.last_cc_data {
-            gst::log!(CAT, obj: element, "Skipping duplicate");
+            gst::log!(CAT, imp: imp, "Skipping duplicate");
             return None;
         }
 
@@ -822,25 +810,25 @@ impl State {
         self.current_duration = duration;
 
         if is_xds(cc_data) {
-            gst::log!(CAT, obj: element, "XDS, ignoring");
+            gst::log!(CAT, imp: imp, "XDS, ignoring");
         } else if is_control(cc_data) {
-            gst::log!(CAT, obj: element, "control!");
-            return self.decode_control(element, cc_data);
+            gst::log!(CAT, imp: imp, "control!");
+            return self.decode_control(imp, cc_data);
         } else if is_basicna(cc_data) || is_specialna(cc_data) || is_westeu(cc_data) {
             if let Some(mode) = self.mode {
                 self.mode?;
-                gst::log!(CAT, obj: element, "text");
-                self.decode_text(element, cc_data);
+                gst::log!(CAT, imp: imp, "text");
+                self.decode_text(imp, cc_data);
 
                 if mode.is_rollup() && self.settings.unbuffered {
-                    return self.drain(element, false);
+                    return self.drain(imp, false);
                 }
             }
         } else if is_preamble(cc_data) {
-            gst::log!(CAT, obj: element, "preamble");
-            return self.decode_preamble(element, cc_data);
+            gst::log!(CAT, imp: imp, "preamble");
+            return self.decode_preamble(imp, cc_data);
         } else if is_midrowchange(cc_data) {
-            gst::log!(CAT, obj: element, "midrowchange");
+            gst::log!(CAT, imp: imp, "midrowchange");
             self.decode_midrowchange(cc_data);
         }
         None
@@ -848,16 +836,12 @@ impl State {
 }
 
 impl Cea608ToJson {
-    fn output(
-        &self,
-        element: &super::Cea608ToJson,
-        lines: TimestampedLines,
-    ) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst::debug!(CAT, obj: element, "outputting: {:?}", lines);
+    fn output(&self, lines: TimestampedLines) -> Result<gst::FlowSuccess, gst::FlowError> {
+        gst::debug!(CAT, imp: self, "outputting: {:?}", lines);
 
         let json = serde_json::to_string(&lines.lines).map_err(|err| {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::ResourceError::Write,
                 ["Failed to serialize as json {}", err]
             );
@@ -872,7 +856,7 @@ impl Cea608ToJson {
             buf_mut.set_duration(lines.duration);
         }
 
-        gst::log!(CAT, obj: element, "Pushing {:?}", buf);
+        gst::log!(CAT, imp: self, "Pushing {:?}", buf);
 
         self.srcpad.push(buf)
     }
@@ -880,7 +864,6 @@ impl Cea608ToJson {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        element: &super::Cea608ToJson,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::trace!(CAT, obj: pad, "Handling buffer {:?}", buffer);
@@ -913,11 +896,11 @@ impl Cea608ToJson {
 
         let cc_data = (data[0] as u16) << 8 | data[1] as u16;
 
-        dump(element, cc_data, pts, duration);
+        dump(self, cc_data, pts, duration);
 
-        if let Some(lines) = state.handle_cc_data(element, pts, duration, cc_data) {
+        if let Some(lines) = state.handle_cc_data(self, pts, duration, cc_data) {
             drop(state);
-            self.output(element, lines)
+            self.output(lines)
         } else if state.settings.unbuffered {
             drop(state);
             self.srcpad.push_event(
@@ -931,7 +914,7 @@ impl Cea608ToJson {
         }
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::Cea608ToJson, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -949,19 +932,19 @@ impl Cea608ToJson {
                 *state = State::default();
                 state.settings = old_settings;
                 drop(state);
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::Eos(..) => {
-                if let Some(lines) = self.state.borrow_mut().drain_pending(element) {
-                    let _ = self.output(element, lines);
+                if let Some(lines) = self.state.borrow_mut().drain_pending(self) {
+                    let _ = self.output(lines);
                 }
-                if let Some(lines) = self.state.borrow_mut().drain(element, true) {
-                    let _ = self.output(element, lines);
+                if let Some(lines) = self.state.borrow_mut().drain(self, true) {
+                    let _ = self.output(lines);
                 }
 
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 }
@@ -979,14 +962,14 @@ impl ObjectSubclass for Cea608ToJson {
                 Cea608ToJson::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |this, element| this.sink_chain(pad, element, buffer),
+                    |this| this.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 Cea608ToJson::catch_panic_pad_function(
                     parent,
                     || false,
-                    |this, element| this.sink_event(pad, element, event),
+                    |this| this.sink_event(pad, event),
                 )
             })
             .flags(gst::PadFlags::FIXED_CAPS)
@@ -1007,9 +990,10 @@ impl ObjectSubclass for Cea608ToJson {
 }
 
 impl ObjectImpl for Cea608ToJson {
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -1030,13 +1014,7 @@ impl ObjectImpl for Cea608ToJson {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "unbuffered" => {
                 self.settings.lock().unwrap().unbuffered =
@@ -1046,7 +1024,7 @@ impl ObjectImpl for Cea608ToJson {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "unbuffered" => {
                 let settings = self.settings.lock().unwrap();
@@ -1106,10 +1084,9 @@ impl ElementImpl for Cea608ToJson {
     #[allow(clippy::single_match)]
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused => {
@@ -1120,7 +1097,7 @@ impl ElementImpl for Cea608ToJson {
             _ => (),
         }
 
-        let ret = self.parent_change_state(element, transition)?;
+        let ret = self.parent_change_state(transition)?;
 
         match transition {
             gst::StateChange::PausedToReady => {
diff --git a/video/closedcaption/src/cea608tott/imp.rs b/video/closedcaption/src/cea608tott/imp.rs
index 622ea915..f0dcdccf 100644
--- a/video/closedcaption/src/cea608tott/imp.rs
+++ b/video/closedcaption/src/cea608tott/imp.rs
@@ -61,7 +61,6 @@ impl Cea608ToTt {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        _element: &super::Cea608ToTt,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
@@ -267,7 +266,7 @@ impl Cea608ToTt {
         buffer
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::Cea608ToTt, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -368,7 +367,7 @@ impl Cea608ToTt {
             _ => (),
         }
 
-        pad.event_default(Some(element), event)
+        pad.event_default(Some(&*self.instance()), event)
     }
 }
 
@@ -385,14 +384,14 @@ impl ObjectSubclass for Cea608ToTt {
                 Cea608ToTt::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |this, element| this.sink_chain(pad, element, buffer),
+                    |this| this.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 Cea608ToTt::catch_panic_pad_function(
                     parent,
                     || false,
-                    |this, element| this.sink_event(pad, element, event),
+                    |this| this.sink_event(pad, event),
                 )
             })
             .flags(gst::PadFlags::FIXED_CAPS)
@@ -412,9 +411,10 @@ impl ObjectSubclass for Cea608ToTt {
 }
 
 impl ObjectImpl for Cea608ToTt {
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -486,10 +486,9 @@ impl ElementImpl for Cea608ToTt {
     #[allow(clippy::single_match)]
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused => {
@@ -499,7 +498,7 @@ impl ElementImpl for Cea608ToTt {
             _ => (),
         }
 
-        let ret = self.parent_change_state(element, transition)?;
+        let ret = self.parent_change_state(transition)?;
 
         match transition {
             gst::StateChange::PausedToReady => {
diff --git a/video/closedcaption/src/jsontovtt/imp.rs b/video/closedcaption/src/jsontovtt/imp.rs
index 199e4269..abdbb865 100644
--- a/video/closedcaption/src/jsontovtt/imp.rs
+++ b/video/closedcaption/src/jsontovtt/imp.rs
@@ -7,7 +7,6 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use gst::element_error;
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
@@ -351,7 +350,6 @@ impl JsonToVtt {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        _element: &super::JsonToVtt,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::trace!(CAT, obj: pad, "Handling buffer {:?}", buffer);
@@ -370,7 +368,7 @@ impl JsonToVtt {
         state.keyunit_requests.push(fku);
     }
 
-    fn src_event(&self, pad: &gst::Pad, element: &super::JsonToVtt, event: gst::Event) -> bool {
+    fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -388,20 +386,20 @@ impl JsonToVtt {
                         }
                         Err(_) => gst::warning!(
                             CAT,
-                            obj: element,
+                            imp: self,
                             "Invalid force-key-unit event received from downstream: {:?}",
                             &ev
                         ),
                     }
                 }
-                pad.event_default(Some(element), event);
+                pad.event_default(Some(&*self.instance()), event);
                 true
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::JsonToVtt, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -412,7 +410,7 @@ impl JsonToVtt {
                 let buffers = state.handle_eos();
                 drop(state);
                 let _ = self.output(buffers);
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::Caps(..) => {
                 let mut downstream_caps = match self.srcpad.allowed_caps() {
@@ -455,8 +453,8 @@ impl JsonToVtt {
                         state.segment = s;
                     }
                     Err(err) => {
-                        element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::StreamError::Failed,
                             ["Time segment needed: {:?}", err]
                         );
@@ -465,7 +463,7 @@ impl JsonToVtt {
                 };
 
                 /* FIXME: Handle segment updates by draining? */
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::Gap(ev) => {
                 gst::log!(CAT, obj: pad, "Handling gap {:?}", ev);
@@ -475,7 +473,7 @@ impl JsonToVtt {
                 let _ = self.output(buffers);
                 true
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
@@ -501,14 +499,14 @@ impl ObjectSubclass for JsonToVtt {
                 JsonToVtt::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |this, element| this.sink_chain(pad, element, buffer),
+                    |this| this.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 JsonToVtt::catch_panic_pad_function(
                     parent,
                     || false,
-                    |this, element| this.sink_event(pad, element, event),
+                    |this| this.sink_event(pad, event),
                 )
             })
             .flags(gst::PadFlags::FIXED_CAPS)
@@ -521,7 +519,7 @@ impl ObjectSubclass for JsonToVtt {
                 JsonToVtt::catch_panic_pad_function(
                     parent,
                     || false,
-                    |this, element| this.src_event(pad, element, event),
+                    |this| this.src_event(pad, event),
                 )
             })
             .build();
@@ -535,9 +533,10 @@ impl ObjectSubclass for JsonToVtt {
 }
 
 impl ObjectImpl for JsonToVtt {
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -593,17 +592,16 @@ impl ElementImpl for JsonToVtt {
 
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         if transition == gst::StateChange::ReadyToPaused {
             let mut state = self.state.lock().unwrap();
             *state = State::default();
         }
 
-        self.parent_change_state(element, transition)
+        self.parent_change_state(transition)
     }
 }
 
diff --git a/video/closedcaption/src/mcc_enc/imp.rs b/video/closedcaption/src/mcc_enc/imp.rs
index 54c4f918..36a66434 100644
--- a/video/closedcaption/src/mcc_enc/imp.rs
+++ b/video/closedcaption/src/mcc_enc/imp.rs
@@ -246,7 +246,6 @@ impl MccEnc {
 
     fn generate_caption(
         &self,
-        element: &super::MccEnc,
         state: &State,
         buffer: &gst::Buffer,
         outbuf: &mut Vec<u8>,
@@ -254,8 +253,8 @@ impl MccEnc {
         let meta = buffer
             .meta::<gst_video::VideoTimeCodeMeta>()
             .ok_or_else(|| {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::StreamError::Format,
                     ["Stream with timecodes on each buffer required"]
                 );
@@ -266,8 +265,8 @@ impl MccEnc {
         let _ = write!(outbuf, "{}\t", meta.tc());
 
         let map = buffer.map_readable().map_err(|_| {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::StreamError::Format,
                 ["Failed to map buffer readable"]
             );
@@ -277,8 +276,8 @@ impl MccEnc {
 
         let len = map.len();
         if len >= 256 {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::StreamError::Format,
                 ["Too big buffer: {}", map.len()]
             );
@@ -314,7 +313,6 @@ impl MccEnc {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        element: &super::MccEnc,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
@@ -327,7 +325,7 @@ impl MccEnc {
             self.generate_headers(&*state, &mut outbuf)?;
         }
 
-        self.generate_caption(element, &*state, &buffer, &mut outbuf)?;
+        self.generate_caption(&*state, &buffer, &mut outbuf)?;
 
         let mut buf = gst::Buffer::from_mut_slice(outbuf);
         buffer
@@ -338,7 +336,7 @@ impl MccEnc {
         self.srcpad.push(buf)
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::MccEnc, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -377,11 +375,11 @@ impl MccEnc {
                     .build();
                 self.srcpad.push_event(gst::event::Caps::new(&caps))
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn src_event(&self, pad: &gst::Pad, element: &super::MccEnc, event: gst::Event) -> bool {
+    fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -390,16 +388,11 @@ impl MccEnc {
                 gst::log!(CAT, obj: pad, "Dropping seek event");
                 false
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn src_query(
-        &self,
-        pad: &gst::Pad,
-        element: &super::MccEnc,
-        query: &mut gst::QueryRef,
-    ) -> bool {
+    fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
         use gst::QueryViewMut;
 
         gst::log!(CAT, obj: pad, "Handling query {:?}", query);
@@ -415,7 +408,7 @@ impl MccEnc {
                 );
                 true
             }
-            _ => pad.query_default(Some(element), query),
+            _ => pad.query_default(Some(&*self.instance()), query),
         }
     }
 }
@@ -433,33 +426,21 @@ impl ObjectSubclass for MccEnc {
                 MccEnc::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |enc, element| enc.sink_chain(pad, element, buffer),
+                    |enc| enc.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
-                MccEnc::catch_panic_pad_function(
-                    parent,
-                    || false,
-                    |enc, element| enc.sink_event(pad, element, event),
-                )
+                MccEnc::catch_panic_pad_function(parent, || false, |enc| enc.sink_event(pad, event))
             })
             .build();
 
         let templ = klass.pad_template("src").unwrap();
         let srcpad = gst::Pad::builder_with_template(&templ, Some("src"))
             .event_function(|pad, parent, event| {
-                MccEnc::catch_panic_pad_function(
-                    parent,
-                    || false,
-                    |enc, element| enc.src_event(pad, element, event),
-                )
+                MccEnc::catch_panic_pad_function(parent, || false, |enc| enc.src_event(pad, event))
             })
             .query_function(|pad, parent, query| {
-                MccEnc::catch_panic_pad_function(
-                    parent,
-                    || false,
-                    |enc, element| enc.src_query(pad, element, query),
-                )
+                MccEnc::catch_panic_pad_function(parent, || false, |enc| enc.src_query(pad, query))
             })
             .build();
 
@@ -492,13 +473,7 @@ impl ObjectImpl for MccEnc {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "uuid" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -512,7 +487,7 @@ impl ObjectImpl for MccEnc {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "uuid" => {
                 let settings = self.settings.lock().unwrap();
@@ -526,9 +501,10 @@ impl ObjectImpl for MccEnc {
         }
     }
 
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -603,10 +579,9 @@ impl ElementImpl for MccEnc {
 
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => {
@@ -617,6 +592,6 @@ impl ElementImpl for MccEnc {
             _ => (),
         }
 
-        self.parent_change_state(element, transition)
+        self.parent_change_state(transition)
     }
 }
diff --git a/video/closedcaption/src/mcc_parse/imp.rs b/video/closedcaption/src/mcc_parse/imp.rs
index 30292b23..911ef21b 100644
--- a/video/closedcaption/src/mcc_parse/imp.rs
+++ b/video/closedcaption/src/mcc_parse/imp.rs
@@ -9,7 +9,6 @@
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{element_error, loggable_error};
 use gst_video::ValidVideoTimeCode;
 
 use std::cmp;
@@ -44,10 +43,12 @@ struct PullState {
 }
 
 impl PullState {
-    fn new(element: &super::MccParse, pad: &gst::Pad) -> Self {
+    fn new(imp: &MccParse, pad: &gst::Pad) -> Self {
         Self {
             need_stream_start: true,
-            stream_id: pad.create_stream_id(element, Some("src")).to_string(),
+            stream_id: pad
+                .create_stream_id(&*imp.instance(), Some("src"))
+                .to_string(),
             offset: 0,
             duration: gst::ClockTime::NONE,
         }
@@ -166,7 +167,7 @@ impl State {
 
     fn handle_timecode(
         &mut self,
-        element: &super::MccParse,
+        imp: &MccParse,
         framerate: gst::Fraction,
         drop_frame: bool,
         tc: TimeCode,
@@ -179,8 +180,8 @@ impl State {
                         .as_ref()
                         .map(Clone::clone)
                         .ok_or_else(|| {
-                            element_error!(
-                                element,
+                            gst::element_imp_error!(
+                                imp,
                                 gst::StreamError::Decode,
                                 ["Invalid first timecode {:?}", timecode]
                             );
@@ -190,7 +191,7 @@ impl State {
 
                 gst::warning!(
                     CAT,
-                    obj: element,
+                    imp: imp,
                     "Invalid timecode {:?}, using previous {:?}",
                     timecode,
                     last_timecode
@@ -203,11 +204,7 @@ impl State {
 
     /// Calculate a timestamp from the timecode and make sure to
     /// not produce timestamps jumping backwards
-    fn update_timestamp(
-        &mut self,
-        element: &super::MccParse,
-        timecode: &gst_video::ValidVideoTimeCode,
-    ) {
+    fn update_timestamp(&mut self, imp: &MccParse, timecode: &gst_video::ValidVideoTimeCode) {
         let nsecs = timecode.time_since_daily_jam();
         if self.start_position.is_none() {
             self.start_position = Some(nsecs);
@@ -217,7 +214,7 @@ impl State {
         let nsecs = nsecs.checked_sub(start_position).unwrap_or_else(|| {
             gst::fixme!(
                 CAT,
-                obj: element,
+                imp: imp,
                 "New position {} < start position {}",
                 nsecs,
                 start_position,
@@ -233,7 +230,7 @@ impl State {
         } else {
             gst::fixme!(
                 CAT,
-                obj: element,
+                imp: imp,
                 "New position {} < last position {}",
                 nsecs,
                 self.last_position.display(),
@@ -243,7 +240,7 @@ impl State {
 
     fn add_buffer_metadata(
         &mut self,
-        element: &super::MccParse,
+        imp: &MccParse,
         buffer: &mut gst::buffer::Buffer,
         timecode: &gst_video::ValidVideoTimeCode,
         framerate: gst::Fraction,
@@ -251,7 +248,7 @@ impl State {
         let buffer = buffer.get_mut().unwrap();
         gst_video::VideoTimeCodeMeta::add(buffer, timecode);
 
-        self.update_timestamp(element, timecode);
+        self.update_timestamp(imp, timecode);
 
         buffer.set_pts(self.last_position);
 
@@ -267,7 +264,7 @@ impl State {
 
     fn create_events(
         &mut self,
-        element: &super::MccParse,
+        imp: &MccParse,
         format: Option<Format>,
         framerate: gst::Fraction,
     ) -> Vec<gst::Event> {
@@ -307,7 +304,7 @@ impl State {
                 };
 
                 events.push(gst::event::Caps::new(&caps));
-                gst::info!(CAT, obj: element, "Caps changed to {:?}", &caps);
+                gst::info!(CAT, imp: imp, "Caps changed to {:?}", &caps);
             }
         }
 
@@ -355,7 +352,6 @@ impl AsMut<[u8]> for OffsetVec {
 impl MccParse {
     fn handle_buffer(
         &self,
-        element: &super::MccParse,
         buffer: Option<gst::Buffer>,
         scan_tc_rate: bool,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
@@ -363,8 +359,8 @@ impl MccParse {
 
         let drain = if let Some(buffer) = buffer {
             let buffer = buffer.into_mapped_buffer_readable().map_err(|_| {
-                element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::ResourceError::Read,
                     ["Failed to map buffer readable"]
                 );
@@ -386,15 +382,15 @@ impl MccParse {
 
                     gst::debug!(
                         CAT,
-                        obj: element,
+                        imp: self,
                         "Got caption buffer with timecode {:?} and size {}",
                         tc,
                         data.len()
                     );
 
                     if scan_tc_rate {
-                        element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::StreamError::Decode,
                             ["Found caption line while scanning for timecode rate"]
                         );
@@ -403,12 +399,7 @@ impl MccParse {
                     }
 
                     if data.len() < 3 {
-                        gst::debug!(
-                            CAT,
-                            obj: element,
-                            "Too small caption packet: {}",
-                            data.len(),
-                        );
+                        gst::debug!(CAT, imp: self, "Too small caption packet: {}", data.len(),);
                         continue;
                     }
 
@@ -416,7 +407,7 @@ impl MccParse {
                         (0x61, 0x01) => Format::Cea708Cdp,
                         (0x61, 0x02) => Format::Cea608,
                         (did, sdid) => {
-                            gst::debug!(CAT, obj: element, "Unknown DID {:x} SDID {:x}", did, sdid);
+                            gst::debug!(CAT, imp: self, "Unknown DID {:x} SDID {:x}", did, sdid);
                             continue;
                         }
                     };
@@ -425,7 +416,7 @@ impl MccParse {
                     if data.len() < 3 + len as usize {
                         gst::debug!(
                             CAT,
-                            obj: element,
+                            imp: self,
                             "Too small caption packet: {} < {}",
                             data.len(),
                             3 + len,
@@ -433,14 +424,14 @@ impl MccParse {
                         continue;
                     }
 
-                    state = self.handle_line(element, tc, data, format, state)?;
+                    state = self.handle_line(tc, data, format, state)?;
                 }
                 Ok(Some(MccLine::Caption(tc, None))) => {
                     assert!(state.seeking);
 
                     if scan_tc_rate {
-                        element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::StreamError::Decode,
                             ["Found caption line while scanning for timecode rate"]
                         );
@@ -448,12 +439,12 @@ impl MccParse {
                         break Err(gst::FlowError::Error);
                     }
 
-                    state = self.handle_skipped_line(element, tc, state)?;
+                    state = self.handle_skipped_line(tc, state)?;
                 }
                 Ok(Some(MccLine::TimeCodeRate(rate, df))) => {
                     gst::debug!(
                         CAT,
-                        obj: element,
+                        imp: self,
                         "Got timecode rate {} (drop frame {})",
                         rate,
                         df
@@ -465,11 +456,11 @@ impl MccParse {
                     }
                 }
                 Ok(Some(line)) => {
-                    gst::debug!(CAT, obj: element, "Got line '{:?}'", line);
+                    gst::debug!(CAT, imp: self, "Got line '{:?}'", line);
                 }
                 Err((line, err)) => {
-                    element_error!(
-                        element,
+                    gst::element_imp_error!(
+                        self,
                         gst::StreamError::Decode,
                         ["Couldn't parse line '{:?}': {:?}", line, err]
                     );
@@ -478,8 +469,8 @@ impl MccParse {
                 }
                 Ok(None) => {
                     if scan_tc_rate {
-                        element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::StreamError::Decode,
                             ["Found end of input while scanning for timecode rate"]
                         );
@@ -498,12 +489,11 @@ impl MccParse {
 
     fn handle_skipped_line(
         &self,
-        element: &super::MccParse,
         tc: TimeCode,
         mut state: MutexGuard<State>,
     ) -> Result<MutexGuard<State>, gst::FlowError> {
         let (framerate, drop_frame) = parse_timecode_rate(state.timecode_rate)?;
-        let timecode = state.handle_timecode(element, framerate, drop_frame, tc)?;
+        let timecode = state.handle_timecode(self, framerate, drop_frame, tc)?;
         let nsecs = timecode.time_since_daily_jam();
 
         state.last_timecode = Some(timecode);
@@ -526,15 +516,14 @@ impl MccParse {
 
     fn handle_line(
         &self,
-        element: &super::MccParse,
         tc: TimeCode,
         data: Vec<u8>,
         format: Format,
         mut state: MutexGuard<State>,
     ) -> Result<MutexGuard<State>, gst::FlowError> {
         let (framerate, drop_frame) = parse_timecode_rate(state.timecode_rate)?;
-        let events = state.create_events(element, Some(format), framerate);
-        let timecode = state.handle_timecode(element, framerate, drop_frame, tc)?;
+        let events = state.create_events(self, Some(format), framerate);
+        let timecode = state.handle_timecode(self, framerate, drop_frame, tc)?;
 
         let len = data[2] as usize;
         let mut buffer = gst::Buffer::from_mut_slice(OffsetVec {
@@ -543,7 +532,7 @@ impl MccParse {
             len,
         });
 
-        state.add_buffer_metadata(element, &mut buffer, &timecode, framerate);
+        state.add_buffer_metadata(self, &mut buffer, &timecode, framerate);
 
         // Update the last_timecode to the current one
         state.last_timecode = Some(timecode);
@@ -558,13 +547,13 @@ impl MccParse {
         drop(state);
 
         for event in events {
-            gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
+            gst::debug!(CAT, imp: self, "Pushing event {:?}", event);
             self.srcpad.push_event(event);
         }
 
         self.srcpad.push(buffer).map_err(|err| {
             if err != gst::FlowError::Flushing && err != gst::FlowError::Eos {
-                gst::error!(CAT, obj: element, "Pushing buffer returned {:?}", err);
+                gst::error!(CAT, imp: self, "Pushing buffer returned {:?}", err);
             }
             err
         })?;
@@ -576,11 +565,7 @@ impl MccParse {
         Ok(self.state.lock().unwrap())
     }
 
-    fn sink_activate(
-        &self,
-        pad: &gst::Pad,
-        element: &super::MccParse,
-    ) -> Result<(), gst::LoggableError> {
+    fn sink_activate(&self, pad: &gst::Pad) -> Result<(), gst::LoggableError> {
         let mode = {
             let mut query = gst::query::Scheduling::new();
             let mut state = self.state.lock().unwrap();
@@ -595,7 +580,7 @@ impl MccParse {
             {
                 gst::debug!(CAT, obj: pad, "Activating in Pull mode");
 
-                state.pull = Some(PullState::new(element, &self.srcpad));
+                state.pull = Some(PullState::new(self, &self.srcpad));
 
                 gst::PadMode::Pull
             } else {
@@ -608,25 +593,13 @@ impl MccParse {
         Ok(())
     }
 
-    fn start_task(&self, element: &super::MccParse) -> Result<(), gst::LoggableError> {
-        let element_weak = element.downgrade();
-        let pad_weak = self.sinkpad.downgrade();
+    fn start_task(&self) -> Result<(), gst::LoggableError> {
+        let imp = self.ref_counted();
         let res = self.sinkpad.start_task(move || {
-            let element = match element_weak.upgrade() {
-                Some(element) => element,
-                None => {
-                    if let Some(pad) = pad_weak.upgrade() {
-                        let _ = pad.pause_task();
-                    }
-                    return;
-                }
-            };
-
-            let parse = element.imp();
-            parse.loop_fn(&element);
+            imp.loop_fn();
         });
         if res.is_err() {
-            return Err(loggable_error!(CAT, "Failed to start pad task"));
+            return Err(gst::loggable_error!(CAT, "Failed to start pad task"));
         }
         Ok(())
     }
@@ -634,13 +607,12 @@ impl MccParse {
     fn sink_activatemode(
         &self,
         _pad: &gst::Pad,
-        element: &super::MccParse,
         mode: gst::PadMode,
         active: bool,
     ) -> Result<(), gst::LoggableError> {
         if mode == gst::PadMode::Pull {
             if active {
-                self.start_task(element)?;
+                self.start_task()?;
             } else {
                 let _ = self.sinkpad.stop_task();
             }
@@ -649,23 +621,26 @@ impl MccParse {
         Ok(())
     }
 
-    fn scan_duration(
-        &self,
-        element: &super::MccParse,
-    ) -> Result<Option<ValidVideoTimeCode>, gst::LoggableError> {
-        gst::debug!(CAT, obj: element, "Scanning duration");
+    fn scan_duration(&self) -> Result<Option<ValidVideoTimeCode>, gst::LoggableError> {
+        gst::debug!(CAT, imp: self, "Scanning duration");
 
         /* First let's query the bytes duration upstream */
         let mut q = gst::query::Duration::new(gst::Format::Bytes);
 
         if !self.sinkpad.peer_query(&mut q) {
-            return Err(loggable_error!(CAT, "Failed to query upstream duration"));
+            return Err(gst::loggable_error!(
+                CAT,
+                "Failed to query upstream duration"
+            ));
         }
 
         let size = match q.result().try_into().unwrap() {
             Some(gst::format::Bytes(size)) => size,
             None => {
-                return Err(loggable_error!(CAT, "Failed to query upstream duration"));
+                return Err(gst::loggable_error!(
+                    CAT,
+                    "Failed to query upstream duration"
+                ));
             }
         };
 
@@ -683,7 +658,7 @@ impl MccParse {
                     buffers.push(buffer);
                 }
                 Err(flow) => {
-                    return Err(loggable_error!(
+                    return Err(gst::loggable_error!(
                         CAT,
                         "Failed to pull buffer while scanning duration: {:?}",
                         flow
@@ -698,7 +673,7 @@ impl MccParse {
                 let buf = buf
                     .clone()
                     .into_mapped_buffer_readable()
-                    .map_err(|_| loggable_error!(CAT, "Failed to map buffer readable"))?;
+                    .map_err(|_| gst::loggable_error!(CAT, "Failed to map buffer readable"))?;
 
                 reader.push(buf);
             }
@@ -709,7 +684,7 @@ impl MccParse {
                 {
                     let state = self.state.lock().unwrap();
                     let (framerate, drop_frame) = parse_timecode_rate(state.timecode_rate)
-                        .map_err(|_| loggable_error!(CAT, "Failed to parse timecode rate"))?;
+                        .map_err(|_| gst::loggable_error!(CAT, "Failed to parse timecode rate"))?;
                     if let Ok(mut timecode) = parse_timecode(framerate, drop_frame, tc) {
                         /* We're looking for the total duration */
                         timecode.increment_frame();
@@ -720,18 +695,13 @@ impl MccParse {
             }
 
             if last_tc.is_some() || offset == 0 {
-                gst::debug!(
-                    CAT,
-                    obj: element,
-                    "Duration scan done, last_tc: {:?}",
-                    last_tc
-                );
+                gst::debug!(CAT, imp: self, "Duration scan done, last_tc: {:?}", last_tc);
                 break (Ok(last_tc));
             }
         }
     }
 
-    fn push_eos(&self, element: &super::MccParse) {
+    fn push_eos(&self) {
         let mut state = self.state.lock().unwrap();
 
         if state.seeking {
@@ -740,7 +710,7 @@ impl MccParse {
 
         match parse_timecode_rate(state.timecode_rate) {
             Ok((framerate, _)) => {
-                let mut events = state.create_events(element, None, framerate);
+                let mut events = state.create_events(self, None, framerate);
                 let mut eos_event = gst::event::Eos::builder();
 
                 if let Some(seek_seqnum) = state.seek_seqnum {
@@ -753,13 +723,13 @@ impl MccParse {
                 drop(state);
 
                 for event in events {
-                    gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
+                    gst::debug!(CAT, imp: self, "Pushing event {:?}", event);
                     self.srcpad.push_event(event);
                 }
             }
             Err(_) => {
-                element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::StreamError::Failed,
                     ["Streaming stopped, failed to parse timecode rate"]
                 );
@@ -767,7 +737,7 @@ impl MccParse {
         }
     }
 
-    fn loop_fn(&self, element: &super::MccParse) {
+    fn loop_fn(&self) {
         let mut state = self.state.lock().unwrap();
         let State {
             timecode_rate: ref tc_rate,
@@ -794,8 +764,8 @@ impl MccParse {
             Err(flow) => {
                 gst::error!(CAT, obj: &self.sinkpad, "Failed to pull, reason: {:?}", flow);
 
-                element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::StreamError::Failed,
                     ["Streaming stopped, failed to pull buffer"]
                 );
@@ -805,11 +775,11 @@ impl MccParse {
             }
         };
 
-        match self.handle_buffer(element, buffer, scan_tc_rate) {
+        match self.handle_buffer(buffer, scan_tc_rate) {
             Ok(_) => {
                 let tc_rate = self.state.lock().unwrap().timecode_rate;
                 if scan_tc_rate && tc_rate.is_some() {
-                    match self.scan_duration(element) {
+                    match self.scan_duration() {
                         Ok(Some(tc)) => {
                             let mut state = self.state.lock().unwrap();
                             let mut pull = state.pull.as_mut().unwrap();
@@ -823,8 +793,8 @@ impl MccParse {
                         Err(err) => {
                             err.log();
 
-                            element_error!(
-                                element,
+                            gst::element_imp_error!(
+                                self,
                                 gst::StreamError::Decode,
                                 ["Failed to scan duration"]
                             );
@@ -837,20 +807,20 @@ impl MccParse {
             Err(flow) => {
                 match flow {
                     gst::FlowError::Flushing => {
-                        gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow);
+                        gst::debug!(CAT, imp: self, "Pausing after flow {:?}", flow);
                     }
                     gst::FlowError::Eos => {
-                        self.push_eos(element);
+                        self.push_eos();
 
-                        gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow);
+                        gst::debug!(CAT, imp: self, "Pausing after flow {:?}", flow);
                     }
                     _ => {
-                        self.push_eos(element);
+                        self.push_eos();
 
-                        gst::error!(CAT, obj: element, "Pausing after flow {:?}", flow);
+                        gst::error!(CAT, imp: self, "Pausing after flow {:?}", flow);
 
-                        element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::StreamError::Failed,
                             ["Streaming stopped, reason: {:?}", flow]
                         );
@@ -865,12 +835,11 @@ impl MccParse {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        element: &super::MccParse,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
 
-        self.handle_buffer(element, Some(buffer), false)
+        self.handle_buffer(Some(buffer), false)
     }
 
     fn flush(&self, mut state: MutexGuard<State>) -> MutexGuard<State> {
@@ -893,7 +862,7 @@ impl MccParse {
         self.state.lock().unwrap()
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::MccParse, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -914,14 +883,14 @@ impl MccParse {
                 let state = self.flush(state);
                 drop(state);
 
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::Eos(_) => {
                 gst::log!(CAT, obj: pad, "Draining");
-                if let Err(err) = self.handle_buffer(element, None, false) {
+                if let Err(err) = self.handle_buffer(None, false) {
                     gst::error!(CAT, obj: pad, "Failed to drain parser: {:?}", err);
                 }
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             _ => {
                 if event.is_sticky()
@@ -933,15 +902,15 @@ impl MccParse {
                     state.pending_events.push(event);
                     true
                 } else {
-                    pad.event_default(Some(element), event)
+                    pad.event_default(Some(&*self.instance()), event)
                 }
             }
         }
     }
 
-    fn perform_seek(&self, event: &gst::event::Seek, element: &super::MccParse) -> bool {
+    fn perform_seek(&self, event: &gst::event::Seek) -> bool {
         if self.state.lock().unwrap().pull.is_none() {
-            gst::error!(CAT, obj: element, "seeking is only supported in pull mode");
+            gst::error!(CAT, imp: self, "seeking is only supported in pull mode");
             return false;
         }
 
@@ -950,7 +919,7 @@ impl MccParse {
         let mut start: Option<gst::ClockTime> = match start.try_into() {
             Ok(start) => start,
             Err(_) => {
-                gst::error!(CAT, obj: element, "seek has invalid format");
+                gst::error!(CAT, imp: self, "seek has invalid format");
                 return false;
             }
         };
@@ -958,18 +927,18 @@ impl MccParse {
         let mut stop: Option<gst::ClockTime> = match stop.try_into() {
             Ok(stop) => stop,
             Err(_) => {
-                gst::error!(CAT, obj: element, "seek has invalid format");
+                gst::error!(CAT, imp: self, "seek has invalid format");
                 return false;
             }
         };
 
         if !flags.contains(gst::SeekFlags::FLUSH) {
-            gst::error!(CAT, obj: element, "only flushing seeks are supported");
+            gst::error!(CAT, imp: self, "only flushing seeks are supported");
             return false;
         }
 
         if start_type == gst::SeekType::End || stop_type == gst::SeekType::End {
-            gst::error!(CAT, obj: element, "Relative seeks are not supported");
+            gst::error!(CAT, imp: self, "Relative seeks are not supported");
             return false;
         }
 
@@ -979,14 +948,14 @@ impl MccParse {
             .seqnum(seek_seqnum)
             .build();
 
-        gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event);
+        gst::debug!(CAT, imp: self, "Sending event {:?} upstream", event);
         self.sinkpad.push_event(event);
 
         let event = gst::event::FlushStart::builder()
             .seqnum(seek_seqnum)
             .build();
 
-        gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
+        gst::debug!(CAT, imp: self, "Pushing event {:?}", event);
         self.srcpad.push_event(event);
 
         let _ = self.sinkpad.pause_task();
@@ -1014,7 +983,7 @@ impl MccParse {
         /* Drop our state while we push a serialized event upstream */
         drop(state);
 
-        gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event);
+        gst::debug!(CAT, imp: self, "Sending event {:?} upstream", event);
         self.sinkpad.push_event(event);
 
         state = self.state.lock().unwrap();
@@ -1023,7 +992,7 @@ impl MccParse {
             .segment
             .do_seek(rate, flags, start_type, start, stop_type, stop);
 
-        match self.start_task(element) {
+        match self.start_task() {
             Err(error) => {
                 error.log();
                 false
@@ -1032,22 +1001,17 @@ impl MccParse {
         }
     }
 
-    fn src_event(&self, pad: &gst::Pad, element: &super::MccParse, event: gst::Event) -> bool {
+    fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
         match event.view() {
-            EventView::Seek(e) => self.perform_seek(e, element),
-            _ => pad.event_default(Some(element), event),
+            EventView::Seek(e) => self.perform_seek(e),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn src_query(
-        &self,
-        pad: &gst::Pad,
-        element: &super::MccParse,
-        query: &mut gst::QueryRef,
-    ) -> bool {
+    fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
         use gst::QueryViewMut;
 
         gst::log!(CAT, obj: pad, "Handling query {:?}", query);
@@ -1097,7 +1061,7 @@ impl MccParse {
                     self.sinkpad.peer_query(query)
                 }
             }
-            _ => pad.query_default(Some(element), query),
+            _ => pad.query_default(Some(&*self.instance()), query),
         }
     }
 }
@@ -1114,29 +1078,34 @@ impl ObjectSubclass for MccParse {
             .activate_function(|pad, parent| {
                 MccParse::catch_panic_pad_function(
                     parent,
-                    || Err(loggable_error!(CAT, "Panic activating sink pad")),
-                    |parse, element| parse.sink_activate(pad, element),
+                    || Err(gst::loggable_error!(CAT, "Panic activating sink pad")),
+                    |parse| parse.sink_activate(pad),
                 )
             })
             .activatemode_function(|pad, parent, mode, active| {
                 MccParse::catch_panic_pad_function(
                     parent,
-                    || Err(loggable_error!(CAT, "Panic activating sink pad with mode")),
-                    |parse, element| parse.sink_activatemode(pad, element, mode, active),
+                    || {
+                        Err(gst::loggable_error!(
+                            CAT,
+                            "Panic activating sink pad with mode"
+                        ))
+                    },
+                    |parse| parse.sink_activatemode(pad, mode, active),
                 )
             })
             .chain_function(|pad, parent, buffer| {
                 MccParse::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |parse, element| parse.sink_chain(pad, element, buffer),
+                    |parse| parse.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 MccParse::catch_panic_pad_function(
                     parent,
                     || false,
-                    |parse, element| parse.sink_event(pad, element, event),
+                    |parse| parse.sink_event(pad, event),
                 )
             })
             .build();
@@ -1147,14 +1116,14 @@ impl ObjectSubclass for MccParse {
                 MccParse::catch_panic_pad_function(
                     parent,
                     || false,
-                    |parse, element| parse.src_event(pad, element, event),
+                    |parse| parse.src_event(pad, event),
                 )
             })
             .query_function(|pad, parent, query| {
                 MccParse::catch_panic_pad_function(
                     parent,
                     || false,
-                    |parse, element| parse.src_query(pad, element, query),
+                    |parse| parse.src_query(pad, query),
                 )
             })
             .build();
@@ -1168,9 +1137,10 @@ impl ObjectSubclass for MccParse {
 }
 
 impl ObjectImpl for MccParse {
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -1241,10 +1211,9 @@ impl ElementImpl for MccParse {
 
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => {
@@ -1255,6 +1224,6 @@ impl ElementImpl for MccParse {
             _ => (),
         }
 
-        self.parent_change_state(element, transition)
+        self.parent_change_state(transition)
     }
 }
diff --git a/video/closedcaption/src/scc_enc/imp.rs b/video/closedcaption/src/scc_enc/imp.rs
index 93f5d79a..2b37a4f6 100644
--- a/video/closedcaption/src/scc_enc/imp.rs
+++ b/video/closedcaption/src/scc_enc/imp.rs
@@ -76,7 +76,7 @@ impl State {
 
     fn generate_caption(
         &mut self,
-        element: &super::SccEnc,
+        imp: &SccEnc,
         buffer: gst::Buffer,
     ) -> Result<Option<gst::Buffer>, gst::FlowError> {
         // Arbitrary number that was chosen to keep in order
@@ -86,8 +86,8 @@ impl State {
         assert!(self.internal_buffer.len() < MAXIMUM_PACKETES_PER_LINE);
 
         if buffer.size() != 2 {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                imp,
                 gst::StreamError::Format,
                 ["Wrongly sized CEA608 packet: {}", buffer.size()]
             );
@@ -97,8 +97,8 @@ impl State {
 
         if !self.settings.output_padding {
             let map = buffer.map_readable().map_err(|_| {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    imp,
                     gst::StreamError::Format,
                     ["Failed to map buffer readable"]
                 );
@@ -116,8 +116,8 @@ impl State {
         let mut timecode = buffer
             .meta::<gst_video::VideoTimeCodeMeta>()
             .ok_or_else(|| {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    imp,
                     gst::StreamError::Format,
                     ["Stream with timecodes on each buffer required"]
                 );
@@ -140,7 +140,7 @@ impl State {
         // flush the previous line into the buffer, and push
         // the new packet to the, now empty, internal buffer
         if Some(&timecode) != self.expected_timecode.as_ref() {
-            let outbuf = self.write_line(element)?;
+            let outbuf = self.write_line(imp)?;
 
             assert!(self.internal_buffer.is_empty());
             self.internal_buffer.push(buffer);
@@ -156,17 +156,14 @@ impl State {
         self.internal_buffer.push(buffer);
 
         if self.internal_buffer.len() == MAXIMUM_PACKETES_PER_LINE {
-            return self.write_line(element);
+            return self.write_line(imp);
         }
 
         Ok(None)
     }
 
     // Flush the internal buffers into a line
-    fn write_line(
-        &mut self,
-        element: &super::SccEnc,
-    ) -> Result<Option<gst::Buffer>, gst::FlowError> {
+    fn write_line(&mut self, imp: &SccEnc) -> Result<Option<gst::Buffer>, gst::FlowError> {
         let mut outbuf = Vec::new();
         let mut line_start = true;
 
@@ -181,8 +178,8 @@ impl State {
         let first_buf = self.internal_buffer.first().unwrap();
         for buffer in self.internal_buffer.iter() {
             let map = buffer.map_readable().map_err(|_| {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    imp,
                     gst::StreamError::Format,
                     ["Failed to map buffer readable"]
                 );
@@ -251,13 +248,12 @@ impl SccEnc {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        element: &super::SccEnc,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
 
         let mut state = self.state.lock().unwrap();
-        let res = state.generate_caption(element, buffer)?;
+        let res = state.generate_caption(self, buffer)?;
 
         if let Some(outbuf) = res {
             gst::trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &outbuf);
@@ -269,7 +265,7 @@ impl SccEnc {
         Ok(gst::FlowSuccess::Ok)
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -297,7 +293,7 @@ impl SccEnc {
             EventView::Eos(_) => {
                 let mut state = self.state.lock().unwrap();
 
-                let outbuf = state.write_line(element);
+                let outbuf = state.write_line(self);
 
                 if let Ok(Some(buffer)) = outbuf {
                     gst::trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &buffer);
@@ -311,13 +307,13 @@ impl SccEnc {
                     gst::error!(CAT, obj: pad, "Failed to write a line after EOS: {:?}", err);
                     return false;
                 }
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn src_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool {
+    fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -326,16 +322,11 @@ impl SccEnc {
                 gst::log!(CAT, obj: pad, "Dropping seek event");
                 false
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn src_query(
-        &self,
-        pad: &gst::Pad,
-        element: &super::SccEnc,
-        query: &mut gst::QueryRef,
-    ) -> bool {
+    fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
         use gst::QueryViewMut;
 
         gst::log!(CAT, obj: pad, "Handling query {:?}", query);
@@ -351,7 +342,7 @@ impl SccEnc {
                 );
                 true
             }
-            _ => pad.query_default(Some(element), query),
+            _ => pad.query_default(Some(&*self.instance()), query),
         }
     }
 }
@@ -369,33 +360,21 @@ impl ObjectSubclass for SccEnc {
                 SccEnc::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |enc, element| enc.sink_chain(pad, element, buffer),
+                    |enc| enc.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
-                SccEnc::catch_panic_pad_function(
-                    parent,
-                    || false,
-                    |enc, element| enc.sink_event(pad, element, event),
-                )
+                SccEnc::catch_panic_pad_function(parent, || false, |enc| enc.sink_event(pad, event))
             })
             .build();
 
         let templ = klass.pad_template("src").unwrap();
         let srcpad = gst::Pad::builder_with_template(&templ, Some("src"))
             .event_function(|pad, parent, event| {
-                SccEnc::catch_panic_pad_function(
-                    parent,
-                    || false,
-                    |enc, element| enc.src_event(pad, element, event),
-                )
+                SccEnc::catch_panic_pad_function(parent, || false, |enc| enc.src_event(pad, event))
             })
             .query_function(|pad, parent, query| {
-                SccEnc::catch_panic_pad_function(
-                    parent,
-                    || false,
-                    |enc, element| enc.src_query(pad, element, query),
-                )
+                SccEnc::catch_panic_pad_function(parent, || false, |enc| enc.src_query(pad, query))
             })
             .build();
 
@@ -409,9 +388,10 @@ impl ObjectSubclass for SccEnc {
 }
 
 impl ObjectImpl for SccEnc {
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -433,13 +413,7 @@ impl ObjectImpl for SccEnc {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "output-padding" => {
                 self.settings.lock().unwrap().output_padding =
@@ -449,7 +423,7 @@ impl ObjectImpl for SccEnc {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "output-padding" => {
                 let settings = self.settings.lock().unwrap();
@@ -509,10 +483,9 @@ impl ElementImpl for SccEnc {
 
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused => {
@@ -529,6 +502,6 @@ impl ElementImpl for SccEnc {
             _ => (),
         }
 
-        self.parent_change_state(element, transition)
+        self.parent_change_state(transition)
     }
 }
diff --git a/video/closedcaption/src/scc_parse/imp.rs b/video/closedcaption/src/scc_parse/imp.rs
index 2a90ba43..5581f31a 100644
--- a/video/closedcaption/src/scc_parse/imp.rs
+++ b/video/closedcaption/src/scc_parse/imp.rs
@@ -10,7 +10,6 @@
 use gst::glib;
 use gst::prelude::*;
 use gst::subclass::prelude::*;
-use gst::{element_error, loggable_error};
 
 use std::cmp;
 use std::sync::{Mutex, MutexGuard};
@@ -38,10 +37,12 @@ struct PullState {
 }
 
 impl PullState {
-    fn new(element: &super::SccParse, pad: &gst::Pad) -> Self {
+    fn new(imp: &SccParse, pad: &gst::Pad) -> Self {
         Self {
             need_stream_start: true,
-            stream_id: pad.create_stream_id(element, Some("src")).to_string(),
+            stream_id: pad
+                .create_stream_id(&*imp.instance(), Some("src"))
+                .to_string(),
             offset: 0,
             duration: gst::ClockTime::NONE,
         }
@@ -142,7 +143,7 @@ impl State {
         &mut self,
         tc: &TimeCode,
         framerate: gst::Fraction,
-        element: &super::SccParse,
+        imp: &SccParse,
     ) -> Result<gst_video::ValidVideoTimeCode, gst::FlowError> {
         match parse_timecode(framerate, tc) {
             Ok(timecode) => Ok(timecode),
@@ -152,8 +153,8 @@ impl State {
                         .as_ref()
                         .map(Clone::clone)
                         .ok_or_else(|| {
-                            element_error!(
-                                element,
+                            gst::element_imp_error!(
+                                imp,
                                 gst::StreamError::Decode,
                                 ["Invalid first timecode {:?}", err]
                             );
@@ -163,7 +164,7 @@ impl State {
 
                 gst::warning!(
                     CAT,
-                    obj: element,
+                    imp: imp,
                     "Invalid timecode {:?}, using previous {:?}",
                     err,
                     last_timecode
@@ -176,11 +177,7 @@ impl State {
 
     /// Calculate a timestamp from the timecode and make sure to
     /// not produce timestamps jumping backwards
-    fn update_timestamp(
-        &mut self,
-        timecode: &gst_video::ValidVideoTimeCode,
-        element: &super::SccParse,
-    ) {
+    fn update_timestamp(&mut self, timecode: &gst_video::ValidVideoTimeCode, imp: &SccParse) {
         let nsecs = timecode.time_since_daily_jam();
 
         if self
@@ -191,7 +188,7 @@ impl State {
         } else {
             gst::fixme!(
                 CAT,
-                obj: element,
+                imp: imp,
                 "New position {} < last position {}",
                 nsecs,
                 self.last_position.display(),
@@ -204,12 +201,12 @@ impl State {
         buffer: &mut gst::buffer::Buffer,
         timecode: &gst_video::ValidVideoTimeCode,
         framerate: gst::Fraction,
-        element: &super::SccParse,
+        imp: &SccParse,
     ) {
         let buffer = buffer.get_mut().unwrap();
         gst_video::VideoTimeCodeMeta::add(buffer, timecode);
 
-        self.update_timestamp(timecode, element);
+        self.update_timestamp(timecode, imp);
 
         buffer.set_pts(self.last_position);
         buffer.set_duration(
@@ -219,7 +216,7 @@ impl State {
 
     fn create_events(
         &mut self,
-        element: &super::SccParse,
+        imp: &SccParse,
         framerate: Option<gst::Fraction>,
     ) -> Vec<gst::Event> {
         let mut events = Vec::new();
@@ -253,7 +250,7 @@ impl State {
                 self.framerate = Some(framerate);
 
                 events.push(gst::event::Caps::new(&caps));
-                gst::info!(CAT, obj: element, "Caps changed to {:?}", &caps);
+                gst::info!(CAT, imp: imp, "Caps changed to {:?}", &caps);
             }
         }
 
@@ -282,15 +279,14 @@ pub struct SccParse {
 impl SccParse {
     fn handle_buffer(
         &self,
-        element: &super::SccParse,
         buffer: Option<gst::Buffer>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         let mut state = self.state.lock().unwrap();
 
         let drain = if let Some(buffer) = buffer {
             let buffer = buffer.into_mapped_buffer_readable().map_err(|_| {
-                element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::ResourceError::Read,
                     ["Failed to map buffer readable"]
                 );
@@ -308,14 +304,14 @@ impl SccParse {
             let line = state.line(drain);
             match line {
                 Ok(Some(SccLine::Caption(tc, data))) => {
-                    state = self.handle_line(tc, data, element, state)?;
+                    state = self.handle_line(tc, data, state)?;
                 }
                 Ok(Some(line)) => {
-                    gst::debug!(CAT, obj: element, "Got line '{:?}'", line);
+                    gst::debug!(CAT, imp: self, "Got line '{:?}'", line);
                 }
                 Err((line, err)) => {
-                    element_error!(
-                        element,
+                    gst::element_imp_error!(
+                        self,
                         gst::StreamError::Decode,
                         ["Couldn't parse line '{:?}': {:?}", line, err]
                     );
@@ -336,12 +332,11 @@ impl SccParse {
         &self,
         tc: TimeCode,
         data: Vec<u8>,
-        element: &super::SccParse,
         mut state: MutexGuard<State>,
     ) -> Result<MutexGuard<State>, gst::FlowError> {
         gst::trace!(
             CAT,
-            obj: element,
+            imp: self,
             "Got caption buffer with timecode {:?} and size {}",
             tc,
             data.len()
@@ -355,7 +350,7 @@ impl SccParse {
             gst::Fraction::new(30, 1)
         };
 
-        let mut timecode = state.handle_timecode(&tc, framerate, element)?;
+        let mut timecode = state.handle_timecode(&tc, framerate, self)?;
         let start_time = timecode.time_since_daily_jam();
         let segment_start = state.segment.start();
         let clip_buffers = if state.seeking {
@@ -369,7 +364,7 @@ impl SccParse {
 
             gst::trace!(
                 CAT,
-                obj: element,
+                imp: self,
                 "Checking inside of segment, line start {} line stop {} segment start {} num bufs {}",
                 start_time,
                 stop_time,
@@ -408,18 +403,13 @@ impl SccParse {
                 buf_mut.copy_from_slice(0, d).unwrap();
             }
 
-            state.add_buffer_metadata(&mut buffer, &timecode, framerate, element);
+            state.add_buffer_metadata(&mut buffer, &timecode, framerate, self);
             timecode.increment_frame();
 
             if clip_buffers {
                 let end_time = buffer.pts().opt_add(buffer.duration());
                 if end_time.opt_lt(segment_start).unwrap_or(false) {
-                    gst::trace!(
-                        CAT,
-                        obj: element,
-                        "Skip segment clipped buffer {:?}",
-                        buffer,
-                    );
+                    gst::trace!(CAT, imp: self, "Skip segment clipped buffer {:?}", buffer,);
 
                     continue;
                 }
@@ -443,19 +433,19 @@ impl SccParse {
         // Update the last_timecode to the current one
         state.last_timecode = Some(timecode);
 
-        let events = state.create_events(element, Some(framerate));
+        let events = state.create_events(self, Some(framerate));
 
         // Drop our state mutex while we push out buffers or events
         drop(state);
 
         for event in events {
-            gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
+            gst::debug!(CAT, imp: self, "Pushing event {:?}", event);
             self.srcpad.push_event(event);
         }
 
         self.srcpad.push_list(buffers).map_err(|err| {
             if err != gst::FlowError::Flushing && err != gst::FlowError::Eos {
-                gst::error!(CAT, obj: element, "Pushing buffer returned {:?}", err);
+                gst::error!(CAT, imp: self, "Pushing buffer returned {:?}", err);
             }
             err
         })?;
@@ -467,11 +457,7 @@ impl SccParse {
         Ok(self.state.lock().unwrap())
     }
 
-    fn sink_activate(
-        &self,
-        pad: &gst::Pad,
-        element: &super::SccParse,
-    ) -> Result<(), gst::LoggableError> {
+    fn sink_activate(&self, pad: &gst::Pad) -> Result<(), gst::LoggableError> {
         let mode = {
             let mut query = gst::query::Scheduling::new();
             let mut state = self.state.lock().unwrap();
@@ -486,7 +472,7 @@ impl SccParse {
             {
                 gst::debug!(CAT, obj: pad, "Activating in Pull mode");
 
-                state.pull = Some(PullState::new(element, &self.srcpad));
+                state.pull = Some(PullState::new(self, &self.srcpad));
 
                 gst::PadMode::Pull
             } else {
@@ -499,25 +485,13 @@ impl SccParse {
         Ok(())
     }
 
-    fn start_task(&self, element: &super::SccParse) -> Result<(), gst::LoggableError> {
-        let element_weak = element.downgrade();
-        let pad_weak = self.sinkpad.downgrade();
+    fn start_task(&self) -> Result<(), gst::LoggableError> {
+        let imp = self.ref_counted();
         let res = self.sinkpad.start_task(move || {
-            let element = match element_weak.upgrade() {
-                Some(element) => element,
-                None => {
-                    if let Some(pad) = pad_weak.upgrade() {
-                        let _ = pad.pause_task();
-                    }
-                    return;
-                }
-            };
-
-            let parse = element.imp();
-            parse.loop_fn(&element);
+            imp.loop_fn();
         });
         if res.is_err() {
-            return Err(loggable_error!(CAT, "Failed to start pad task"));
+            return Err(gst::loggable_error!(CAT, "Failed to start pad task"));
         }
         Ok(())
     }
@@ -525,13 +499,12 @@ impl SccParse {
     fn sink_activatemode(
         &self,
         _pad: &gst::Pad,
-        element: &super::SccParse,
         mode: gst::PadMode,
         active: bool,
     ) -> Result<(), gst::LoggableError> {
         if mode == gst::PadMode::Pull {
             if active {
-                self.start_task(element)?;
+                self.start_task()?;
             } else {
                 let _ = self.sinkpad.stop_task();
             }
@@ -540,23 +513,26 @@ impl SccParse {
         Ok(())
     }
 
-    fn scan_duration(
-        &self,
-        element: &super::SccParse,
-    ) -> Result<Option<gst_video::ValidVideoTimeCode>, gst::LoggableError> {
-        gst::debug!(CAT, obj: element, "Scanning duration");
+    fn scan_duration(&self) -> Result<Option<gst_video::ValidVideoTimeCode>, gst::LoggableError> {
+        gst::debug!(CAT, imp: self, "Scanning duration");
 
         /* First let's query the bytes duration upstream */
         let mut q = gst::query::Duration::new(gst::Format::Bytes);
 
         if !self.sinkpad.peer_query(&mut q) {
-            return Err(loggable_error!(CAT, "Failed to query upstream duration"));
+            return Err(gst::loggable_error!(
+                CAT,
+                "Failed to query upstream duration"
+            ));
         }
 
         let size = match q.result().try_into().unwrap() {
             Some(gst::format::Bytes(size)) => size,
             None => {
-                return Err(loggable_error!(CAT, "Failed to query upstream duration"));
+                return Err(gst::loggable_error!(
+                    CAT,
+                    "Failed to query upstream duration"
+                ));
             }
         };
 
@@ -574,7 +550,7 @@ impl SccParse {
                     buffers.push(buffer);
                 }
                 Err(flow) => {
-                    return Err(loggable_error!(
+                    return Err(gst::loggable_error!(
                         CAT,
                         "Failed to pull buffer while scanning duration: {:?}",
                         flow
@@ -589,7 +565,7 @@ impl SccParse {
                 let buf = buf
                     .clone()
                     .into_mapped_buffer_readable()
-                    .map_err(|_| loggable_error!(CAT, "Failed to map buffer readable"))?;
+                    .map_err(|_| gst::loggable_error!(CAT, "Failed to map buffer readable"))?;
 
                 reader.push(buf);
             }
@@ -613,25 +589,20 @@ impl SccParse {
             }
 
             if last_tc.is_some() || offset == 0 {
-                gst::debug!(
-                    CAT,
-                    obj: element,
-                    "Duration scan done, last_tc: {:?}",
-                    last_tc
-                );
+                gst::debug!(CAT, imp: self, "Duration scan done, last_tc: {:?}", last_tc);
                 break (Ok(last_tc));
             }
         }
     }
 
-    fn push_eos(&self, element: &super::SccParse) {
+    fn push_eos(&self) {
         let mut state = self.state.lock().unwrap();
 
         if state.seeking {
             state.need_flush_stop = true;
         }
 
-        let mut events = state.create_events(element, None);
+        let mut events = state.create_events(self, None);
         let mut eos_event = gst::event::Eos::builder();
 
         if let Some(seek_seqnum) = state.seek_seqnum {
@@ -644,12 +615,12 @@ impl SccParse {
         drop(state);
 
         for event in events {
-            gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
+            gst::debug!(CAT, imp: self, "Pushing event {:?}", event);
             self.srcpad.push_event(event);
         }
     }
 
-    fn loop_fn(&self, element: &super::SccParse) {
+    fn loop_fn(&self) {
         let mut state = self.state.lock().unwrap();
         let State {
             ref framerate,
@@ -676,8 +647,8 @@ impl SccParse {
             Err(flow) => {
                 gst::error!(CAT, obj: &self.sinkpad, "Failed to pull, reason: {:?}", flow);
 
-                element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::StreamError::Failed,
                     ["Streaming stopped, failed to pull buffer"]
                 );
@@ -687,10 +658,10 @@ impl SccParse {
             }
         };
 
-        match self.handle_buffer(element, buffer) {
+        match self.handle_buffer(buffer) {
             Ok(_) => {
                 if scan_duration {
-                    match self.scan_duration(element) {
+                    match self.scan_duration() {
                         Ok(Some(tc)) => {
                             let mut state = self.state.lock().unwrap();
                             let mut pull = state.pull.as_mut().unwrap();
@@ -704,8 +675,8 @@ impl SccParse {
                         Err(err) => {
                             err.log();
 
-                            element_error!(
-                                element,
+                            gst::element_imp_error!(
+                                self,
                                 gst::StreamError::Decode,
                                 ["Failed to scan duration"]
                             );
@@ -718,20 +689,20 @@ impl SccParse {
             Err(flow) => {
                 match flow {
                     gst::FlowError::Flushing => {
-                        gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow);
+                        gst::debug!(CAT, imp: self, "Pausing after flow {:?}", flow);
                     }
                     gst::FlowError::Eos => {
-                        self.push_eos(element);
+                        self.push_eos();
 
-                        gst::debug!(CAT, obj: element, "Pausing after flow {:?}", flow);
+                        gst::debug!(CAT, imp: self, "Pausing after flow {:?}", flow);
                     }
                     _ => {
-                        self.push_eos(element);
+                        self.push_eos();
 
-                        gst::error!(CAT, obj: element, "Pausing after flow {:?}", flow);
+                        gst::error!(CAT, imp: self, "Pausing after flow {:?}", flow);
 
-                        element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::StreamError::Failed,
                             ["Streaming stopped, reason: {:?}", flow]
                         );
@@ -746,12 +717,11 @@ impl SccParse {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        element: &super::SccParse,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
 
-        self.handle_buffer(element, Some(buffer))
+        self.handle_buffer(Some(buffer))
     }
 
     fn flush(&self, mut state: MutexGuard<State>) -> MutexGuard<State> {
@@ -771,7 +741,7 @@ impl SccParse {
         self.state.lock().unwrap()
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::SccParse, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -792,14 +762,14 @@ impl SccParse {
                 let state = self.flush(state);
                 drop(state);
 
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::Eos(_) => {
                 gst::log!(CAT, obj: pad, "Draining");
-                if let Err(err) = self.handle_buffer(element, None) {
+                if let Err(err) = self.handle_buffer(None) {
                     gst::error!(CAT, obj: pad, "Failed to drain parser: {:?}", err);
                 }
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             _ => {
                 if event.is_sticky()
@@ -811,15 +781,15 @@ impl SccParse {
                     state.pending_events.push(event);
                     true
                 } else {
-                    pad.event_default(Some(element), event)
+                    pad.event_default(Some(&*self.instance()), event)
                 }
             }
         }
     }
 
-    fn perform_seek(&self, event: &gst::event::Seek, element: &super::SccParse) -> bool {
+    fn perform_seek(&self, event: &gst::event::Seek) -> bool {
         if self.state.lock().unwrap().pull.is_none() {
-            gst::error!(CAT, obj: element, "seeking is only supported in pull mode");
+            gst::error!(CAT, imp: self, "seeking is only supported in pull mode");
             return false;
         }
 
@@ -828,7 +798,7 @@ impl SccParse {
         let mut start: Option<gst::ClockTime> = match start.try_into() {
             Ok(start) => start,
             Err(_) => {
-                gst::error!(CAT, obj: element, "seek has invalid format");
+                gst::error!(CAT, imp: self, "seek has invalid format");
                 return false;
             }
         };
@@ -836,18 +806,18 @@ impl SccParse {
         let mut stop: Option<gst::ClockTime> = match stop.try_into() {
             Ok(stop) => stop,
             Err(_) => {
-                gst::error!(CAT, obj: element, "seek has invalid format");
+                gst::error!(CAT, imp: self, "seek has invalid format");
                 return false;
             }
         };
 
         if !flags.contains(gst::SeekFlags::FLUSH) {
-            gst::error!(CAT, obj: element, "only flushing seeks are supported");
+            gst::error!(CAT, imp: self, "only flushing seeks are supported");
             return false;
         }
 
         if start_type == gst::SeekType::End || stop_type == gst::SeekType::End {
-            gst::error!(CAT, obj: element, "Relative seeks are not supported");
+            gst::error!(CAT, imp: self, "Relative seeks are not supported");
             return false;
         }
 
@@ -857,14 +827,14 @@ impl SccParse {
             .seqnum(seek_seqnum)
             .build();
 
-        gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event);
+        gst::debug!(CAT, imp: self, "Sending event {:?} upstream", event);
         self.sinkpad.push_event(event);
 
         let event = gst::event::FlushStart::builder()
             .seqnum(seek_seqnum)
             .build();
 
-        gst::debug!(CAT, obj: element, "Pushing event {:?}", event);
+        gst::debug!(CAT, imp: self, "Pushing event {:?}", event);
         self.srcpad.push_event(event);
 
         let _ = self.sinkpad.pause_task();
@@ -892,7 +862,7 @@ impl SccParse {
         /* Drop our state while we push a serialized event upstream */
         drop(state);
 
-        gst::debug!(CAT, obj: element, "Sending event {:?} upstream", event);
+        gst::debug!(CAT, imp: self, "Sending event {:?} upstream", event);
         self.sinkpad.push_event(event);
 
         state = self.state.lock().unwrap();
@@ -901,7 +871,7 @@ impl SccParse {
             .segment
             .do_seek(rate, flags, start_type, start, stop_type, stop);
 
-        match self.start_task(element) {
+        match self.start_task() {
             Err(error) => {
                 error.log();
                 false
@@ -910,22 +880,17 @@ impl SccParse {
         }
     }
 
-    fn src_event(&self, pad: &gst::Pad, element: &super::SccParse, event: gst::Event) -> bool {
+    fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
         match event.view() {
-            EventView::Seek(e) => self.perform_seek(e, element),
-            _ => pad.event_default(Some(element), event),
+            EventView::Seek(e) => self.perform_seek(e),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn src_query(
-        &self,
-        pad: &gst::Pad,
-        element: &super::SccParse,
-        query: &mut gst::QueryRef,
-    ) -> bool {
+    fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
         use gst::QueryViewMut;
 
         gst::log!(CAT, obj: pad, "Handling query {:?}", query);
@@ -975,7 +940,7 @@ impl SccParse {
                     self.sinkpad.peer_query(query)
                 }
             }
-            _ => pad.query_default(Some(element), query),
+            _ => pad.query_default(Some(&*self.instance()), query),
         }
     }
 }
@@ -992,29 +957,34 @@ impl ObjectSubclass for SccParse {
             .activate_function(|pad, parent| {
                 SccParse::catch_panic_pad_function(
                     parent,
-                    || Err(loggable_error!(CAT, "Panic activating sink pad")),
-                    |parse, element| parse.sink_activate(pad, element),
+                    || Err(gst::loggable_error!(CAT, "Panic activating sink pad")),
+                    |parse| parse.sink_activate(pad),
                 )
             })
             .activatemode_function(|pad, parent, mode, active| {
                 SccParse::catch_panic_pad_function(
                     parent,
-                    || Err(loggable_error!(CAT, "Panic activating sink pad with mode")),
-                    |parse, element| parse.sink_activatemode(pad, element, mode, active),
+                    || {
+                        Err(gst::loggable_error!(
+                            CAT,
+                            "Panic activating sink pad with mode"
+                        ))
+                    },
+                    |parse| parse.sink_activatemode(pad, mode, active),
                 )
             })
             .chain_function(|pad, parent, buffer| {
                 SccParse::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |parse, element| parse.sink_chain(pad, element, buffer),
+                    |parse| parse.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 SccParse::catch_panic_pad_function(
                     parent,
                     || false,
-                    |parse, element| parse.sink_event(pad, element, event),
+                    |parse| parse.sink_event(pad, event),
                 )
             })
             .build();
@@ -1025,14 +995,14 @@ impl ObjectSubclass for SccParse {
                 SccParse::catch_panic_pad_function(
                     parent,
                     || false,
-                    |parse, element| parse.src_event(pad, element, event),
+                    |parse| parse.src_event(pad, event),
                 )
             })
             .query_function(|pad, parent, query| {
                 SccParse::catch_panic_pad_function(
                     parent,
                     || false,
-                    |parse, element| parse.src_query(pad, element, query),
+                    |parse| parse.src_query(pad, query),
                 )
             })
             .build();
@@ -1046,9 +1016,10 @@ impl ObjectSubclass for SccParse {
 }
 
 impl ObjectImpl for SccParse {
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -1104,10 +1075,9 @@ impl ElementImpl for SccParse {
 
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => {
@@ -1118,6 +1088,6 @@ impl ElementImpl for SccParse {
             _ => (),
         }
 
-        self.parent_change_state(element, transition)
+        self.parent_change_state(transition)
     }
 }
diff --git a/video/closedcaption/src/transcriberbin/imp.rs b/video/closedcaption/src/transcriberbin/imp.rs
index fa4c275f..5bb928e9 100644
--- a/video/closedcaption/src/transcriberbin/imp.rs
+++ b/video/closedcaption/src/transcriberbin/imp.rs
@@ -85,12 +85,8 @@ pub struct TranscriberBin {
 }
 
 impl TranscriberBin {
-    fn construct_transcription_bin(
-        &self,
-        element: &super::TranscriberBin,
-        state: &mut State,
-    ) -> Result<(), Error> {
-        gst::debug!(CAT, obj: element, "Building transcription bin");
+    fn construct_transcription_bin(&self, state: &mut State) -> Result<(), Error> {
+        gst::debug!(CAT, imp: self, "Building transcription bin");
 
         let aqueue_transcription = gst::ElementFactory::make("queue", Some("transqueue"))?;
         aqueue_transcription.set_property("max-size-buffers", 0u32);
@@ -153,11 +149,7 @@ impl TranscriberBin {
         Ok(())
     }
 
-    fn construct_internal_bin(
-        &self,
-        element: &super::TranscriberBin,
-        state: &mut State,
-    ) -> Result<(), Error> {
+    fn construct_internal_bin(&self, state: &mut State) -> Result<(), Error> {
         let aclocksync = gst::ElementFactory::make("clocksync", None)?;
 
         let vclocksync = gst::ElementFactory::make("clocksync", None)?;
@@ -202,17 +194,16 @@ impl TranscriberBin {
         state.internal_bin.add_pad(&internal_video_sinkpad)?;
         state.internal_bin.add_pad(&internal_video_srcpad)?;
 
-        let element_weak = element.downgrade();
+        let imp_weak = self.downgrade();
         let comp_sinkpad = &state.cccombiner.static_pad("sink").unwrap();
         // Drop caption meta from video buffer if user preference is transcription
         comp_sinkpad.add_probe(gst::PadProbeType::BUFFER, move |_, probe_info| {
-            let element = match element_weak.upgrade() {
+            let imp = match imp_weak.upgrade() {
                 None => return gst::PadProbeReturn::Remove,
-                Some(element) => element,
+                Some(imp) => imp,
             };
 
-            let trans = TranscriberBin::from_instance(&element);
-            let settings = trans.settings.lock().unwrap();
+            let settings = imp.settings.lock().unwrap();
             if settings.caption_source != CaptionSource::Transcription {
                 return gst::PadProbeReturn::Pass;
             }
@@ -227,7 +218,7 @@ impl TranscriberBin {
             gst::PadProbeReturn::Ok
         });
 
-        element.add(&state.internal_bin)?;
+        self.instance().add(&state.internal_bin)?;
 
         state
             .cccombiner
@@ -242,12 +233,12 @@ impl TranscriberBin {
         self.video_srcpad
             .set_target(Some(&state.internal_bin.static_pad("video_src").unwrap()))?;
 
-        self.construct_transcription_bin(element, state)?;
+        self.construct_transcription_bin(state)?;
 
         Ok(())
     }
 
-    fn setup_transcription(&self, element: &super::TranscriberBin, state: &State) {
+    fn setup_transcription(&self, state: &State) {
         let settings = self.settings.lock().unwrap();
         let mut cc_caps = settings.cc_caps.clone();
 
@@ -285,10 +276,10 @@ impl TranscriberBin {
 
         drop(settings);
 
-        self.setup_cc_mode(element, state);
+        self.setup_cc_mode(state);
     }
 
-    fn disable_transcription_bin(&self, element: &super::TranscriberBin) {
+    fn disable_transcription_bin(&self) {
         let mut state = self.state.lock().unwrap();
 
         if let Some(ref mut state) = state.as_mut() {
@@ -299,7 +290,7 @@ impl TranscriberBin {
             let passthrough = self.settings.lock().unwrap().passthrough;
 
             if passthrough {
-                gst::debug!(CAT, obj: element, "disabling transcription bin");
+                gst::debug!(CAT, imp: self, "disabling transcription bin");
 
                 let bin_sink_pad = state.transcription_bin.static_pad("sink").unwrap();
                 if let Some(audio_tee_pad) = bin_sink_pad.peer() {
@@ -319,13 +310,13 @@ impl TranscriberBin {
         }
     }
 
-    fn block_and_update(&self, element: &super::TranscriberBin, passthrough: bool) {
+    fn block_and_update(&self, passthrough: bool) {
         let mut s = self.state.lock().unwrap();
 
         if let Some(ref mut state) = s.as_mut() {
             if passthrough {
                 let sinkpad = state.transcription_bin.static_pad("sink").unwrap();
-                let element_weak = element.downgrade();
+                let imp_weak = self.downgrade();
                 state.tearing_down = true;
                 drop(s);
                 let _ = sinkpad.add_probe(
@@ -333,14 +324,12 @@ impl TranscriberBin {
                         | gst::PadProbeType::BUFFER
                         | gst::PadProbeType::EVENT_DOWNSTREAM,
                     move |_pad, _info| {
-                        let element = match element_weak.upgrade() {
+                        let imp = match imp_weak.upgrade() {
                             None => return gst::PadProbeReturn::Pass,
-                            Some(element) => element,
+                            Some(imp) => imp,
                         };
 
-                        let this = element.imp();
-
-                        this.disable_transcription_bin(&element);
+                        imp.disable_transcription_bin();
 
                         gst::PadProbeReturn::Remove
                     },
@@ -363,10 +352,10 @@ impl TranscriberBin {
         }
     }
 
-    fn setup_cc_mode(&self, element: &super::TranscriberBin, state: &State) {
+    fn setup_cc_mode(&self, state: &State) {
         let mode = self.settings.lock().unwrap().mode;
 
-        gst::debug!(CAT, obj: element, "setting CC mode {:?}", mode);
+        gst::debug!(CAT, imp: self, "setting CC mode {:?}", mode);
 
         state.tttocea608.set_property("mode", mode);
 
@@ -386,12 +375,11 @@ impl TranscriberBin {
     fn relink_transcriber(
         &self,
         state: &mut State,
-        element: &super::TranscriberBin,
         old_transcriber: &gst::Element,
     ) -> Result<(), Error> {
         gst::error!(
             CAT,
-            obj: element,
+            imp: self,
             "Relinking transcriber, old: {:?}, new: {:?}",
             old_transcriber,
             state.transcriber
@@ -414,12 +402,7 @@ impl TranscriberBin {
     }
 
     #[allow(clippy::single_match)]
-    fn src_query(
-        &self,
-        pad: &gst::Pad,
-        element: &super::TranscriberBin,
-        query: &mut gst::QueryRef,
-    ) -> bool {
+    fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
         use gst::QueryViewMut;
 
         gst::log!(CAT, obj: pad, "Handling query {:?}", query);
@@ -428,7 +411,7 @@ impl TranscriberBin {
             QueryViewMut::Latency(q) => {
                 let mut upstream_query = gst::query::Latency::new();
 
-                let ret = pad.query_default(Some(element), &mut upstream_query);
+                let ret = pad.query_default(Some(&*self.instance()), &mut upstream_query);
 
                 if ret {
                     let (_, mut min, _) = upstream_query.result();
@@ -453,7 +436,7 @@ impl TranscriberBin {
 
                 ret
             }
-            _ => pad.query_default(Some(element), query),
+            _ => pad.query_default(Some(&*self.instance()), query),
         }
     }
 
@@ -497,12 +480,7 @@ impl TranscriberBin {
     }
 
     #[allow(clippy::single_match)]
-    fn video_sink_event(
-        &self,
-        pad: &gst::Pad,
-        element: &super::TranscriberBin,
-        event: gst::Event,
-    ) -> bool {
+    fn video_sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -525,16 +503,16 @@ impl TranscriberBin {
                     if !had_framerate {
                         gst::info!(
                             CAT,
-                            obj: element,
+                            imp: self,
                             "Received video caps, setting up transcription"
                         );
-                        self.setup_transcription(element, state);
+                        self.setup_transcription(state);
                     }
                 }
 
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 }
@@ -554,7 +532,7 @@ impl ObjectSubclass for TranscriberBin {
                 TranscriberBin::catch_panic_pad_function(
                     parent,
                     || false,
-                    |transcriber, element| transcriber.src_query(pad.upcast_ref(), element, query),
+                    |transcriber| transcriber.src_query(pad.upcast_ref(), query),
                 )
             })
             .build();
@@ -565,9 +543,7 @@ impl ObjectSubclass for TranscriberBin {
                 TranscriberBin::catch_panic_pad_function(
                     parent,
                     || false,
-                    |transcriber, element| {
-                        transcriber.video_sink_event(pad.upcast_ref(), element, event)
-                    },
+                    |transcriber| transcriber.video_sink_event(pad.upcast_ref(), event),
                 )
             })
             .build();
@@ -577,7 +553,7 @@ impl ObjectSubclass for TranscriberBin {
                 TranscriberBin::catch_panic_pad_function(
                     parent,
                     || false,
-                    |transcriber, element| transcriber.src_query(pad.upcast_ref(), element, query),
+                    |transcriber| transcriber.src_query(pad.upcast_ref(), query),
                 )
             })
             .build();
@@ -644,13 +620,7 @@ impl ObjectImpl for TranscriberBin {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "passthrough" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -661,7 +631,7 @@ impl ObjectImpl for TranscriberBin {
 
                 if old_passthrough != new_passthrough {
                     drop(settings);
-                    self.block_and_update(obj, new_passthrough);
+                    self.block_and_update(new_passthrough);
                 }
             }
             "latency" => {
@@ -685,7 +655,7 @@ impl ObjectImpl for TranscriberBin {
 
                 if old_mode != new_mode {
                     drop(settings);
-                    self.setup_cc_mode(obj, self.state.lock().unwrap().as_ref().unwrap());
+                    self.setup_cc_mode(self.state.lock().unwrap().as_ref().unwrap());
                 }
             }
             "cc-caps" => {
@@ -698,7 +668,7 @@ impl ObjectImpl for TranscriberBin {
                     let old_transcriber = state.transcriber.clone();
                     state.transcriber = value.get().expect("type checked upstream");
                     if old_transcriber != state.transcriber {
-                        match self.relink_transcriber(state, obj, &old_transcriber) {
+                        match self.relink_transcriber(state, &old_transcriber) {
                             Ok(()) => (),
                             Err(err) => {
                                 gst::error!(CAT, "invalid transcriber: {}", err);
@@ -716,10 +686,10 @@ impl ObjectImpl for TranscriberBin {
                 let s = self.state.lock().unwrap();
                 if let Some(state) = s.as_ref() {
                     if settings.caption_source == CaptionSource::Inband {
-                        gst::debug!(CAT, obj: obj, "Use inband caption, dropping transcription");
+                        gst::debug!(CAT, imp: self, "Use inband caption, dropping transcription");
                         state.transcription_valve.set_property("drop", true);
                     } else {
-                        gst::debug!(CAT, obj: obj, "Stop dropping transcription");
+                        gst::debug!(CAT, imp: self, "Stop dropping transcription");
                         state.transcription_valve.set_property("drop", false);
                     }
                 }
@@ -728,7 +698,7 @@ impl ObjectImpl for TranscriberBin {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "passthrough" => {
                 let settings = self.settings.lock().unwrap();
@@ -767,16 +737,17 @@ impl ObjectImpl for TranscriberBin {
         }
     }
 
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.audio_srcpad).unwrap();
         obj.add_pad(&self.audio_sinkpad).unwrap();
         obj.add_pad(&self.video_srcpad).unwrap();
         obj.add_pad(&self.video_sinkpad).unwrap();
 
         *self.state.lock().unwrap() = match self.build_state() {
-            Ok(mut state) => match self.construct_internal_bin(obj, &mut state) {
+            Ok(mut state) => match self.construct_internal_bin(&mut state) {
                 Ok(()) => Some(state),
                 Err(err) => {
                     gst::error!(CAT, "Failed to build internal bin: {}", err);
@@ -855,10 +826,9 @@ impl ElementImpl for TranscriberBin {
     #[allow(clippy::single_match)]
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused => {
@@ -868,14 +838,14 @@ impl ElementImpl for TranscriberBin {
                     if state.framerate.is_some() {
                         gst::info!(
                             CAT,
-                            obj: element,
+                            imp: self,
                             "Received video caps, setting up transcription"
                         );
-                        self.setup_transcription(element, state);
+                        self.setup_transcription(state);
                     }
                 } else {
-                    gst::element_error!(
-                        element,
+                    gst::element_imp_error!(
+                        self,
                         gst::StreamError::Failed,
                         ["Can't change state with no state"]
                     );
@@ -885,12 +855,12 @@ impl ElementImpl for TranscriberBin {
             _ => (),
         }
 
-        self.parent_change_state(element, transition)
+        self.parent_change_state(transition)
     }
 }
 
 impl BinImpl for TranscriberBin {
-    fn handle_message(&self, bin: &Self::Type, msg: gst::Message) {
+    fn handle_message(&self, msg: gst::Message) {
         use gst::MessageView;
 
         match msg.view() {
@@ -902,7 +872,7 @@ impl BinImpl for TranscriberBin {
                     if msg.src().as_ref() == Some(state.transcriber.upcast_ref()) {
                         gst::error!(
                             CAT,
-                            obj: bin,
+                            imp: self,
                             "Transcriber has posted an error ({:?}), going back to passthrough",
                             m
                         );
@@ -910,21 +880,21 @@ impl BinImpl for TranscriberBin {
                         let mut settings = self.settings.lock().unwrap();
                         settings.passthrough = true;
                         drop(settings);
-                        bin.notify("passthrough");
-                        bin.call_async(move |bin| {
+                        self.instance().notify("passthrough");
+                        self.instance().call_async(move |bin| {
                             let thiz = bin.imp();
-                            thiz.block_and_update(bin, true);
+                            thiz.block_and_update(true);
                         });
                     } else {
                         drop(s);
-                        self.parent_handle_message(bin, msg);
+                        self.parent_handle_message(msg);
                     }
                 } else {
                     drop(s);
-                    self.parent_handle_message(bin, msg);
+                    self.parent_handle_message(msg);
                 }
             }
-            _ => self.parent_handle_message(bin, msg),
+            _ => self.parent_handle_message(msg),
         }
     }
 }
diff --git a/video/closedcaption/src/tttocea608/imp.rs b/video/closedcaption/src/tttocea608/imp.rs
index c20ff2fb..22ca651b 100644
--- a/video/closedcaption/src/tttocea608/imp.rs
+++ b/video/closedcaption/src/tttocea608/imp.rs
@@ -151,7 +151,7 @@ static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
 static SPACE: Lazy<u16> = Lazy::new(|| eia608_from_utf8_1(&[0x20, 0, 0, 0, 0]));
 
 fn cc_data_buffer(
-    element: &super::TtToCea608,
+    imp: &TtToCea608,
     cc_data: u16,
     pts: gst::ClockTime,
     duration: gst::ClockTime,
@@ -163,14 +163,14 @@ fn cc_data_buffer(
     if cc_data != 0x8080 {
         gst::log!(
             CAT,
-            obj: element,
+            imp: imp,
             "{} -> {}: {}",
             pts,
             pts + duration,
             eia608_to_text(cc_data)
         );
     } else {
-        gst::trace!(CAT, obj: element, "{} -> {}: padding", pts, pts + duration);
+        gst::trace!(CAT, imp: imp, "{} -> {}: padding", pts, pts + duration);
     }
 
     buf_mut.copy_from_slice(0, &data).unwrap();
@@ -183,7 +183,7 @@ fn cc_data_buffer(
 impl State {
     fn check_erase_display(
         &mut self,
-        element: &super::TtToCea608,
+        imp: &TtToCea608,
         bufferlist: &mut gst::BufferListRef,
     ) -> bool {
         if let Some(erase_display_frame_no) = self.erase_display_frame_no {
@@ -191,7 +191,7 @@ impl State {
                 self.erase_display_frame_no = None;
                 self.column = 0;
                 self.send_roll_up_preamble = true;
-                self.erase_display_memory(element, bufferlist);
+                self.erase_display_memory(imp, bufferlist);
                 return true;
             }
         }
@@ -199,13 +199,8 @@ impl State {
         false
     }
 
-    fn cc_data(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-        cc_data: u16,
-    ) {
-        self.check_erase_display(element, bufferlist);
+    fn cc_data(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, cc_data: u16) {
+        self.check_erase_display(imp, bufferlist);
 
         let (fps_n, fps_d) = (self.framerate.numer() as u64, self.framerate.denom() as u64);
 
@@ -216,7 +211,7 @@ impl State {
         if self.last_frame_no < self.max_frame_no {
             self.last_frame_no += 1;
         } else {
-            gst::debug!(CAT, obj: element, "More text than bandwidth!");
+            gst::debug!(CAT, imp: imp, "More text than bandwidth!");
         }
 
         let next_pts = (self.last_frame_no * gst::ClockTime::SECOND)
@@ -225,122 +220,96 @@ impl State {
 
         let duration = next_pts - pts;
 
-        bufferlist.insert(-1, cc_data_buffer(element, cc_data, pts, duration));
+        bufferlist.insert(-1, cc_data_buffer(imp, cc_data, pts, duration));
     }
 
-    fn pad(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-        frame_no: u64,
-    ) {
+    fn pad(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, frame_no: u64) {
         while self.last_frame_no < frame_no {
-            if !self.check_erase_display(element, bufferlist) {
-                self.cc_data(element, bufferlist, 0x8080);
+            if !self.check_erase_display(imp, bufferlist) {
+                self.cc_data(imp, bufferlist, 0x8080);
             }
         }
     }
 
-    fn resume_caption_loading(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-    ) {
+    fn resume_caption_loading(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_resume_caption_loading),
         )
     }
 
-    fn resume_direct_captioning(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-    ) {
+    fn resume_direct_captioning(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_resume_direct_captioning),
         )
     }
 
-    fn delete_to_end_of_row(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-    ) {
+    fn delete_to_end_of_row(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_delete_to_end_of_row),
         )
     }
 
-    fn roll_up_2(&mut self, element: &super::TtToCea608, bufferlist: &mut gst::BufferListRef) {
+    fn roll_up_2(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_roll_up_2),
         )
     }
 
-    fn roll_up_3(&mut self, element: &super::TtToCea608, bufferlist: &mut gst::BufferListRef) {
+    fn roll_up_3(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_roll_up_3),
         )
     }
 
-    fn roll_up_4(&mut self, element: &super::TtToCea608, bufferlist: &mut gst::BufferListRef) {
+    fn roll_up_4(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_roll_up_4),
         )
     }
 
-    fn carriage_return(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-    ) {
+    fn carriage_return(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_carriage_return),
         )
     }
 
-    fn end_of_caption(&mut self, element: &super::TtToCea608, bufferlist: &mut gst::BufferListRef) {
+    fn end_of_caption(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_end_of_caption),
         )
     }
 
-    fn tab_offset(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-        offset: u32,
-    ) {
+    fn tab_offset(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, offset: u32) {
         match offset {
             0 => (),
             1 => self.cc_data(
-                element,
+                imp,
                 bufferlist,
                 eia608_control_command(ffi::eia608_control_t_eia608_tab_offset_1),
             ),
             2 => self.cc_data(
-                element,
+                imp,
                 bufferlist,
                 eia608_control_command(ffi::eia608_control_t_eia608_tab_offset_2),
             ),
             3 => self.cc_data(
-                element,
+                imp,
                 bufferlist,
                 eia608_control_command(ffi::eia608_control_t_eia608_tab_offset_3),
             ),
@@ -350,14 +319,14 @@ impl State {
 
     fn preamble_indent(
         &mut self,
-        element: &super::TtToCea608,
+        imp: &TtToCea608,
         bufferlist: &mut gst::BufferListRef,
         row: i32,
         col: i32,
         underline: bool,
     ) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_row_column_preamble(row, col, underline),
         )
@@ -365,14 +334,14 @@ impl State {
 
     fn preamble_style(
         &mut self,
-        element: &super::TtToCea608,
+        imp: &TtToCea608,
         bufferlist: &mut gst::BufferListRef,
         row: i32,
         style: u32,
         underline: bool,
     ) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_row_style_preamble(row, style, underline),
         )
@@ -380,31 +349,21 @@ impl State {
 
     fn midrow_change(
         &mut self,
-        element: &super::TtToCea608,
+        imp: &TtToCea608,
         bufferlist: &mut gst::BufferListRef,
         style: u32,
         underline: bool,
     ) {
-        self.cc_data(element, bufferlist, eia608_midrow_change(style, underline))
+        self.cc_data(imp, bufferlist, eia608_midrow_change(style, underline))
     }
 
-    fn bna(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-        bna1: u16,
-        bna2: u16,
-    ) {
-        self.cc_data(element, bufferlist, eia608_from_basicna(bna1, bna2))
+    fn bna(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef, bna1: u16, bna2: u16) {
+        self.cc_data(imp, bufferlist, eia608_from_basicna(bna1, bna2))
     }
 
-    fn erase_display_memory(
-        &mut self,
-        element: &super::TtToCea608,
-        bufferlist: &mut gst::BufferListRef,
-    ) {
+    fn erase_display_memory(&mut self, imp: &TtToCea608, bufferlist: &mut gst::BufferListRef) {
         self.cc_data(
-            element,
+            imp,
             bufferlist,
             eia608_control_command(ffi::eia608_control_t_eia608_control_erase_display_memory),
         )
@@ -423,14 +382,13 @@ pub struct TtToCea608 {
 impl TtToCea608 {
     fn open_chunk(
         &self,
-        element: &super::TtToCea608,
         state: &mut State,
         chunk: &Chunk,
         bufferlist: &mut gst::BufferListRef,
         col: u32,
     ) -> bool {
         if (chunk.style != state.style || chunk.underline != state.underline) && col < 31 {
-            state.midrow_change(element, bufferlist, chunk.style as u32, chunk.underline);
+            state.midrow_change(self, bufferlist, chunk.style as u32, chunk.underline);
             state.style = chunk.style;
             state.underline = chunk.underline;
             true
@@ -442,7 +400,6 @@ impl TtToCea608 {
     #[allow(clippy::too_many_arguments)]
     fn open_line(
         &self,
-        element: &super::TtToCea608,
         state: &mut State,
         settings: &Settings,
         chunk: &Chunk,
@@ -459,7 +416,7 @@ impl TtToCea608 {
                 if let Some(carriage_return) = carriage_return {
                     if carriage_return {
                         *col = settings.origin_column;
-                        state.carriage_return(element, bufferlist);
+                        state.carriage_return(self, bufferlist);
                         true
                     } else {
                         state.send_roll_up_preamble
@@ -475,20 +432,14 @@ impl TtToCea608 {
 
         if do_preamble {
             match state.mode {
-                Cea608Mode::RollUp2 => state.roll_up_2(element, bufferlist),
-                Cea608Mode::RollUp3 => state.roll_up_3(element, bufferlist),
-                Cea608Mode::RollUp4 => state.roll_up_4(element, bufferlist),
+                Cea608Mode::RollUp2 => state.roll_up_2(self, bufferlist),
+                Cea608Mode::RollUp3 => state.roll_up_3(self, bufferlist),
+                Cea608Mode::RollUp4 => state.roll_up_4(self, bufferlist),
                 _ => (),
             }
 
             if chunk.style != TextStyle::White && indent == 0 {
-                state.preamble_style(
-                    element,
-                    bufferlist,
-                    row,
-                    chunk.style as u32,
-                    chunk.underline,
-                );
+                state.preamble_style(self, bufferlist, row, chunk.style as u32, chunk.underline);
                 state.style = chunk.style;
             } else {
                 if chunk.style != TextStyle::White {
@@ -502,20 +453,14 @@ impl TtToCea608 {
                 }
 
                 state.style = TextStyle::White;
-                state.preamble_indent(
-                    element,
-                    bufferlist,
-                    row,
-                    (indent * 4) as i32,
-                    chunk.underline,
-                );
+                state.preamble_indent(self, bufferlist, row, (indent * 4) as i32, chunk.underline);
             }
 
             if state.mode == Cea608Mode::PaintOn {
-                state.delete_to_end_of_row(element, bufferlist);
+                state.delete_to_end_of_row(self, bufferlist);
             }
 
-            state.tab_offset(element, bufferlist, offset);
+            state.tab_offset(self, bufferlist, offset);
 
             state.underline = chunk.underline;
             state.send_roll_up_preamble = false;
@@ -524,7 +469,7 @@ impl TtToCea608 {
             ret = false;
         }
 
-        if self.open_chunk(element, state, chunk, bufferlist, *col) {
+        if self.open_chunk(state, chunk, bufferlist, *col) {
             *col += 1;
             ret = false
         }
@@ -540,7 +485,6 @@ impl TtToCea608 {
         &self,
         mut state: &mut State,
         settings: &Settings,
-        element: &super::TtToCea608,
         pts: gst::ClockTime,
         duration: gst::ClockTime,
         lines: Lines,
@@ -564,7 +508,7 @@ impl TtToCea608 {
         let frame_no = pts.mul_div_round(fps_n, fps_d).unwrap().seconds();
 
         if state.last_frame_no == 0 {
-            gst::debug!(CAT, obj: element, "Initial skip to frame no {}", frame_no);
+            gst::debug!(CAT, imp: self, "Initial skip to frame no {}", frame_no);
             state.last_frame_no = pts.mul_div_floor(fps_n, fps_d).unwrap().seconds();
         }
 
@@ -573,7 +517,7 @@ impl TtToCea608 {
             .unwrap()
             .seconds();
 
-        state.pad(element, mut_list, frame_no);
+        state.pad(self, mut_list, frame_no);
 
         let mut cleared = false;
         if let Some(mode) = lines.mode {
@@ -581,7 +525,7 @@ impl TtToCea608 {
                 /* Always erase the display when going to or from pop-on */
                 if state.mode == Cea608Mode::PopOn || mode == Cea608Mode::PopOn {
                     state.erase_display_frame_no = None;
-                    state.erase_display_memory(element, mut_list);
+                    state.erase_display_memory(self, mut_list);
                     cleared = true;
                 }
 
@@ -598,7 +542,7 @@ impl TtToCea608 {
         if let Some(clear) = lines.clear {
             if clear && !cleared {
                 state.erase_display_frame_no = None;
-                state.erase_display_memory(element, mut_list);
+                state.erase_display_memory(self, mut_list);
                 if state.mode != Cea608Mode::PopOn && state.mode != Cea608Mode::PaintOn {
                     state.send_roll_up_preamble = true;
                 }
@@ -607,28 +551,23 @@ impl TtToCea608 {
         }
 
         if state.mode == Cea608Mode::PopOn {
-            state.resume_caption_loading(element, mut_list);
-            state.cc_data(element, mut_list, erase_non_displayed_memory());
+            state.resume_caption_loading(self, mut_list);
+            state.cc_data(self, mut_list, erase_non_displayed_memory());
         } else if state.mode == Cea608Mode::PaintOn {
-            state.resume_direct_captioning(element, mut_list);
+            state.resume_direct_captioning(self, mut_list);
         }
 
         let mut prev_char = 0;
 
         for line in &lines.lines {
-            gst::log!(CAT, obj: element, "Processing {:?}", line);
+            gst::log!(CAT, imp: self, "Processing {:?}", line);
 
             if let Some(line_row) = line.row {
                 row = line_row;
             }
 
             if row > 14 {
-                gst::warning!(
-                    CAT,
-                    obj: element,
-                    "Dropping line after 15th row: {:?}",
-                    line
-                );
+                gst::warning!(CAT, imp: self, "Dropping line after 15th row: {:?}", line);
                 continue;
             }
 
@@ -644,13 +583,12 @@ impl TtToCea608 {
             for (j, chunk) in line.chunks.iter().enumerate() {
                 let mut prepend_space = true;
                 if prev_char != 0 {
-                    state.cc_data(element, mut_list, prev_char);
+                    state.cc_data(self, mut_list, prev_char);
                     prev_char = 0;
                 }
 
                 if j == 0 {
                     prepend_space = self.open_line(
-                        element,
                         state,
                         settings,
                         chunk,
@@ -659,7 +597,7 @@ impl TtToCea608 {
                         row as i32,
                         line.carriage_return,
                     );
-                } else if self.open_chunk(element, state, chunk, mut_list, col) {
+                } else if self.open_chunk(state, chunk, mut_list, col) {
                     prepend_space = false;
                     col += 1;
                 }
@@ -690,36 +628,36 @@ impl TtToCea608 {
                     let mut cc_data = eia608_from_utf8_1(&encoded);
 
                     if cc_data == 0 {
-                        gst::warning!(CAT, obj: element, "Not translating UTF8: {}", c);
+                        gst::warning!(CAT, imp: self, "Not translating UTF8: {}", c);
                         cc_data = *SPACE;
                     }
 
                     if is_basicna(prev_char) {
                         if is_basicna(cc_data) {
-                            state.bna(element, mut_list, prev_char, cc_data);
+                            state.bna(self, mut_list, prev_char, cc_data);
                         } else if is_westeu(cc_data) {
                             // extended characters overwrite the previous character,
                             // so insert a dummy char then write the extended char
-                            state.bna(element, mut_list, prev_char, *SPACE);
-                            state.cc_data(element, mut_list, cc_data);
+                            state.bna(self, mut_list, prev_char, *SPACE);
+                            state.cc_data(self, mut_list, cc_data);
                         } else {
-                            state.cc_data(element, mut_list, prev_char);
-                            state.cc_data(element, mut_list, cc_data);
+                            state.cc_data(self, mut_list, prev_char);
+                            state.cc_data(self, mut_list, cc_data);
                         }
                         prev_char = 0;
                     } else if is_westeu(cc_data) {
                         // extended characters overwrite the previous character,
                         // so insert a dummy char then write the extended char
-                        state.cc_data(element, mut_list, *SPACE);
-                        state.cc_data(element, mut_list, cc_data);
+                        state.cc_data(self, mut_list, *SPACE);
+                        state.cc_data(self, mut_list, cc_data);
                     } else if is_basicna(cc_data) {
                         prev_char = cc_data;
                     } else {
-                        state.cc_data(element, mut_list, cc_data);
+                        state.cc_data(self, mut_list, cc_data);
                     }
 
                     if is_specialna(cc_data) {
-                        state.resume_caption_loading(element, mut_list);
+                        state.resume_caption_loading(self, mut_list);
                     }
 
                     col += 1;
@@ -742,12 +680,11 @@ impl TtToCea608 {
                             || col > 31
                         {
                             if prev_char != 0 {
-                                state.cc_data(element, mut_list, prev_char);
+                                state.cc_data(self, mut_list, prev_char);
                                 prev_char = 0;
                             }
 
                             self.open_line(
-                                element,
                                 state,
                                 settings,
                                 chunk,
@@ -761,7 +698,7 @@ impl TtToCea608 {
                         if chars.peek().is_some() {
                             gst::warning!(
                                 CAT,
-                                obj: element,
+                                imp: self,
                                 "Dropping characters after 32nd column: {}",
                                 c
                             );
@@ -773,7 +710,7 @@ impl TtToCea608 {
 
             if state.mode == Cea608Mode::PopOn || state.mode == Cea608Mode::PaintOn {
                 if prev_char != 0 {
-                    state.cc_data(element, mut_list, prev_char);
+                    state.cc_data(self, mut_list, prev_char);
                     prev_char = 0;
                 }
                 row += 1;
@@ -781,13 +718,13 @@ impl TtToCea608 {
         }
 
         if prev_char != 0 {
-            state.cc_data(element, mut_list, prev_char);
+            state.cc_data(self, mut_list, prev_char);
         }
 
         if state.mode == Cea608Mode::PopOn {
             /* No need to erase the display at this point, end_of_caption will be equivalent */
             state.erase_display_frame_no = None;
-            state.end_of_caption(element, mut_list);
+            state.end_of_caption(self, mut_list);
         }
 
         state.column = col;
@@ -800,7 +737,7 @@ impl TtToCea608 {
                 Some(state.last_frame_no + timeout.mul_div_round(fps_n, fps_d).unwrap().seconds());
         }
 
-        state.pad(element, mut_list, state.max_frame_no);
+        state.pad(self, mut_list, state.max_frame_no);
 
         Ok(bufferlist)
     }
@@ -808,14 +745,13 @@ impl TtToCea608 {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        element: &super::TtToCea608,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst::log!(CAT, obj: element, "Handling {:?}", buffer);
+        gst::log!(CAT, imp: self, "Handling {:?}", buffer);
 
         let pts = buffer.pts().ok_or_else(|| {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::StreamError::Format,
                 ["Stream with timestamped buffers required"]
             );
@@ -823,8 +759,8 @@ impl TtToCea608 {
         })?;
 
         let duration = buffer.duration().ok_or_else(|| {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::StreamError::Format,
                 ["Buffers of stream need to have a duration"]
             );
@@ -890,7 +826,7 @@ impl TtToCea608 {
             }
         }
 
-        let bufferlist = self.generate(&mut state, &settings, element, pts, duration, lines)?;
+        let bufferlist = self.generate(&mut state, &settings, pts, duration, lines)?;
 
         drop(settings);
         drop(state);
@@ -898,7 +834,7 @@ impl TtToCea608 {
         self.srcpad.push_list(bufferlist)
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::TtToCea608, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
 
         use gst::EventView;
@@ -954,7 +890,7 @@ impl TtToCea608 {
 
                     gst::debug!(
                         CAT,
-                        obj: element,
+                        imp: self,
                         "Initial skip to frame no {}",
                         state.last_frame_no
                     );
@@ -969,7 +905,7 @@ impl TtToCea608 {
                 let mut bufferlist = gst::BufferList::new();
                 let mut_list = bufferlist.get_mut().unwrap();
 
-                state.pad(element, mut_list, frame_no);
+                state.pad(self, mut_list, frame_no);
 
                 drop(state);
 
@@ -984,7 +920,7 @@ impl TtToCea608 {
                     let mut_list = bufferlist.get_mut().unwrap();
 
                     state.max_frame_no = erase_display_frame_no;
-                    state.pad(element, mut_list, erase_display_frame_no);
+                    state.pad(self, mut_list, erase_display_frame_no);
 
                     drop(state);
 
@@ -993,7 +929,7 @@ impl TtToCea608 {
                     drop(state);
                 }
 
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::FlushStop(_) => {
                 let mut state = self.state.lock().unwrap();
@@ -1010,9 +946,9 @@ impl TtToCea608 {
                 drop(settings);
                 drop(state);
 
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 }
@@ -1030,14 +966,14 @@ impl ObjectSubclass for TtToCea608 {
                 TtToCea608::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |this, element| this.sink_chain(pad, element, buffer),
+                    |this| this.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 TtToCea608::catch_panic_pad_function(
                     parent,
                     || false,
-                    |this, element| this.sink_event(pad, element, event),
+                    |this| this.sink_event(pad, event),
                 )
             })
             .flags(gst::PadFlags::FIXED_CAPS)
@@ -1093,20 +1029,15 @@ impl ObjectImpl for TtToCea608 {
         PROPERTIES.as_ref()
     }
 
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "mode" => {
                 let mut state = self.state.lock().unwrap();
@@ -1141,7 +1072,7 @@ impl ObjectImpl for TtToCea608 {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "mode" => {
                 let settings = self.settings.lock().unwrap();
@@ -1235,10 +1166,9 @@ impl ElementImpl for TtToCea608 {
     #[allow(clippy::single_match)]
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         match transition {
             gst::StateChange::ReadyToPaused => {
@@ -1255,7 +1185,7 @@ impl ElementImpl for TtToCea608 {
             _ => (),
         }
 
-        let ret = self.parent_change_state(element, transition)?;
+        let ret = self.parent_change_state(transition)?;
 
         match transition {
             gst::StateChange::PausedToReady => {
diff --git a/video/closedcaption/src/tttojson/imp.rs b/video/closedcaption/src/tttojson/imp.rs
index 4efc494f..030efe63 100644
--- a/video/closedcaption/src/tttojson/imp.rs
+++ b/video/closedcaption/src/tttojson/imp.rs
@@ -48,15 +48,14 @@ impl TtToJson {
     fn sink_chain(
         &self,
         _pad: &gst::Pad,
-        element: &super::TtToJson,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         let pts = buffer.pts();
         let duration = buffer.duration();
 
         let buffer = buffer.into_mapped_buffer_readable().map_err(|_| {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::ResourceError::Read,
                 ["Failed to map buffer readable"]
             );
@@ -65,8 +64,8 @@ impl TtToJson {
         })?;
 
         let text = std::str::from_utf8(buffer.as_slice()).map_err(|err| {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::ResourceError::Read,
                 ["Failed to map decode as utf8: {}", err]
             );
@@ -101,8 +100,8 @@ impl TtToJson {
         }
 
         let json = serde_json::to_string(&lines).map_err(|err| {
-            gst::element_error!(
-                element,
+            gst::element_imp_error!(
+                self,
                 gst::ResourceError::Write,
                 ["Failed to serialize as json {}", err]
             );
@@ -120,7 +119,7 @@ impl TtToJson {
         self.srcpad.push(buf)
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::TtToJson, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -133,8 +132,8 @@ impl TtToJson {
                     .build();
                 self.srcpad.push_event(gst::event::Caps::new(&caps))
             }
-            EventView::Eos(_) => pad.event_default(Some(element), event),
-            _ => pad.event_default(Some(element), event),
+            EventView::Eos(_) => pad.event_default(Some(&*self.instance()), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 }
@@ -197,14 +196,14 @@ impl ObjectSubclass for TtToJson {
                 TtToJson::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |enc, element| enc.sink_chain(pad, element, buffer),
+                    |enc| enc.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 TtToJson::catch_panic_pad_function(
                     parent,
                     || false,
-                    |enc, element| enc.sink_event(pad, element, event),
+                    |enc| enc.sink_event(pad, event),
                 )
             })
             .build();
@@ -235,20 +234,15 @@ impl ObjectImpl for TtToJson {
         PROPERTIES.as_ref()
     }
 
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "mode" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -258,7 +252,7 @@ impl ObjectImpl for TtToJson {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "mode" => {
                 let settings = self.settings.lock().unwrap();
diff --git a/video/dav1d/src/dav1ddec/imp.rs b/video/dav1d/src/dav1ddec/imp.rs
index 02eb10fd..21115868 100644
--- a/video/dav1d/src/dav1ddec/imp.rs
+++ b/video/dav1d/src/dav1ddec/imp.rs
@@ -71,11 +71,7 @@ impl Dav1dDec {
         }
     }
 
-    fn gst_video_format_from_dav1d_picture(
-        &self,
-        element: &super::Dav1dDec,
-        pic: &dav1d::Picture,
-    ) -> gst_video::VideoFormat {
+    fn gst_video_format_from_dav1d_picture(&self, pic: &dav1d::Picture) -> gst_video::VideoFormat {
         let bpc = pic.bits_per_component();
         let format_desc = match (pic.pixel_layout(), bpc) {
             (dav1d::PixelLayout::I400, Some(dav1d::BitsPerComponent(8))) => "GRAY8",
@@ -91,7 +87,7 @@ impl Dav1dDec {
             (layout, bpc) => {
                 gst::warning!(
                     CAT,
-                    obj: element,
+                    imp: self,
                     "Unsupported dav1d format {:?}/{:?}",
                     layout,
                     bpc
@@ -119,20 +115,19 @@ impl Dav1dDec {
             }
         };
         f.parse::<gst_video::VideoFormat>().unwrap_or_else(|_| {
-            gst::warning!(CAT, obj: element, "Unsupported dav1d format: {}", f);
+            gst::warning!(CAT, imp: self, "Unsupported dav1d format: {}", f);
             gst_video::VideoFormat::Unknown
         })
     }
 
     fn handle_resolution_change<'s>(
         &'s self,
-        element: &super::Dav1dDec,
         mut state_guard: MutexGuard<'s, Option<State>>,
         pic: &dav1d::Picture,
     ) -> Result<MutexGuard<'s, Option<State>>, gst::FlowError> {
         let state = state_guard.as_ref().unwrap();
 
-        let format = self.gst_video_format_from_dav1d_picture(element, pic);
+        let format = self.gst_video_format_from_dav1d_picture(pic);
         if format == gst_video::VideoFormat::Unknown {
             return Err(gst::FlowError::NotNegotiated);
         }
@@ -152,7 +147,7 @@ impl Dav1dDec {
 
         gst::info!(
             CAT,
-            obj: element,
+            imp: self,
             "Negotiating format {:?} picture dimensions {}x{}",
             format,
             pic.width(),
@@ -162,10 +157,11 @@ impl Dav1dDec {
         let input_state = state.input_state.clone();
         drop(state_guard);
 
+        let instance = self.instance();
         let output_state =
-            element.set_output_state(format, pic.width(), pic.height(), Some(&input_state))?;
-        element.negotiate(output_state)?;
-        let out_state = element.output_state().unwrap();
+            instance.set_output_state(format, pic.width(), pic.height(), Some(&input_state))?;
+        instance.negotiate(output_state)?;
+        let out_state = instance.output_state().unwrap();
 
         state_guard = self.state.lock().unwrap();
         let state = state_guard.as_mut().unwrap();
@@ -174,22 +170,21 @@ impl Dav1dDec {
         Ok(state_guard)
     }
 
-    fn flush_decoder(&self, element: &super::Dav1dDec, state: &mut State) {
-        gst::info!(CAT, obj: element, "Flushing decoder");
+    fn flush_decoder(&self, state: &mut State) {
+        gst::info!(CAT, imp: self, "Flushing decoder");
 
         state.decoder.flush();
     }
 
     fn send_data(
         &self,
-        element: &super::Dav1dDec,
         state_guard: &mut MutexGuard<Option<State>>,
         input_buffer: gst::Buffer,
         frame: gst_video::VideoCodecFrame,
     ) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> {
         gst::trace!(
             CAT,
-            obj: element,
+            imp: self,
             "Sending data to decoder for frame {}",
             frame.system_frame_number()
         );
@@ -210,18 +205,18 @@ impl Dav1dDec {
             .send_data(input_data, frame_number, timestamp, duration)
         {
             Ok(()) => {
-                gst::trace!(CAT, obj: element, "Decoder returned OK");
+                gst::trace!(CAT, imp: self, "Decoder returned OK");
                 Ok(std::ops::ControlFlow::Break(()))
             }
             Err(err) if err.is_again() => {
-                gst::trace!(CAT, obj: element, "Decoder returned EAGAIN");
+                gst::trace!(CAT, imp: self, "Decoder returned EAGAIN");
                 Ok(std::ops::ControlFlow::Continue(()))
             }
             Err(err) => {
                 gst::error!(CAT, "Sending data failed (error code: {})", err);
-                element.release_frame(frame);
+                self.instance().release_frame(frame);
                 gst_video::video_decoder_error!(
-                    element,
+                    &*self.instance(),
                     1,
                     gst::StreamError::Decode,
                     ["Sending data failed (error code {})", err]
@@ -233,26 +228,25 @@ impl Dav1dDec {
 
     fn send_pending_data(
         &self,
-        element: &super::Dav1dDec,
         state_guard: &mut MutexGuard<Option<State>>,
     ) -> Result<std::ops::ControlFlow<(), ()>, gst::FlowError> {
-        gst::trace!(CAT, obj: element, "Sending pending data to decoder");
+        gst::trace!(CAT, imp: self, "Sending pending data to decoder");
 
         let state = state_guard.as_mut().unwrap();
 
         match state.decoder.send_pending_data() {
             Ok(()) => {
-                gst::trace!(CAT, obj: element, "Decoder returned OK");
+                gst::trace!(CAT, imp: self, "Decoder returned OK");
                 Ok(std::ops::ControlFlow::Break(()))
             }
             Err(err) if err.is_again() => {
-                gst::trace!(CAT, obj: element, "Decoder returned EAGAIN");
+                gst::trace!(CAT, imp: self, "Decoder returned EAGAIN");
                 Ok(std::ops::ControlFlow::Continue(()))
             }
             Err(err) => {
                 gst::error!(CAT, "Sending data failed (error code: {})", err);
                 gst_video::video_decoder_error!(
-                    element,
+                    &*self.instance(),
                     1,
                     gst::StreamError::Decode,
                     ["Sending data failed (error code {})", err]
@@ -264,7 +258,6 @@ impl Dav1dDec {
 
     fn decoded_picture_as_buffer(
         &self,
-        element: &super::Dav1dDec,
         state_guard: &mut MutexGuard<Option<State>>,
         pic: &dav1d::Picture,
         output_state: gst_video::VideoCodecState<gst_video::video_codec_state::Readable>,
@@ -304,7 +297,7 @@ impl Dav1dDec {
             } else {
                 gst::trace!(
                     gst::CAT_PERFORMANCE,
-                    obj: element,
+                    imp: self,
                     "Copying decoded video frame component {:?}",
                     component
                 );
@@ -359,71 +352,67 @@ impl Dav1dDec {
 
     fn handle_picture<'s>(
         &'s self,
-        element: &super::Dav1dDec,
         mut state_guard: MutexGuard<'s, Option<State>>,
         pic: &dav1d::Picture,
     ) -> Result<MutexGuard<'s, Option<State>>, gst::FlowError> {
-        gst::trace!(CAT, obj: element, "Handling picture {}", pic.offset());
+        gst::trace!(CAT, imp: self, "Handling picture {}", pic.offset());
 
-        state_guard = self.handle_resolution_change(element, state_guard, pic)?;
+        state_guard = self.handle_resolution_change(state_guard, pic)?;
 
-        let output_state = element
+        let instance = self.instance();
+        let output_state = instance
             .output_state()
             .expect("Output state not set. Shouldn't happen!");
         let offset = pic.offset() as i32;
 
-        if let Some(mut frame) = element.frame(offset) {
+        let frame = instance.frame(offset);
+        if let Some(mut frame) = frame {
             let output_buffer =
-                self.decoded_picture_as_buffer(element, &mut state_guard, pic, output_state)?;
+                self.decoded_picture_as_buffer(&mut state_guard, pic, output_state)?;
             frame.set_output_buffer(output_buffer);
             drop(state_guard);
-            element.finish_frame(frame)?;
+            instance.finish_frame(frame)?;
             Ok(self.state.lock().unwrap())
         } else {
-            gst::warning!(CAT, obj: element, "No frame found for offset {}", offset);
+            gst::warning!(CAT, imp: self, "No frame found for offset {}", offset);
             Ok(state_guard)
         }
     }
 
-    fn drop_decoded_pictures(
-        &self,
-        element: &super::Dav1dDec,
-        state_guard: &mut MutexGuard<Option<State>>,
-    ) {
-        while let Ok(Some(pic)) = self.pending_pictures(element, state_guard) {
-            gst::debug!(CAT, obj: element, "Dropping picture {}", pic.offset());
+    fn drop_decoded_pictures(&self, state_guard: &mut MutexGuard<Option<State>>) {
+        while let Ok(Some(pic)) = self.pending_pictures(state_guard) {
+            gst::debug!(CAT, imp: self, "Dropping picture {}", pic.offset());
             drop(pic);
         }
     }
 
     fn pending_pictures(
         &self,
-        element: &super::Dav1dDec,
         state_guard: &mut MutexGuard<Option<State>>,
     ) -> Result<Option<dav1d::Picture>, gst::FlowError> {
-        gst::trace!(CAT, obj: element, "Retrieving pending picture");
+        gst::trace!(CAT, imp: self, "Retrieving pending picture");
 
         let state = state_guard.as_mut().unwrap();
 
         match state.decoder.get_picture() {
             Ok(pic) => {
-                gst::trace!(CAT, obj: element, "Retrieved picture {}", pic.offset());
+                gst::trace!(CAT, imp: self, "Retrieved picture {}", pic.offset());
                 Ok(Some(pic))
             }
             Err(err) if err.is_again() => {
-                gst::trace!(CAT, obj: element, "Decoder needs more data");
+                gst::trace!(CAT, imp: self, "Decoder needs more data");
                 Ok(None)
             }
             Err(err) => {
                 gst::error!(
                     CAT,
-                    obj: element,
+                    imp: self,
                     "Retrieving decoded picture failed (error code {})",
                     err
                 );
 
                 gst_video::video_decoder_error!(
-                    element,
+                    &*self.instance(),
                     1,
                     gst::StreamError::Decode,
                     ["Retrieving decoded picture failed (error code {})", err]
@@ -435,11 +424,10 @@ impl Dav1dDec {
 
     fn forward_pending_pictures<'s>(
         &'s self,
-        element: &super::Dav1dDec,
         mut state_guard: MutexGuard<'s, Option<State>>,
     ) -> Result<MutexGuard<Option<State>>, gst::FlowError> {
-        while let Some(pic) = self.pending_pictures(element, &mut state_guard)? {
-            state_guard = self.handle_picture(element, state_guard, &pic)?;
+        while let Some(pic) = self.pending_pictures(&mut state_guard)? {
+            state_guard = self.handle_picture(state_guard, &pic)?;
         }
 
         Ok(state_guard)
@@ -516,13 +504,7 @@ impl ObjectImpl for Dav1dDec {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         let mut settings = self.settings.lock().unwrap();
 
         match pspec.name() {
@@ -536,7 +518,7 @@ impl ObjectImpl for Dav1dDec {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         let settings = self.settings.lock().unwrap();
 
         match pspec.name() {
@@ -600,7 +582,7 @@ impl ElementImpl for Dav1dDec {
 }
 
 impl VideoDecoderImpl for Dav1dDec {
-    fn src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
+    fn src_query(&self, query: &mut gst::QueryRef) -> bool {
         match query.view_mut() {
             gst::QueryViewMut::Latency(q) => {
                 let state_guard = self.state.lock().unwrap();
@@ -613,9 +595,8 @@ impl VideoDecoderImpl for Dav1dDec {
                     Some(ref state) => match state.output_info {
                         Some(ref info) => {
                             let mut upstream_latency = gst::query::Latency::new();
-                            let sinkpad = element.sink_pad();
 
-                            if sinkpad.peer_query(&mut upstream_latency) {
+                            if self.instance().sink_pad().peer_query(&mut upstream_latency) {
                                 let (live, mut min, mut max) = upstream_latency.result();
                                 // For autodetection: 1 if live, else whatever dav1d gives us
                                 let frame_latency: u64 = if max_frame_delay < 0 && live {
@@ -638,7 +619,7 @@ impl VideoDecoderImpl for Dav1dDec {
                                     * gst::ClockTime::SECOND
                                     / (fps_n as u64);
 
-                                gst::debug!(CAT, obj: element, "Reporting latency of {}", latency);
+                                gst::debug!(CAT, imp: self, "Reporting latency of {}", latency);
 
                                 min += latency;
                                 max = max.opt_add(latency);
@@ -657,22 +638,21 @@ impl VideoDecoderImpl for Dav1dDec {
                     None => false,
                 }
             }
-            _ => VideoDecoderImplExt::parent_src_query(self, element, query),
+            _ => VideoDecoderImplExt::parent_src_query(self, query),
         }
     }
 
-    fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         {
             let mut state_guard = self.state.lock().unwrap();
             *state_guard = None;
         }
 
-        self.parent_stop(element)
+        self.parent_stop()
     }
 
     fn set_format(
         &self,
-        element: &Self::Type,
         input_state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>,
     ) -> Result<(), gst::LoggableError> {
         let mut state_guard = self.state.lock().unwrap();
@@ -681,14 +661,13 @@ impl VideoDecoderImpl for Dav1dDec {
         let max_frame_delay: u32;
         let n_cpus = num_cpus::get();
 
-        gst::info!(CAT, obj: element, "Detected {} logical CPUs", n_cpus);
+        gst::info!(CAT, imp: self, "Detected {} logical CPUs", n_cpus);
 
         if settings.max_frame_delay == -1 {
             let mut latency_query = gst::query::Latency::new();
             let mut is_live = false;
-            let sinkpad = element.sink_pad();
 
-            if sinkpad.peer_query(&mut latency_query) {
+            if self.instance().sink_pad().peer_query(&mut latency_query) {
                 is_live = latency_query.result().0;
             }
 
@@ -699,7 +678,7 @@ impl VideoDecoderImpl for Dav1dDec {
 
         gst::info!(
             CAT,
-            obj: element,
+            imp: self,
             "Creating decoder with n-threads={} and max-frame-delay={}",
             settings.n_threads,
             max_frame_delay
@@ -719,12 +698,11 @@ impl VideoDecoderImpl for Dav1dDec {
             n_cpus,
         });
 
-        self.parent_set_format(element, input_state)
+        self.parent_set_format(input_state)
     }
 
     fn handle_frame(
         &self,
-        element: &Self::Type,
         frame: gst_video::VideoCodecFrame,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         let input_buffer = frame
@@ -733,73 +711,71 @@ impl VideoDecoderImpl for Dav1dDec {
 
         {
             let mut state_guard = self.state.lock().unwrap();
-            state_guard = self.forward_pending_pictures(element, state_guard)?;
-            if self.send_data(element, &mut state_guard, input_buffer, frame)?
+            state_guard = self.forward_pending_pictures(state_guard)?;
+            if self.send_data(&mut state_guard, input_buffer, frame)?
                 == std::ops::ControlFlow::Continue(())
             {
                 loop {
-                    state_guard = self.forward_pending_pictures(element, state_guard)?;
-                    if self.send_pending_data(element, &mut state_guard)?
-                        == std::ops::ControlFlow::Break(())
+                    state_guard = self.forward_pending_pictures(state_guard)?;
+                    if self.send_pending_data(&mut state_guard)? == std::ops::ControlFlow::Break(())
                     {
                         break;
                     }
                 }
             }
-            let _state_guard = self.forward_pending_pictures(element, state_guard)?;
+            let _state_guard = self.forward_pending_pictures(state_guard)?;
         }
 
         Ok(gst::FlowSuccess::Ok)
     }
 
-    fn flush(&self, element: &Self::Type) -> bool {
-        gst::info!(CAT, obj: element, "Flushing");
+    fn flush(&self) -> bool {
+        gst::info!(CAT, imp: self, "Flushing");
 
         {
             let mut state_guard = self.state.lock().unwrap();
             if state_guard.is_some() {
                 let state = state_guard.as_mut().unwrap();
-                self.flush_decoder(element, state);
-                self.drop_decoded_pictures(element, &mut state_guard);
+                self.flush_decoder(state);
+                self.drop_decoded_pictures(&mut state_guard);
             }
         }
 
         true
     }
 
-    fn drain(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst::info!(CAT, obj: element, "Draining");
+    fn drain(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
+        gst::info!(CAT, imp: self, "Draining");
 
         {
             let mut state_guard = self.state.lock().unwrap();
             if state_guard.is_some() {
                 let state = state_guard.as_mut().unwrap();
-                self.flush_decoder(element, state);
-                let _state_guard = self.forward_pending_pictures(element, state_guard)?;
+                self.flush_decoder(state);
+                let _state_guard = self.forward_pending_pictures(state_guard)?;
             }
         }
 
-        self.parent_drain(element)
+        self.parent_drain()
     }
 
-    fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst::info!(CAT, obj: element, "Finishing");
+    fn finish(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
+        gst::info!(CAT, imp: self, "Finishing");
 
         {
             let mut state_guard = self.state.lock().unwrap();
             if state_guard.is_some() {
                 let state = state_guard.as_mut().unwrap();
-                self.flush_decoder(element, state);
-                let _state_guard = self.forward_pending_pictures(element, state_guard)?;
+                self.flush_decoder(state);
+                let _state_guard = self.forward_pending_pictures(state_guard)?;
             }
         }
 
-        self.parent_finish(element)
+        self.parent_finish()
     }
 
     fn decide_allocation(
         &self,
-        element: &Self::Type,
         query: &mut gst::query::Allocation,
     ) -> Result<(), gst::LoggableError> {
         {
@@ -810,6 +786,6 @@ impl VideoDecoderImpl for Dav1dDec {
                 .is_some();
         }
 
-        self.parent_decide_allocation(element, query)
+        self.parent_decide_allocation(query)
     }
 }
diff --git a/video/ffv1/src/ffv1dec/imp.rs b/video/ffv1/src/ffv1dec/imp.rs
index 6d6372fe..6fcfd6b4 100644
--- a/video/ffv1/src/ffv1dec/imp.rs
+++ b/video/ffv1/src/ffv1dec/imp.rs
@@ -358,7 +358,6 @@ impl VideoDecoderImpl for Ffv1Dec {
     /* We allocate the decoder here rather than start() because we need the sink caps */
     fn set_format(
         &self,
-        element: &super::Ffv1Dec,
         state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>,
     ) -> Result<(), gst::LoggableError> {
         let info = state.info();
@@ -372,7 +371,8 @@ impl VideoDecoderImpl for Ffv1Dec {
         let format = get_output_format(decoder.config_record())
             .ok_or_else(|| gst::loggable_error!(CAT, "Unsupported format"))?;
 
-        let output_state = element
+        let instance = self.instance();
+        let output_state = instance
             .set_output_state(format, info.width(), info.height(), Some(state))
             .map_err(|err| gst::loggable_error!(CAT, "Failed to set output params: {}", err))?;
 
@@ -386,23 +386,22 @@ impl VideoDecoderImpl for Ffv1Dec {
         };
         drop(decoder_state);
 
-        element
+        instance
             .negotiate(output_state)
             .map_err(|err| gst::loggable_error!(CAT, "Negotiation failed: {}", err))?;
 
-        self.parent_set_format(element, state)
+        self.parent_set_format(state)
     }
 
-    fn stop(&self, element: &super::Ffv1Dec) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         let mut decoder_state = self.state.lock().unwrap();
         *decoder_state = DecoderState::Stopped;
 
-        self.parent_stop(element)
+        self.parent_stop()
     }
 
     fn handle_frame(
         &self,
-        element: &super::Ffv1Dec,
         mut frame: gst_video::VideoCodecFrame,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         let mut state = self.state.lock().unwrap();
@@ -438,14 +437,13 @@ impl VideoDecoderImpl for Ffv1Dec {
         drop(state);
 
         frame.set_output_buffer(buf);
-        element.finish_frame(frame)?;
+        self.instance().finish_frame(frame)?;
 
         Ok(gst::FlowSuccess::Ok)
     }
 
     fn decide_allocation(
         &self,
-        element: &Self::Type,
         query: &mut gst::query::Allocation,
     ) -> Result<(), gst::LoggableError> {
         let supported = query
@@ -461,6 +459,6 @@ impl VideoDecoderImpl for Ffv1Dec {
             *video_meta_supported = supported;
         }
 
-        self.parent_decide_allocation(element, query)
+        self.parent_decide_allocation(query)
     }
 }
diff --git a/video/flavors/src/flvdemux/imp.rs b/video/flavors/src/flvdemux/imp.rs
index b2a42a83..80c683d1 100644
--- a/video/flavors/src/flvdemux/imp.rs
+++ b/video/flavors/src/flvdemux/imp.rs
@@ -134,7 +134,7 @@ impl ObjectSubclass for FlvDemux {
                 FlvDemux::catch_panic_pad_function(
                     parent,
                     || Err(gst::loggable_error!(CAT, "Panic activating sink pad")),
-                    |demux, element| demux.sink_activate(pad, element),
+                    |demux| demux.sink_activate(pad),
                 )
             })
             .activatemode_function(|pad, parent, mode, active| {
@@ -146,8 +146,8 @@ impl ObjectSubclass for FlvDemux {
                             "Panic activating sink pad with mode"
                         ))
                     },
-                    |demux, element| {
-                        demux.sink_activatemode(pad, element, mode, active);
+                    |demux| {
+                        demux.sink_activatemode(pad, mode, active);
                         Ok(())
                     },
                 )
@@ -156,14 +156,14 @@ impl ObjectSubclass for FlvDemux {
                 FlvDemux::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |demux, element| demux.sink_chain(pad, element, buffer),
+                    |demux| demux.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 FlvDemux::catch_panic_pad_function(
                     parent,
                     || false,
-                    |demux, element| demux.sink_event(pad, element, event),
+                    |demux| demux.sink_event(pad, event),
                 )
             })
             .build();
@@ -180,10 +180,10 @@ impl ObjectSubclass for FlvDemux {
 }
 
 impl ObjectImpl for FlvDemux {
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
-        obj.add_pad(&self.sinkpad).unwrap();
+        self.instance().add_pad(&self.sinkpad).unwrap();
     }
 }
 
@@ -298,11 +298,7 @@ impl ElementImpl for FlvDemux {
 }
 
 impl FlvDemux {
-    fn sink_activate(
-        &self,
-        pad: &gst::Pad,
-        _element: &super::FlvDemux,
-    ) -> Result<(), gst::LoggableError> {
+    fn sink_activate(&self, pad: &gst::Pad) -> Result<(), gst::LoggableError> {
         let mode = {
             let mut query = gst::query::Scheduling::new();
             if !pad.peer_query(&mut query) {
@@ -327,15 +323,9 @@ impl FlvDemux {
         Ok(())
     }
 
-    fn sink_activatemode(
-        &self,
-        _pad: &gst::Pad,
-        element: &super::FlvDemux,
-        mode: gst::PadMode,
-        active: bool,
-    ) {
+    fn sink_activatemode(&self, _pad: &gst::Pad, mode: gst::PadMode, active: bool) {
         if active {
-            self.start(element, mode);
+            self.start(mode);
 
             if mode == gst::PadMode::Pull {
                 // TODO implement pull mode
@@ -347,63 +337,58 @@ impl FlvDemux {
                 let _ = self.sinkpad.stop_task();
             }
 
-            self.stop(element);
+            self.stop();
         }
     }
 
-    fn start(&self, _element: &super::FlvDemux, _mode: gst::PadMode) {
+    fn start(&self, _mode: gst::PadMode) {
         *self.state.lock().unwrap() = State::NeedHeader;
     }
 
-    fn stop(&self, element: &super::FlvDemux) {
+    fn stop(&self) {
         *self.state.lock().unwrap() = State::Stopped;
         self.adapter.lock().unwrap().clear();
 
         let mut flow_combiner = self.flow_combiner.lock().unwrap();
         if let Some(pad) = self.audio_srcpad.lock().unwrap().take() {
-            element.remove_pad(&pad).unwrap();
+            self.instance().remove_pad(&pad).unwrap();
             flow_combiner.remove_pad(&pad);
         }
 
         if let Some(pad) = self.video_srcpad.lock().unwrap().take() {
-            element.remove_pad(&pad).unwrap();
+            self.instance().remove_pad(&pad).unwrap();
             flow_combiner.remove_pad(&pad);
         }
 
         flow_combiner.reset();
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::FlvDemux, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
         match event.view() {
             EventView::Eos(..) => {
                 // TODO implement
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::Segment(..) => {
                 // TODO implement
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::FlushStart(..) => {
                 // TODO implement
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::FlushStop(..) => {
                 // TODO implement
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn src_query(
-        &self,
-        pad: &gst::Pad,
-        element: &super::FlvDemux,
-        query: &mut gst::QueryRef,
-    ) -> bool {
+    fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
         use gst::QueryViewMut;
 
         match query.view_mut() {
@@ -447,11 +432,11 @@ impl FlvDemux {
                     false
                 }
             }
-            _ => pad.query_default(Some(element), query),
+            _ => pad.query_default(Some(&*self.instance()), query),
         }
     }
 
-    fn src_event(&self, pad: &gst::Pad, element: &super::FlvDemux, event: gst::Event) -> bool {
+    fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         match event.view() {
@@ -459,14 +444,13 @@ impl FlvDemux {
                 // TODO: Implement
                 false
             }
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        element: &super::FlvDemux,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
@@ -479,10 +463,10 @@ impl FlvDemux {
             match *state {
                 State::Stopped => unreachable!(),
                 State::NeedHeader => {
-                    let header = match self.find_header(element, &mut *adapter) {
+                    let header = match self.find_header(&mut *adapter) {
                         Ok(header) => header,
                         Err(_) => {
-                            gst::trace!(CAT, obj: element, "Need more data");
+                            gst::trace!(CAT, imp: self, "Need more data");
                             return Ok(gst::FlowSuccess::Ok);
                         }
                     };
@@ -511,7 +495,7 @@ impl FlvDemux {
                 } => {
                     let avail = adapter.available();
                     if avail == 0 {
-                        gst::trace!(CAT, obj: element, "Need more data");
+                        gst::trace!(CAT, imp: self, "Need more data");
                         return Ok(gst::FlowSuccess::Ok);
                     }
                     let skip = cmp::min(avail, *skip_left as usize);
@@ -519,24 +503,24 @@ impl FlvDemux {
                     *skip_left -= skip as u32;
                 }
                 State::Streaming(ref mut sstate) => {
-                    let res = sstate.handle_tag(element, &mut *adapter);
+                    let res = sstate.handle_tag(self, &mut *adapter);
 
                     match res {
                         Ok(None) => {
-                            gst::trace!(CAT, obj: element, "Need more data");
+                            gst::trace!(CAT, imp: self, "Need more data");
                             return Ok(gst::FlowSuccess::Ok);
                         }
                         Ok(Some(events)) => {
                             drop(state);
                             drop(adapter);
 
-                            self.handle_events(element, events)?;
+                            self.handle_events(events)?;
 
                             adapter = self.adapter.lock().unwrap();
                             state = self.state.lock().unwrap();
                         }
                         Err(err) => {
-                            element.post_error_message(err);
+                            self.post_error_message(err);
                             return Err(gst::FlowError::Error);
                         }
                     }
@@ -545,16 +529,12 @@ impl FlvDemux {
         }
     }
 
-    fn find_header(
-        &self,
-        element: &super::FlvDemux,
-        adapter: &mut gst_base::UniqueAdapter,
-    ) -> Result<flavors::Header, ()> {
+    fn find_header(&self, adapter: &mut gst_base::UniqueAdapter) -> Result<flavors::Header, ()> {
         while adapter.available() >= 9 {
             let data = adapter.map(9).unwrap();
 
             if let Ok((_, header)) = flavors::header(&*data) {
-                gst::debug!(CAT, obj: element, "Found FLV header: {:?}", header);
+                gst::debug!(CAT, imp: self, "Found FLV header: {:?}", header);
                 drop(data);
                 adapter.flush(9);
 
@@ -570,7 +550,6 @@ impl FlvDemux {
 
     fn handle_events(
         &self,
-        element: &super::FlvDemux,
         events: SmallVec<[Event; 4]>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         for event in events {
@@ -582,7 +561,7 @@ impl FlvDemux {
                             if let Some(ref srcpad) = *audio_srcpad {
                                 srcpad.clone()
                             } else {
-                                let srcpad = self.create_srcpad(element, "audio", &caps);
+                                let srcpad = self.create_srcpad("audio", &caps);
                                 *audio_srcpad = Some(srcpad.clone());
 
                                 srcpad
@@ -593,7 +572,7 @@ impl FlvDemux {
                             if let Some(ref srcpad) = *video_srcpad {
                                 srcpad.clone()
                             } else {
-                                let srcpad = self.create_srcpad(element, "video", &caps);
+                                let srcpad = self.create_srcpad("video", &caps);
 
                                 *video_srcpad = Some(srcpad.clone());
 
@@ -618,7 +597,7 @@ impl FlvDemux {
                         let res = pad.push(buffer);
                         gst::trace!(
                             CAT,
-                            obj: element,
+                            imp: self,
                             "Pushing buffer for stream {:?} returned {:?}",
                             stream,
                             res
@@ -631,7 +610,7 @@ impl FlvDemux {
                     }
                 }
                 Event::HaveAllStreams => {
-                    element.no_more_pads();
+                    self.instance().no_more_pads();
                 }
             }
         }
@@ -639,28 +618,28 @@ impl FlvDemux {
         Ok(gst::FlowSuccess::Ok)
     }
 
-    fn create_srcpad(&self, element: &super::FlvDemux, name: &str, caps: &gst::Caps) -> gst::Pad {
-        let templ = element.element_class().pad_template(name).unwrap();
+    fn create_srcpad(&self, name: &str, caps: &gst::Caps) -> gst::Pad {
+        let templ = self.instance().element_class().pad_template(name).unwrap();
         let srcpad = gst::Pad::builder_with_template(&templ, Some(name))
             .event_function(|pad, parent, event| {
                 FlvDemux::catch_panic_pad_function(
                     parent,
                     || false,
-                    |demux, element| demux.src_event(pad, element, event),
+                    |demux| demux.src_event(pad, event),
                 )
             })
             .query_function(|pad, parent, query| {
                 FlvDemux::catch_panic_pad_function(
                     parent,
                     || false,
-                    |demux, element| demux.src_query(pad, element, query),
+                    |demux| demux.src_query(pad, query),
                 )
             })
             .build();
 
         srcpad.set_active(true).unwrap();
 
-        let full_stream_id = srcpad.create_stream_id(element, Some(name));
+        let full_stream_id = srcpad.create_stream_id(&*self.instance(), Some(name));
         // FIXME group id
         srcpad.push_event(gst::event::StreamStart::new(&full_stream_id));
         srcpad.push_event(gst::event::Caps::new(caps));
@@ -671,7 +650,7 @@ impl FlvDemux {
 
         self.flow_combiner.lock().unwrap().add_pad(&srcpad);
 
-        element.add_pad(&srcpad).unwrap();
+        self.instance().add_pad(&srcpad).unwrap();
 
         srcpad
     }
@@ -694,7 +673,7 @@ impl StreamingState {
 
     fn handle_tag(
         &mut self,
-        element: &super::FlvDemux,
+        imp: &FlvDemux,
         adapter: &mut gst_base::UniqueAdapter,
     ) -> Result<Option<SmallVec<[Event; 4]>>, gst::ErrorMessage> {
         use nom::number::complete::be_u32;
@@ -708,7 +687,7 @@ impl StreamingState {
         match be_u32::<_, (_, nom::error::ErrorKind)>(&data[0..4]) {
             Err(_) => unreachable!(),
             Ok((_, previous_size)) => {
-                gst::trace!(CAT, obj: element, "Previous tag size {}", previous_size);
+                gst::trace!(CAT, imp: imp, "Previous tag size {}", previous_size);
                 // Nothing to do here, we just consume it for now
             }
         }
@@ -724,7 +703,7 @@ impl StreamingState {
             Ok((_, tag_header)) => tag_header,
         };
 
-        gst::trace!(CAT, obj: element, "Parsed tag header {:?}", tag_header);
+        gst::trace!(CAT, imp: imp, "Parsed tag header {:?}", tag_header);
 
         drop(data);
 
@@ -736,19 +715,19 @@ impl StreamingState {
 
         match tag_header.tag_type {
             flavors::TagType::Script => {
-                gst::trace!(CAT, obj: element, "Found script tag");
+                gst::trace!(CAT, imp: imp, "Found script tag");
 
-                Ok(self.handle_script_tag(element, &tag_header, adapter))
+                Ok(self.handle_script_tag(imp, &tag_header, adapter))
             }
             flavors::TagType::Audio => {
-                gst::trace!(CAT, obj: element, "Found audio tag");
+                gst::trace!(CAT, imp: imp, "Found audio tag");
 
-                self.handle_audio_tag(element, &tag_header, adapter)
+                self.handle_audio_tag(imp, &tag_header, adapter)
             }
             flavors::TagType::Video => {
-                gst::trace!(CAT, obj: element, "Found video tag");
+                gst::trace!(CAT, imp: imp, "Found video tag");
 
-                self.handle_video_tag(element, &tag_header, adapter)
+                self.handle_video_tag(imp, &tag_header, adapter)
             }
         }
         .map(Option::Some)
@@ -756,7 +735,7 @@ impl StreamingState {
 
     fn handle_script_tag(
         &mut self,
-        element: &super::FlvDemux,
+        imp: &FlvDemux,
         tag_header: &flavors::TagHeader,
         adapter: &mut gst_base::UniqueAdapter,
     ) -> SmallVec<[Event; 4]> {
@@ -768,10 +747,10 @@ impl StreamingState {
 
         match flavors::script_data(&*data) {
             Ok((_, ref script_data)) if script_data.name == "onMetaData" => {
-                gst::trace!(CAT, obj: element, "Got script tag: {:?}", script_data);
+                gst::trace!(CAT, imp: imp, "Got script tag: {:?}", script_data);
 
                 let metadata = Metadata::new(script_data);
-                gst::debug!(CAT, obj: element, "Got metadata: {:?}", metadata);
+                gst::debug!(CAT, imp: imp, "Got metadata: {:?}", metadata);
 
                 let audio_changed = self
                     .audio
@@ -799,10 +778,10 @@ impl StreamingState {
                 }
             }
             Ok((_, ref script_data)) => {
-                gst::trace!(CAT, obj: element, "Got script tag: {:?}", script_data);
+                gst::trace!(CAT, imp: imp, "Got script tag: {:?}", script_data);
             }
             Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
-                gst::error!(CAT, obj: element, "Error parsing script tag: {:?}", err);
+                gst::error!(CAT, imp: imp, "Error parsing script tag: {:?}", err);
             }
             Err(nom::Err::Incomplete(_)) => {
                 // ignore
@@ -817,17 +796,12 @@ impl StreamingState {
 
     fn update_audio_stream(
         &mut self,
-        element: &super::FlvDemux,
+        imp: &FlvDemux,
         data_header: &flavors::AudioDataHeader,
     ) -> SmallVec<[Event; 4]> {
         let mut events = SmallVec::new();
 
-        gst::trace!(
-            CAT,
-            obj: element,
-            "Got audio data header: {:?}",
-            data_header
-        );
+        gst::trace!(CAT, imp: imp, "Got audio data header: {:?}", data_header);
 
         let new_audio_format =
             AudioFormat::new(data_header, &self.metadata, &self.aac_sequence_header);
@@ -835,7 +809,7 @@ impl StreamingState {
         if self.audio.as_ref() != Some(&new_audio_format) {
             gst::debug!(
                 CAT,
-                obj: element,
+                imp: imp,
                 "Got new audio format: {:?}",
                 new_audio_format
             );
@@ -851,7 +825,7 @@ impl StreamingState {
 
         if (!self.expect_video || self.video != None) && self.audio != None && !self.got_all_streams
         {
-            gst::debug!(CAT, obj: element, "Have all expected streams now");
+            gst::debug!(CAT, imp: imp, "Have all expected streams now");
             self.got_all_streams = true;
             events.push(Event::HaveAllStreams);
         }
@@ -861,7 +835,7 @@ impl StreamingState {
 
     fn handle_aac_audio_packet_header(
         &mut self,
-        element: &super::FlvDemux,
+        imp: &FlvDemux,
         tag_header: &flavors::TagHeader,
         adapter: &mut gst_base::UniqueAdapter,
     ) -> Result<bool, gst::ErrorMessage> {
@@ -870,7 +844,7 @@ impl StreamingState {
             adapter.flush((tag_header.data_size - 1) as usize);
             gst::warning!(
                 CAT,
-                obj: element,
+                imp: imp,
                 "Too small packet for AAC packet header {}",
                 tag_header.data_size
             );
@@ -881,19 +855,14 @@ impl StreamingState {
 
         match flavors::aac_audio_packet_header(&*data) {
             Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
-                gst::error!(
-                    CAT,
-                    obj: element,
-                    "Invalid AAC audio packet header: {:?}",
-                    err
-                );
+                gst::error!(CAT, imp: imp, "Invalid AAC audio packet header: {:?}", err);
                 drop(data);
                 adapter.flush((tag_header.data_size - 1) as usize);
                 Ok(true)
             }
             Err(nom::Err::Incomplete(_)) => unreachable!(),
             Ok((_, header)) => {
-                gst::trace!(CAT, obj: element, "Got AAC packet header {:?}", header);
+                gst::trace!(CAT, imp: imp, "Got AAC packet header {:?}", header);
                 match header.packet_type {
                     flavors::AACPacketType::SequenceHeader => {
                         drop(data);
@@ -901,7 +870,7 @@ impl StreamingState {
                         let buffer = adapter
                             .take_buffer((tag_header.data_size - 1 - 1) as usize)
                             .unwrap();
-                        gst::debug!(CAT, obj: element, "Got AAC sequence header {:?}", buffer,);
+                        gst::debug!(CAT, imp: imp, "Got AAC sequence header {:?}", buffer,);
 
                         self.aac_sequence_header = Some(buffer);
                         Ok(true)
@@ -918,7 +887,7 @@ impl StreamingState {
 
     fn handle_audio_tag(
         &mut self,
-        element: &super::FlvDemux,
+        imp: &FlvDemux,
         tag_header: &flavors::TagHeader,
         adapter: &mut gst_base::UniqueAdapter,
     ) -> Result<SmallVec<[Event; 4]>, gst::ErrorMessage> {
@@ -927,7 +896,7 @@ impl StreamingState {
         let data = adapter.map(1).unwrap();
         let data_header = match flavors::audio_data_header(&*data) {
             Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
-                gst::error!(CAT, obj: element, "Invalid audio data header: {:?}", err);
+                gst::error!(CAT, imp: imp, "Invalid audio data header: {:?}", err);
                 drop(data);
                 adapter.flush(tag_header.data_size as usize);
                 return Ok(SmallVec::new());
@@ -938,11 +907,11 @@ impl StreamingState {
         drop(data);
         adapter.flush(1);
 
-        let mut events = self.update_audio_stream(element, &data_header);
+        let mut events = self.update_audio_stream(imp, &data_header);
 
         // AAC special case
         if data_header.sound_format == flavors::SoundFormat::AAC
-            && self.handle_aac_audio_packet_header(element, tag_header, adapter)?
+            && self.handle_aac_audio_packet_header(imp, tag_header, adapter)?
         {
             return Ok(events);
         }
@@ -972,7 +941,7 @@ impl StreamingState {
 
         gst::trace!(
             CAT,
-            obj: element,
+            imp: imp,
             "Outputting audio buffer {:?} for tag {:?}",
             buffer,
             tag_header,
@@ -987,17 +956,12 @@ impl StreamingState {
 
     fn update_video_stream(
         &mut self,
-        element: &super::FlvDemux,
+        imp: &FlvDemux,
         data_header: &flavors::VideoDataHeader,
     ) -> SmallVec<[Event; 4]> {
         let mut events = SmallVec::new();
 
-        gst::trace!(
-            CAT,
-            obj: element,
-            "Got video data header: {:?}",
-            data_header
-        );
+        gst::trace!(CAT, imp: imp, "Got video data header: {:?}", data_header);
 
         let new_video_format =
             VideoFormat::new(data_header, &self.metadata, &self.avc_sequence_header);
@@ -1005,7 +969,7 @@ impl StreamingState {
         if self.video.as_ref() != Some(&new_video_format) {
             gst::debug!(
                 CAT,
-                obj: element,
+                imp: imp,
                 "Got new video format: {:?}",
                 new_video_format
             );
@@ -1021,7 +985,7 @@ impl StreamingState {
 
         if (!self.expect_audio || self.audio != None) && self.video != None && !self.got_all_streams
         {
-            gst::debug!(CAT, obj: element, "Have all expected streams now");
+            gst::debug!(CAT, imp: imp, "Have all expected streams now");
             self.got_all_streams = true;
             events.push(Event::HaveAllStreams);
         }
@@ -1031,7 +995,7 @@ impl StreamingState {
 
     fn handle_avc_video_packet_header(
         &mut self,
-        element: &super::FlvDemux,
+        imp: &FlvDemux,
         tag_header: &flavors::TagHeader,
         adapter: &mut gst_base::UniqueAdapter,
     ) -> Result<Option<i32>, gst::ErrorMessage> {
@@ -1040,7 +1004,7 @@ impl StreamingState {
             adapter.flush((tag_header.data_size - 1) as usize);
             gst::warning!(
                 CAT,
-                obj: element,
+                imp: imp,
                 "Too small packet for AVC packet header {}",
                 tag_header.data_size
             );
@@ -1050,19 +1014,14 @@ impl StreamingState {
         let data = adapter.map(4).unwrap();
         match flavors::avc_video_packet_header(&*data) {
             Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
-                gst::error!(
-                    CAT,
-                    obj: element,
-                    "Invalid AVC video packet header: {:?}",
-                    err
-                );
+                gst::error!(CAT, imp: imp, "Invalid AVC video packet header: {:?}", err);
                 drop(data);
                 adapter.flush((tag_header.data_size - 1) as usize);
                 Ok(None)
             }
             Err(nom::Err::Incomplete(_)) => unreachable!(),
             Ok((_, header)) => {
-                gst::trace!(CAT, obj: element, "Got AVC packet header {:?}", header);
+                gst::trace!(CAT, imp: imp, "Got AVC packet header {:?}", header);
                 match header.packet_type {
                     flavors::AVCPacketType::SequenceHeader => {
                         drop(data);
@@ -1072,7 +1031,7 @@ impl StreamingState {
                             .unwrap();
                         gst::debug!(
                             CAT,
-                            obj: element,
+                            imp: imp,
                             "Got AVC sequence header {:?} of size {}",
                             buffer,
                             tag_header.data_size - 1 - 4
@@ -1099,7 +1058,7 @@ impl StreamingState {
 
     fn handle_video_tag(
         &mut self,
-        element: &super::FlvDemux,
+        imp: &FlvDemux,
         tag_header: &flavors::TagHeader,
         adapter: &mut gst_base::UniqueAdapter,
     ) -> Result<SmallVec<[Event; 4]>, gst::ErrorMessage> {
@@ -1108,7 +1067,7 @@ impl StreamingState {
         let data = adapter.map(1).unwrap();
         let data_header = match flavors::video_data_header(&*data) {
             Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
-                gst::error!(CAT, obj: element, "Invalid video data header: {:?}", err);
+                gst::error!(CAT, imp: imp, "Invalid video data header: {:?}", err);
                 drop(data);
                 adapter.flush(tag_header.data_size as usize);
                 return Ok(SmallVec::new());
@@ -1119,11 +1078,11 @@ impl StreamingState {
         drop(data);
         adapter.flush(1);
 
-        let mut events = self.update_video_stream(element, &data_header);
+        let mut events = self.update_video_stream(imp, &data_header);
 
         // AVC/H264 special case
         let cts = if data_header.codec_id == flavors::CodecId::H264 {
-            match self.handle_avc_video_packet_header(element, tag_header, adapter)? {
+            match self.handle_avc_video_packet_header(imp, tag_header, adapter)? {
                 Some(cts) => cts,
                 None => {
                     return Ok(events);
@@ -1184,7 +1143,7 @@ impl StreamingState {
 
         gst::trace!(
             CAT,
-            obj: element,
+            imp: imp,
             "Outputting video buffer {:?} for tag {:?}, keyframe: {}",
             buffer,
             tag_header,
diff --git a/video/gif/src/gifenc/imp.rs b/video/gif/src/gifenc/imp.rs
index 68786dfb..c7a6617c 100644
--- a/video/gif/src/gifenc/imp.rs
+++ b/video/gif/src/gifenc/imp.rs
@@ -168,13 +168,7 @@ impl ObjectImpl for GifEnc {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "repeat" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -188,7 +182,7 @@ impl ObjectImpl for GifEnc {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "repeat" => {
                 let settings = self.settings.lock().unwrap();
@@ -251,30 +245,28 @@ impl ElementImpl for GifEnc {
 }
 
 impl VideoEncoderImpl for GifEnc {
-    fn stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         *self.state.borrow_mut() = None;
         Ok(())
     }
 
     fn propose_allocation(
         &self,
-        element: &Self::Type,
         query: &mut gst::query::Allocation,
     ) -> Result<(), gst::LoggableError> {
         query.add_allocation_meta::<gst_video::VideoMeta>(None);
-        self.parent_propose_allocation(element, query)
+        self.parent_propose_allocation(query)
     }
 
     fn set_format(
         &self,
-        element: &Self::Type,
         state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>,
     ) -> Result<(), gst::LoggableError> {
-        self.flush_encoder(element)
+        self.flush_encoder()
             .map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?;
 
         let video_info = state.info();
-        gst::debug!(CAT, obj: element, "Setting format {:?}", video_info);
+        gst::debug!(CAT, imp: self, "Setting format {:?}", video_info);
 
         {
             let mut state = State::new(video_info);
@@ -283,23 +275,23 @@ impl VideoEncoderImpl for GifEnc {
             *self.state.borrow_mut() = Some(state);
         }
 
-        let output_state = element
+        let instance = self.instance();
+        let output_state = instance
             .set_output_state(gst::Caps::builder("image/gif").build(), Some(state))
             .map_err(|_| gst::loggable_error!(CAT, "Failed to set output state"))?;
-        element
+        instance
             .negotiate(output_state)
             .map_err(|_| gst::loggable_error!(CAT, "Failed to negotiate"))?;
 
-        self.parent_set_format(element, state)
+        self.parent_set_format(state)
     }
 
-    fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
-        self.flush_encoder(element)
+    fn finish(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
+        self.flush_encoder()
     }
 
     fn handle_frame(
         &self,
-        element: &Self::Type,
         mut frame: gst_video::VideoCodecFrame,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         let mut state_guard = self.state.borrow_mut();
@@ -307,7 +299,7 @@ impl VideoEncoderImpl for GifEnc {
 
         gst::debug!(
             CAT,
-            obj: element,
+            imp: self,
             "Sending frame {}",
             frame.system_frame_number()
         );
@@ -318,8 +310,8 @@ impl VideoEncoderImpl for GifEnc {
             let in_frame =
                 gst_video::VideoFrameRef::from_buffer_ref_readable(input_buffer, &state.video_info)
                     .map_err(|_| {
-                        gst::element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::CoreError::Failed,
                             ["Failed to map output buffer readable"]
                         );
@@ -339,8 +331,8 @@ impl VideoEncoderImpl for GifEnc {
                 state.gif_pts = pts;
             }
             let pts = pts.ok_or_else(|| {
-                gst::element_error!(
-                    element,
+                gst::element_imp_error!(
+                    self,
                     gst::CoreError::Failed,
                     ["No PTS set on input frame. Unable to calculate proper frame timing."]
                 );
@@ -349,8 +341,8 @@ impl VideoEncoderImpl for GifEnc {
             let frame_delay = pts
                 .checked_sub(state.gif_pts.expect("checked above"))
                 .ok_or_else(|| {
-                    gst::element_error!(
-                        element,
+                    gst::element_imp_error!(
+                        self,
                         gst::CoreError::Failed,
                         ["Input frame PTS is greater than gif_pts. Unable to calculate proper frame timing."]
                     );
@@ -388,7 +380,7 @@ impl VideoEncoderImpl for GifEnc {
             // encode new frame
             let context = state.context.as_mut().unwrap();
             if let Err(e) = context.write_frame(&gif_frame) {
-                gst::element_error!(element, gst::CoreError::Failed, [&e.to_string()]);
+                gst::element_imp_error!(self, gst::CoreError::Failed, [&e.to_string()]);
                 return Err(gst::FlowError::Error);
             }
         }
@@ -405,13 +397,13 @@ impl VideoEncoderImpl for GifEnc {
         // Currently not using incremental frames -> every frame is a keyframe
         frame.set_flags(gst_video::VideoCodecFrameFlags::SYNC_POINT);
         frame.set_output_buffer(output_buffer);
-        element.finish_frame(Some(frame))
+        self.instance().finish_frame(Some(frame))
     }
 }
 
 impl GifEnc {
-    fn flush_encoder(&self, element: &super::GifEnc) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst::debug!(CAT, obj: element, "Flushing");
+    fn flush_encoder(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
+        gst::debug!(CAT, imp: self, "Flushing");
 
         let trailer_buffer = self.state.borrow_mut().as_mut().map(|state| {
             // Drop encoder to flush and take flushed data (gif trailer)
@@ -433,8 +425,7 @@ impl GifEnc {
         });
         if let Some(trailer_buffer) = trailer_buffer {
             // manually push GIF trailer to the encoder's src pad
-            let srcpad = element.static_pad("src").unwrap();
-            srcpad.push(trailer_buffer)?;
+            self.instance().src_pad().push(trailer_buffer)?;
         }
 
         Ok(gst::FlowSuccess::Ok)
diff --git a/video/gtk4/src/sink/imp.rs b/video/gtk4/src/sink/imp.rs
index 054c3e72..ee65609d 100644
--- a/video/gtk4/src/sink/imp.rs
+++ b/video/gtk4/src/sink/imp.rs
@@ -80,18 +80,18 @@ impl ObjectImpl for PaintableSink {
         PROPERTIES.as_ref()
     }
 
-    fn property(&self, obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "paintable" => {
                 let mut paintable = self.paintable.lock().unwrap();
                 if paintable.is_none() {
-                    obj.initialize_paintable(&mut paintable);
+                    self.instance().initialize_paintable(&mut paintable);
                 }
 
                 let paintable = match &*paintable {
                     Some(ref paintable) => paintable,
                     None => {
-                        gst::error!(CAT, obj: obj, "Failed to create paintable");
+                        gst::error!(CAT, imp: self, "Failed to create paintable");
                         return None::<&gtk::gdk::Paintable>.to_value();
                     }
                 };
@@ -102,7 +102,7 @@ impl ObjectImpl for PaintableSink {
                     Err(_) => {
                         gst::error!(
                             CAT,
-                            obj: obj,
+                            imp: self,
                             "Can't retrieve Paintable from non-main thread"
                         );
                         None::<&gtk::gdk::Paintable>.to_value()
@@ -177,25 +177,24 @@ impl ElementImpl for PaintableSink {
     #[allow(clippy::single_match)]
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
         match transition {
             gst::StateChange::NullToReady => {
                 let mut paintable = self.paintable.lock().unwrap();
                 if paintable.is_none() {
-                    element.initialize_paintable(&mut paintable);
+                    self.instance().initialize_paintable(&mut paintable);
                 }
 
                 if paintable.is_none() {
-                    gst::error!(CAT, obj: element, "Failed to create paintable");
+                    gst::error!(CAT, imp: self, "Failed to create paintable");
                     return Err(gst::StateChangeError);
                 }
             }
             _ => (),
         }
 
-        let res = self.parent_change_state(element, transition);
+        let res = self.parent_change_state(transition);
 
         match transition {
             gst::StateChange::PausedToReady => {
@@ -210,8 +209,8 @@ impl ElementImpl for PaintableSink {
 }
 
 impl BaseSinkImpl for PaintableSink {
-    fn set_caps(&self, element: &Self::Type, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
-        gst::debug!(CAT, obj: element, "Setting caps {:?}", caps);
+    fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
+        gst::debug!(CAT, imp: self, "Setting caps {:?}", caps);
 
         let video_info = gst_video::VideoInfo::from_caps(caps)
             .map_err(|_| gst::loggable_error!(CAT, "Invalid caps"))?;
@@ -223,7 +222,6 @@ impl BaseSinkImpl for PaintableSink {
 
     fn propose_allocation(
         &self,
-        element: &Self::Type,
         query: &mut gst::query::Allocation,
     ) -> Result<(), gst::LoggableError> {
         query.add_allocation_meta::<gst_video::VideoMeta>(None);
@@ -231,38 +229,34 @@ impl BaseSinkImpl for PaintableSink {
         // TODO: Provide a preferred "window size" here for higher-resolution rendering
         query.add_allocation_meta::<gst_video::VideoOverlayCompositionMeta>(None);
 
-        self.parent_propose_allocation(element, query)
+        self.parent_propose_allocation(query)
     }
 }
 
 impl VideoSinkImpl for PaintableSink {
-    fn show_frame(
-        &self,
-        element: &Self::Type,
-        buffer: &gst::Buffer,
-    ) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst::trace!(CAT, obj: element, "Rendering buffer {:?}", buffer);
+    fn show_frame(&self, buffer: &gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError> {
+        gst::trace!(CAT, imp: self, "Rendering buffer {:?}", buffer);
 
         let info = self.info.lock().unwrap();
         let info = info.as_ref().ok_or_else(|| {
-            gst::error!(CAT, obj: element, "Received no caps yet");
+            gst::error!(CAT, imp: self, "Received no caps yet");
             gst::FlowError::NotNegotiated
         })?;
 
         let frame = Frame::new(buffer, info).map_err(|err| {
-            gst::error!(CAT, obj: element, "Failed to map video frame");
+            gst::error!(CAT, imp: self, "Failed to map video frame");
             err
         })?;
         self.pending_frame.lock().unwrap().replace(frame);
 
         let sender = self.sender.lock().unwrap();
         let sender = sender.as_ref().ok_or_else(|| {
-            gst::error!(CAT, obj: element, "Have no main thread sender");
+            gst::error!(CAT, imp: self, "Have no main thread sender");
             gst::FlowError::Error
         })?;
 
         sender.send(SinkEvent::FrameChanged).map_err(|_| {
-            gst::error!(CAT, obj: element, "Have main thread receiver shut down");
+            gst::error!(CAT, imp: self, "Have main thread receiver shut down");
             gst::FlowError::Error
         })?;
 
diff --git a/video/gtk4/src/sink/paintable/imp.rs b/video/gtk4/src/sink/paintable/imp.rs
index c33cd9b5..ce1b3f55 100644
--- a/video/gtk4/src/sink/paintable/imp.rs
+++ b/video/gtk4/src/sink/paintable/imp.rs
@@ -45,7 +45,7 @@ impl ObjectSubclass for SinkPaintable {
 impl ObjectImpl for SinkPaintable {}
 
 impl PaintableImpl for SinkPaintable {
-    fn intrinsic_height(&self, _paintable: &Self::Type) -> i32 {
+    fn intrinsic_height(&self) -> i32 {
         if let Some(paintable) = self.paintables.borrow().first() {
             f32::round(paintable.height) as i32
         } else {
@@ -53,7 +53,7 @@ impl PaintableImpl for SinkPaintable {
         }
     }
 
-    fn intrinsic_width(&self, _paintable: &Self::Type) -> i32 {
+    fn intrinsic_width(&self) -> i32 {
         if let Some(paintable) = self.paintables.borrow().first() {
             f32::round(paintable.width) as i32
         } else {
@@ -61,7 +61,7 @@ impl PaintableImpl for SinkPaintable {
         }
     }
 
-    fn intrinsic_aspect_ratio(&self, _paintable: &Self::Type) -> f64 {
+    fn intrinsic_aspect_ratio(&self) -> f64 {
         if let Some(paintable) = self.paintables.borrow().first() {
             paintable.width as f64 / paintable.height as f64
         } else {
@@ -69,13 +69,13 @@ impl PaintableImpl for SinkPaintable {
         }
     }
 
-    fn snapshot(&self, paintable: &Self::Type, snapshot: &gdk::Snapshot, width: f64, height: f64) {
+    fn snapshot(&self, snapshot: &gdk::Snapshot, width: f64, height: f64) {
         let snapshot = snapshot.downcast_ref::<gtk::Snapshot>().unwrap();
 
         let paintables = self.paintables.borrow();
 
         if !paintables.is_empty() {
-            gst::trace!(CAT, obj: paintable, "Snapshotting frame");
+            gst::trace!(CAT, imp: self, "Snapshotting frame");
 
             let (frame_width, frame_height) =
                 paintables.first().map(|p| (p.width, p.height)).unwrap();
@@ -125,7 +125,7 @@ impl PaintableImpl for SinkPaintable {
                 snapshot.pop();
             }
         } else {
-            gst::trace!(CAT, obj: paintable, "Snapshotting black frame");
+            gst::trace!(CAT, imp: self, "Snapshotting black frame");
             snapshot.append_color(
                 &gdk::RGBA::BLACK,
                 &graphene::Rect::new(0f32, 0f32, width as f32, height as f32),
@@ -135,9 +135,9 @@ impl PaintableImpl for SinkPaintable {
 }
 
 impl SinkPaintable {
-    pub(super) fn handle_frame_changed(&self, obj: &super::SinkPaintable, frame: Option<Frame>) {
+    pub(super) fn handle_frame_changed(&self, frame: Option<Frame>) {
         if let Some(frame) = frame {
-            gst::trace!(CAT, obj: obj, "Received new frame");
+            gst::trace!(CAT, imp: self, "Received new frame");
 
             let new_paintables = frame.into_textures(&mut *self.cached_textures.borrow_mut());
             let new_size = new_paintables
@@ -153,15 +153,15 @@ impl SinkPaintable {
             if Some(new_size) != old_size {
                 gst::debug!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Size changed from {:?} to {:?}",
                     old_size,
                     new_size,
                 );
-                obj.invalidate_size();
+                self.instance().invalidate_size();
             }
 
-            obj.invalidate_contents();
+            self.instance().invalidate_contents();
         }
     }
 }
diff --git a/video/gtk4/src/sink/paintable/mod.rs b/video/gtk4/src/sink/paintable/mod.rs
index da66360f..60459533 100644
--- a/video/gtk4/src/sink/paintable/mod.rs
+++ b/video/gtk4/src/sink/paintable/mod.rs
@@ -36,6 +36,6 @@ impl Default for SinkPaintable {
 impl SinkPaintable {
     pub(crate) fn handle_frame_changed(&self, frame: Option<Frame>) {
         let imp = self.imp();
-        imp.handle_frame_changed(self, frame);
+        imp.handle_frame_changed(frame);
     }
 }
diff --git a/video/hsv/src/hsvdetector/imp.rs b/video/hsv/src/hsvdetector/imp.rs
index 7653b7ee..5386a22f 100644
--- a/video/hsv/src/hsvdetector/imp.rs
+++ b/video/hsv/src/hsvdetector/imp.rs
@@ -215,20 +215,14 @@ impl ObjectImpl for HsvDetector {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "hue-ref" => {
                 let mut settings = self.settings.lock().unwrap();
                 let hue_ref = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing hue-ref from {} to {}",
                     settings.hue_ref,
                     hue_ref
@@ -240,7 +234,7 @@ impl ObjectImpl for HsvDetector {
                 let hue_var = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing hue-var from {} to {}",
                     settings.hue_var,
                     hue_var
@@ -252,7 +246,7 @@ impl ObjectImpl for HsvDetector {
                 let saturation_ref = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing saturation-ref from {} to {}",
                     settings.saturation_ref,
                     saturation_ref
@@ -264,7 +258,7 @@ impl ObjectImpl for HsvDetector {
                 let saturation_var = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing saturation-var from {} to {}",
                     settings.saturation_var,
                     saturation_var
@@ -276,7 +270,7 @@ impl ObjectImpl for HsvDetector {
                 let value_ref = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing value-ref from {} to {}",
                     settings.value_ref,
                     value_ref
@@ -288,7 +282,7 @@ impl ObjectImpl for HsvDetector {
                 let value_var = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing value-var from {} to {}",
                     settings.value_var,
                     value_var
@@ -301,7 +295,7 @@ impl ObjectImpl for HsvDetector {
 
     // Called whenever a value of a property is read. It can be called
     // at any time from any thread.
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "hue-ref" => {
                 let settings = self.settings.lock().unwrap();
@@ -390,7 +384,6 @@ impl BaseTransformImpl for HsvDetector {
 
     fn transform_caps(
         &self,
-        element: &Self::Type,
         direction: gst::PadDirection,
         caps: &gst::Caps,
         filter: Option<&gst::Caps>,
@@ -408,7 +401,7 @@ impl BaseTransformImpl for HsvDetector {
 
         gst::debug!(
             CAT,
-            obj: element,
+            imp: self,
             "Transformed caps from {} to {} in direction {:?}",
             caps,
             other_caps,
@@ -428,7 +421,6 @@ impl BaseTransformImpl for HsvDetector {
 impl VideoFilterImpl for HsvDetector {
     fn transform_frame(
         &self,
-        _element: &Self::Type,
         in_frame: &gst_video::VideoFrameRef<&gst::BufferRef>,
         out_frame: &mut gst_video::VideoFrameRef<&mut gst::BufferRef>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
diff --git a/video/hsv/src/hsvfilter/imp.rs b/video/hsv/src/hsvfilter/imp.rs
index 2b1542ae..f198f5a0 100644
--- a/video/hsv/src/hsvfilter/imp.rs
+++ b/video/hsv/src/hsvfilter/imp.rs
@@ -159,20 +159,14 @@ impl ObjectImpl for HsvFilter {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "hue-shift" => {
                 let mut settings = self.settings.lock().unwrap();
                 let hue_shift = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing hue-shift from {} to {}",
                     settings.hue_shift,
                     hue_shift
@@ -184,7 +178,7 @@ impl ObjectImpl for HsvFilter {
                 let saturation_mul = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing saturation-mul from {} to {}",
                     settings.saturation_mul,
                     saturation_mul
@@ -196,7 +190,7 @@ impl ObjectImpl for HsvFilter {
                 let saturation_off = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing saturation-off from {} to {}",
                     settings.saturation_off,
                     saturation_off
@@ -208,7 +202,7 @@ impl ObjectImpl for HsvFilter {
                 let value_mul = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing value-mul from {} to {}",
                     settings.value_mul,
                     value_mul
@@ -220,7 +214,7 @@ impl ObjectImpl for HsvFilter {
                 let value_off = value.get().expect("type checked upstream");
                 gst::info!(
                     CAT,
-                    obj: obj,
+                    imp: self,
                     "Changing value-off from {} to {}",
                     settings.value_off,
                     value_off
@@ -233,7 +227,7 @@ impl ObjectImpl for HsvFilter {
 
     // Called whenever a value of a property is read. It can be called
     // at any time from any thread.
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "hue-shift" => {
                 let settings = self.settings.lock().unwrap();
@@ -327,7 +321,6 @@ impl BaseTransformImpl for HsvFilter {
 impl VideoFilterImpl for HsvFilter {
     fn transform_frame_ip(
         &self,
-        _element: &Self::Type,
         frame: &mut gst_video::VideoFrameRef<&mut gst::BufferRef>,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         match frame.format() {
diff --git a/video/rav1e/src/rav1enc/imp.rs b/video/rav1e/src/rav1enc/imp.rs
index ce459dcc..cefa894e 100644
--- a/video/rav1e/src/rav1enc/imp.rs
+++ b/video/rav1e/src/rav1enc/imp.rs
@@ -348,13 +348,7 @@ impl ObjectImpl for Rav1Enc {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "speed-preset" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -424,7 +418,7 @@ impl ObjectImpl for Rav1Enc {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "speed-preset" => {
                 let settings = self.settings.lock().unwrap();
@@ -555,7 +549,7 @@ impl ElementImpl for Rav1Enc {
 }
 
 impl VideoEncoderImpl for Rav1Enc {
-    fn stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         *self.state.borrow_mut() = None;
 
         Ok(())
@@ -563,25 +557,23 @@ impl VideoEncoderImpl for Rav1Enc {
 
     fn propose_allocation(
         &self,
-        element: &Self::Type,
         query: &mut gst::query::Allocation,
     ) -> Result<(), gst::LoggableError> {
         query.add_allocation_meta::<gst_video::VideoMeta>(None);
-        self.parent_propose_allocation(element, query)
+        self.parent_propose_allocation(query)
     }
 
     // For the colorimetry mapping below
     #[allow(clippy::wildcard_in_or_patterns)]
     fn set_format(
         &self,
-        element: &Self::Type,
         state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>,
     ) -> Result<(), gst::LoggableError> {
-        self.finish(element)
+        self.finish()
             .map_err(|_| gst::loggable_error!(CAT, "Failed to drain"))?;
 
         let video_info = state.info();
-        gst::debug!(CAT, obj: element, "Setting format {:?}", video_info);
+        gst::debug!(CAT, imp: self, "Setting format {:?}", video_info);
 
         let settings = self.settings.lock().unwrap();
 
@@ -813,7 +805,8 @@ impl VideoEncoderImpl for Rav1Enc {
             video_info,
         });
 
-        let output_state = element
+        let instance = self.instance();
+        let output_state = instance
             .set_output_state(
                 gst::Caps::builder("video/x-av1")
                     .field("stream-format", "obu-stream")
@@ -823,34 +816,34 @@ impl VideoEncoderImpl for Rav1Enc {
                 Some(state),
             )
             .map_err(|_| gst::loggable_error!(CAT, "Failed to set output state"))?;
-        element
+        instance
             .negotiate(output_state)
             .map_err(|_| gst::loggable_error!(CAT, "Failed to negotiate"))?;
 
-        self.parent_set_format(element, state)
+        self.parent_set_format(state)
     }
 
-    fn flush(&self, element: &Self::Type) -> bool {
-        gst::debug!(CAT, obj: element, "Flushing");
+    fn flush(&self) -> bool {
+        gst::debug!(CAT, imp: self, "Flushing");
 
         let mut state_guard = self.state.borrow_mut();
         if let Some(ref mut state) = *state_guard {
             state.context.flush();
             while let Ok(_) | Err(data::EncoderStatus::Encoded) = state.context.receive_packet() {
-                gst::debug!(CAT, obj: element, "Dropping packet on flush",);
+                gst::debug!(CAT, imp: self, "Dropping packet on flush",);
             }
         }
 
         true
     }
 
-    fn finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
-        gst::debug!(CAT, obj: element, "Finishing");
+    fn finish(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
+        gst::debug!(CAT, imp: self, "Finishing");
 
         let mut state_guard = self.state.borrow_mut();
         if let Some(ref mut state) = *state_guard {
             state.context.flush();
-            self.output_frames(element, state)?;
+            self.output_frames(state)?;
         }
 
         Ok(gst::FlowSuccess::Ok)
@@ -858,17 +851,16 @@ impl VideoEncoderImpl for Rav1Enc {
 
     fn handle_frame(
         &self,
-        element: &Self::Type,
         frame: gst_video::VideoCodecFrame,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         let mut state_guard = self.state.borrow_mut();
         let state = state_guard.as_mut().ok_or(gst::FlowError::NotNegotiated)?;
 
-        self.output_frames(element, state)?;
+        self.output_frames(state)?;
 
         gst::debug!(
             CAT,
-            obj: element,
+            imp: self,
             "Sending frame {}",
             frame.system_frame_number()
         );
@@ -878,8 +870,8 @@ impl VideoEncoderImpl for Rav1Enc {
         let in_frame =
             gst_video::VideoFrameRef::from_buffer_ref_readable(input_buffer, &state.video_info)
                 .map_err(|_| {
-                    gst::element_error!(
-                        element,
+                    gst::element_imp_error!(
+                        self,
                         gst::CoreError::Failed,
                         ["Failed to map output buffer readable"]
                     );
@@ -894,73 +886,62 @@ impl VideoEncoderImpl for Rav1Enc {
                 .contains(gst_video::VideoCodecFrameFlags::FORCE_KEYFRAME),
         ) {
             Ok(_) => {
-                gst::debug!(
-                    CAT,
-                    obj: element,
-                    "Sent frame {}",
-                    frame.system_frame_number()
-                );
+                gst::debug!(CAT, imp: self, "Sent frame {}", frame.system_frame_number());
             }
             Err(data::EncoderStatus::Failure) => {
-                gst::element_error!(element, gst::CoreError::Failed, ["Failed to send frame"]);
+                gst::element_imp_error!(self, gst::CoreError::Failed, ["Failed to send frame"]);
                 return Err(gst::FlowError::Error);
             }
             Err(_) => (),
         }
 
-        self.output_frames(element, state)
+        self.output_frames(state)
     }
 }
 
 impl Rav1Enc {
-    fn output_frames(
-        &self,
-        element: &super::Rav1Enc,
-        state: &mut State,
-    ) -> Result<gst::FlowSuccess, gst::FlowError> {
+    fn output_frames(&self, state: &mut State) -> Result<gst::FlowSuccess, gst::FlowError> {
         loop {
             match state.context.receive_packet() {
                 Ok((packet_type, packet_number, frame_number, packet_data)) => {
                     gst::debug!(
                         CAT,
-                        obj: element,
+                        imp: self,
                         "Received packet {} of size {}, frame type {:?}",
                         packet_number,
                         packet_data.len(),
                         packet_type
                     );
 
-                    let mut frame = element.frame(frame_number as i32).expect("frame not found");
+                    let instance = self.instance();
+                    let mut frame = instance
+                        .frame(frame_number as i32)
+                        .expect("frame not found");
 
                     if packet_type == data::FrameType::KEY {
                         frame.set_flags(gst_video::VideoCodecFrameFlags::SYNC_POINT);
                     }
                     let output_buffer = gst::Buffer::from_mut_slice(packet_data);
                     frame.set_output_buffer(output_buffer);
-                    element.finish_frame(Some(frame))?;
+                    instance.finish_frame(Some(frame))?;
                 }
                 Err(data::EncoderStatus::Encoded) => {
-                    gst::debug!(CAT, obj: element, "Encoded but not output frame yet",);
+                    gst::debug!(CAT, imp: self, "Encoded but not output frame yet",);
                 }
                 Err(data::EncoderStatus::NeedMoreData) => {
-                    gst::debug!(CAT, obj: element, "Encoded but need more data",);
+                    gst::debug!(CAT, imp: self, "Encoded but need more data",);
                     return Ok(gst::FlowSuccess::Ok);
                 }
                 Err(data::EncoderStatus::Failure) => {
-                    gst::element_error!(
-                        element,
+                    gst::element_imp_error!(
+                        self,
                         gst::CoreError::Failed,
                         ["Failed to receive frame"]
                     );
                     return Err(gst::FlowError::Error);
                 }
                 Err(err) => {
-                    gst::debug!(
-                        CAT,
-                        obj: element,
-                        "Soft error when receiving frame: {:?}",
-                        err
-                    );
+                    gst::debug!(CAT, imp: self, "Soft error when receiving frame: {:?}", err);
                     return Ok(gst::FlowSuccess::Ok);
                 }
             }
diff --git a/video/rspng/src/pngenc/imp.rs b/video/rspng/src/pngenc/imp.rs
index 04b82ec3..851677d8 100644
--- a/video/rspng/src/pngenc/imp.rs
+++ b/video/rspng/src/pngenc/imp.rs
@@ -195,13 +195,7 @@ impl ObjectImpl for PngEncoder {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "compression-level" => {
                 let mut settings = self.settings.lock();
@@ -217,7 +211,7 @@ impl ObjectImpl for PngEncoder {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "compression-level" => {
                 let settings = self.settings.lock();
@@ -283,18 +277,17 @@ impl ElementImpl for PngEncoder {
 }
 
 impl VideoEncoderImpl for PngEncoder {
-    fn stop(&self, _element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         *self.state.lock() = None;
         Ok(())
     }
 
     fn set_format(
         &self,
-        element: &Self::Type,
         state: &gst_video::VideoCodecState<'static, gst_video::video_codec_state::Readable>,
     ) -> Result<(), gst::LoggableError> {
         let video_info = state.info();
-        gst::debug!(CAT, obj: element, "Setting format {:?}", video_info);
+        gst::debug!(CAT, imp: self, "Setting format {:?}", video_info);
         {
             let settings = self.settings.lock();
             let mut state = State::new(video_info);
@@ -302,17 +295,17 @@ impl VideoEncoderImpl for PngEncoder {
             *self.state.lock() = Some(state);
         }
 
-        let output_state = element
+        let instance = self.instance();
+        let output_state = instance
             .set_output_state(gst::Caps::builder("image/png").build(), Some(state))
             .map_err(|_| gst::loggable_error!(CAT, "Failed to set output state"))?;
-        element
+        instance
             .negotiate(output_state)
             .map_err(|_| gst::loggable_error!(CAT, "Failed to negotiate"))
     }
 
     fn handle_frame(
         &self,
-        element: &Self::Type,
         mut frame: gst_video::VideoCodecFrame,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         let mut state_guard = self.state.lock();
@@ -320,7 +313,7 @@ impl VideoEncoderImpl for PngEncoder {
 
         gst::debug!(
             CAT,
-            obj: element,
+            imp: self,
             "Sending frame {}",
             frame.system_frame_number()
         );
@@ -330,7 +323,7 @@ impl VideoEncoderImpl for PngEncoder {
             let input_map = input_buffer.map_readable().unwrap();
             let data = input_map.as_slice();
             state.write_data(data).map_err(|e| {
-                gst::element_error!(element, gst::CoreError::Failed, [&e.to_string()]);
+                gst::element_imp_error!(self, gst::CoreError::Failed, [&e.to_string()]);
                 gst::FlowError::Error
             })?;
         }
@@ -342,6 +335,6 @@ impl VideoEncoderImpl for PngEncoder {
         // There are no such incremental frames in the png format
         frame.set_flags(gst_video::VideoCodecFrameFlags::SYNC_POINT);
         frame.set_output_buffer(output_buffer);
-        element.finish_frame(Some(frame))
+        self.instance().finish_frame(Some(frame))
     }
 }
diff --git a/video/videofx/src/border/roundedcorners.rs b/video/videofx/src/border/imp.rs
index c1a192e1..f3fb220e 100644
--- a/video/videofx/src/border/roundedcorners.rs
+++ b/video/videofx/src/border/imp.rs
@@ -289,13 +289,7 @@ impl ObjectImpl for RoundedCorners {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "border-radius-px" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -304,20 +298,20 @@ impl ObjectImpl for RoundedCorners {
                     settings.changed = true;
                     gst::info!(
                         CAT,
-                        obj: obj,
+                        imp: self,
                         "Changing border radius from {} to {}",
                         settings.border_radius_px,
                         border_radius
                     );
                     settings.border_radius_px = border_radius;
-                    obj.reconfigure_src();
+                    self.instance().reconfigure_src();
                 }
             }
             _ => unimplemented!(),
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "border-radius-px" => {
                 let settings = self.settings.lock().unwrap();
@@ -381,17 +375,16 @@ impl BaseTransformImpl for RoundedCorners {
     const PASSTHROUGH_ON_SAME_CAPS: bool = false;
     const TRANSFORM_IP_ON_PASSTHROUGH: bool = false;
 
-    fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         let _ = self.state.lock().unwrap().take();
 
-        gst::info!(CAT, obj: element, "Stopped");
+        gst::info!(CAT, imp: self, "Stopped");
 
         Ok(())
     }
 
     fn transform_caps(
         &self,
-        element: &Self::Type,
         direction: gst::PadDirection,
         caps: &gst::Caps,
         filter: Option<&gst::Caps>,
@@ -438,7 +431,7 @@ impl BaseTransformImpl for RoundedCorners {
 
         gst::debug!(
             CAT,
-            obj: element,
+            imp: self,
             "Transformed caps from {} to {} in direction {:?}",
             caps,
             other_caps,
@@ -452,12 +445,7 @@ impl BaseTransformImpl for RoundedCorners {
         }
     }
 
-    fn set_caps(
-        &self,
-        element: &Self::Type,
-        incaps: &gst::Caps,
-        outcaps: &gst::Caps,
-    ) -> Result<(), gst::LoggableError> {
+    fn set_caps(&self, incaps: &gst::Caps, outcaps: &gst::Caps) -> Result<(), gst::LoggableError> {
         let mut settings = self.settings.lock().unwrap();
 
         let out_info = match gst_video::VideoInfo::from_caps(outcaps) {
@@ -467,17 +455,17 @@ impl BaseTransformImpl for RoundedCorners {
 
         gst::debug!(
             CAT,
-            obj: element,
+            imp: self,
             "Configured for caps {} to {}",
             incaps,
             outcaps
         );
 
         if out_info.format() == VideoFormat::I420 {
-            element.set_passthrough(true);
+            self.instance().set_passthrough(true);
             return Ok(());
         } else {
-            element.set_passthrough(false);
+            self.instance().set_passthrough(false);
         }
 
         // See "A420" planar 4:4:2:0 AYUV section
@@ -497,10 +485,9 @@ impl BaseTransformImpl for RoundedCorners {
 
     fn prepare_output_buffer(
         &self,
-        element: &Self::Type,
         inbuf: InputBuffer,
     ) -> Result<PrepareOutputBufferSuccess, gst::FlowError> {
-        if element.is_passthrough() {
+        if self.instance().is_passthrough() {
             return Ok(PrepareOutputBufferSuccess::InputBuffer);
         }
 
@@ -509,12 +496,12 @@ impl BaseTransformImpl for RoundedCorners {
             settings.changed = false;
             gst::debug!(
                 CAT,
-                obj: element,
+                imp: self,
                 "Caps or border radius changed, generating alpha mask"
             );
             let state_guard = self.state.lock().unwrap();
             let state = state_guard.as_ref().ok_or_else(|| {
-                gst::element_error!(element, gst::CoreError::Negotiation, ["Have no state yet"]);
+                gst::element_imp_error!(self, gst::CoreError::Negotiation, ["Have no state yet"]);
                 gst::FlowError::NotNegotiated
             })?;
 
@@ -523,8 +510,8 @@ impl BaseTransformImpl for RoundedCorners {
                 VideoFormat::A420 => {
                     drop(state_guard);
                     if self.generate_alpha_mask(settings.border_radius_px).is_err() {
-                        gst::element_error!(
-                            element,
+                        gst::element_imp_error!(
+                            self,
                             gst::CoreError::Negotiation,
                             ["Failed to generate alpha mask"]
                         );
@@ -537,7 +524,7 @@ impl BaseTransformImpl for RoundedCorners {
 
         let mut state_guard = self.state.lock().unwrap();
         let state = state_guard.as_mut().ok_or_else(|| {
-            gst::element_error!(element, gst::CoreError::Negotiation, ["Have no state yet"]);
+            gst::element_imp_error!(self, gst::CoreError::Negotiation, ["Have no state yet"]);
             gst::FlowError::NotNegotiated
         })?;
 
@@ -549,7 +536,7 @@ impl BaseTransformImpl for RoundedCorners {
             InputBuffer::Writable(outbuf) => {
                 gst::log!(
                     CAT,
-                    obj: element,
+                    imp: self,
                     "Received writable input buffer of size: {}",
                     outbuf.size()
                 );
@@ -561,7 +548,7 @@ impl BaseTransformImpl for RoundedCorners {
             InputBuffer::Readable(buf) => {
                 gst::log!(
                     CAT,
-                    obj: element,
+                    imp: self,
                     "Received readable input buffer of size: {}",
                     buf.size()
                 );
@@ -575,21 +562,16 @@ impl BaseTransformImpl for RoundedCorners {
         }
     }
 
-    fn transform_ip(
-        &self,
-        _element: &Self::Type,
-        _buf: &mut gst::BufferRef,
-    ) -> Result<gst::FlowSuccess, gst::FlowError> {
+    fn transform_ip(&self, _buf: &mut gst::BufferRef) -> Result<gst::FlowSuccess, gst::FlowError> {
         Ok(gst::FlowSuccess::Ok)
     }
 
     fn propose_allocation(
         &self,
-        element: &Self::Type,
         decide_query: Option<&gst::query::Allocation>,
         query: &mut gst::query::Allocation,
     ) -> Result<(), gst::LoggableError> {
         query.add_allocation_meta::<gst_video::VideoMeta>(None);
-        self.parent_propose_allocation(element, decide_query, query)
+        self.parent_propose_allocation(decide_query, query)
     }
 }
diff --git a/video/videofx/src/border/mod.rs b/video/videofx/src/border/mod.rs
index 6d612eda..d81fcfa8 100644
--- a/video/videofx/src/border/mod.rs
+++ b/video/videofx/src/border/mod.rs
@@ -10,10 +10,10 @@
 use gst::glib;
 use gst::prelude::*;
 
-pub mod roundedcorners;
+mod imp;
 
 glib::wrapper! {
-    pub struct RoundedCorners(ObjectSubclass<roundedcorners::RoundedCorners>) @extends gst_base::BaseTransform, gst::Element, gst::Object;
+    pub struct RoundedCorners(ObjectSubclass<imp::RoundedCorners>) @extends gst_base::BaseTransform, gst::Element, gst::Object;
 }
 
 pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
diff --git a/video/videofx/src/colordetect/imp.rs b/video/videofx/src/colordetect/imp.rs
index 2152ab77..b321d150 100644
--- a/video/videofx/src/colordetect/imp.rs
+++ b/video/videofx/src/colordetect/imp.rs
@@ -57,12 +57,11 @@ pub struct ColorDetect {
 impl ColorDetect {
     fn detect_color(
         &self,
-        element: &super::ColorDetect,
         buf: &mut gst::BufferRef,
     ) -> Result<Option<(String, Vec<Color>)>, gst::FlowError> {
         let mut state_guard = self.state.borrow_mut();
         let state = state_guard.as_mut().ok_or_else(|| {
-            gst::element_error!(element, gst::CoreError::Negotiation, ["Have no state yet"]);
+            gst::element_imp_error!(self, gst::CoreError::Negotiation, ["Have no state yet"]);
             gst::FlowError::NotNegotiated
         })?;
 
@@ -93,15 +92,10 @@ impl ColorDetect {
         Ok(None)
     }
 
-    fn color_changed(
-        &self,
-        element: &super::ColorDetect,
-        dominant_color_name: &str,
-        palette: Vec<Color>,
-    ) {
+    fn color_changed(&self, dominant_color_name: &str, palette: Vec<Color>) {
         gst::debug!(
             CAT,
-            obj: element,
+            imp: self,
             "Dominant color changed to {}",
             dominant_color_name
         );
@@ -111,7 +105,7 @@ impl ColorDetect {
                 .map(|c| ((c.r as u32) << 16) | ((c.g as u32) << 8) | (c.b as u32)),
         );
 
-        element
+        self.instance()
             .post_message(
                 gst::message::Element::builder(
                     gst::structure::Structure::builder("colordetect")
@@ -157,13 +151,7 @@ impl ObjectImpl for ColorDetect {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "quality" => {
                 let mut settings = self.settings.lock().unwrap();
@@ -171,7 +159,7 @@ impl ObjectImpl for ColorDetect {
                 if settings.quality != quality {
                     gst::info!(
                         CAT,
-                        obj: obj,
+                        imp: self,
                         "Changing quality from {} to {}",
                         settings.quality,
                         quality
@@ -185,7 +173,7 @@ impl ObjectImpl for ColorDetect {
                 if settings.max_colors != max_colors {
                     gst::info!(
                         CAT,
-                        obj: obj,
+                        imp: self,
                         "Changing max_colors from {} to {}",
                         settings.max_colors,
                         max_colors
@@ -197,7 +185,7 @@ impl ObjectImpl for ColorDetect {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "quality" => {
                 let settings = self.settings.lock().unwrap();
@@ -268,18 +256,13 @@ impl BaseTransformImpl for ColorDetect {
     const PASSTHROUGH_ON_SAME_CAPS: bool = false;
     const TRANSFORM_IP_ON_PASSTHROUGH: bool = false;
 
-    fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
         *self.state.borrow_mut() = None;
-        gst::info!(CAT, obj: element, "Stopped");
+        gst::info!(CAT, imp: self, "Stopped");
         Ok(())
     }
 
-    fn set_caps(
-        &self,
-        element: &Self::Type,
-        incaps: &gst::Caps,
-        outcaps: &gst::Caps,
-    ) -> Result<(), gst::LoggableError> {
+    fn set_caps(&self, incaps: &gst::Caps, outcaps: &gst::Caps) -> Result<(), gst::LoggableError> {
         let in_info = match gst_video::VideoInfo::from_caps(incaps) {
             Err(_) => return Err(gst::loggable_error!(CAT, "Failed to parse input caps")),
             Ok(info) => info,
@@ -292,7 +275,7 @@ impl BaseTransformImpl for ColorDetect {
 
         gst::debug!(
             CAT,
-            obj: element,
+            imp: self,
             "Configured for caps {} to {}",
             incaps,
             outcaps
@@ -320,13 +303,9 @@ impl BaseTransformImpl for ColorDetect {
         Ok(())
     }
 
-    fn transform_ip(
-        &self,
-        element: &Self::Type,
-        buf: &mut gst::BufferRef,
-    ) -> Result<gst::FlowSuccess, gst::FlowError> {
-        if let Some((dominant_color_name, palette)) = self.detect_color(element, buf)? {
-            self.color_changed(element, &dominant_color_name, palette);
+    fn transform_ip(&self, buf: &mut gst::BufferRef) -> Result<gst::FlowSuccess, gst::FlowError> {
+        if let Some((dominant_color_name, palette)) = self.detect_color(buf)? {
+            self.color_changed(&dominant_color_name, palette);
         }
 
         Ok(gst::FlowSuccess::Ok)
diff --git a/video/webp/src/dec/imp.rs b/video/webp/src/dec/imp.rs
index a1910067..8c90375a 100644
--- a/video/webp/src/dec/imp.rs
+++ b/video/webp/src/dec/imp.rs
@@ -136,7 +136,6 @@ impl WebPDec {
     fn sink_chain(
         &self,
         pad: &gst::Pad,
-        _element: &super::WebPDec,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
         gst::log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
@@ -149,7 +148,7 @@ impl WebPDec {
         Ok(gst::FlowSuccess::Ok)
     }
 
-    fn decode(&self, _element: &super::WebPDec) -> Result<(), gst::ErrorMessage> {
+    fn decode(&self) -> Result<(), gst::ErrorMessage> {
         let mut prev_timestamp: Option<gst::ClockTime> = Some(gst::ClockTime::ZERO);
         let mut state = self.state.lock().unwrap();
 
@@ -234,7 +233,7 @@ impl WebPDec {
         Ok(())
     }
 
-    fn sink_event(&self, pad: &gst::Pad, element: &super::WebPDec, event: gst::Event) -> bool {
+    fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
@@ -242,26 +241,26 @@ impl WebPDec {
             EventView::FlushStop(..) => {
                 let mut state = self.state.lock().unwrap();
                 *state = State::default();
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::Eos(..) => {
-                if let Err(err) = self.decode(element) {
-                    element.post_error_message(err);
+                if let Err(err) = self.decode() {
+                    self.post_error_message(err);
                 }
-                pad.event_default(Some(element), event)
+                pad.event_default(Some(&*self.instance()), event)
             }
             EventView::Segment(..) => true,
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 
-    fn src_event(&self, pad: &gst::Pad, element: &super::WebPDec, event: gst::Event) -> bool {
+    fn src_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
         use gst::EventView;
 
         gst::log!(CAT, obj: pad, "Handling event {:?}", event);
         match event.view() {
             EventView::Seek(..) => false,
-            _ => pad.event_default(Some(element), event),
+            _ => pad.event_default(Some(&*self.instance()), event),
         }
     }
 }
@@ -279,14 +278,14 @@ impl ObjectSubclass for WebPDec {
                 WebPDec::catch_panic_pad_function(
                     parent,
                     || Err(gst::FlowError::Error),
-                    |dec, element| dec.sink_chain(pad, element, buffer),
+                    |dec| dec.sink_chain(pad, buffer),
                 )
             })
             .event_function(|pad, parent, event| {
                 WebPDec::catch_panic_pad_function(
                     parent,
                     || false,
-                    |dec, element| dec.sink_event(pad, element, event),
+                    |dec| dec.sink_event(pad, event),
                 )
             })
             .build();
@@ -294,11 +293,7 @@ impl ObjectSubclass for WebPDec {
         let templ = klass.pad_template("src").unwrap();
         let srcpad = gst::Pad::builder_with_template(&templ, Some("src"))
             .event_function(|pad, parent, event| {
-                WebPDec::catch_panic_pad_function(
-                    parent,
-                    || false,
-                    |dec, element| dec.src_event(pad, element, event),
-                )
+                WebPDec::catch_panic_pad_function(parent, || false, |dec| dec.src_event(pad, event))
             })
             .build();
 
@@ -311,9 +306,10 @@ impl ObjectSubclass for WebPDec {
 }
 
 impl ObjectImpl for WebPDec {
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
 
+        let obj = self.instance();
         obj.add_pad(&self.sinkpad).unwrap();
         obj.add_pad(&self.srcpad).unwrap();
     }
@@ -367,15 +363,14 @@ impl ElementImpl for WebPDec {
 
     fn change_state(
         &self,
-        element: &Self::Type,
         transition: gst::StateChange,
     ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
-        gst::trace!(CAT, obj: element, "Changing state {:?}", transition);
+        gst::trace!(CAT, imp: self, "Changing state {:?}", transition);
 
         if transition == gst::StateChange::PausedToReady {
             *self.state.lock().unwrap() = State::default();
         }
 
-        self.parent_change_state(element, transition)
+        self.parent_change_state(transition)
     }
 }