diff --git a/gstreamer-app-sys/src/lib.rs b/gstreamer-app-sys/src/lib.rs
index 1916b7521..a0676f618 100644
--- a/gstreamer-app-sys/src/lib.rs
+++ b/gstreamer-app-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -31,6 +31,12 @@ pub struct GstAppSinkCallbacks {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAppSinkCallbacks {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAppSinkCallbacks @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAppSinkClass {
     pub basesink_class: gst_base::GstBaseSinkClass,
@@ -44,9 +50,21 @@ pub struct GstAppSinkClass {
     pub _gst_reserved: [gpointer; 2],
 }
 
+impl ::std::fmt::Debug for GstAppSinkClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAppSinkClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAppSinkPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAppSinkPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAppSinkPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAppSrcCallbacks {
     pub need_data: Option<unsafe extern "C" fn(*mut GstAppSrc, c_uint, gpointer)>,
@@ -55,6 +73,12 @@ pub struct GstAppSrcCallbacks {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAppSrcCallbacks {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAppSrcCallbacks @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAppSrcClass {
     pub basesrc_class: gst_base::GstBaseSrcClass,
@@ -67,9 +91,21 @@ pub struct GstAppSrcClass {
     pub _gst_reserved: [gpointer; 3],
 }
 
+impl ::std::fmt::Debug for GstAppSrcClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAppSrcClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAppSrcPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAppSrcPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAppSrcPrivate @ {:?}", self as *const _)
+    }
+}
+
 // Classes
 #[repr(C)]
 pub struct GstAppSink {
@@ -78,6 +114,16 @@ pub struct GstAppSink {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAppSink {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAppSink @ {:?}", self as *const _))
+         .field("basesink", &self.basesink)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAppSrc {
     pub basesrc: gst_base::GstBaseSrc,
@@ -85,6 +131,16 @@ pub struct GstAppSrc {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAppSrc {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAppSrc @ {:?}", self as *const _))
+         .field("basesrc", &self.basesrc)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 extern "C" {
 
     //=========================================================================
diff --git a/gstreamer-audio-sys/src/lib.rs b/gstreamer-audio-sys/src/lib.rs
index 646f2fe24..c579643a2 100644
--- a/gstreamer-audio-sys/src/lib.rs
+++ b/gstreamer-audio-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -311,9 +311,21 @@ pub struct GstAudioBaseSinkClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioBaseSinkClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioBaseSinkClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioBaseSinkPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAudioBaseSinkPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioBaseSinkPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioBaseSrcClass {
     pub parent_class: gst_base::GstPushSrcClass,
@@ -321,9 +333,21 @@ pub struct GstAudioBaseSrcClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioBaseSrcClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioBaseSrcClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioBaseSrcPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAudioBaseSrcPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioBaseSrcPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioCdSrcClass {
     pub pushsrc_class: gst_base::GstPushSrcClass,
@@ -333,9 +357,21 @@ pub struct GstAudioCdSrcClass {
     pub _gst_reserved: [gpointer; 20],
 }
 
+impl ::std::fmt::Debug for GstAudioCdSrcClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioCdSrcClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioCdSrcPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAudioCdSrcPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioCdSrcPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioCdSrcTrack {
     pub is_audio: gboolean,
@@ -347,9 +383,21 @@ pub struct GstAudioCdSrcTrack {
     pub _gst_reserved2: [gpointer; 2],
 }
 
+impl ::std::fmt::Debug for GstAudioCdSrcTrack {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioCdSrcTrack @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioChannelMixer(c_void);
 
+impl ::std::fmt::Debug for GstAudioChannelMixer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioChannelMixer @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioClippingMeta {
     pub meta: gst::GstMeta,
@@ -358,15 +406,33 @@ pub struct GstAudioClippingMeta {
     pub end: u64,
 }
 
+impl ::std::fmt::Debug for GstAudioClippingMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioClippingMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioClockClass {
     pub parent_class: gst::GstSystemClockClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioClockClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioClockClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioConverter(c_void);
 
+impl ::std::fmt::Debug for GstAudioConverter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioConverter @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioDecoderClass {
     pub element_class: gst::GstElementClass,
@@ -391,9 +457,21 @@ pub struct GstAudioDecoderClass {
     pub _gst_reserved: [gpointer; 16],
 }
 
+impl ::std::fmt::Debug for GstAudioDecoderClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioDecoderClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioDecoderPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAudioDecoderPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioDecoderPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioDownmixMeta {
     pub meta: gst::GstMeta,
@@ -404,6 +482,12 @@ pub struct GstAudioDownmixMeta {
     pub matrix: *mut *mut c_float,
 }
 
+impl ::std::fmt::Debug for GstAudioDownmixMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioDownmixMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioEncoderClass {
     pub element_class: gst::GstElementClass,
@@ -427,9 +511,21 @@ pub struct GstAudioEncoderClass {
     pub _gst_reserved: [gpointer; 17],
 }
 
+impl ::std::fmt::Debug for GstAudioEncoderClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioEncoderClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioEncoderPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAudioEncoderPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioEncoderPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioFilterClass {
     pub basetransformclass: gst_base::GstBaseTransformClass,
@@ -437,6 +533,12 @@ pub struct GstAudioFilterClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioFilterClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioFilterClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioFormatInfo {
     pub format: GstAudioFormat,
@@ -453,6 +555,12 @@ pub struct GstAudioFormatInfo {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioFormatInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioFormatInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioInfo {
     pub finfo: *const GstAudioFormatInfo,
@@ -465,12 +573,30 @@ pub struct GstAudioInfo {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioQuantize(c_void);
 
+impl ::std::fmt::Debug for GstAudioQuantize {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioQuantize @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioResampler(c_void);
 
+impl ::std::fmt::Debug for GstAudioResampler {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioResampler @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioRingBufferClass {
     pub parent_class: gst::GstObjectClass,
@@ -489,6 +615,12 @@ pub struct GstAudioRingBufferClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioRingBufferClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioRingBufferClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioRingBufferSpec {
     pub caps: *mut gst::GstCaps,
@@ -502,6 +634,12 @@ pub struct GstAudioRingBufferSpec {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioRingBufferSpec {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioRingBufferSpec @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioSinkClass {
     pub parent_class: GstAudioBaseSinkClass,
@@ -515,6 +653,12 @@ pub struct GstAudioSinkClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioSinkClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioSinkClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioSrcClass {
     pub parent_class: GstAudioBaseSrcClass,
@@ -528,11 +672,23 @@ pub struct GstAudioSrcClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioSrcClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioSrcClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstStreamVolumeInterface {
     pub iface: gobject::GTypeInterface,
 }
 
+impl ::std::fmt::Debug for GstStreamVolumeInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStreamVolumeInterface @ {:?}", self as *const _)
+    }
+}
+
 // Classes
 #[repr(C)]
 pub struct GstAudioBaseSink {
@@ -547,6 +703,22 @@ pub struct GstAudioBaseSink {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioBaseSink {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioBaseSink @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("ringbuffer", &self.ringbuffer)
+         .field("buffer_time", &self.buffer_time)
+         .field("latency_time", &self.latency_time)
+         .field("next_sample", &self.next_sample)
+         .field("provided_clock", &self.provided_clock)
+         .field("eos_rendering", &self.eos_rendering)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioBaseSrc {
     pub element: gst_base::GstPushSrc,
@@ -559,6 +731,21 @@ pub struct GstAudioBaseSrc {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioBaseSrc {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioBaseSrc @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("ringbuffer", &self.ringbuffer)
+         .field("buffer_time", &self.buffer_time)
+         .field("latency_time", &self.latency_time)
+         .field("next_sample", &self.next_sample)
+         .field("clock", &self.clock)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioCdSrc {
     pub pushsrc: gst_base::GstPushSrc,
@@ -568,6 +755,18 @@ pub struct GstAudioCdSrc {
     pub _gst_reserved2: [gpointer; 2],
 }
 
+impl ::std::fmt::Debug for GstAudioCdSrc {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioCdSrc @ {:?}", self as *const _))
+         .field("pushsrc", &self.pushsrc)
+         .field("tags", &self.tags)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved1", &self._gst_reserved1)
+         .field("_gst_reserved2", &self._gst_reserved2)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioClock {
     pub clock: gst::GstSystemClock,
@@ -579,6 +778,20 @@ pub struct GstAudioClock {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioClock {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioClock @ {:?}", self as *const _))
+         .field("clock", &self.clock)
+         .field("func", &self.func)
+         .field("user_data", &self.user_data)
+         .field("destroy_notify", &self.destroy_notify)
+         .field("last_time", &self.last_time)
+         .field("time_offset", &self.time_offset)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioDecoder {
     pub element: gst::GstElement,
@@ -591,6 +804,21 @@ pub struct GstAudioDecoder {
     pub _gst_reserved: [gpointer; 20],
 }
 
+impl ::std::fmt::Debug for GstAudioDecoder {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioDecoder @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("sinkpad", &self.sinkpad)
+         .field("srcpad", &self.srcpad)
+         .field("stream_lock", &self.stream_lock)
+         .field("input_segment", &self.input_segment)
+         .field("output_segment", &self.output_segment)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioEncoder {
     pub element: gst::GstElement,
@@ -603,6 +831,21 @@ pub struct GstAudioEncoder {
     pub _gst_reserved: [gpointer; 20],
 }
 
+impl ::std::fmt::Debug for GstAudioEncoder {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioEncoder @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("sinkpad", &self.sinkpad)
+         .field("srcpad", &self.srcpad)
+         .field("stream_lock", &self.stream_lock)
+         .field("input_segment", &self.input_segment)
+         .field("output_segment", &self.output_segment)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioFilter {
     pub basetransform: gst_base::GstBaseTransform,
@@ -610,6 +853,16 @@ pub struct GstAudioFilter {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioFilter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioFilter @ {:?}", self as *const _))
+         .field("basetransform", &self.basetransform)
+         .field("info", &self.info)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioRingBuffer {
     pub object: gst::GstObject,
@@ -637,6 +890,36 @@ pub struct GstAudioRingBuffer {
     pub _gst_reserved: [gpointer; 3],
 }
 
+impl ::std::fmt::Debug for GstAudioRingBuffer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioRingBuffer @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("cond", &self.cond)
+         .field("open", &self.open)
+         .field("acquired", &self.acquired)
+         .field("memory", &self.memory)
+         .field("size", &self.size)
+         .field("timestamps", &self.timestamps)
+         .field("spec", &self.spec)
+         .field("samples_per_seg", &self.samples_per_seg)
+         .field("empty_seg", &self.empty_seg)
+         .field("state", &self.state)
+         .field("segdone", &self.segdone)
+         .field("segbase", &self.segbase)
+         .field("waiting", &self.waiting)
+         .field("callback", &self.callback)
+         .field("cb_data", &self.cb_data)
+         .field("need_reorder", &self.need_reorder)
+         .field("channel_reorder_map", &format!("{:?}", &self.channel_reorder_map as *const _))
+         .field("flushing", &self.flushing)
+         .field("may_start", &self.may_start)
+         .field("active", &self.active)
+         .field("cb_data_notify", &self.cb_data_notify)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioSink {
     pub element: GstAudioBaseSink,
@@ -644,6 +927,16 @@ pub struct GstAudioSink {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioSink {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioSink @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("thread", &self.thread)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioSrc {
     pub element: GstAudioBaseSrc,
@@ -651,10 +944,27 @@ pub struct GstAudioSrc {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAudioSrc {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioSrc @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("thread", &self.thread)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 // Interfaces
 #[repr(C)]
 pub struct GstStreamVolume(c_void);
 
+impl ::std::fmt::Debug for GstStreamVolume {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStreamVolume @ {:?}", self as *const _)
+    }
+}
+
+
 extern "C" {
 
     //=========================================================================
diff --git a/gstreamer-base-sys/src/lib.rs b/gstreamer-base-sys/src/lib.rs
index c00d6d129..bbb6845f3 100644
--- a/gstreamer-base-sys/src/lib.rs
+++ b/gstreamer-base-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -88,6 +88,12 @@ pub type GstTypeFindHelperGetRangeFunction = Option<unsafe extern "C" fn(*mut gs
 #[repr(C)]
 pub struct GstAdapterClass(c_void);
 
+impl ::std::fmt::Debug for GstAdapterClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAdapterClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseParseClass {
     pub parent_class: gst::GstElementClass,
@@ -106,6 +112,12 @@ pub struct GstBaseParseClass {
     pub _gst_reserved: [gpointer; 18],
 }
 
+impl ::std::fmt::Debug for GstBaseParseClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseParseClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseParseFrame {
     pub buffer: *mut gst::GstBuffer,
@@ -119,9 +131,21 @@ pub struct GstBaseParseFrame {
     pub _private_flags: c_uint,
 }
 
+impl ::std::fmt::Debug for GstBaseParseFrame {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseParseFrame @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseParsePrivate(c_void);
 
+impl ::std::fmt::Debug for GstBaseParsePrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseParsePrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseSinkClass {
     pub parent_class: gst::GstElementClass,
@@ -146,9 +170,21 @@ pub struct GstBaseSinkClass {
     pub _gst_reserved: [gpointer; 20],
 }
 
+impl ::std::fmt::Debug for GstBaseSinkClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseSinkClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseSinkPrivate(c_void);
 
+impl ::std::fmt::Debug for GstBaseSinkPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseSinkPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseSrcClass {
     pub parent_class: gst::GstElementClass,
@@ -174,9 +210,21 @@ pub struct GstBaseSrcClass {
     pub _gst_reserved: [gpointer; 20],
 }
 
+impl ::std::fmt::Debug for GstBaseSrcClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseSrcClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseSrcPrivate(c_void);
 
+impl ::std::fmt::Debug for GstBaseSrcPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseSrcPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseTransformClass {
     pub parent_class: gst::GstElementClass,
@@ -207,9 +255,21 @@ pub struct GstBaseTransformClass {
     pub _gst_reserved: [gpointer; 18],
 }
 
+impl ::std::fmt::Debug for GstBaseTransformClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseTransformClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseTransformPrivate(c_void);
 
+impl ::std::fmt::Debug for GstBaseTransformPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBaseTransformPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBitReader {
     pub data: *mut u8,
@@ -219,6 +279,12 @@ pub struct GstBitReader {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstBitReader {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBitReader @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstByteReader {
     pub data: *mut u8,
@@ -227,6 +293,12 @@ pub struct GstByteReader {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstByteReader {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstByteReader @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstByteWriter {
     pub parent: GstByteReader,
@@ -236,6 +308,12 @@ pub struct GstByteWriter {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstByteWriter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstByteWriter @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstCollectData {
     pub collect: *mut GstCollectPads,
@@ -248,18 +326,42 @@ pub struct GstCollectData {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstCollectData {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstCollectData @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstCollectDataPrivate(c_void);
 
+impl ::std::fmt::Debug for GstCollectDataPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstCollectDataPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstCollectPadsClass {
     pub parent_class: gst::GstObjectClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstCollectPadsClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstCollectPadsClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstCollectPadsPrivate(c_void);
 
+impl ::std::fmt::Debug for GstCollectPadsPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstCollectPadsPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDataQueueClass {
     pub parent_class: gobject::GObjectClass,
@@ -268,6 +370,12 @@ pub struct GstDataQueueClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDataQueueClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDataQueueClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDataQueueItem {
     pub object: *mut gst::GstMiniObject,
@@ -278,9 +386,21 @@ pub struct GstDataQueueItem {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDataQueueItem {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDataQueueItem @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDataQueuePrivate(c_void);
 
+impl ::std::fmt::Debug for GstDataQueuePrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDataQueuePrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDataQueueSize {
     pub visible: c_uint,
@@ -288,9 +408,21 @@ pub struct GstDataQueueSize {
     pub time: u64,
 }
 
+impl ::std::fmt::Debug for GstDataQueueSize {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDataQueueSize @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstFlowCombiner(c_void);
 
+impl ::std::fmt::Debug for GstFlowCombiner {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstFlowCombiner @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPushSrcClass {
     pub parent_class: GstBaseSrcClass,
@@ -300,13 +432,31 @@ pub struct GstPushSrcClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPushSrcClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPushSrcClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstQueueArray(c_void);
 
+impl ::std::fmt::Debug for GstQueueArray {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstQueueArray @ {:?}", self as *const _)
+    }
+}
+
 // Classes
 #[repr(C)]
 pub struct GstAdapter(c_void);
 
+impl ::std::fmt::Debug for GstAdapter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAdapter @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseParse {
     pub element: gst::GstElement,
@@ -318,6 +468,20 @@ pub struct GstBaseParse {
     pub priv_: *mut GstBaseParsePrivate,
 }
 
+impl ::std::fmt::Debug for GstBaseParse {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstBaseParse @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("sinkpad", &self.sinkpad)
+         .field("srcpad", &self.srcpad)
+         .field("flags", &self.flags)
+         .field("segment", &self.segment)
+         .field("_gst_reserved", &self._gst_reserved)
+         .field("priv_", &self.priv_)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseSink {
     pub element: gst::GstElement,
@@ -343,6 +507,34 @@ pub struct GstBaseSink {
     pub _gst_reserved: [gpointer; 20],
 }
 
+impl ::std::fmt::Debug for GstBaseSink {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstBaseSink @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("sinkpad", &self.sinkpad)
+         .field("pad_mode", &self.pad_mode)
+         .field("offset", &self.offset)
+         .field("can_activate_pull", &self.can_activate_pull)
+         .field("can_activate_push", &self.can_activate_push)
+         .field("preroll_lock", &self.preroll_lock)
+         .field("preroll_cond", &self.preroll_cond)
+         .field("eos", &self.eos)
+         .field("need_preroll", &self.need_preroll)
+         .field("have_preroll", &self.have_preroll)
+         .field("playing_async", &self.playing_async)
+         .field("have_newsegment", &self.have_newsegment)
+         .field("segment", &self.segment)
+         .field("clock_id", &self.clock_id)
+         .field("sync", &self.sync)
+         .field("flushing", &self.flushing)
+         .field("running", &self.running)
+         .field("max_lateness", &self.max_lateness)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseSrc {
     pub element: gst::GstElement,
@@ -366,6 +558,32 @@ pub struct GstBaseSrc {
     pub _gst_reserved: [gpointer; 20],
 }
 
+impl ::std::fmt::Debug for GstBaseSrc {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstBaseSrc @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("srcpad", &self.srcpad)
+         .field("live_lock", &self.live_lock)
+         .field("live_cond", &self.live_cond)
+         .field("is_live", &self.is_live)
+         .field("live_running", &self.live_running)
+         .field("blocksize", &self.blocksize)
+         .field("can_activate_push", &self.can_activate_push)
+         .field("random_access", &self.random_access)
+         .field("clock_id", &self.clock_id)
+         .field("segment", &self.segment)
+         .field("need_newsegment", &self.need_newsegment)
+         .field("num_buffers", &self.num_buffers)
+         .field("num_buffers_left", &self.num_buffers_left)
+         .field("typefind", &self.typefind)
+         .field("running", &self.running)
+         .field("pending_seek", &self.pending_seek)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstBaseTransform {
     pub element: gst::GstElement,
@@ -378,6 +596,21 @@ pub struct GstBaseTransform {
     pub _gst_reserved: [gpointer; 19],
 }
 
+impl ::std::fmt::Debug for GstBaseTransform {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstBaseTransform @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("sinkpad", &self.sinkpad)
+         .field("srcpad", &self.srcpad)
+         .field("have_segment", &self.have_segment)
+         .field("segment", &self.segment)
+         .field("queued_buf", &self.queued_buf)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstCollectPads {
     pub object: gst::GstObject,
@@ -387,6 +620,18 @@ pub struct GstCollectPads {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstCollectPads {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstCollectPads @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("data", &self.data)
+         .field("stream_lock", &self.stream_lock)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstDataQueue {
     pub object: gobject::GObject,
@@ -394,12 +639,31 @@ pub struct GstDataQueue {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDataQueue {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstDataQueue @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstPushSrc {
     pub parent: GstBaseSrc,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPushSrc {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstPushSrc @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 extern "C" {
 
     //=========================================================================
diff --git a/gstreamer-mpegts-sys/Cargo.toml b/gstreamer-mpegts-sys/Cargo.toml
index f582aa5ba..f316218bd 100644
--- a/gstreamer-mpegts-sys/Cargo.toml
+++ b/gstreamer-mpegts-sys/Cargo.toml
@@ -8,7 +8,7 @@ pkg-config = "0.3.7"
 [dependencies]
 libc = "0.2"
 glib-sys = { git = "https://github.com/gtk-rs/sys" }
-gobject-sys = {  git = "https://github.com/gtk-rs/sys" }
+gobject-sys = { git = "https://github.com/gtk-rs/sys" }
 
 [dependencies.gstreamer-base-sys]
 path = "../gstreamer-base-sys"
diff --git a/gstreamer-mpegts-sys/src/lib.rs b/gstreamer-mpegts-sys/src/lib.rs
index 2447823e1..4be11a4f2 100644
--- a/gstreamer-mpegts-sys/src/lib.rs
+++ b/gstreamer-mpegts-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -581,6 +581,12 @@ pub struct GstMpegtsAtscEIT {
     pub events: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscEIT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscEIT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscEITEvent {
     pub event_id: u16,
@@ -591,6 +597,12 @@ pub struct GstMpegtsAtscEITEvent {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscEITEvent {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscEITEvent @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscETT {
     pub ett_table_id_extension: u16,
@@ -599,6 +611,12 @@ pub struct GstMpegtsAtscETT {
     pub messages: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscETT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscETT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscMGT {
     pub protocol_version: u8,
@@ -607,6 +625,12 @@ pub struct GstMpegtsAtscMGT {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscMGT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscMGT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscMGTTable {
     pub table_type: u16,
@@ -616,12 +640,24 @@ pub struct GstMpegtsAtscMGTTable {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscMGTTable {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscMGTTable @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscMultString {
     pub iso_639_langcode: [c_char; 4],
     pub segments: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscMultString {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscMultString @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscSTT {
     pub protocol_version: u8,
@@ -634,6 +670,12 @@ pub struct GstMpegtsAtscSTT {
     pub utc_datetime: *mut gst::GstDateTime,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscSTT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscSTT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscStringSegment {
     pub compression_type: u8,
@@ -643,6 +685,12 @@ pub struct GstMpegtsAtscStringSegment {
     pub cached_string: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscStringSegment {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscStringSegment @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscVCT {
     pub transport_stream_id: u16,
@@ -651,6 +699,12 @@ pub struct GstMpegtsAtscVCT {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscVCT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscVCT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsAtscVCTSource {
     pub short_name: *mut c_char,
@@ -671,12 +725,24 @@ pub struct GstMpegtsAtscVCTSource {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsAtscVCTSource {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsAtscVCTSource @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsBAT {
     pub descriptors: *mut glib::GPtrArray,
     pub streams: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsBAT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsBAT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsBATStream {
     pub transport_stream_id: u16,
@@ -684,6 +750,12 @@ pub struct GstMpegtsBATStream {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsBATStream {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsBATStream @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsCableDeliverySystemDescriptor {
     pub frequency: u32,
@@ -693,6 +765,12 @@ pub struct GstMpegtsCableDeliverySystemDescriptor {
     pub fec_inner: GstMpegtsDVBCodeRate,
 }
 
+impl ::std::fmt::Debug for GstMpegtsCableDeliverySystemDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsCableDeliverySystemDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsComponentDescriptor {
     pub stream_content: u8,
@@ -702,6 +780,12 @@ pub struct GstMpegtsComponentDescriptor {
     pub text: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsComponentDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsComponentDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsContent {
     pub content_nibble_1: GstMpegtsContentNibbleHi,
@@ -709,6 +793,12 @@ pub struct GstMpegtsContent {
     pub user_byte: u8,
 }
 
+impl ::std::fmt::Debug for GstMpegtsContent {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsContent @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDVBLinkageDescriptor {
     pub transport_stream_id: u16,
@@ -720,6 +810,12 @@ pub struct GstMpegtsDVBLinkageDescriptor {
     pub private_data_bytes: *mut u8,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDVBLinkageDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDVBLinkageDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDVBLinkageEvent {
     pub target_event_id: u16,
@@ -727,6 +823,12 @@ pub struct GstMpegtsDVBLinkageEvent {
     pub event_simulcast: gboolean,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDVBLinkageEvent {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDVBLinkageEvent @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDVBLinkageExtendedEvent {
     pub target_event_id: u16,
@@ -742,6 +844,12 @@ pub struct GstMpegtsDVBLinkageExtendedEvent {
     pub target_service_id: u16,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDVBLinkageExtendedEvent {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDVBLinkageExtendedEvent @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDVBLinkageMobileHandOver {
     pub hand_over_type: GstMpegtsDVBLinkageHandOverType,
@@ -750,18 +858,36 @@ pub struct GstMpegtsDVBLinkageMobileHandOver {
     pub initial_service_id: u16,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDVBLinkageMobileHandOver {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDVBLinkageMobileHandOver @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDVBParentalRatingItem {
     pub country_code: *mut c_char,
     pub rating: u8,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDVBParentalRatingItem {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDVBParentalRatingItem @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDVBServiceListItem {
     pub service_id: u16,
     pub type_: GstMpegtsDVBServiceType,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDVBServiceListItem {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDVBServiceListItem @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDataBroadcastDescriptor {
     pub data_broadcast_id: u16,
@@ -772,6 +898,12 @@ pub struct GstMpegtsDataBroadcastDescriptor {
     pub text: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDataBroadcastDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDataBroadcastDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDescriptor {
     pub tag: u8,
@@ -781,24 +913,48 @@ pub struct GstMpegtsDescriptor {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstMpegtsDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDvbMultilingualBouquetNameItem {
     pub language_code: *mut c_char,
     pub bouquet_name: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDvbMultilingualBouquetNameItem {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDvbMultilingualBouquetNameItem @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDvbMultilingualComponentItem {
     pub language_code: *mut c_char,
     pub description: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDvbMultilingualComponentItem {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDvbMultilingualComponentItem @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDvbMultilingualNetworkNameItem {
     pub language_code: *mut c_char,
     pub network_name: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDvbMultilingualNetworkNameItem {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDvbMultilingualNetworkNameItem @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsDvbMultilingualServiceNameItem {
     pub language_code: *mut c_char,
@@ -806,6 +962,12 @@ pub struct GstMpegtsDvbMultilingualServiceNameItem {
     pub service_name: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsDvbMultilingualServiceNameItem {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsDvbMultilingualServiceNameItem @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsEIT {
     pub transport_stream_id: u16,
@@ -817,6 +979,12 @@ pub struct GstMpegtsEIT {
     pub events: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsEIT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsEIT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsEITEvent {
     pub event_id: u16,
@@ -827,6 +995,12 @@ pub struct GstMpegtsEITEvent {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsEITEvent {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsEITEvent @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsExtendedEventDescriptor {
     pub descriptor_number: u8,
@@ -836,12 +1010,24 @@ pub struct GstMpegtsExtendedEventDescriptor {
     pub text: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsExtendedEventDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsExtendedEventDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsExtendedEventItem {
     pub item_description: *mut c_char,
     pub item: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstMpegtsExtendedEventItem {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsExtendedEventItem @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsISO639LanguageDescriptor {
     pub nb_language: c_uint,
@@ -849,6 +1035,12 @@ pub struct GstMpegtsISO639LanguageDescriptor {
     pub audio_type: [GstMpegtsIso639AudioType; 64],
 }
 
+impl ::std::fmt::Debug for GstMpegtsISO639LanguageDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsISO639LanguageDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsLogicalChannel {
     pub service_id: u16,
@@ -856,12 +1048,24 @@ pub struct GstMpegtsLogicalChannel {
     pub logical_channel_number: u16,
 }
 
+impl ::std::fmt::Debug for GstMpegtsLogicalChannel {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsLogicalChannel @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsLogicalChannelDescriptor {
     pub nb_channels: c_uint,
     pub channels: [GstMpegtsLogicalChannel; 64],
 }
 
+impl ::std::fmt::Debug for GstMpegtsLogicalChannelDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsLogicalChannelDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsNIT {
     pub actual_network: gboolean,
@@ -870,6 +1074,12 @@ pub struct GstMpegtsNIT {
     pub streams: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsNIT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsNIT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsNITStream {
     pub transport_stream_id: u16,
@@ -877,6 +1087,12 @@ pub struct GstMpegtsNITStream {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsNITStream {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsNITStream @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsPMT {
     pub pcr_pid: u16,
@@ -885,6 +1101,12 @@ pub struct GstMpegtsPMT {
     pub streams: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsPMT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsPMT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsPMTStream {
     pub stream_type: u8,
@@ -892,12 +1114,24 @@ pub struct GstMpegtsPMTStream {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsPMTStream {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsPMTStream @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsPatProgram {
     pub program_number: u16,
     pub network_or_program_map_PID: u16,
 }
 
+impl ::std::fmt::Debug for GstMpegtsPatProgram {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsPatProgram @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsSDT {
     pub original_network_id: u16,
@@ -906,6 +1140,12 @@ pub struct GstMpegtsSDT {
     pub services: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsSDT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsSDT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsSDTService {
     pub service_id: u16,
@@ -916,6 +1156,12 @@ pub struct GstMpegtsSDTService {
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsSDTService {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsSDTService @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsSatelliteDeliverySystemDescriptor {
     pub frequency: u32,
@@ -929,6 +1175,12 @@ pub struct GstMpegtsSatelliteDeliverySystemDescriptor {
     pub fec_inner: GstMpegtsDVBCodeRate,
 }
 
+impl ::std::fmt::Debug for GstMpegtsSatelliteDeliverySystemDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsSatelliteDeliverySystemDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsSection {
     pub parent: gst::GstMiniObject,
@@ -951,6 +1203,12 @@ pub struct GstMpegtsSection {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstMpegtsSection {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsSection @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsT2DeliverySystemCell {
     pub cell_id: u16,
@@ -958,12 +1216,24 @@ pub struct GstMpegtsT2DeliverySystemCell {
     pub sub_cells: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemCell {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsT2DeliverySystemCell @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsT2DeliverySystemCellExtension {
     pub cell_id_extension: u8,
     pub transposer_frequency: u32,
 }
 
+impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemCellExtension {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsT2DeliverySystemCellExtension @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsT2DeliverySystemDescriptor {
     pub plp_id: u8,
@@ -977,12 +1247,24 @@ pub struct GstMpegtsT2DeliverySystemDescriptor {
     pub cells: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsT2DeliverySystemDescriptor @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsTOT {
     pub utc_time: *mut gst::GstDateTime,
     pub descriptors: *mut glib::GPtrArray,
 }
 
+impl ::std::fmt::Debug for GstMpegtsTOT {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsTOT @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMpegtsTerrestrialDeliverySystemDescriptor {
     pub frequency: u32,
@@ -999,6 +1281,12 @@ pub struct GstMpegtsTerrestrialDeliverySystemDescriptor {
     pub other_frequency: gboolean,
 }
 
+impl ::std::fmt::Debug for GstMpegtsTerrestrialDeliverySystemDescriptor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMpegtsTerrestrialDeliverySystemDescriptor @ {:?}", self as *const _)
+    }
+}
+
 extern "C" {
 
     //=========================================================================
diff --git a/gstreamer-pbutils-sys/src/lib.rs b/gstreamer-pbutils-sys/src/lib.rs
index 54f566a86..9994a64ff 100644
--- a/gstreamer-pbutils-sys/src/lib.rs
+++ b/gstreamer-pbutils-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -103,9 +103,21 @@ pub struct GstAudioVisualizerClass {
     pub decide_allocation: Option<unsafe extern "C" fn(*mut GstAudioVisualizer, *mut gst::GstQuery) -> gboolean>,
 }
 
+impl ::std::fmt::Debug for GstAudioVisualizerClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioVisualizerClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAudioVisualizerPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAudioVisualizerPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAudioVisualizerPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscovererClass {
     pub parentclass: gobject::GObjectClass,
@@ -116,24 +128,66 @@ pub struct GstDiscovererClass {
     pub _reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDiscovererClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDiscovererClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscovererPrivate(c_void);
 
+impl ::std::fmt::Debug for GstDiscovererPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDiscovererPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingAudioProfileClass(c_void);
 
+impl ::std::fmt::Debug for GstEncodingAudioProfileClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingAudioProfileClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingContainerProfileClass(c_void);
 
+impl ::std::fmt::Debug for GstEncodingContainerProfileClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingContainerProfileClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingProfileClass(c_void);
 
+impl ::std::fmt::Debug for GstEncodingProfileClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingProfileClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingVideoProfileClass(c_void);
 
+impl ::std::fmt::Debug for GstEncodingVideoProfileClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingVideoProfileClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstInstallPluginsContext(c_void);
 
+impl ::std::fmt::Debug for GstInstallPluginsContext {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstInstallPluginsContext @ {:?}", self as *const _)
+    }
+}
+
 // Classes
 #[repr(C)]
 pub struct GstAudioVisualizer {
@@ -144,6 +198,18 @@ pub struct GstAudioVisualizer {
     pub priv_: *mut GstAudioVisualizerPrivate,
 }
 
+impl ::std::fmt::Debug for GstAudioVisualizer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAudioVisualizer @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("req_spf", &self.req_spf)
+         .field("vinfo", &self.vinfo)
+         .field("ainfo", &self.ainfo)
+         .field("priv_", &self.priv_)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscoverer {
     pub parent: gobject::GObject,
@@ -151,39 +217,115 @@ pub struct GstDiscoverer {
     pub _reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDiscoverer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstDiscoverer @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("priv_", &self.priv_)
+         .field("_reserved", &self._reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscovererAudioInfo(c_void);
 
+impl ::std::fmt::Debug for GstDiscovererAudioInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDiscovererAudioInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscovererContainerInfo(c_void);
 
+impl ::std::fmt::Debug for GstDiscovererContainerInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDiscovererContainerInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscovererInfo(c_void);
 
+impl ::std::fmt::Debug for GstDiscovererInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDiscovererInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscovererStreamInfo(c_void);
 
+impl ::std::fmt::Debug for GstDiscovererStreamInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDiscovererStreamInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscovererSubtitleInfo(c_void);
 
+impl ::std::fmt::Debug for GstDiscovererSubtitleInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDiscovererSubtitleInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDiscovererVideoInfo(c_void);
 
+impl ::std::fmt::Debug for GstDiscovererVideoInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDiscovererVideoInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingAudioProfile(c_void);
 
+impl ::std::fmt::Debug for GstEncodingAudioProfile {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingAudioProfile @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingContainerProfile(c_void);
 
+impl ::std::fmt::Debug for GstEncodingContainerProfile {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingContainerProfile @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingProfile(c_void);
 
+impl ::std::fmt::Debug for GstEncodingProfile {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingProfile @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingTarget(c_void);
 
+impl ::std::fmt::Debug for GstEncodingTarget {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingTarget @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEncodingVideoProfile(c_void);
 
+impl ::std::fmt::Debug for GstEncodingVideoProfile {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEncodingVideoProfile @ {:?}", self as *const _)
+    }
+}
+
 extern "C" {
 
     //=========================================================================
diff --git a/gstreamer-player-sys/src/lib.rs b/gstreamer-player-sys/src/lib.rs
index 710428b69..422733981 100644
--- a/gstreamer-player-sys/src/lib.rs
+++ b/gstreamer-player-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -48,76 +48,204 @@ pub type GstPlayerSignalDispatcherFunc = Option<unsafe extern "C" fn(gpointer)>;
 #[repr(C)]
 pub struct GstPlayerAudioInfoClass(c_void);
 
+impl ::std::fmt::Debug for GstPlayerAudioInfoClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerAudioInfoClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerClass(c_void);
 
+impl ::std::fmt::Debug for GstPlayerClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerGMainContextSignalDispatcherClass(c_void);
 
+impl ::std::fmt::Debug for GstPlayerGMainContextSignalDispatcherClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerGMainContextSignalDispatcherClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerMediaInfoClass(c_void);
 
+impl ::std::fmt::Debug for GstPlayerMediaInfoClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerMediaInfoClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerSignalDispatcherInterface {
     pub parent_iface: gobject::GTypeInterface,
     pub dispatch: Option<unsafe extern "C" fn(*mut GstPlayerSignalDispatcher, *mut GstPlayer, GstPlayerSignalDispatcherFunc, gpointer, glib::GDestroyNotify)>,
 }
 
+impl ::std::fmt::Debug for GstPlayerSignalDispatcherInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerSignalDispatcherInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerStreamInfoClass(c_void);
 
+impl ::std::fmt::Debug for GstPlayerStreamInfoClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerStreamInfoClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerSubtitleInfoClass(c_void);
 
+impl ::std::fmt::Debug for GstPlayerSubtitleInfoClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerSubtitleInfoClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerVideoInfoClass(c_void);
 
+impl ::std::fmt::Debug for GstPlayerVideoInfoClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerVideoInfoClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerVideoOverlayVideoRendererClass(c_void);
 
+impl ::std::fmt::Debug for GstPlayerVideoOverlayVideoRendererClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerVideoOverlayVideoRendererClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerVideoRendererInterface {
     pub parent_iface: gobject::GTypeInterface,
     pub create_video_sink: Option<unsafe extern "C" fn(*mut GstPlayerVideoRenderer, *mut GstPlayer) -> *mut gst::GstElement>,
 }
 
+impl ::std::fmt::Debug for GstPlayerVideoRendererInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerVideoRendererInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerVisualization {
     pub name: *mut c_char,
     pub description: *mut c_char,
 }
 
+impl ::std::fmt::Debug for GstPlayerVisualization {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerVisualization @ {:?}", self as *const _)
+    }
+}
+
 // Classes
 #[repr(C)]
 pub struct GstPlayer(c_void);
 
+impl ::std::fmt::Debug for GstPlayer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayer @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerAudioInfo(c_void);
 
+impl ::std::fmt::Debug for GstPlayerAudioInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerAudioInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerGMainContextSignalDispatcher(c_void);
 
+impl ::std::fmt::Debug for GstPlayerGMainContextSignalDispatcher {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerGMainContextSignalDispatcher @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerMediaInfo(c_void);
 
+impl ::std::fmt::Debug for GstPlayerMediaInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerMediaInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerStreamInfo(c_void);
 
+impl ::std::fmt::Debug for GstPlayerStreamInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerStreamInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerSubtitleInfo(c_void);
 
+impl ::std::fmt::Debug for GstPlayerSubtitleInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerSubtitleInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerVideoInfo(c_void);
 
+impl ::std::fmt::Debug for GstPlayerVideoInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerVideoInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerVideoOverlayVideoRenderer(c_void);
 
+impl ::std::fmt::Debug for GstPlayerVideoOverlayVideoRenderer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerVideoOverlayVideoRenderer @ {:?}", self as *const _)
+    }
+}
+
 // Interfaces
 #[repr(C)]
 pub struct GstPlayerSignalDispatcher(c_void);
+
+impl ::std::fmt::Debug for GstPlayerSignalDispatcher {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerSignalDispatcher @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPlayerVideoRenderer(c_void);
 
+impl ::std::fmt::Debug for GstPlayerVideoRenderer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlayerVideoRenderer @ {:?}", self as *const _)
+    }
+}
+
+
 extern "C" {
 
     //=========================================================================
diff --git a/gstreamer-sys/src/lib.rs b/gstreamer-sys/src/lib.rs
index 343de6faf..4aaa40d3f 100644
--- a/gstreamer-sys/src/lib.rs
+++ b/gstreamer-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -1342,6 +1342,12 @@ pub struct GstAllocationParams {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAllocationParams {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAllocationParams @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAllocatorClass {
     pub object_class: GstObjectClass,
@@ -1350,12 +1356,30 @@ pub struct GstAllocatorClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstAllocatorClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAllocatorClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAllocatorPrivate(c_void);
 
+impl ::std::fmt::Debug for GstAllocatorPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAllocatorPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstAtomicQueue(c_void);
 
+impl ::std::fmt::Debug for GstAtomicQueue {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstAtomicQueue @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBinClass {
     pub parent_class: GstElementClass,
@@ -1371,9 +1395,21 @@ pub struct GstBinClass {
     pub _gst_reserved: [gpointer; 2],
 }
 
+impl ::std::fmt::Debug for GstBinClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBinClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBinPrivate(c_void);
 
+impl ::std::fmt::Debug for GstBinPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBinPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBuffer {
     pub mini_object: GstMiniObject,
@@ -1385,9 +1421,21 @@ pub struct GstBuffer {
     pub offset_end: u64,
 }
 
+impl ::std::fmt::Debug for GstBuffer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBuffer @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBufferList(c_void);
 
+impl ::std::fmt::Debug for GstBufferList {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBufferList @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBufferPoolAcquireParams {
     pub format: GstFormat,
@@ -1397,6 +1445,12 @@ pub struct GstBufferPoolAcquireParams {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstBufferPoolAcquireParams {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBufferPoolAcquireParams @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBufferPoolClass {
     pub object_class: GstObjectClass,
@@ -1414,9 +1468,21 @@ pub struct GstBufferPoolClass {
     pub _gst_reserved: [gpointer; 2],
 }
 
+impl ::std::fmt::Debug for GstBufferPoolClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBufferPoolClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBufferPoolPrivate(c_void);
 
+impl ::std::fmt::Debug for GstBufferPoolPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBufferPoolPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBusClass {
     pub parent_class: GstObjectClass,
@@ -1425,17 +1491,41 @@ pub struct GstBusClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstBusClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBusClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBusPrivate(c_void);
 
+impl ::std::fmt::Debug for GstBusPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBusPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstCaps {
     pub mini_object: GstMiniObject,
 }
 
+impl ::std::fmt::Debug for GstCaps {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstCaps @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstCapsFeatures(c_void);
 
+impl ::std::fmt::Debug for GstCapsFeatures {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstCapsFeatures @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstChildProxyInterface {
     pub parent: gobject::GTypeInterface,
@@ -1447,6 +1537,12 @@ pub struct GstChildProxyInterface {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstChildProxyInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstChildProxyInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstClockClass {
     pub parent_class: GstObjectClass,
@@ -1459,6 +1555,12 @@ pub struct GstClockClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstClockClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstClockClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstClockEntry {
     pub refcount: c_int,
@@ -1475,12 +1577,30 @@ pub struct GstClockEntry {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstClockEntry {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstClockEntry @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstClockPrivate(c_void);
 
+impl ::std::fmt::Debug for GstClockPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstClockPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstContext(c_void);
 
+impl ::std::fmt::Debug for GstContext {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstContext @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstControlBindingClass {
     pub parent_class: GstObjectClass,
@@ -1491,18 +1611,42 @@ pub struct GstControlBindingClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstControlBindingClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstControlBindingClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstControlBindingPrivate(c_void);
 
+impl ::std::fmt::Debug for GstControlBindingPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstControlBindingPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstControlSourceClass {
     pub parent_class: GstObjectClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstControlSourceClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstControlSourceClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDateTime(c_void);
 
+impl ::std::fmt::Debug for GstDateTime {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDateTime @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDebugCategory {
     pub threshold: c_int,
@@ -1511,9 +1655,21 @@ pub struct GstDebugCategory {
     pub description: *const c_char,
 }
 
+impl ::std::fmt::Debug for GstDebugCategory {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDebugCategory @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDebugMessage(c_void);
 
+impl ::std::fmt::Debug for GstDebugMessage {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDebugMessage @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceClass {
     pub parent_class: GstObjectClass,
@@ -1522,18 +1678,42 @@ pub struct GstDeviceClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDeviceClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDeviceClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceMonitorClass {
     pub parent_class: GstObjectClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDeviceMonitorClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDeviceMonitorClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceMonitorPrivate(c_void);
 
+impl ::std::fmt::Debug for GstDeviceMonitorPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDeviceMonitorPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDevicePrivate(c_void);
 
+impl ::std::fmt::Debug for GstDevicePrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDevicePrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceProviderClass {
     pub parent_class: GstObjectClass,
@@ -1545,15 +1725,39 @@ pub struct GstDeviceProviderClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDeviceProviderClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDeviceProviderClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceProviderFactoryClass(c_void);
 
+impl ::std::fmt::Debug for GstDeviceProviderFactoryClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDeviceProviderFactoryClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceProviderPrivate(c_void);
 
+impl ::std::fmt::Debug for GstDeviceProviderPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDeviceProviderPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDynamicTypeFactoryClass(c_void);
 
+impl ::std::fmt::Debug for GstDynamicTypeFactoryClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDynamicTypeFactoryClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstElementClass {
     pub parent_class: GstObjectClass,
@@ -1581,9 +1785,21 @@ pub struct GstElementClass {
     pub _gst_reserved: [gpointer; 18],
 }
 
+impl ::std::fmt::Debug for GstElementClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstElementClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstElementFactoryClass(c_void);
 
+impl ::std::fmt::Debug for GstElementFactoryClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstElementFactoryClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstEvent {
     pub mini_object: GstMiniObject,
@@ -1592,6 +1808,12 @@ pub struct GstEvent {
     pub seqnum: u32,
 }
 
+impl ::std::fmt::Debug for GstEvent {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstEvent @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstFormatDefinition {
     pub value: GstFormat,
@@ -1600,15 +1822,33 @@ pub struct GstFormatDefinition {
     pub quark: glib::GQuark,
 }
 
+impl ::std::fmt::Debug for GstFormatDefinition {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstFormatDefinition @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstGhostPadClass {
     pub parent_class: GstProxyPadClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstGhostPadClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstGhostPadClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstGhostPadPrivate(c_void);
 
+impl ::std::fmt::Debug for GstGhostPadPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstGhostPadPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstIterator {
     pub copy: GstIteratorCopyFunction,
@@ -1625,6 +1865,12 @@ pub struct GstIterator {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstIterator {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstIterator @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMapInfo {
     pub memory: *mut GstMemory,
@@ -1636,6 +1882,12 @@ pub struct GstMapInfo {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstMapInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMapInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMemory {
     pub mini_object: GstMiniObject,
@@ -1647,6 +1899,12 @@ pub struct GstMemory {
     pub size: size_t,
 }
 
+impl ::std::fmt::Debug for GstMemory {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMemory @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMessage {
     pub mini_object: GstMiniObject,
@@ -1658,12 +1916,24 @@ pub struct GstMessage {
     pub cond: glib::GCond,
 }
 
+impl ::std::fmt::Debug for GstMessage {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMessage @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMeta {
     pub flags: GstMetaFlags,
     pub info: *const GstMetaInfo,
 }
 
+impl ::std::fmt::Debug for GstMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMetaInfo {
     pub api: GType,
@@ -1674,6 +1944,12 @@ pub struct GstMetaInfo {
     pub transform_func: GstMetaTransformFunction,
 }
 
+impl ::std::fmt::Debug for GstMetaInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMetaInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMetaTransformCopy {
     pub region: gboolean,
@@ -1681,6 +1957,12 @@ pub struct GstMetaTransformCopy {
     pub size: size_t,
 }
 
+impl ::std::fmt::Debug for GstMetaTransformCopy {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMetaTransformCopy @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstMiniObject {
     pub type_: GType,
@@ -1694,6 +1976,12 @@ pub struct GstMiniObject {
     pub qdata: gpointer,
 }
 
+impl ::std::fmt::Debug for GstMiniObject {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstMiniObject @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstObjectClass {
     pub parent_class: gobject::GInitiallyUnownedClass,
@@ -1702,6 +1990,12 @@ pub struct GstObjectClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstObjectClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstObjectClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPadClass {
     pub parent_class: GstObjectClass,
@@ -1710,9 +2004,21 @@ pub struct GstPadClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPadClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPadClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPadPrivate(c_void);
 
+impl ::std::fmt::Debug for GstPadPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPadPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPadProbeInfo {
     pub type_: GstPadProbeType,
@@ -1723,6 +2029,12 @@ pub struct GstPadProbeInfo {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPadProbeInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPadProbeInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPadTemplateClass {
     pub parent_class: GstObjectClass,
@@ -1730,12 +2042,24 @@ pub struct GstPadTemplateClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPadTemplateClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPadTemplateClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstParamSpecArray {
     pub parent_instance: gobject::GParamSpec,
     pub element_spec: *mut gobject::GParamSpec,
 }
 
+impl ::std::fmt::Debug for GstParamSpecArray {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstParamSpecArray @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstParamSpecFraction {
     pub parent_instance: gobject::GParamSpec,
@@ -1747,27 +2071,63 @@ pub struct GstParamSpecFraction {
     pub def_den: c_int,
 }
 
+impl ::std::fmt::Debug for GstParamSpecFraction {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstParamSpecFraction @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstParentBufferMeta {
     pub parent: GstMeta,
     pub buffer: *mut GstBuffer,
 }
 
+impl ::std::fmt::Debug for GstParentBufferMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstParentBufferMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstParseContext(c_void);
 
+impl ::std::fmt::Debug for GstParseContext {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstParseContext @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPipelineClass {
     pub parent_class: GstBinClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPipelineClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPipelineClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPipelinePrivate(c_void);
 
+impl ::std::fmt::Debug for GstPipelinePrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPipelinePrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPluginClass(c_void);
 
+impl ::std::fmt::Debug for GstPluginClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPluginClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPluginDesc {
     pub major_version: c_int,
@@ -1784,18 +2144,42 @@ pub struct GstPluginDesc {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPluginDesc {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPluginDesc @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPluginFeatureClass(c_void);
 
+impl ::std::fmt::Debug for GstPluginFeatureClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPluginFeatureClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPoll(c_void);
 
+impl ::std::fmt::Debug for GstPoll {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPoll @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPollFD {
     pub fd: c_int,
     pub idx: c_int,
 }
 
+impl ::std::fmt::Debug for GstPollFD {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPollFD @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPresetInterface {
     pub parent: gobject::GTypeInterface,
@@ -1810,38 +2194,86 @@ pub struct GstPresetInterface {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPresetInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPresetInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstProtectionMeta {
     pub meta: GstMeta,
     pub info: *mut GstStructure,
 }
 
+impl ::std::fmt::Debug for GstProtectionMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstProtectionMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstProxyPadClass {
     pub parent_class: GstPadClass,
     pub _gst_reserved: [gpointer; 1],
 }
 
+impl ::std::fmt::Debug for GstProxyPadClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstProxyPadClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstProxyPadPrivate(c_void);
 
+impl ::std::fmt::Debug for GstProxyPadPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstProxyPadPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstQuery {
     pub mini_object: GstMiniObject,
     pub type_: GstQueryType,
 }
 
+impl ::std::fmt::Debug for GstQuery {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstQuery @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstRegistryClass {
     pub parent_class: GstObjectClass,
 }
 
+impl ::std::fmt::Debug for GstRegistryClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstRegistryClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstRegistryPrivate(c_void);
 
+impl ::std::fmt::Debug for GstRegistryPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstRegistryPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstSample(c_void);
 
+impl ::std::fmt::Debug for GstSample {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstSample @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstSegment {
     pub flags: GstSegmentFlags,
@@ -1858,6 +2290,12 @@ pub struct GstSegment {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstSegment {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstSegment @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstStaticCaps {
     pub caps: *mut GstCaps,
@@ -1865,6 +2303,12 @@ pub struct GstStaticCaps {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstStaticCaps {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStaticCaps @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstStaticPadTemplate {
     pub name_template: *const c_char,
@@ -1873,12 +2317,24 @@ pub struct GstStaticPadTemplate {
     pub static_caps: GstStaticCaps,
 }
 
+impl ::std::fmt::Debug for GstStaticPadTemplate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStaticPadTemplate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstStreamClass {
     pub parent_class: GstObjectClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstStreamClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStreamClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstStreamCollectionClass {
     pub parent_class: GstObjectClass,
@@ -1886,37 +2342,85 @@ pub struct GstStreamCollectionClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstStreamCollectionClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStreamCollectionClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstStreamCollectionPrivate(c_void);
 
+impl ::std::fmt::Debug for GstStreamCollectionPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStreamCollectionPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstStreamPrivate(c_void);
 
+impl ::std::fmt::Debug for GstStreamPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStreamPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstStructure {
     pub type_: GType,
     pub name: glib::GQuark,
 }
 
+impl ::std::fmt::Debug for GstStructure {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstStructure @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstSystemClockClass {
     pub parent_class: GstClockClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstSystemClockClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstSystemClockClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstSystemClockPrivate(c_void);
 
+impl ::std::fmt::Debug for GstSystemClockPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstSystemClockPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTagList {
     pub mini_object: GstMiniObject,
 }
 
+impl ::std::fmt::Debug for GstTagList {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagList @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTagSetterInterface {
     pub g_iface: gobject::GTypeInterface,
 }
 
+impl ::std::fmt::Debug for GstTagSetterInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagSetterInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTaskClass {
     pub parent_class: GstObjectClass,
@@ -1924,6 +2428,12 @@ pub struct GstTaskClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTaskClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTaskClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTaskPoolClass {
     pub parent_class: GstObjectClass,
@@ -1934,41 +2444,101 @@ pub struct GstTaskPoolClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTaskPoolClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTaskPoolClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTaskPrivate(c_void);
 
+impl ::std::fmt::Debug for GstTaskPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTaskPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTimedValue {
     pub timestamp: GstClockTime,
     pub value: c_double,
 }
 
+impl ::std::fmt::Debug for GstTimedValue {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTimedValue @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstToc(c_void);
 
+impl ::std::fmt::Debug for GstToc {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstToc @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTocEntry(c_void);
 
+impl ::std::fmt::Debug for GstTocEntry {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTocEntry @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTocSetterInterface {
     pub g_iface: gobject::GTypeInterface,
 }
 
+impl ::std::fmt::Debug for GstTocSetterInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTocSetterInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTracerClass {
     pub parent_class: GstObjectClass,
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTracerClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTracerClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTracerFactoryClass(c_void);
 
+impl ::std::fmt::Debug for GstTracerFactoryClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTracerFactoryClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTracerPrivate(c_void);
 
+impl ::std::fmt::Debug for GstTracerPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTracerPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTracerRecordClass(c_void);
 
+impl ::std::fmt::Debug for GstTracerRecordClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTracerRecordClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTypeFind {
     pub peek: Option<unsafe extern "C" fn(gpointer, i64, c_uint) -> *const u8>,
@@ -1978,9 +2548,21 @@ pub struct GstTypeFind {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTypeFind {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTypeFind @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTypeFindFactoryClass(c_void);
 
+impl ::std::fmt::Debug for GstTypeFindFactoryClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTypeFindFactoryClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstURIHandlerInterface {
     pub parent: gobject::GTypeInterface,
@@ -1990,9 +2572,21 @@ pub struct GstURIHandlerInterface {
     pub set_uri: Option<unsafe extern "C" fn(*mut GstURIHandler, *const c_char, *mut *mut glib::GError) -> gboolean>,
 }
 
+impl ::std::fmt::Debug for GstURIHandlerInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstURIHandlerInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstUri(c_void);
 
+impl ::std::fmt::Debug for GstUri {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstUri @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstValueTable {
     pub type_: GType,
@@ -2002,6 +2596,12 @@ pub struct GstValueTable {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstValueTable {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstValueTable @ {:?}", self as *const _)
+    }
+}
+
 // Classes
 #[repr(C)]
 pub struct GstAllocator {
@@ -2018,6 +2618,24 @@ pub struct GstAllocator {
     pub priv_: *mut GstAllocatorPrivate,
 }
 
+impl ::std::fmt::Debug for GstAllocator {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstAllocator @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("mem_type", &self.mem_type)
+         .field("mem_map", &self.mem_map)
+         .field("mem_unmap", &self.mem_unmap)
+         .field("mem_copy", &self.mem_copy)
+         .field("mem_share", &self.mem_share)
+         .field("mem_is_span", &self.mem_is_span)
+         .field("mem_map_full", &self.mem_map_full)
+         .field("mem_unmap_full", &self.mem_unmap_full)
+         .field("_gst_reserved", &self._gst_reserved)
+         .field("priv_", &self.priv_)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstBin {
     pub element: GstElement,
@@ -2035,9 +2653,35 @@ pub struct GstBin {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstBin {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstBin @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("numchildren", &self.numchildren)
+         .field("children", &self.children)
+         .field("children_cookie", &self.children_cookie)
+         .field("child_bus", &self.child_bus)
+         .field("messages", &self.messages)
+         .field("polling", &self.polling)
+         .field("state_dirty", &self.state_dirty)
+         .field("clock_dirty", &self.clock_dirty)
+         .field("provided_clock", &self.provided_clock)
+         .field("clock_provider", &self.clock_provider)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstBitmask(c_void);
 
+impl ::std::fmt::Debug for GstBitmask {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstBitmask @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstBufferPool {
     pub object: GstObject,
@@ -2046,6 +2690,17 @@ pub struct GstBufferPool {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstBufferPool {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstBufferPool @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("flushing", &self.flushing)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstBus {
     pub object: GstObject,
@@ -2053,6 +2708,16 @@ pub struct GstBus {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstBus {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstBus @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstClock {
     pub object: GstObject,
@@ -2060,6 +2725,16 @@ pub struct GstClock {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstClock {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstClock @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstControlBinding {
     pub parent: GstObject,
@@ -2070,6 +2745,19 @@ pub struct GstControlBinding {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstControlBinding {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstControlBinding @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("name", &self.name)
+         .field("pspec", &self.pspec)
+         .field("object", &self.object)
+         .field("disabled", &self.disabled)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstControlSource {
     pub parent: GstObject,
@@ -2078,6 +2766,17 @@ pub struct GstControlSource {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstControlSource {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstControlSource @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("get_value", &self.get_value)
+         .field("get_value_array", &self.get_value_array)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstDevice {
     pub parent: GstObject,
@@ -2085,6 +2784,16 @@ pub struct GstDevice {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDevice {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstDevice @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceMonitor {
     pub parent: GstObject,
@@ -2092,6 +2801,16 @@ pub struct GstDeviceMonitor {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDeviceMonitor {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstDeviceMonitor @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceProvider {
     pub parent: GstObject,
@@ -2100,15 +2819,44 @@ pub struct GstDeviceProvider {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstDeviceProvider {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstDeviceProvider @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("devices", &self.devices)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstDeviceProviderFactory(c_void);
 
+impl ::std::fmt::Debug for GstDeviceProviderFactory {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDeviceProviderFactory @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDoubleRange(c_void);
 
+impl ::std::fmt::Debug for GstDoubleRange {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDoubleRange @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstDynamicTypeFactory(c_void);
 
+impl ::std::fmt::Debug for GstDynamicTypeFactory {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstDynamicTypeFactory @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstElement {
     pub object: GstObject,
@@ -2135,30 +2883,104 @@ pub struct GstElement {
     pub _gst_reserved: [gpointer; 3],
 }
 
+impl ::std::fmt::Debug for GstElement {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstElement @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("state_lock", &self.state_lock)
+         .field("state_cond", &self.state_cond)
+         .field("state_cookie", &self.state_cookie)
+         .field("target_state", &self.target_state)
+         .field("current_state", &self.current_state)
+         .field("next_state", &self.next_state)
+         .field("pending_state", &self.pending_state)
+         .field("last_return", &self.last_return)
+         .field("bus", &self.bus)
+         .field("clock", &self.clock)
+         .field("base_time", &self.base_time)
+         .field("start_time", &self.start_time)
+         .field("numpads", &self.numpads)
+         .field("pads", &self.pads)
+         .field("numsrcpads", &self.numsrcpads)
+         .field("srcpads", &self.srcpads)
+         .field("numsinkpads", &self.numsinkpads)
+         .field("sinkpads", &self.sinkpads)
+         .field("pads_cookie", &self.pads_cookie)
+         .field("contexts", &self.contexts)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstElementFactory(c_void);
 
+impl ::std::fmt::Debug for GstElementFactory {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstElementFactory @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstFlagSet(c_void);
 
+impl ::std::fmt::Debug for GstFlagSet {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstFlagSet @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstFraction(c_void);
 
+impl ::std::fmt::Debug for GstFraction {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstFraction @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstFractionRange(c_void);
 
+impl ::std::fmt::Debug for GstFractionRange {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstFractionRange @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstGhostPad {
     pub pad: GstProxyPad,
     pub priv_: *mut GstGhostPadPrivate,
 }
 
+impl ::std::fmt::Debug for GstGhostPad {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstGhostPad @ {:?}", self as *const _))
+         .field("pad", &self.pad)
+         .field("priv_", &self.priv_)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstInt64Range(c_void);
 
+impl ::std::fmt::Debug for GstInt64Range {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstInt64Range @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstIntRange(c_void);
 
+impl ::std::fmt::Debug for GstIntRange {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstIntRange @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstObject {
     pub object: gobject::GInitiallyUnowned,
@@ -2172,6 +2994,22 @@ pub struct GstObject {
     pub _gst_reserved: gpointer,
 }
 
+impl ::std::fmt::Debug for GstObject {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstObject @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("lock", &self.lock)
+         .field("name", &self.name)
+         .field("parent", &self.parent)
+         .field("flags", &self.flags)
+         .field("control_bindings", &self.control_bindings)
+         .field("control_rate", &self.control_rate)
+         .field("last_sync", &self.last_sync)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstPad {
     pub object: GstObject,
@@ -2221,6 +3059,58 @@ pub struct GstPad {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPad {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstPad @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("element_private", &self.element_private)
+         .field("padtemplate", &self.padtemplate)
+         .field("direction", &self.direction)
+         .field("stream_rec_lock", &self.stream_rec_lock)
+         .field("task", &self.task)
+         .field("block_cond", &self.block_cond)
+         .field("probes", &self.probes)
+         .field("mode", &self.mode)
+         .field("activatefunc", &self.activatefunc)
+         .field("activatedata", &self.activatedata)
+         .field("activatenotify", &self.activatenotify)
+         .field("activatemodefunc", &self.activatemodefunc)
+         .field("activatemodedata", &self.activatemodedata)
+         .field("activatemodenotify", &self.activatemodenotify)
+         .field("peer", &self.peer)
+         .field("linkfunc", &self.linkfunc)
+         .field("linkdata", &self.linkdata)
+         .field("linknotify", &self.linknotify)
+         .field("unlinkfunc", &self.unlinkfunc)
+         .field("unlinkdata", &self.unlinkdata)
+         .field("unlinknotify", &self.unlinknotify)
+         .field("chainfunc", &self.chainfunc)
+         .field("chaindata", &self.chaindata)
+         .field("chainnotify", &self.chainnotify)
+         .field("chainlistfunc", &self.chainlistfunc)
+         .field("chainlistdata", &self.chainlistdata)
+         .field("chainlistnotify", &self.chainlistnotify)
+         .field("getrangefunc", &self.getrangefunc)
+         .field("getrangedata", &self.getrangedata)
+         .field("getrangenotify", &self.getrangenotify)
+         .field("eventfunc", &self.eventfunc)
+         .field("eventdata", &self.eventdata)
+         .field("eventnotify", &self.eventnotify)
+         .field("offset", &self.offset)
+         .field("queryfunc", &self.queryfunc)
+         .field("querydata", &self.querydata)
+         .field("querynotify", &self.querynotify)
+         .field("iterintlinkfunc", &self.iterintlinkfunc)
+         .field("iterintlinkdata", &self.iterintlinkdata)
+         .field("iterintlinknotify", &self.iterintlinknotify)
+         .field("num_probes", &self.num_probes)
+         .field("num_blocked", &self.num_blocked)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstPadTemplate {
     pub object: GstObject,
@@ -2231,12 +3121,37 @@ pub struct GstPadTemplate {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPadTemplate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstPadTemplate @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("name_template", &self.name_template)
+         .field("direction", &self.direction)
+         .field("presence", &self.presence)
+         .field("caps", &self.caps)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstParamArray(c_void);
 
+impl ::std::fmt::Debug for GstParamArray {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstParamArray @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstParamFraction(c_void);
 
+impl ::std::fmt::Debug for GstParamFraction {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstParamFraction @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPipeline {
     pub bin: GstBin,
@@ -2247,24 +3162,67 @@ pub struct GstPipeline {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstPipeline {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstPipeline @ {:?}", self as *const _))
+         .field("bin", &self.bin)
+         .field("fixed_clock", &self.fixed_clock)
+         .field("stream_time", &self.stream_time)
+         .field("delay", &self.delay)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstPlugin(c_void);
 
+impl ::std::fmt::Debug for GstPlugin {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPlugin @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPluginFeature(c_void);
 
+impl ::std::fmt::Debug for GstPluginFeature {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPluginFeature @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstProxyPad {
     pub pad: GstPad,
     pub priv_: *mut GstProxyPadPrivate,
 }
 
+impl ::std::fmt::Debug for GstProxyPad {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstProxyPad @ {:?}", self as *const _))
+         .field("pad", &self.pad)
+         .field("priv_", &self.priv_)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstRegistry {
     pub object: GstObject,
     pub priv_: *mut GstRegistryPrivate,
 }
 
+impl ::std::fmt::Debug for GstRegistry {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstRegistry @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("priv_", &self.priv_)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstStream {
     pub object: GstObject,
@@ -2273,6 +3231,17 @@ pub struct GstStream {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstStream {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstStream @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("stream_id", &self.stream_id)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstStreamCollection {
     pub object: GstObject,
@@ -2281,6 +3250,17 @@ pub struct GstStreamCollection {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstStreamCollection {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstStreamCollection @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("upstream_id", &self.upstream_id)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstSystemClock {
     pub clock: GstClock,
@@ -2288,6 +3268,16 @@ pub struct GstSystemClock {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstSystemClock {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstSystemClock @ {:?}", self as *const _))
+         .field("clock", &self.clock)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstTask {
     pub object: GstObject,
@@ -2303,6 +3293,24 @@ pub struct GstTask {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTask {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstTask @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("state", &self.state)
+         .field("cond", &self.cond)
+         .field("lock", &self.lock)
+         .field("func", &self.func)
+         .field("user_data", &self.user_data)
+         .field("notify", &self.notify)
+         .field("running", &self.running)
+         .field("thread", &self.thread)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstTaskPool {
     pub object: GstObject,
@@ -2310,6 +3318,16 @@ pub struct GstTaskPool {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTaskPool {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstTaskPool @ {:?}", self as *const _))
+         .field("object", &self.object)
+         .field("pool", &self.pool)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstTracer {
     pub parent: GstObject,
@@ -2317,33 +3335,108 @@ pub struct GstTracer {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTracer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstTracer @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstTracerFactory(c_void);
 
+impl ::std::fmt::Debug for GstTracerFactory {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTracerFactory @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTracerRecord(c_void);
 
+impl ::std::fmt::Debug for GstTracerRecord {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTracerRecord @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTypeFindFactory(c_void);
 
+impl ::std::fmt::Debug for GstTypeFindFactory {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTypeFindFactory @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstValueArray(c_void);
 
+impl ::std::fmt::Debug for GstValueArray {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstValueArray @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstValueList(c_void);
 
+impl ::std::fmt::Debug for GstValueList {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstValueList @ {:?}", self as *const _)
+    }
+}
+
 // Interfaces
 #[repr(C)]
 pub struct GstChildProxy(c_void);
+
+impl ::std::fmt::Debug for GstChildProxy {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstChildProxy @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstPreset(c_void);
+
+impl ::std::fmt::Debug for GstPreset {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstPreset @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTagSetter(c_void);
+
+impl ::std::fmt::Debug for GstTagSetter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagSetter @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTocSetter(c_void);
+
+impl ::std::fmt::Debug for GstTocSetter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTocSetter @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstURIHandler(c_void);
 
+impl ::std::fmt::Debug for GstURIHandler {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstURIHandler @ {:?}", self as *const _)
+    }
+}
+
+
 extern "C" {
 
     //=========================================================================
diff --git a/gstreamer-tag-sys/src/lib.rs b/gstreamer-tag-sys/src/lib.rs
index 0e4c8723d..40c7dc35e 100644
--- a/gstreamer-tag-sys/src/lib.rs
+++ b/gstreamer-tag-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -8,6 +8,7 @@ extern crate libc;
 extern crate glib_sys as glib;
 extern crate gobject_sys as gobject;
 extern crate gstreamer_sys as gst;
+extern crate gstreamer_base_sys as gst_base;
 
 #[allow(unused_imports)]
 use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
@@ -129,9 +130,21 @@ pub struct GstTagDemuxClass {
     pub reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTagDemuxClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagDemuxClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTagDemuxPrivate(c_void);
 
+impl ::std::fmt::Debug for GstTagDemuxPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagDemuxPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTagMuxClass {
     pub parent_class: gst::GstElementClass,
@@ -140,14 +153,32 @@ pub struct GstTagMuxClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTagMuxClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagMuxClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTagMuxPrivate(c_void);
 
+impl ::std::fmt::Debug for GstTagMuxPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagMuxPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstTagXmpWriterInterface {
     pub parent: gobject::GTypeInterface,
 }
 
+impl ::std::fmt::Debug for GstTagXmpWriterInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagXmpWriterInterface @ {:?}", self as *const _)
+    }
+}
+
 // Classes
 #[repr(C)]
 pub struct GstTagDemux {
@@ -156,6 +187,16 @@ pub struct GstTagDemux {
     pub reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTagDemux {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstTagDemux @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("priv_", &self.priv_)
+         .field("reserved", &self.reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstTagMux {
     pub element: gst::GstElement,
@@ -163,10 +204,27 @@ pub struct GstTagMux {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstTagMux {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstTagMux @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 // Interfaces
 #[repr(C)]
 pub struct GstTagXmpWriter(c_void);
 
+impl ::std::fmt::Debug for GstTagXmpWriter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstTagXmpWriter @ {:?}", self as *const _)
+    }
+}
+
+
 extern "C" {
 
     //=========================================================================
diff --git a/gstreamer-video-sys/src/lib.rs b/gstreamer-video-sys/src/lib.rs
index 63f28644c..3aacdc01a 100644
--- a/gstreamer-video-sys/src/lib.rs
+++ b/gstreamer-video-sys/src/lib.rs
@@ -1,4 +1,4 @@
-// This file was generated by gir (94e079d) from gir-files (???)
+// This file was generated by gir (0113735) from gir-files (???)
 // DO NOT EDIT
 
 #![allow(non_camel_case_types, non_upper_case_globals)]
@@ -603,6 +603,12 @@ pub struct GstColorBalanceChannelClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstColorBalanceChannelClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstColorBalanceChannelClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstColorBalanceInterface {
     pub iface: gobject::GTypeInterface,
@@ -614,18 +620,36 @@ pub struct GstColorBalanceInterface {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstColorBalanceInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstColorBalanceInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstNavigationInterface {
     pub iface: gobject::GTypeInterface,
     pub send_event: Option<unsafe extern "C" fn(*mut GstNavigation, *mut gst::GstStructure)>,
 }
 
+impl ::std::fmt::Debug for GstNavigationInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstNavigationInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoAffineTransformationMeta {
     pub meta: gst::GstMeta,
     pub matrix: [c_float; 16],
 }
 
+impl ::std::fmt::Debug for GstVideoAffineTransformationMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoAffineTransformationMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoAlignment {
     pub padding_top: c_uint,
@@ -635,17 +659,41 @@ pub struct GstVideoAlignment {
     pub stride_align: [c_uint; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoAlignment {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoAlignment @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoBufferPoolClass {
     pub parent_class: gst::GstBufferPoolClass,
 }
 
+impl ::std::fmt::Debug for GstVideoBufferPoolClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoBufferPoolClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoBufferPoolPrivate(c_void);
 
+impl ::std::fmt::Debug for GstVideoBufferPoolPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoBufferPoolPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoChromaResample(c_void);
 
+impl ::std::fmt::Debug for GstVideoChromaResample {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoChromaResample @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoCodecFrame {
     pub ref_count: c_int,
@@ -666,6 +714,12 @@ pub struct GstVideoCodecFrame {
     pub padding: [c_void; 20],
 }
 
+impl ::std::fmt::Debug for GstVideoCodecFrame {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoCodecFrame @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoCodecState {
     pub ref_count: c_int,
@@ -676,6 +730,12 @@ pub struct GstVideoCodecState {
     pub padding: [c_void; 19],
 }
 
+impl ::std::fmt::Debug for GstVideoCodecState {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoCodecState @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoColorPrimariesInfo {
     pub primaries: GstVideoColorPrimaries,
@@ -689,6 +749,12 @@ pub struct GstVideoColorPrimariesInfo {
     pub By: c_double,
 }
 
+impl ::std::fmt::Debug for GstVideoColorPrimariesInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoColorPrimariesInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoColorimetry {
     pub range: GstVideoColorRange,
@@ -697,9 +763,21 @@ pub struct GstVideoColorimetry {
     pub primaries: GstVideoColorPrimaries,
 }
 
+impl ::std::fmt::Debug for GstVideoColorimetry {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoColorimetry @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoConverter(c_void);
 
+impl ::std::fmt::Debug for GstVideoConverter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoConverter @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoCropMeta {
     pub meta: gst::GstMeta,
@@ -709,6 +787,12 @@ pub struct GstVideoCropMeta {
     pub height: c_uint,
 }
 
+impl ::std::fmt::Debug for GstVideoCropMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoCropMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoDecoderClass {
     pub element_class: gst::GstElementClass,
@@ -735,17 +819,41 @@ pub struct GstVideoDecoderClass {
     pub padding: [c_void; 14],
 }
 
+impl ::std::fmt::Debug for GstVideoDecoderClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoDecoderClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoDecoderPrivate(c_void);
 
+impl ::std::fmt::Debug for GstVideoDecoderPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoDecoderPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoDirectionInterface {
     pub iface: gobject::GTypeInterface,
 }
 
+impl ::std::fmt::Debug for GstVideoDirectionInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoDirectionInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoDither(c_void);
 
+impl ::std::fmt::Debug for GstVideoDither {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoDither @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoEncoderClass {
     pub element_class: gst::GstElementClass,
@@ -771,9 +879,21 @@ pub struct GstVideoEncoderClass {
     pub _gst_reserved: [gpointer; 16],
 }
 
+impl ::std::fmt::Debug for GstVideoEncoderClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoEncoderClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoEncoderPrivate(c_void);
 
+impl ::std::fmt::Debug for GstVideoEncoderPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoEncoderPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoFilterClass {
     pub parent_class: gst_base::GstBaseTransformClass,
@@ -783,6 +903,12 @@ pub struct GstVideoFilterClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoFilterClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoFilterClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoFormatInfo {
     pub format: GstVideoFormat,
@@ -809,6 +935,12 @@ pub struct GstVideoFormatInfo {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoFormatInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoFormatInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoFrame {
     pub info: GstVideoInfo,
@@ -821,6 +953,12 @@ pub struct GstVideoFrame {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoFrame {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoFrame @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoGLTextureUploadMeta {
     pub meta: gst::GstMeta,
@@ -834,6 +972,12 @@ pub struct GstVideoGLTextureUploadMeta {
     pub user_data_free: gobject::GBoxedFreeFunc,
 }
 
+impl ::std::fmt::Debug for GstVideoGLTextureUploadMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoGLTextureUploadMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoInfo {
     pub finfo: *const GstVideoFormatInfo,
@@ -854,6 +998,12 @@ pub struct GstVideoInfo {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoInfo @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoMeta {
     pub meta: gst::GstMeta,
@@ -870,12 +1020,24 @@ pub struct GstVideoMeta {
     pub unmap: Option<unsafe extern "C" fn(*mut GstVideoMeta, c_uint, *mut gst::GstMapInfo) -> gboolean>,
 }
 
+impl ::std::fmt::Debug for GstVideoMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoMetaTransform {
     pub in_info: *mut GstVideoInfo,
     pub out_info: *mut GstVideoInfo,
 }
 
+impl ::std::fmt::Debug for GstVideoMetaTransform {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoMetaTransform @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoOrientationInterface {
     pub iface: gobject::GTypeInterface,
@@ -889,15 +1051,33 @@ pub struct GstVideoOrientationInterface {
     pub set_vcenter: Option<unsafe extern "C" fn(*mut GstVideoOrientation, c_int) -> gboolean>,
 }
 
+impl ::std::fmt::Debug for GstVideoOrientationInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoOrientationInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoOverlayComposition(c_void);
 
+impl ::std::fmt::Debug for GstVideoOverlayComposition {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoOverlayComposition @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoOverlayCompositionMeta {
     pub meta: gst::GstMeta,
     pub overlay: *mut GstVideoOverlayComposition,
 }
 
+impl ::std::fmt::Debug for GstVideoOverlayCompositionMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoOverlayCompositionMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoOverlayInterface {
     pub iface: gobject::GTypeInterface,
@@ -907,9 +1087,21 @@ pub struct GstVideoOverlayInterface {
     pub set_window_handle: Option<unsafe extern "C" fn(*mut GstVideoOverlay, uintptr_t)>,
 }
 
+impl ::std::fmt::Debug for GstVideoOverlayInterface {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoOverlayInterface @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoOverlayRectangle(c_void);
 
+impl ::std::fmt::Debug for GstVideoOverlayRectangle {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoOverlayRectangle @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoRectangle {
     pub x: c_int,
@@ -918,6 +1110,12 @@ pub struct GstVideoRectangle {
     pub h: c_int,
 }
 
+impl ::std::fmt::Debug for GstVideoRectangle {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoRectangle @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoRegionOfInterestMeta {
     pub meta: gst::GstMeta,
@@ -930,6 +1128,12 @@ pub struct GstVideoRegionOfInterestMeta {
     pub h: c_uint,
 }
 
+impl ::std::fmt::Debug for GstVideoRegionOfInterestMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoRegionOfInterestMeta @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoResampler {
     pub in_size: c_int,
@@ -943,9 +1147,21 @@ pub struct GstVideoResampler {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoResampler {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoResampler @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoScaler(c_void);
 
+impl ::std::fmt::Debug for GstVideoScaler {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoScaler @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoSinkClass {
     pub parent_class: gst_base::GstBaseSinkClass,
@@ -953,9 +1169,21 @@ pub struct GstVideoSinkClass {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoSinkClass {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoSinkClass @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoSinkPrivate(c_void);
 
+impl ::std::fmt::Debug for GstVideoSinkPrivate {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoSinkPrivate @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoTimeCode {
     pub config: GstVideoTimeCodeConfig,
@@ -966,6 +1194,12 @@ pub struct GstVideoTimeCode {
     pub field_count: c_uint,
 }
 
+impl ::std::fmt::Debug for GstVideoTimeCode {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoTimeCode @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoTimeCodeConfig {
     pub fps_n: c_uint,
@@ -974,6 +1208,12 @@ pub struct GstVideoTimeCodeConfig {
     pub latest_daily_jam: *mut glib::GDateTime,
 }
 
+impl ::std::fmt::Debug for GstVideoTimeCodeConfig {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoTimeCodeConfig @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoTimeCodeInterval {
     pub hours: c_uint,
@@ -982,12 +1222,24 @@ pub struct GstVideoTimeCodeInterval {
     pub frames: c_uint,
 }
 
+impl ::std::fmt::Debug for GstVideoTimeCodeInterval {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoTimeCodeInterval @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoTimeCodeMeta {
     pub meta: gst::GstMeta,
     pub tc: GstVideoTimeCode,
 }
 
+impl ::std::fmt::Debug for GstVideoTimeCodeMeta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoTimeCodeMeta @ {:?}", self as *const _)
+    }
+}
+
 // Classes
 #[repr(C)]
 pub struct GstColorBalanceChannel {
@@ -998,12 +1250,33 @@ pub struct GstColorBalanceChannel {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstColorBalanceChannel {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstColorBalanceChannel @ {:?}", self as *const _))
+         .field("parent", &self.parent)
+         .field("label", &self.label)
+         .field("min_value", &self.min_value)
+         .field("max_value", &self.max_value)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoBufferPool {
     pub bufferpool: gst::GstBufferPool,
     pub priv_: *mut GstVideoBufferPoolPrivate,
 }
 
+impl ::std::fmt::Debug for GstVideoBufferPool {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstVideoBufferPool @ {:?}", self as *const _))
+         .field("bufferpool", &self.bufferpool)
+         .field("priv_", &self.priv_)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoDecoder {
     pub element: gst::GstElement,
@@ -1016,6 +1289,22 @@ pub struct GstVideoDecoder {
     pub padding: [c_void; 20],
 }
 
+impl ::std::fmt::Debug for GstVideoDecoder {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstVideoDecoder @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("sinkpad", &self.sinkpad)
+         .field("srcpad", &self.srcpad)
+         .field("stream_lock", &self.stream_lock)
+         .field("input_segment", &self.input_segment)
+         .field("output_segment", &self.output_segment)
+         .field("priv_", &self.priv_)
+         .field("padding",
+                                                  &format!("{:?}", &self.padding as *const _))
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoEncoder {
     pub element: gst::GstElement,
@@ -1028,6 +1317,22 @@ pub struct GstVideoEncoder {
     pub padding: [c_void; 20],
 }
 
+impl ::std::fmt::Debug for GstVideoEncoder {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstVideoEncoder @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("sinkpad", &self.sinkpad)
+         .field("srcpad", &self.srcpad)
+         .field("stream_lock", &self.stream_lock)
+         .field("input_segment", &self.input_segment)
+         .field("output_segment", &self.output_segment)
+         .field("priv_", &self.priv_)
+         .field("padding",
+                                                  &format!("{:?}", &self.padding as *const _))
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoFilter {
     pub element: gst_base::GstBaseTransform,
@@ -1037,9 +1342,27 @@ pub struct GstVideoFilter {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoFilter {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstVideoFilter @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("negotiated", &self.negotiated)
+         .field("in_info", &self.in_info)
+         .field("out_info", &self.out_info)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoMultiviewFlagsSet(c_void);
 
+impl ::std::fmt::Debug for GstVideoMultiviewFlagsSet {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoMultiviewFlagsSet @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoSink {
     pub element: gst_base::GstBaseSink,
@@ -1049,18 +1372,65 @@ pub struct GstVideoSink {
     pub _gst_reserved: [gpointer; 4],
 }
 
+impl ::std::fmt::Debug for GstVideoSink {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct(&format!("GstVideoSink @ {:?}", self as *const _))
+         .field("element", &self.element)
+         .field("width", &self.width)
+         .field("height", &self.height)
+         .field("priv_", &self.priv_)
+         .field("_gst_reserved", &self._gst_reserved)
+         .finish()
+    }
+}
+
 // Interfaces
 #[repr(C)]
 pub struct GstColorBalance(c_void);
+
+impl ::std::fmt::Debug for GstColorBalance {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstColorBalance @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstNavigation(c_void);
+
+impl ::std::fmt::Debug for GstNavigation {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstNavigation @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoDirection(c_void);
+
+impl ::std::fmt::Debug for GstVideoDirection {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoDirection @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoOrientation(c_void);
+
+impl ::std::fmt::Debug for GstVideoOrientation {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoOrientation @ {:?}", self as *const _)
+    }
+}
+
 #[repr(C)]
 pub struct GstVideoOverlay(c_void);
 
+impl ::std::fmt::Debug for GstVideoOverlay {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "GstVideoOverlay @ {:?}", self as *const _)
+    }
+}
+
+
 extern "C" {
 
     //=========================================================================