regen

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" {
 
     //=========================================================================

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" {
 
     //=========================================================================

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" {
 
     //=========================================================================

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"

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" {
 
     //=========================================================================

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" {
 
     //=========================================================================

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" {
 
     //=========================================================================

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" {
 
     //=========================================================================

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" {
 
     //=========================================================================