diff --git a/gir b/gir index 011373584..81a781f2e 160000 --- a/gir +++ b/gir @@ -1 +1 @@ -Subproject commit 01137358493a9e19382045c84a141273f7e29b46 +Subproject commit 81a781f2e852b0d2f58b3cf3da002e1ef5ed5bce diff --git a/gstreamer-app-sys/src/lib.rs b/gstreamer-app-sys/src/lib.rs index a0676f618..1437177b2 100644 --- a/gstreamer-app-sys/src/lib.rs +++ b/gstreamer-app-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; extern crate glib_sys as glib; @@ -24,6 +24,7 @@ pub const GST_APP_STREAM_TYPE_RANDOM_ACCESS: GstAppStreamType = 2; // Records #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAppSinkCallbacks { pub eos: Option, pub new_preroll: Option gst::GstFlowReturn>, @@ -33,11 +34,16 @@ pub struct GstAppSinkCallbacks { impl ::std::fmt::Debug for GstAppSinkCallbacks { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAppSinkCallbacks @ {:?}", self as *const _) + f.debug_struct(&format!("GstAppSinkCallbacks @ {:?}", self as *const _)) + .field("eos", &self.eos) + .field("new_preroll", &self.new_preroll) + .field("new_sample", &self.new_sample) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAppSinkClass { pub basesink_class: gst_base::GstBaseSinkClass, pub eos: Option, @@ -52,7 +58,16 @@ pub struct GstAppSinkClass { impl ::std::fmt::Debug for GstAppSinkClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAppSinkClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAppSinkClass @ {:?}", self as *const _)) + .field("basesink_class", &self.basesink_class) + .field("eos", &self.eos) + .field("new_preroll", &self.new_preroll) + .field("new_sample", &self.new_sample) + .field("pull_preroll", &self.pull_preroll) + .field("pull_sample", &self.pull_sample) + .field("try_pull_preroll", &self.try_pull_preroll) + .field("try_pull_sample", &self.try_pull_sample) + .finish() } } @@ -61,11 +76,13 @@ 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 _) + f.debug_struct(&format!("GstAppSinkPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAppSrcCallbacks { pub need_data: Option, pub enough_data: Option, @@ -75,11 +92,16 @@ pub struct GstAppSrcCallbacks { impl ::std::fmt::Debug for GstAppSrcCallbacks { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAppSrcCallbacks @ {:?}", self as *const _) + f.debug_struct(&format!("GstAppSrcCallbacks @ {:?}", self as *const _)) + .field("need_data", &self.need_data) + .field("enough_data", &self.enough_data) + .field("seek_data", &self.seek_data) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAppSrcClass { pub basesrc_class: gst_base::GstBaseSrcClass, pub need_data: Option, @@ -93,7 +115,15 @@ pub struct GstAppSrcClass { impl ::std::fmt::Debug for GstAppSrcClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAppSrcClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAppSrcClass @ {:?}", self as *const _)) + .field("basesrc_class", &self.basesrc_class) + .field("need_data", &self.need_data) + .field("enough_data", &self.enough_data) + .field("seek_data", &self.seek_data) + .field("push_buffer", &self.push_buffer) + .field("end_of_stream", &self.end_of_stream) + .field("push_sample", &self.push_sample) + .finish() } } @@ -102,12 +132,14 @@ 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 _) + f.debug_struct(&format!("GstAppSrcPrivate @ {:?}", self as *const _)) + .finish() } } // Classes #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAppSink { pub basesink: gst_base::GstBaseSink, pub priv_: *mut GstAppSinkPrivate, @@ -118,13 +150,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstAppSrc { pub basesrc: gst_base::GstBaseSrc, pub priv_: *mut GstAppSrcPrivate, @@ -135,8 +166,6 @@ 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() } } diff --git a/gstreamer-audio-sys/src/lib.rs b/gstreamer-audio-sys/src/lib.rs index c579643a2..721ce4a7d 100644 --- a/gstreamer-audio-sys/src/lib.rs +++ b/gstreamer-audio-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; #[macro_use] extern crate bitflags; @@ -304,6 +304,7 @@ pub type GstAudioRingBufferCallback = Option *mut GstAudioRingBuffer>, @@ -313,7 +314,11 @@ pub struct GstAudioBaseSinkClass { impl ::std::fmt::Debug for GstAudioBaseSinkClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioBaseSinkClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioBaseSinkClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("create_ringbuffer", &self.create_ringbuffer) + .field("payload", &self.payload) + .finish() } } @@ -322,11 +327,13 @@ 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 _) + f.debug_struct(&format!("GstAudioBaseSinkPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioBaseSrcClass { pub parent_class: gst_base::GstPushSrcClass, pub create_ringbuffer: Option *mut GstAudioRingBuffer>, @@ -335,7 +342,10 @@ pub struct GstAudioBaseSrcClass { impl ::std::fmt::Debug for GstAudioBaseSrcClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioBaseSrcClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioBaseSrcClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("create_ringbuffer", &self.create_ringbuffer) + .finish() } } @@ -344,11 +354,13 @@ 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 _) + f.debug_struct(&format!("GstAudioBaseSrcPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioCdSrcClass { pub pushsrc_class: gst_base::GstPushSrcClass, pub open: Option gboolean>, @@ -359,7 +371,12 @@ pub struct GstAudioCdSrcClass { impl ::std::fmt::Debug for GstAudioCdSrcClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioCdSrcClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioCdSrcClass @ {:?}", self as *const _)) + .field("pushsrc_class", &self.pushsrc_class) + .field("open", &self.open) + .field("close", &self.close) + .field("read_sector", &self.read_sector) + .finish() } } @@ -368,11 +385,13 @@ 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 _) + f.debug_struct(&format!("GstAudioCdSrcPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioCdSrcTrack { pub is_audio: gboolean, pub num: c_uint, @@ -385,7 +404,13 @@ pub struct GstAudioCdSrcTrack { impl ::std::fmt::Debug for GstAudioCdSrcTrack { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioCdSrcTrack @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioCdSrcTrack @ {:?}", self as *const _)) + .field("is_audio", &self.is_audio) + .field("num", &self.num) + .field("start", &self.start) + .field("end", &self.end) + .field("tags", &self.tags) + .finish() } } @@ -394,11 +419,13 @@ 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 _) + f.debug_struct(&format!("GstAudioChannelMixer @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioClippingMeta { pub meta: gst::GstMeta, pub format: gst::GstFormat, @@ -408,11 +435,17 @@ pub struct GstAudioClippingMeta { impl ::std::fmt::Debug for GstAudioClippingMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioClippingMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioClippingMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("format", &self.format) + .field("start", &self.start) + .field("end", &self.end) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioClockClass { pub parent_class: gst::GstSystemClockClass, pub _gst_reserved: [gpointer; 4], @@ -420,7 +453,9 @@ pub struct GstAudioClockClass { impl ::std::fmt::Debug for GstAudioClockClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioClockClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioClockClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -429,11 +464,13 @@ 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 _) + f.debug_struct(&format!("GstAudioConverter @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioDecoderClass { pub element_class: gst::GstElementClass, pub start: Option gboolean>, @@ -459,7 +496,27 @@ pub struct GstAudioDecoderClass { impl ::std::fmt::Debug for GstAudioDecoderClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioDecoderClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioDecoderClass @ {:?}", self as *const _)) + .field("element_class", &self.element_class) + .field("start", &self.start) + .field("stop", &self.stop) + .field("set_format", &self.set_format) + .field("parse", &self.parse) + .field("handle_frame", &self.handle_frame) + .field("flush", &self.flush) + .field("pre_push", &self.pre_push) + .field("sink_event", &self.sink_event) + .field("src_event", &self.src_event) + .field("open", &self.open) + .field("close", &self.close) + .field("negotiate", &self.negotiate) + .field("decide_allocation", &self.decide_allocation) + .field("propose_allocation", &self.propose_allocation) + .field("sink_query", &self.sink_query) + .field("src_query", &self.src_query) + .field("getcaps", &self.getcaps) + .field("transform_meta", &self.transform_meta) + .finish() } } @@ -468,11 +525,13 @@ 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 _) + f.debug_struct(&format!("GstAudioDecoderPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioDownmixMeta { pub meta: gst::GstMeta, pub from_position: *mut GstAudioChannelPosition, @@ -484,11 +543,19 @@ pub struct GstAudioDownmixMeta { impl ::std::fmt::Debug for GstAudioDownmixMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioDownmixMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioDownmixMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("from_position", &self.from_position) + .field("to_position", &self.to_position) + .field("from_channels", &self.from_channels) + .field("to_channels", &self.to_channels) + .field("matrix", &self.matrix) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioEncoderClass { pub element_class: gst::GstElementClass, pub start: Option gboolean>, @@ -513,7 +580,26 @@ pub struct GstAudioEncoderClass { impl ::std::fmt::Debug for GstAudioEncoderClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioEncoderClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioEncoderClass @ {:?}", self as *const _)) + .field("element_class", &self.element_class) + .field("start", &self.start) + .field("stop", &self.stop) + .field("set_format", &self.set_format) + .field("handle_frame", &self.handle_frame) + .field("flush", &self.flush) + .field("pre_push", &self.pre_push) + .field("sink_event", &self.sink_event) + .field("src_event", &self.src_event) + .field("getcaps", &self.getcaps) + .field("open", &self.open) + .field("close", &self.close) + .field("negotiate", &self.negotiate) + .field("decide_allocation", &self.decide_allocation) + .field("propose_allocation", &self.propose_allocation) + .field("transform_meta", &self.transform_meta) + .field("sink_query", &self.sink_query) + .field("src_query", &self.src_query) + .finish() } } @@ -522,11 +608,13 @@ 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 _) + f.debug_struct(&format!("GstAudioEncoderPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioFilterClass { pub basetransformclass: gst_base::GstBaseTransformClass, pub setup: Option gboolean>, @@ -535,11 +623,15 @@ pub struct GstAudioFilterClass { impl ::std::fmt::Debug for GstAudioFilterClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioFilterClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioFilterClass @ {:?}", self as *const _)) + .field("basetransformclass", &self.basetransformclass) + .field("setup", &self.setup) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioFormatInfo { pub format: GstAudioFormat, pub name: *const c_char, @@ -557,11 +649,24 @@ pub struct GstAudioFormatInfo { impl ::std::fmt::Debug for GstAudioFormatInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioFormatInfo @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioFormatInfo @ {:?}", self as *const _)) + .field("format", &self.format) + .field("name", &self.name) + .field("description", &self.description) + .field("flags", &self.flags) + .field("endianness", &self.endianness) + .field("width", &self.width) + .field("depth", &self.depth) + .field("silence", &self.silence) + .field("unpack_format", &self.unpack_format) + .field("unpack_func", &self.unpack_func) + .field("pack_func", &self.pack_func) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioInfo { pub finfo: *const GstAudioFormatInfo, pub flags: GstAudioFlags, @@ -575,7 +680,14 @@ pub struct GstAudioInfo { impl ::std::fmt::Debug for GstAudioInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioInfo @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioInfo @ {:?}", self as *const _)) + .field("finfo", &self.finfo) + .field("flags", &self.flags) + .field("layout", &self.layout) + .field("rate", &self.rate) + .field("channels", &self.channels) + .field("bpf", &self.bpf) + .finish() } } @@ -584,7 +696,8 @@ 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 _) + f.debug_struct(&format!("GstAudioQuantize @ {:?}", self as *const _)) + .finish() } } @@ -593,11 +706,13 @@ 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 _) + f.debug_struct(&format!("GstAudioResampler @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioRingBufferClass { pub parent_class: gst::GstObjectClass, pub open_device: Option gboolean>, @@ -617,11 +732,26 @@ pub struct GstAudioRingBufferClass { impl ::std::fmt::Debug for GstAudioRingBufferClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioRingBufferClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioRingBufferClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("open_device", &self.open_device) + .field("acquire", &self.acquire) + .field("release", &self.release) + .field("close_device", &self.close_device) + .field("start", &self.start) + .field("pause", &self.pause) + .field("resume", &self.resume) + .field("stop", &self.stop) + .field("delay", &self.delay) + .field("activate", &self.activate) + .field("commit", &self.commit) + .field("clear_all", &self.clear_all) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioRingBufferSpec { pub caps: *mut gst::GstCaps, pub type_: GstAudioRingBufferFormatType, @@ -636,11 +766,21 @@ pub struct GstAudioRingBufferSpec { impl ::std::fmt::Debug for GstAudioRingBufferSpec { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioRingBufferSpec @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioRingBufferSpec @ {:?}", self as *const _)) + .field("caps", &self.caps) + .field("type_", &self.type_) + .field("info", &self.info) + .field("latency_time", &self.latency_time) + .field("buffer_time", &self.buffer_time) + .field("segsize", &self.segsize) + .field("segtotal", &self.segtotal) + .field("seglatency", &self.seglatency) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioSinkClass { pub parent_class: GstAudioBaseSinkClass, pub open: Option gboolean>, @@ -655,11 +795,21 @@ pub struct GstAudioSinkClass { impl ::std::fmt::Debug for GstAudioSinkClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioSinkClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioSinkClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("open", &self.open) + .field("prepare", &self.prepare) + .field("unprepare", &self.unprepare) + .field("close", &self.close) + .field("write", &self.write) + .field("delay", &self.delay) + .field("reset", &self.reset) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioSrcClass { pub parent_class: GstAudioBaseSrcClass, pub open: Option gboolean>, @@ -674,23 +824,36 @@ pub struct GstAudioSrcClass { impl ::std::fmt::Debug for GstAudioSrcClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioSrcClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioSrcClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("open", &self.open) + .field("prepare", &self.prepare) + .field("unprepare", &self.unprepare) + .field("close", &self.close) + .field("read", &self.read) + .field("delay", &self.delay) + .field("reset", &self.reset) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstStreamVolumeInterface @ {:?}", self as *const _)) + .field("iface", &self.iface) + .finish() } } // Classes #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioBaseSink { pub element: gst_base::GstBaseSink, pub ringbuffer: *mut GstAudioRingBuffer, @@ -713,13 +876,12 @@ impl ::std::fmt::Debug for GstAudioBaseSink { .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)] +#[derive(Copy, Clone)] pub struct GstAudioBaseSrc { pub element: gst_base::GstPushSrc, pub ringbuffer: *mut GstAudioRingBuffer, @@ -740,13 +902,12 @@ impl ::std::fmt::Debug for GstAudioBaseSrc { .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)] +#[derive(Copy, Clone)] pub struct GstAudioCdSrc { pub pushsrc: gst_base::GstPushSrc, pub tags: *mut gst::GstTagList, @@ -760,14 +921,12 @@ impl ::std::fmt::Debug for GstAudioCdSrc { 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)] +#[derive(Copy, Clone)] pub struct GstAudioClock { pub clock: gst::GstSystemClock, pub func: GstAudioClockGetTimeFunc, @@ -785,14 +944,12 @@ impl ::std::fmt::Debug for GstAudioClock { .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)] +#[derive(Copy, Clone)] pub struct GstAudioDecoder { pub element: gst::GstElement, pub sinkpad: *mut gst::GstPad, @@ -813,13 +970,12 @@ impl ::std::fmt::Debug for GstAudioDecoder { .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)] +#[derive(Copy, Clone)] pub struct GstAudioEncoder { pub element: gst::GstElement, pub sinkpad: *mut gst::GstPad, @@ -840,13 +996,12 @@ impl ::std::fmt::Debug for GstAudioEncoder { .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)] +#[derive(Copy, Clone)] pub struct GstAudioFilter { pub basetransform: gst_base::GstBaseTransform, pub info: GstAudioInfo, @@ -858,12 +1013,12 @@ impl ::std::fmt::Debug for GstAudioFilter { 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)] +#[derive(Copy, Clone)] pub struct GstAudioRingBuffer { pub object: gst::GstObject, pub cond: glib::GCond, @@ -907,20 +1062,12 @@ impl ::std::fmt::Debug for GstAudioRingBuffer { .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)] +#[derive(Copy, Clone)] pub struct GstAudioSink { pub element: GstAudioBaseSink, pub thread: *mut glib::GThread, @@ -931,13 +1078,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstAudioSrc { pub element: GstAudioBaseSrc, pub thread: *mut glib::GThread, @@ -948,8 +1094,6 @@ 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() } } diff --git a/gstreamer-base-sys/src/lib.rs b/gstreamer-base-sys/src/lib.rs index bbb6845f3..89d4c1cc0 100644 --- a/gstreamer-base-sys/src/lib.rs +++ b/gstreamer-base-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; #[macro_use] extern crate bitflags; @@ -70,6 +70,22 @@ pub const GST_COLLECT_PADS_STATE_NEW_SEGMENT: GstCollectPadsStateFlags = GstColl pub const GST_COLLECT_PADS_STATE_WAITING: GstCollectPadsStateFlags = GstCollectPadsStateFlags::WAITING; pub const GST_COLLECT_PADS_STATE_LOCKED: GstCollectPadsStateFlags = GstCollectPadsStateFlags::LOCKED; +// Unions +#[repr(C)] +#[derive(Copy, Clone)] +pub union GstCollectData_ABI { + pub abi: GstCollectData_ABI_abi, + pub _gst_reserved: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstCollectData_ABI { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstCollectData_ABI @ {:?}", self as *const _)) + .field("abi", unsafe { &self.abi }) + .finish() + } +} + // Callbacks pub type GstCollectDataDestroyNotify = Option; pub type GstCollectPadsBufferFunction = Option gst::GstFlowReturn>; @@ -90,11 +106,13 @@ 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 _) + f.debug_struct(&format!("GstAdapterClass @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBaseParseClass { pub parent_class: gst::GstElementClass, pub start: Option gboolean>, @@ -114,11 +132,26 @@ pub struct GstBaseParseClass { impl ::std::fmt::Debug for GstBaseParseClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBaseParseClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstBaseParseClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("start", &self.start) + .field("stop", &self.stop) + .field("set_sink_caps", &self.set_sink_caps) + .field("handle_frame", &self.handle_frame) + .field("pre_push_frame", &self.pre_push_frame) + .field("convert", &self.convert) + .field("sink_event", &self.sink_event) + .field("src_event", &self.src_event) + .field("get_sink_caps", &self.get_sink_caps) + .field("detect", &self.detect) + .field("sink_query", &self.sink_query) + .field("src_query", &self.src_query) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBaseParseFrame { pub buffer: *mut gst::GstBuffer, pub out_buffer: *mut gst::GstBuffer, @@ -133,7 +166,13 @@ pub struct GstBaseParseFrame { impl ::std::fmt::Debug for GstBaseParseFrame { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBaseParseFrame @ {:?}", self as *const _) + f.debug_struct(&format!("GstBaseParseFrame @ {:?}", self as *const _)) + .field("buffer", &self.buffer) + .field("out_buffer", &self.out_buffer) + .field("flags", &self.flags) + .field("offset", &self.offset) + .field("overhead", &self.overhead) + .finish() } } @@ -142,11 +181,13 @@ 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 _) + f.debug_struct(&format!("GstBaseParsePrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBaseSinkClass { pub parent_class: gst::GstElementClass, pub get_caps: Option *mut gst::GstCaps>, @@ -172,7 +213,27 @@ pub struct GstBaseSinkClass { impl ::std::fmt::Debug for GstBaseSinkClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBaseSinkClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstBaseSinkClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("get_caps", &self.get_caps) + .field("set_caps", &self.set_caps) + .field("fixate", &self.fixate) + .field("activate_pull", &self.activate_pull) + .field("get_times", &self.get_times) + .field("propose_allocation", &self.propose_allocation) + .field("start", &self.start) + .field("stop", &self.stop) + .field("unlock", &self.unlock) + .field("unlock_stop", &self.unlock_stop) + .field("query", &self.query) + .field("event", &self.event) + .field("wait_event", &self.wait_event) + .field("prepare", &self.prepare) + .field("prepare_list", &self.prepare_list) + .field("preroll", &self.preroll) + .field("render", &self.render) + .field("render_list", &self.render_list) + .finish() } } @@ -181,11 +242,13 @@ 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 _) + f.debug_struct(&format!("GstBaseSinkPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBaseSrcClass { pub parent_class: gst::GstElementClass, pub get_caps: Option *mut gst::GstCaps>, @@ -212,7 +275,28 @@ pub struct GstBaseSrcClass { impl ::std::fmt::Debug for GstBaseSrcClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBaseSrcClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstBaseSrcClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("get_caps", &self.get_caps) + .field("negotiate", &self.negotiate) + .field("fixate", &self.fixate) + .field("set_caps", &self.set_caps) + .field("decide_allocation", &self.decide_allocation) + .field("start", &self.start) + .field("stop", &self.stop) + .field("get_times", &self.get_times) + .field("get_size", &self.get_size) + .field("is_seekable", &self.is_seekable) + .field("prepare_seek_segment", &self.prepare_seek_segment) + .field("do_seek", &self.do_seek) + .field("unlock", &self.unlock) + .field("unlock_stop", &self.unlock_stop) + .field("query", &self.query) + .field("event", &self.event) + .field("create", &self.create) + .field("alloc", &self.alloc) + .field("fill", &self.fill) + .finish() } } @@ -221,11 +305,13 @@ 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 _) + f.debug_struct(&format!("GstBaseSrcPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBaseTransformClass { pub parent_class: gst::GstElementClass, pub passthrough_on_same_caps: gboolean, @@ -257,7 +343,33 @@ pub struct GstBaseTransformClass { impl ::std::fmt::Debug for GstBaseTransformClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBaseTransformClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstBaseTransformClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("passthrough_on_same_caps", &self.passthrough_on_same_caps) + .field("transform_ip_on_passthrough", &self.transform_ip_on_passthrough) + .field("transform_caps", &self.transform_caps) + .field("fixate_caps", &self.fixate_caps) + .field("accept_caps", &self.accept_caps) + .field("set_caps", &self.set_caps) + .field("query", &self.query) + .field("decide_allocation", &self.decide_allocation) + .field("filter_meta", &self.filter_meta) + .field("propose_allocation", &self.propose_allocation) + .field("transform_size", &self.transform_size) + .field("get_unit_size", &self.get_unit_size) + .field("start", &self.start) + .field("stop", &self.stop) + .field("sink_event", &self.sink_event) + .field("src_event", &self.src_event) + .field("prepare_output_buffer", &self.prepare_output_buffer) + .field("copy_metadata", &self.copy_metadata) + .field("transform_meta", &self.transform_meta) + .field("before_transform", &self.before_transform) + .field("transform", &self.transform) + .field("transform_ip", &self.transform_ip) + .field("submit_input_buffer", &self.submit_input_buffer) + .field("generate_output", &self.generate_output) + .finish() } } @@ -266,11 +378,13 @@ 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 _) + f.debug_struct(&format!("GstBaseTransformPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBitReader { pub data: *mut u8, pub size: c_uint, @@ -281,11 +395,17 @@ pub struct GstBitReader { impl ::std::fmt::Debug for GstBitReader { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBitReader @ {:?}", self as *const _) + f.debug_struct(&format!("GstBitReader @ {:?}", self as *const _)) + .field("data", &self.data) + .field("size", &self.size) + .field("byte", &self.byte) + .field("bit", &self.bit) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstByteReader { pub data: *mut u8, pub size: c_uint, @@ -295,11 +415,16 @@ pub struct GstByteReader { impl ::std::fmt::Debug for GstByteReader { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstByteReader @ {:?}", self as *const _) + f.debug_struct(&format!("GstByteReader @ {:?}", self as *const _)) + .field("data", &self.data) + .field("size", &self.size) + .field("byte", &self.byte) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstByteWriter { pub parent: GstByteReader, pub alloc_size: c_uint, @@ -310,11 +435,17 @@ pub struct GstByteWriter { impl ::std::fmt::Debug for GstByteWriter { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstByteWriter @ {:?}", self as *const _) + f.debug_struct(&format!("GstByteWriter @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("alloc_size", &self.alloc_size) + .field("fixed", &self.fixed) + .field("owned", &self.owned) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstCollectData { pub collect: *mut GstCollectPads, pub pad: *mut gst::GstPad, @@ -323,12 +454,19 @@ pub struct GstCollectData { pub segment: gst::GstSegment, pub state: GstCollectPadsStateFlags, pub priv_: *mut GstCollectDataPrivate, - pub _gst_reserved: [gpointer; 4], + pub ABI: GstCollectData_ABI, } impl ::std::fmt::Debug for GstCollectData { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstCollectData @ {:?}", self as *const _) + f.debug_struct(&format!("GstCollectData @ {:?}", self as *const _)) + .field("collect", &self.collect) + .field("pad", &self.pad) + .field("buffer", &self.buffer) + .field("pos", &self.pos) + .field("segment", &self.segment) + .field("ABI", &self.ABI) + .finish() } } @@ -337,11 +475,27 @@ 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 _) + f.debug_struct(&format!("GstCollectDataPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] +pub struct GstCollectData_ABI_abi { + pub dts: i64, +} + +impl ::std::fmt::Debug for GstCollectData_ABI_abi { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstCollectData_ABI_abi @ {:?}", self as *const _)) + .field("dts", &self.dts) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] pub struct GstCollectPadsClass { pub parent_class: gst::GstObjectClass, pub _gst_reserved: [gpointer; 4], @@ -349,7 +503,9 @@ pub struct GstCollectPadsClass { impl ::std::fmt::Debug for GstCollectPadsClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstCollectPadsClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstCollectPadsClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -358,11 +514,13 @@ 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 _) + f.debug_struct(&format!("GstCollectPadsPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDataQueueClass { pub parent_class: gobject::GObjectClass, pub empty: Option, @@ -372,11 +530,17 @@ pub struct GstDataQueueClass { impl ::std::fmt::Debug for GstDataQueueClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstDataQueueClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstDataQueueClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("empty", &self.empty) + .field("full", &self.full) + .field("_gst_reserved", &self._gst_reserved) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDataQueueItem { pub object: *mut gst::GstMiniObject, pub size: c_uint, @@ -388,7 +552,13 @@ pub struct GstDataQueueItem { impl ::std::fmt::Debug for GstDataQueueItem { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstDataQueueItem @ {:?}", self as *const _) + f.debug_struct(&format!("GstDataQueueItem @ {:?}", self as *const _)) + .field("object", &self.object) + .field("size", &self.size) + .field("duration", &self.duration) + .field("visible", &self.visible) + .field("destroy", &self.destroy) + .finish() } } @@ -397,11 +567,13 @@ 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 _) + f.debug_struct(&format!("GstDataQueuePrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDataQueueSize { pub visible: c_uint, pub bytes: c_uint, @@ -410,7 +582,11 @@ pub struct GstDataQueueSize { impl ::std::fmt::Debug for GstDataQueueSize { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstDataQueueSize @ {:?}", self as *const _) + f.debug_struct(&format!("GstDataQueueSize @ {:?}", self as *const _)) + .field("visible", &self.visible) + .field("bytes", &self.bytes) + .field("time", &self.time) + .finish() } } @@ -419,11 +595,13 @@ 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 _) + f.debug_struct(&format!("GstFlowCombiner @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPushSrcClass { pub parent_class: GstBaseSrcClass, pub create: Option gst::GstFlowReturn>, @@ -434,7 +612,12 @@ pub struct GstPushSrcClass { impl ::std::fmt::Debug for GstPushSrcClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPushSrcClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstPushSrcClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("create", &self.create) + .field("alloc", &self.alloc) + .field("fill", &self.fill) + .finish() } } @@ -443,7 +626,8 @@ 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 _) + f.debug_struct(&format!("GstQueueArray @ {:?}", self as *const _)) + .finish() } } @@ -453,11 +637,13 @@ 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 _) + f.debug_struct(&format!("GstAdapter @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBaseParse { pub element: gst::GstElement, pub sinkpad: *mut gst::GstPad, @@ -476,13 +662,12 @@ impl ::std::fmt::Debug for GstBaseParse { .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)] +#[derive(Copy, Clone)] pub struct GstBaseSink { pub element: gst::GstElement, pub sinkpad: *mut gst::GstPad, @@ -524,18 +709,12 @@ impl ::std::fmt::Debug for GstBaseSink { .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)] +#[derive(Copy, Clone)] pub struct GstBaseSrc { pub element: gst::GstElement, pub srcpad: *mut gst::GstPad, @@ -579,12 +758,12 @@ impl ::std::fmt::Debug for GstBaseSrc { .field("running", &self.running) .field("pending_seek", &self.pending_seek) .field("priv_", &self.priv_) - .field("_gst_reserved", &self._gst_reserved) .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBaseTransform { pub element: gst::GstElement, pub sinkpad: *mut gst::GstPad, @@ -605,13 +784,12 @@ impl ::std::fmt::Debug for GstBaseTransform { .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)] +#[derive(Copy, Clone)] pub struct GstCollectPads { pub object: gst::GstObject, pub data: *mut glib::GSList, @@ -625,14 +803,12 @@ impl ::std::fmt::Debug for GstCollectPads { 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)] +#[derive(Copy, Clone)] pub struct GstDataQueue { pub object: gobject::GObject, pub priv_: *mut GstDataQueuePrivate, @@ -643,13 +819,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstPushSrc { pub parent: GstBaseSrc, pub _gst_reserved: [gpointer; 4], @@ -659,7 +834,6 @@ 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() } } diff --git a/gstreamer-mpegts-sys/src/lib.rs b/gstreamer-mpegts-sys/src/lib.rs index 4be11a4f2..e1281d9b6 100644 --- a/gstreamer-mpegts-sys/src/lib.rs +++ b/gstreamer-mpegts-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; extern crate glib_sys as glib; @@ -575,6 +575,7 @@ pub type GstMpegtsPacketizeFunc = Option ::std::fmt::Result { - write!(f, "GstMpegtsAtscEIT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscEIT @ {:?}", self as *const _)) + .field("source_id", &self.source_id) + .field("protocol_version", &self.protocol_version) + .field("events", &self.events) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscEITEvent { pub event_id: u16, pub start_time: u32, @@ -599,11 +605,19 @@ pub struct GstMpegtsAtscEITEvent { impl ::std::fmt::Debug for GstMpegtsAtscEITEvent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscEITEvent @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscEITEvent @ {:?}", self as *const _)) + .field("event_id", &self.event_id) + .field("start_time", &self.start_time) + .field("etm_location", &self.etm_location) + .field("length_in_seconds", &self.length_in_seconds) + .field("titles", &self.titles) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscETT { pub ett_table_id_extension: u16, pub protocol_version: u16, @@ -613,11 +627,17 @@ pub struct GstMpegtsAtscETT { impl ::std::fmt::Debug for GstMpegtsAtscETT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscETT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscETT @ {:?}", self as *const _)) + .field("ett_table_id_extension", &self.ett_table_id_extension) + .field("protocol_version", &self.protocol_version) + .field("etm_id", &self.etm_id) + .field("messages", &self.messages) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscMGT { pub protocol_version: u8, pub tables_defined: u16, @@ -627,11 +647,17 @@ pub struct GstMpegtsAtscMGT { impl ::std::fmt::Debug for GstMpegtsAtscMGT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscMGT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscMGT @ {:?}", self as *const _)) + .field("protocol_version", &self.protocol_version) + .field("tables_defined", &self.tables_defined) + .field("tables", &self.tables) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscMGTTable { pub table_type: u16, pub pid: u16, @@ -642,11 +668,18 @@ pub struct GstMpegtsAtscMGTTable { impl ::std::fmt::Debug for GstMpegtsAtscMGTTable { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscMGTTable @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscMGTTable @ {:?}", self as *const _)) + .field("table_type", &self.table_type) + .field("pid", &self.pid) + .field("version_number", &self.version_number) + .field("number_bytes", &self.number_bytes) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscMultString { pub iso_639_langcode: [c_char; 4], pub segments: *mut glib::GPtrArray, @@ -654,11 +687,15 @@ pub struct GstMpegtsAtscMultString { impl ::std::fmt::Debug for GstMpegtsAtscMultString { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscMultString @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscMultString @ {:?}", self as *const _)) + .field("iso_639_langcode", &self.iso_639_langcode) + .field("segments", &self.segments) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscSTT { pub protocol_version: u8, pub system_time: u32, @@ -672,11 +709,21 @@ pub struct GstMpegtsAtscSTT { impl ::std::fmt::Debug for GstMpegtsAtscSTT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscSTT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscSTT @ {:?}", self as *const _)) + .field("protocol_version", &self.protocol_version) + .field("system_time", &self.system_time) + .field("gps_utc_offset", &self.gps_utc_offset) + .field("ds_status", &self.ds_status) + .field("ds_dayofmonth", &self.ds_dayofmonth) + .field("ds_hour", &self.ds_hour) + .field("descriptors", &self.descriptors) + .field("utc_datetime", &self.utc_datetime) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscStringSegment { pub compression_type: u8, pub mode: u8, @@ -687,11 +734,18 @@ pub struct GstMpegtsAtscStringSegment { impl ::std::fmt::Debug for GstMpegtsAtscStringSegment { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscStringSegment @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscStringSegment @ {:?}", self as *const _)) + .field("compression_type", &self.compression_type) + .field("mode", &self.mode) + .field("compressed_data_size", &self.compressed_data_size) + .field("compressed_data", &self.compressed_data) + .field("cached_string", &self.cached_string) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscVCT { pub transport_stream_id: u16, pub protocol_version: u8, @@ -701,11 +755,17 @@ pub struct GstMpegtsAtscVCT { impl ::std::fmt::Debug for GstMpegtsAtscVCT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscVCT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscVCT @ {:?}", self as *const _)) + .field("transport_stream_id", &self.transport_stream_id) + .field("protocol_version", &self.protocol_version) + .field("sources", &self.sources) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsAtscVCTSource { pub short_name: *mut c_char, pub major_channel_number: u16, @@ -727,11 +787,29 @@ pub struct GstMpegtsAtscVCTSource { impl ::std::fmt::Debug for GstMpegtsAtscVCTSource { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsAtscVCTSource @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsAtscVCTSource @ {:?}", self as *const _)) + .field("short_name", &self.short_name) + .field("major_channel_number", &self.major_channel_number) + .field("minor_channel_number", &self.minor_channel_number) + .field("modulation_mode", &self.modulation_mode) + .field("carrier_frequency", &self.carrier_frequency) + .field("channel_TSID", &self.channel_TSID) + .field("program_number", &self.program_number) + .field("ETM_location", &self.ETM_location) + .field("access_controlled", &self.access_controlled) + .field("hidden", &self.hidden) + .field("path_select", &self.path_select) + .field("out_of_band", &self.out_of_band) + .field("hide_guide", &self.hide_guide) + .field("service_type", &self.service_type) + .field("source_id", &self.source_id) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsBAT { pub descriptors: *mut glib::GPtrArray, pub streams: *mut glib::GPtrArray, @@ -739,11 +817,15 @@ pub struct GstMpegtsBAT { impl ::std::fmt::Debug for GstMpegtsBAT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsBAT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsBAT @ {:?}", self as *const _)) + .field("descriptors", &self.descriptors) + .field("streams", &self.streams) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsBATStream { pub transport_stream_id: u16, pub original_network_id: u16, @@ -752,11 +834,16 @@ pub struct GstMpegtsBATStream { impl ::std::fmt::Debug for GstMpegtsBATStream { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsBATStream @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsBATStream @ {:?}", self as *const _)) + .field("transport_stream_id", &self.transport_stream_id) + .field("original_network_id", &self.original_network_id) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsCableDeliverySystemDescriptor { pub frequency: u32, pub outer_fec: GstMpegtsCableOuterFECScheme, @@ -767,11 +854,18 @@ pub struct GstMpegtsCableDeliverySystemDescriptor { impl ::std::fmt::Debug for GstMpegtsCableDeliverySystemDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsCableDeliverySystemDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsCableDeliverySystemDescriptor @ {:?}", self as *const _)) + .field("frequency", &self.frequency) + .field("outer_fec", &self.outer_fec) + .field("modulation", &self.modulation) + .field("symbol_rate", &self.symbol_rate) + .field("fec_inner", &self.fec_inner) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsComponentDescriptor { pub stream_content: u8, pub component_type: u8, @@ -782,11 +876,18 @@ pub struct GstMpegtsComponentDescriptor { impl ::std::fmt::Debug for GstMpegtsComponentDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsComponentDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsComponentDescriptor @ {:?}", self as *const _)) + .field("stream_content", &self.stream_content) + .field("component_type", &self.component_type) + .field("component_tag", &self.component_tag) + .field("language_code", &self.language_code) + .field("text", &self.text) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsContent { pub content_nibble_1: GstMpegtsContentNibbleHi, pub content_nibble_2: u8, @@ -795,11 +896,16 @@ pub struct GstMpegtsContent { impl ::std::fmt::Debug for GstMpegtsContent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsContent @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsContent @ {:?}", self as *const _)) + .field("content_nibble_1", &self.content_nibble_1) + .field("content_nibble_2", &self.content_nibble_2) + .field("user_byte", &self.user_byte) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDVBLinkageDescriptor { pub transport_stream_id: u16, pub original_network_id: u16, @@ -812,11 +918,19 @@ pub struct GstMpegtsDVBLinkageDescriptor { impl ::std::fmt::Debug for GstMpegtsDVBLinkageDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDVBLinkageDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDVBLinkageDescriptor @ {:?}", self as *const _)) + .field("transport_stream_id", &self.transport_stream_id) + .field("original_network_id", &self.original_network_id) + .field("service_id", &self.service_id) + .field("linkage_type", &self.linkage_type) + .field("private_data_length", &self.private_data_length) + .field("private_data_bytes", &self.private_data_bytes) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDVBLinkageEvent { pub target_event_id: u16, pub target_listed: gboolean, @@ -825,11 +939,16 @@ pub struct GstMpegtsDVBLinkageEvent { impl ::std::fmt::Debug for GstMpegtsDVBLinkageEvent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDVBLinkageEvent @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDVBLinkageEvent @ {:?}", self as *const _)) + .field("target_event_id", &self.target_event_id) + .field("target_listed", &self.target_listed) + .field("event_simulcast", &self.event_simulcast) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDVBLinkageExtendedEvent { pub target_event_id: u16, pub target_listed: gboolean, @@ -846,11 +965,24 @@ pub struct GstMpegtsDVBLinkageExtendedEvent { impl ::std::fmt::Debug for GstMpegtsDVBLinkageExtendedEvent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDVBLinkageExtendedEvent @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDVBLinkageExtendedEvent @ {:?}", self as *const _)) + .field("target_event_id", &self.target_event_id) + .field("target_listed", &self.target_listed) + .field("event_simulcast", &self.event_simulcast) + .field("link_type", &self.link_type) + .field("target_id_type", &self.target_id_type) + .field("original_network_id_flag", &self.original_network_id_flag) + .field("service_id_flag", &self.service_id_flag) + .field("user_defined_id", &self.user_defined_id) + .field("target_transport_stream_id", &self.target_transport_stream_id) + .field("target_original_network_id", &self.target_original_network_id) + .field("target_service_id", &self.target_service_id) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDVBLinkageMobileHandOver { pub hand_over_type: GstMpegtsDVBLinkageHandOverType, pub origin_type: gboolean, @@ -860,11 +992,17 @@ pub struct GstMpegtsDVBLinkageMobileHandOver { impl ::std::fmt::Debug for GstMpegtsDVBLinkageMobileHandOver { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDVBLinkageMobileHandOver @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDVBLinkageMobileHandOver @ {:?}", self as *const _)) + .field("hand_over_type", &self.hand_over_type) + .field("origin_type", &self.origin_type) + .field("network_id", &self.network_id) + .field("initial_service_id", &self.initial_service_id) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDVBParentalRatingItem { pub country_code: *mut c_char, pub rating: u8, @@ -872,11 +1010,15 @@ pub struct GstMpegtsDVBParentalRatingItem { impl ::std::fmt::Debug for GstMpegtsDVBParentalRatingItem { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDVBParentalRatingItem @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDVBParentalRatingItem @ {:?}", self as *const _)) + .field("country_code", &self.country_code) + .field("rating", &self.rating) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDVBServiceListItem { pub service_id: u16, pub type_: GstMpegtsDVBServiceType, @@ -884,11 +1026,15 @@ pub struct GstMpegtsDVBServiceListItem { impl ::std::fmt::Debug for GstMpegtsDVBServiceListItem { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDVBServiceListItem @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDVBServiceListItem @ {:?}", self as *const _)) + .field("service_id", &self.service_id) + .field("type_", &self.type_) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDataBroadcastDescriptor { pub data_broadcast_id: u16, pub component_tag: u8, @@ -900,11 +1046,19 @@ pub struct GstMpegtsDataBroadcastDescriptor { impl ::std::fmt::Debug for GstMpegtsDataBroadcastDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDataBroadcastDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDataBroadcastDescriptor @ {:?}", self as *const _)) + .field("data_broadcast_id", &self.data_broadcast_id) + .field("component_tag", &self.component_tag) + .field("length", &self.length) + .field("selector_bytes", &self.selector_bytes) + .field("language_code", &self.language_code) + .field("text", &self.text) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDescriptor { pub tag: u8, pub tag_extension: u8, @@ -915,11 +1069,17 @@ pub struct GstMpegtsDescriptor { impl ::std::fmt::Debug for GstMpegtsDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDescriptor @ {:?}", self as *const _)) + .field("tag", &self.tag) + .field("tag_extension", &self.tag_extension) + .field("length", &self.length) + .field("data", &self.data) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDvbMultilingualBouquetNameItem { pub language_code: *mut c_char, pub bouquet_name: *mut c_char, @@ -927,11 +1087,15 @@ pub struct GstMpegtsDvbMultilingualBouquetNameItem { impl ::std::fmt::Debug for GstMpegtsDvbMultilingualBouquetNameItem { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDvbMultilingualBouquetNameItem @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDvbMultilingualBouquetNameItem @ {:?}", self as *const _)) + .field("language_code", &self.language_code) + .field("bouquet_name", &self.bouquet_name) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDvbMultilingualComponentItem { pub language_code: *mut c_char, pub description: *mut c_char, @@ -939,11 +1103,15 @@ pub struct GstMpegtsDvbMultilingualComponentItem { impl ::std::fmt::Debug for GstMpegtsDvbMultilingualComponentItem { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDvbMultilingualComponentItem @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDvbMultilingualComponentItem @ {:?}", self as *const _)) + .field("language_code", &self.language_code) + .field("description", &self.description) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDvbMultilingualNetworkNameItem { pub language_code: *mut c_char, pub network_name: *mut c_char, @@ -951,11 +1119,15 @@ pub struct GstMpegtsDvbMultilingualNetworkNameItem { impl ::std::fmt::Debug for GstMpegtsDvbMultilingualNetworkNameItem { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDvbMultilingualNetworkNameItem @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDvbMultilingualNetworkNameItem @ {:?}", self as *const _)) + .field("language_code", &self.language_code) + .field("network_name", &self.network_name) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsDvbMultilingualServiceNameItem { pub language_code: *mut c_char, pub provider_name: *mut c_char, @@ -964,11 +1136,16 @@ pub struct GstMpegtsDvbMultilingualServiceNameItem { impl ::std::fmt::Debug for GstMpegtsDvbMultilingualServiceNameItem { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsDvbMultilingualServiceNameItem @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsDvbMultilingualServiceNameItem @ {:?}", self as *const _)) + .field("language_code", &self.language_code) + .field("provider_name", &self.provider_name) + .field("service_name", &self.service_name) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsEIT { pub transport_stream_id: u16, pub original_network_id: u16, @@ -981,11 +1158,20 @@ pub struct GstMpegtsEIT { impl ::std::fmt::Debug for GstMpegtsEIT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsEIT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsEIT @ {:?}", self as *const _)) + .field("transport_stream_id", &self.transport_stream_id) + .field("original_network_id", &self.original_network_id) + .field("segment_last_section_number", &self.segment_last_section_number) + .field("last_table_id", &self.last_table_id) + .field("actual_stream", &self.actual_stream) + .field("present_following", &self.present_following) + .field("events", &self.events) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsEITEvent { pub event_id: u16, pub start_time: *mut gst::GstDateTime, @@ -997,11 +1183,19 @@ pub struct GstMpegtsEITEvent { impl ::std::fmt::Debug for GstMpegtsEITEvent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsEITEvent @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsEITEvent @ {:?}", self as *const _)) + .field("event_id", &self.event_id) + .field("start_time", &self.start_time) + .field("duration", &self.duration) + .field("running_status", &self.running_status) + .field("free_CA_mode", &self.free_CA_mode) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsExtendedEventDescriptor { pub descriptor_number: u8, pub last_descriptor_number: u8, @@ -1012,11 +1206,18 @@ pub struct GstMpegtsExtendedEventDescriptor { impl ::std::fmt::Debug for GstMpegtsExtendedEventDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsExtendedEventDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsExtendedEventDescriptor @ {:?}", self as *const _)) + .field("descriptor_number", &self.descriptor_number) + .field("last_descriptor_number", &self.last_descriptor_number) + .field("language_code", &self.language_code) + .field("items", &self.items) + .field("text", &self.text) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsExtendedEventItem { pub item_description: *mut c_char, pub item: *mut c_char, @@ -1024,11 +1225,15 @@ pub struct GstMpegtsExtendedEventItem { impl ::std::fmt::Debug for GstMpegtsExtendedEventItem { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsExtendedEventItem @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsExtendedEventItem @ {:?}", self as *const _)) + .field("item_description", &self.item_description) + .field("item", &self.item) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsISO639LanguageDescriptor { pub nb_language: c_uint, pub language: [c_char; 64], @@ -1037,11 +1242,14 @@ pub struct GstMpegtsISO639LanguageDescriptor { impl ::std::fmt::Debug for GstMpegtsISO639LanguageDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsISO639LanguageDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsISO639LanguageDescriptor @ {:?}", self as *const _)) + .field("nb_language", &self.nb_language) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsLogicalChannel { pub service_id: u16, pub visible_service: gboolean, @@ -1050,11 +1258,16 @@ pub struct GstMpegtsLogicalChannel { impl ::std::fmt::Debug for GstMpegtsLogicalChannel { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsLogicalChannel @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsLogicalChannel @ {:?}", self as *const _)) + .field("service_id", &self.service_id) + .field("visible_service", &self.visible_service) + .field("logical_channel_number", &self.logical_channel_number) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsLogicalChannelDescriptor { pub nb_channels: c_uint, pub channels: [GstMpegtsLogicalChannel; 64], @@ -1062,11 +1275,14 @@ pub struct GstMpegtsLogicalChannelDescriptor { impl ::std::fmt::Debug for GstMpegtsLogicalChannelDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsLogicalChannelDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsLogicalChannelDescriptor @ {:?}", self as *const _)) + .field("nb_channels", &self.nb_channels) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsNIT { pub actual_network: gboolean, pub network_id: u16, @@ -1076,11 +1292,17 @@ pub struct GstMpegtsNIT { impl ::std::fmt::Debug for GstMpegtsNIT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsNIT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsNIT @ {:?}", self as *const _)) + .field("actual_network", &self.actual_network) + .field("network_id", &self.network_id) + .field("descriptors", &self.descriptors) + .field("streams", &self.streams) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsNITStream { pub transport_stream_id: u16, pub original_network_id: u16, @@ -1089,11 +1311,16 @@ pub struct GstMpegtsNITStream { impl ::std::fmt::Debug for GstMpegtsNITStream { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsNITStream @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsNITStream @ {:?}", self as *const _)) + .field("transport_stream_id", &self.transport_stream_id) + .field("original_network_id", &self.original_network_id) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsPMT { pub pcr_pid: u16, pub program_number: u16, @@ -1103,11 +1330,17 @@ pub struct GstMpegtsPMT { impl ::std::fmt::Debug for GstMpegtsPMT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsPMT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsPMT @ {:?}", self as *const _)) + .field("pcr_pid", &self.pcr_pid) + .field("program_number", &self.program_number) + .field("descriptors", &self.descriptors) + .field("streams", &self.streams) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsPMTStream { pub stream_type: u8, pub pid: u16, @@ -1116,11 +1349,16 @@ pub struct GstMpegtsPMTStream { impl ::std::fmt::Debug for GstMpegtsPMTStream { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsPMTStream @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsPMTStream @ {:?}", self as *const _)) + .field("stream_type", &self.stream_type) + .field("pid", &self.pid) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsPatProgram { pub program_number: u16, pub network_or_program_map_PID: u16, @@ -1128,11 +1366,15 @@ pub struct GstMpegtsPatProgram { impl ::std::fmt::Debug for GstMpegtsPatProgram { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsPatProgram @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsPatProgram @ {:?}", self as *const _)) + .field("program_number", &self.program_number) + .field("network_or_program_map_PID", &self.network_or_program_map_PID) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsSDT { pub original_network_id: u16, pub actual_ts: gboolean, @@ -1142,11 +1384,17 @@ pub struct GstMpegtsSDT { impl ::std::fmt::Debug for GstMpegtsSDT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsSDT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsSDT @ {:?}", self as *const _)) + .field("original_network_id", &self.original_network_id) + .field("actual_ts", &self.actual_ts) + .field("transport_stream_id", &self.transport_stream_id) + .field("services", &self.services) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsSDTService { pub service_id: u16, pub EIT_schedule_flag: gboolean, @@ -1158,11 +1406,19 @@ pub struct GstMpegtsSDTService { impl ::std::fmt::Debug for GstMpegtsSDTService { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsSDTService @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsSDTService @ {:?}", self as *const _)) + .field("service_id", &self.service_id) + .field("EIT_schedule_flag", &self.EIT_schedule_flag) + .field("EIT_present_following_flag", &self.EIT_present_following_flag) + .field("running_status", &self.running_status) + .field("free_CA_mode", &self.free_CA_mode) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsSatelliteDeliverySystemDescriptor { pub frequency: u32, pub orbital_position: c_float, @@ -1177,11 +1433,22 @@ pub struct GstMpegtsSatelliteDeliverySystemDescriptor { impl ::std::fmt::Debug for GstMpegtsSatelliteDeliverySystemDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsSatelliteDeliverySystemDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsSatelliteDeliverySystemDescriptor @ {:?}", self as *const _)) + .field("frequency", &self.frequency) + .field("orbital_position", &self.orbital_position) + .field("west_east", &self.west_east) + .field("polarization", &self.polarization) + .field("roll_off", &self.roll_off) + .field("modulation_system", &self.modulation_system) + .field("modulation_type", &self.modulation_type) + .field("symbol_rate", &self.symbol_rate) + .field("fec_inner", &self.fec_inner) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsSection { pub parent: gst::GstMiniObject, pub section_type: GstMpegtsSectionType, @@ -1205,11 +1472,22 @@ pub struct GstMpegtsSection { impl ::std::fmt::Debug for GstMpegtsSection { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsSection @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsSection @ {:?}", self as *const _)) + .field("section_type", &self.section_type) + .field("pid", &self.pid) + .field("table_id", &self.table_id) + .field("subtable_extension", &self.subtable_extension) + .field("version_number", &self.version_number) + .field("current_next_indicator", &self.current_next_indicator) + .field("section_number", &self.section_number) + .field("last_section_number", &self.last_section_number) + .field("crc", &self.crc) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsT2DeliverySystemCell { pub cell_id: u16, pub centre_frequencies: *mut glib::GArray, @@ -1218,11 +1496,16 @@ pub struct GstMpegtsT2DeliverySystemCell { impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemCell { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsT2DeliverySystemCell @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsT2DeliverySystemCell @ {:?}", self as *const _)) + .field("cell_id", &self.cell_id) + .field("centre_frequencies", &self.centre_frequencies) + .field("sub_cells", &self.sub_cells) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsT2DeliverySystemCellExtension { pub cell_id_extension: u8, pub transposer_frequency: u32, @@ -1230,11 +1513,15 @@ pub struct GstMpegtsT2DeliverySystemCellExtension { impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemCellExtension { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsT2DeliverySystemCellExtension @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsT2DeliverySystemCellExtension @ {:?}", self as *const _)) + .field("cell_id_extension", &self.cell_id_extension) + .field("transposer_frequency", &self.transposer_frequency) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsT2DeliverySystemDescriptor { pub plp_id: u8, pub t2_system_id: u16, @@ -1249,11 +1536,22 @@ pub struct GstMpegtsT2DeliverySystemDescriptor { impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsT2DeliverySystemDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsT2DeliverySystemDescriptor @ {:?}", self as *const _)) + .field("plp_id", &self.plp_id) + .field("t2_system_id", &self.t2_system_id) + .field("siso_miso", &self.siso_miso) + .field("bandwidth", &self.bandwidth) + .field("guard_interval", &self.guard_interval) + .field("transmission_mode", &self.transmission_mode) + .field("other_frequency", &self.other_frequency) + .field("tfs", &self.tfs) + .field("cells", &self.cells) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsTOT { pub utc_time: *mut gst::GstDateTime, pub descriptors: *mut glib::GPtrArray, @@ -1261,11 +1559,15 @@ pub struct GstMpegtsTOT { impl ::std::fmt::Debug for GstMpegtsTOT { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsTOT @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsTOT @ {:?}", self as *const _)) + .field("utc_time", &self.utc_time) + .field("descriptors", &self.descriptors) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMpegtsTerrestrialDeliverySystemDescriptor { pub frequency: u32, pub bandwidth: u32, @@ -1283,7 +1585,20 @@ pub struct GstMpegtsTerrestrialDeliverySystemDescriptor { impl ::std::fmt::Debug for GstMpegtsTerrestrialDeliverySystemDescriptor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMpegtsTerrestrialDeliverySystemDescriptor @ {:?}", self as *const _) + f.debug_struct(&format!("GstMpegtsTerrestrialDeliverySystemDescriptor @ {:?}", self as *const _)) + .field("frequency", &self.frequency) + .field("bandwidth", &self.bandwidth) + .field("priority", &self.priority) + .field("time_slicing", &self.time_slicing) + .field("mpe_fec", &self.mpe_fec) + .field("constellation", &self.constellation) + .field("hierarchy", &self.hierarchy) + .field("code_rate_hp", &self.code_rate_hp) + .field("code_rate_lp", &self.code_rate_lp) + .field("guard_interval", &self.guard_interval) + .field("transmission_mode", &self.transmission_mode) + .field("other_frequency", &self.other_frequency) + .finish() } } diff --git a/gstreamer-net-sys/src/lib.rs b/gstreamer-net-sys/src/lib.rs index a8b22ee0a..09248c809 100644 --- a/gstreamer-net-sys/src/lib.rs +++ b/gstreamer-net-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; extern crate glib_sys as glib; @@ -30,6 +30,7 @@ pub type GstPtpStatisticsCallback = Option ::std::fmt::Result { - write!(f, "GstNetAddressMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstNetAddressMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("addr", &self.addr) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNetClientClockClass { pub parent_class: gst::GstSystemClockClass, pub _gst_reserved: [gpointer; 4], @@ -49,7 +54,9 @@ pub struct GstNetClientClockClass { impl ::std::fmt::Debug for GstNetClientClockClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstNetClientClockClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstNetClientClockClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -58,11 +65,13 @@ pub struct GstNetClientClockPrivate(c_void); impl ::std::fmt::Debug for GstNetClientClockPrivate { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstNetClientClockPrivate @ {:?}", self as *const _) + f.debug_struct(&format!("GstNetClientClockPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNetControlMessageMeta { pub meta: gst::GstMeta, pub message: *mut gio::GSocketControlMessage, @@ -70,11 +79,15 @@ pub struct GstNetControlMessageMeta { impl ::std::fmt::Debug for GstNetControlMessageMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstNetControlMessageMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstNetControlMessageMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("message", &self.message) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNetTimePacket { pub local_time: gst::GstClockTime, pub remote_time: gst::GstClockTime, @@ -82,11 +95,15 @@ pub struct GstNetTimePacket { impl ::std::fmt::Debug for GstNetTimePacket { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstNetTimePacket @ {:?}", self as *const _) + f.debug_struct(&format!("GstNetTimePacket @ {:?}", self as *const _)) + .field("local_time", &self.local_time) + .field("remote_time", &self.remote_time) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNetTimeProviderClass { pub parent_class: gst::GstObjectClass, pub _gst_reserved: [gpointer; 4], @@ -94,7 +111,10 @@ pub struct GstNetTimeProviderClass { impl ::std::fmt::Debug for GstNetTimeProviderClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstNetTimeProviderClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstNetTimeProviderClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("_gst_reserved", &self._gst_reserved) + .finish() } } @@ -103,11 +123,13 @@ pub struct GstNetTimeProviderPrivate(c_void); impl ::std::fmt::Debug for GstNetTimeProviderPrivate { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstNetTimeProviderPrivate @ {:?}", self as *const _) + f.debug_struct(&format!("GstNetTimeProviderPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNtpClockClass { pub parent_class: gst::GstSystemClockClass, pub _gst_reserved: [gpointer; 4], @@ -115,11 +137,14 @@ pub struct GstNtpClockClass { impl ::std::fmt::Debug for GstNtpClockClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstNtpClockClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstNtpClockClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPtpClockClass { pub parent_class: gst::GstSystemClockClass, pub _gst_reserved: [gpointer; 4], @@ -127,7 +152,9 @@ pub struct GstPtpClockClass { impl ::std::fmt::Debug for GstPtpClockClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPtpClockClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstPtpClockClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -136,12 +163,14 @@ pub struct GstPtpClockPrivate(c_void); impl ::std::fmt::Debug for GstPtpClockPrivate { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPtpClockPrivate @ {:?}", self as *const _) + f.debug_struct(&format!("GstPtpClockPrivate @ {:?}", self as *const _)) + .finish() } } // Classes #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNetClientClock { pub clock: gst::GstSystemClock, pub priv_: *mut GstNetClientClockPrivate, @@ -152,13 +181,12 @@ impl ::std::fmt::Debug for GstNetClientClock { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GstNetClientClock @ {:?}", self as *const _)) .field("clock", &self.clock) - .field("priv_", &self.priv_) - .field("_gst_reserved", &self._gst_reserved) .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNetTimeProvider { pub parent: gst::GstObject, pub priv_: *mut GstNetTimeProviderPrivate, @@ -169,13 +197,12 @@ impl ::std::fmt::Debug for GstNetTimeProvider { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GstNetTimeProvider @ {:?}", self as *const _)) .field("parent", &self.parent) - .field("priv_", &self.priv_) - .field("_gst_reserved", &self._gst_reserved) .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNtpClock { pub clock: gst::GstSystemClock, pub priv_: *mut GstNetClientClockPrivate, @@ -186,13 +213,12 @@ impl ::std::fmt::Debug for GstNtpClock { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GstNtpClock @ {:?}", self as *const _)) .field("clock", &self.clock) - .field("priv_", &self.priv_) - .field("_gst_reserved", &self._gst_reserved) .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPtpClock { pub clock: gst::GstSystemClock, pub priv_: *mut GstPtpClockPrivate, @@ -203,8 +229,6 @@ impl ::std::fmt::Debug for GstPtpClock { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GstPtpClock @ {:?}", self as *const _)) .field("clock", &self.clock) - .field("priv_", &self.priv_) - .field("_gst_reserved", &self._gst_reserved) .finish() } } diff --git a/gstreamer-pbutils-sys/src/lib.rs b/gstreamer-pbutils-sys/src/lib.rs index 9994a64ff..afca931b1 100644 --- a/gstreamer-pbutils-sys/src/lib.rs +++ b/gstreamer-pbutils-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; #[macro_use] extern crate bitflags; @@ -96,6 +96,7 @@ pub type GstInstallPluginsResultFunc = Option gboolean>, @@ -105,7 +106,12 @@ pub struct GstAudioVisualizerClass { impl ::std::fmt::Debug for GstAudioVisualizerClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAudioVisualizerClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAudioVisualizerClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("setup", &self.setup) + .field("render", &self.render) + .field("decide_allocation", &self.decide_allocation) + .finish() } } @@ -114,11 +120,13 @@ 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 _) + f.debug_struct(&format!("GstAudioVisualizerPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDiscovererClass { pub parentclass: gobject::GObjectClass, pub finished: Option, @@ -130,7 +138,14 @@ pub struct GstDiscovererClass { impl ::std::fmt::Debug for GstDiscovererClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstDiscovererClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstDiscovererClass @ {:?}", self as *const _)) + .field("parentclass", &self.parentclass) + .field("finished", &self.finished) + .field("starting", &self.starting) + .field("discovered", &self.discovered) + .field("source_setup", &self.source_setup) + .field("_reserved", &self._reserved) + .finish() } } @@ -139,7 +154,8 @@ 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 _) + f.debug_struct(&format!("GstDiscovererPrivate @ {:?}", self as *const _)) + .finish() } } @@ -148,7 +164,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingAudioProfileClass @ {:?}", self as *const _)) + .finish() } } @@ -157,7 +174,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingContainerProfileClass @ {:?}", self as *const _)) + .finish() } } @@ -166,7 +184,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingProfileClass @ {:?}", self as *const _)) + .finish() } } @@ -175,7 +194,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingVideoProfileClass @ {:?}", self as *const _)) + .finish() } } @@ -184,12 +204,14 @@ 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 _) + f.debug_struct(&format!("GstInstallPluginsContext @ {:?}", self as *const _)) + .finish() } } // Classes #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAudioVisualizer { pub parent: gst::GstElement, pub req_spf: c_uint, @@ -205,12 +227,12 @@ impl ::std::fmt::Debug for GstAudioVisualizer { .field("req_spf", &self.req_spf) .field("vinfo", &self.vinfo) .field("ainfo", &self.ainfo) - .field("priv_", &self.priv_) .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDiscoverer { pub parent: gobject::GObject, pub priv_: *mut GstDiscovererPrivate, @@ -221,8 +243,6 @@ 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() } } @@ -232,7 +252,8 @@ 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 _) + f.debug_struct(&format!("GstDiscovererAudioInfo @ {:?}", self as *const _)) + .finish() } } @@ -241,7 +262,8 @@ 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 _) + f.debug_struct(&format!("GstDiscovererContainerInfo @ {:?}", self as *const _)) + .finish() } } @@ -250,7 +272,8 @@ 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 _) + f.debug_struct(&format!("GstDiscovererInfo @ {:?}", self as *const _)) + .finish() } } @@ -259,7 +282,8 @@ 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 _) + f.debug_struct(&format!("GstDiscovererStreamInfo @ {:?}", self as *const _)) + .finish() } } @@ -268,7 +292,8 @@ 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 _) + f.debug_struct(&format!("GstDiscovererSubtitleInfo @ {:?}", self as *const _)) + .finish() } } @@ -277,7 +302,8 @@ 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 _) + f.debug_struct(&format!("GstDiscovererVideoInfo @ {:?}", self as *const _)) + .finish() } } @@ -286,7 +312,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingAudioProfile @ {:?}", self as *const _)) + .finish() } } @@ -295,7 +322,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingContainerProfile @ {:?}", self as *const _)) + .finish() } } @@ -304,7 +332,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingProfile @ {:?}", self as *const _)) + .finish() } } @@ -313,7 +342,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingTarget @ {:?}", self as *const _)) + .finish() } } @@ -322,7 +352,8 @@ 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 _) + f.debug_struct(&format!("GstEncodingVideoProfile @ {:?}", self as *const _)) + .finish() } } diff --git a/gstreamer-player-sys/src/lib.rs b/gstreamer-player-sys/src/lib.rs index aa36fe624..868d76816 100644 --- a/gstreamer-player-sys/src/lib.rs +++ b/gstreamer-player-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; extern crate glib_sys as glib; @@ -50,7 +50,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerAudioInfoClass @ {:?}", self as *const _)) + .finish() } } @@ -59,7 +60,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerClass @ {:?}", self as *const _)) + .finish() } } @@ -68,7 +70,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerGMainContextSignalDispatcherClass @ {:?}", self as *const _)) + .finish() } } @@ -77,11 +80,13 @@ 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 _) + f.debug_struct(&format!("GstPlayerMediaInfoClass @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPlayerSignalDispatcherInterface { pub parent_iface: gobject::GTypeInterface, pub dispatch: Option, @@ -89,7 +94,10 @@ pub struct GstPlayerSignalDispatcherInterface { impl ::std::fmt::Debug for GstPlayerSignalDispatcherInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPlayerSignalDispatcherInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstPlayerSignalDispatcherInterface @ {:?}", self as *const _)) + .field("parent_iface", &self.parent_iface) + .field("dispatch", &self.dispatch) + .finish() } } @@ -98,7 +106,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerStreamInfoClass @ {:?}", self as *const _)) + .finish() } } @@ -107,7 +116,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerSubtitleInfoClass @ {:?}", self as *const _)) + .finish() } } @@ -116,7 +126,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerVideoInfoClass @ {:?}", self as *const _)) + .finish() } } @@ -125,11 +136,13 @@ 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 _) + f.debug_struct(&format!("GstPlayerVideoOverlayVideoRendererClass @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPlayerVideoRendererInterface { pub parent_iface: gobject::GTypeInterface, pub create_video_sink: Option *mut gst::GstElement>, @@ -137,11 +150,15 @@ pub struct GstPlayerVideoRendererInterface { impl ::std::fmt::Debug for GstPlayerVideoRendererInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPlayerVideoRendererInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstPlayerVideoRendererInterface @ {:?}", self as *const _)) + .field("parent_iface", &self.parent_iface) + .field("create_video_sink", &self.create_video_sink) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPlayerVisualization { pub name: *mut c_char, pub description: *mut c_char, @@ -149,7 +166,10 @@ pub struct GstPlayerVisualization { impl ::std::fmt::Debug for GstPlayerVisualization { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPlayerVisualization @ {:?}", self as *const _) + f.debug_struct(&format!("GstPlayerVisualization @ {:?}", self as *const _)) + .field("name", &self.name) + .field("description", &self.description) + .finish() } } @@ -159,7 +179,8 @@ 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 _) + f.debug_struct(&format!("GstPlayer @ {:?}", self as *const _)) + .finish() } } @@ -168,7 +189,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerAudioInfo @ {:?}", self as *const _)) + .finish() } } @@ -177,7 +199,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerGMainContextSignalDispatcher @ {:?}", self as *const _)) + .finish() } } @@ -186,7 +209,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerMediaInfo @ {:?}", self as *const _)) + .finish() } } @@ -195,7 +219,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerStreamInfo @ {:?}", self as *const _)) + .finish() } } @@ -204,7 +229,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerSubtitleInfo @ {:?}", self as *const _)) + .finish() } } @@ -213,7 +239,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerVideoInfo @ {:?}", self as *const _)) + .finish() } } @@ -222,7 +249,8 @@ 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 _) + f.debug_struct(&format!("GstPlayerVideoOverlayVideoRenderer @ {:?}", self as *const _)) + .finish() } } diff --git a/gstreamer-sys/src/lib.rs b/gstreamer-sys/src/lib.rs index 294fdbf2e..a28907bc2 100644 --- a/gstreamer-sys/src/lib.rs +++ b/gstreamer-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; #[macro_use] extern crate bitflags; @@ -1265,6 +1265,55 @@ pub const GST_TRACER_VALUE_FLAGS_NONE: GstTracerValueFlags = GstTracerValueFlags pub const GST_TRACER_VALUE_FLAGS_OPTIONAL: GstTracerValueFlags = GstTracerValueFlags::OPTIONAL; pub const GST_TRACER_VALUE_FLAGS_AGGREGATED: GstTracerValueFlags = GstTracerValueFlags::AGGREGATED; +// Unions +#[repr(C)] +#[derive(Copy, Clone)] +pub union GstControlBinding_ABI { + pub abi: GstControlBinding_ABI_abi, + pub _gst_reserved: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstControlBinding_ABI { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstControlBinding_ABI @ {:?}", self as *const _)) + .field("abi", unsafe { &self.abi }) + .field("_gst_reserved", unsafe { &self._gst_reserved }) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub union GstPadProbeInfo_ABI { + pub _gst_reserved: [gpointer; 4], + pub abi: GstPadProbeInfo_ABI_abi, +} + +impl ::std::fmt::Debug for GstPadProbeInfo_ABI { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstPadProbeInfo_ABI @ {:?}", self as *const _)) + .field("_gst_reserved", unsafe { &self._gst_reserved }) + .field("abi", unsafe { &self.abi }) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub union GstPad_ABI { + pub _gst_reserved: [gpointer; 4], + pub abi: GstPad_ABI_abi, +} + +impl ::std::fmt::Debug for GstPad_ABI { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstPad_ABI @ {:?}", self as *const _)) + .field("_gst_reserved", unsafe { &self._gst_reserved }) + .field("abi", unsafe { &self.abi }) + .finish() + } +} + // Callbacks pub type GstBufferForeachMetaFunc = Option gboolean>; pub type GstBufferListFunc = Option gboolean>; @@ -1334,6 +1383,7 @@ pub type GstValueSerializeFunc = Option ::std::fmt::Result { - write!(f, "GstAllocationParams @ {:?}", self as *const _) + f.debug_struct(&format!("GstAllocationParams @ {:?}", self as *const _)) + .field("flags", &self.flags) + .field("align", &self.align) + .field("prefix", &self.prefix) + .field("padding", &self.padding) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAllocatorClass { pub object_class: GstObjectClass, pub alloc: Option *mut GstMemory>, @@ -1358,7 +1414,11 @@ pub struct GstAllocatorClass { impl ::std::fmt::Debug for GstAllocatorClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstAllocatorClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstAllocatorClass @ {:?}", self as *const _)) + .field("object_class", &self.object_class) + .field("alloc", &self.alloc) + .field("free", &self.free) + .finish() } } @@ -1367,7 +1427,8 @@ 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 _) + f.debug_struct(&format!("GstAllocatorPrivate @ {:?}", self as *const _)) + .finish() } } @@ -1376,11 +1437,13 @@ 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 _) + f.debug_struct(&format!("GstAtomicQueue @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBinClass { pub parent_class: GstElementClass, pub pool: *mut glib::GThreadPool, @@ -1397,7 +1460,17 @@ pub struct GstBinClass { impl ::std::fmt::Debug for GstBinClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBinClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstBinClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("element_added", &self.element_added) + .field("element_removed", &self.element_removed) + .field("add_element", &self.add_element) + .field("remove_element", &self.remove_element) + .field("handle_message", &self.handle_message) + .field("do_latency", &self.do_latency) + .field("deep_element_added", &self.deep_element_added) + .field("deep_element_removed", &self.deep_element_removed) + .finish() } } @@ -1406,11 +1479,13 @@ 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 _) + f.debug_struct(&format!("GstBinPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBuffer { pub mini_object: GstMiniObject, pub pool: *mut GstBufferPool, @@ -1423,7 +1498,15 @@ pub struct GstBuffer { impl ::std::fmt::Debug for GstBuffer { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBuffer @ {:?}", self as *const _) + f.debug_struct(&format!("GstBuffer @ {:?}", self as *const _)) + .field("mini_object", &self.mini_object) + .field("pool", &self.pool) + .field("pts", &self.pts) + .field("dts", &self.dts) + .field("duration", &self.duration) + .field("offset", &self.offset) + .field("offset_end", &self.offset_end) + .finish() } } @@ -1432,11 +1515,13 @@ 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 _) + f.debug_struct(&format!("GstBufferList @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBufferPoolAcquireParams { pub format: GstFormat, pub start: i64, @@ -1447,11 +1532,17 @@ pub struct GstBufferPoolAcquireParams { impl ::std::fmt::Debug for GstBufferPoolAcquireParams { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBufferPoolAcquireParams @ {:?}", self as *const _) + f.debug_struct(&format!("GstBufferPoolAcquireParams @ {:?}", self as *const _)) + .field("format", &self.format) + .field("start", &self.start) + .field("stop", &self.stop) + .field("flags", &self.flags) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBufferPoolClass { pub object_class: GstObjectClass, pub get_options: Option *mut *mut c_char>, @@ -1470,7 +1561,20 @@ pub struct GstBufferPoolClass { impl ::std::fmt::Debug for GstBufferPoolClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBufferPoolClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstBufferPoolClass @ {:?}", self as *const _)) + .field("object_class", &self.object_class) + .field("get_options", &self.get_options) + .field("set_config", &self.set_config) + .field("start", &self.start) + .field("stop", &self.stop) + .field("acquire_buffer", &self.acquire_buffer) + .field("alloc_buffer", &self.alloc_buffer) + .field("reset_buffer", &self.reset_buffer) + .field("release_buffer", &self.release_buffer) + .field("free_buffer", &self.free_buffer) + .field("flush_start", &self.flush_start) + .field("flush_stop", &self.flush_stop) + .finish() } } @@ -1479,11 +1583,13 @@ 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 _) + f.debug_struct(&format!("GstBufferPoolPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBusClass { pub parent_class: GstObjectClass, pub message: Option, @@ -1493,7 +1599,11 @@ pub struct GstBusClass { impl ::std::fmt::Debug for GstBusClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstBusClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstBusClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("message", &self.message) + .field("sync_message", &self.sync_message) + .finish() } } @@ -1502,18 +1612,22 @@ 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 _) + f.debug_struct(&format!("GstBusPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstCaps @ {:?}", self as *const _)) + .field("mini_object", &self.mini_object) + .finish() } } @@ -1522,11 +1636,13 @@ 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 _) + f.debug_struct(&format!("GstCapsFeatures @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstChildProxyInterface { pub parent: gobject::GTypeInterface, pub get_child_by_name: Option *mut gobject::GObject>, @@ -1539,11 +1655,19 @@ pub struct GstChildProxyInterface { impl ::std::fmt::Debug for GstChildProxyInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstChildProxyInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstChildProxyInterface @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("get_child_by_name", &self.get_child_by_name) + .field("get_child_by_index", &self.get_child_by_index) + .field("get_children_count", &self.get_children_count) + .field("child_added", &self.child_added) + .field("child_removed", &self.child_removed) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstClockClass { pub parent_class: GstObjectClass, pub change_resolution: Option GstClockTime>, @@ -1557,11 +1681,20 @@ pub struct GstClockClass { impl ::std::fmt::Debug for GstClockClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstClockClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstClockClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("change_resolution", &self.change_resolution) + .field("get_resolution", &self.get_resolution) + .field("get_internal_time", &self.get_internal_time) + .field("wait", &self.wait) + .field("wait_async", &self.wait_async) + .field("unschedule", &self.unschedule) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstClockEntry { pub refcount: c_int, pub clock: *mut GstClock, @@ -1579,7 +1712,19 @@ pub struct GstClockEntry { impl ::std::fmt::Debug for GstClockEntry { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstClockEntry @ {:?}", self as *const _) + f.debug_struct(&format!("GstClockEntry @ {:?}", self as *const _)) + .field("refcount", &self.refcount) + .field("clock", &self.clock) + .field("type_", &self.type_) + .field("time", &self.time) + .field("interval", &self.interval) + .field("status", &self.status) + .field("func", &self.func) + .field("user_data", &self.user_data) + .field("destroy_data", &self.destroy_data) + .field("unscheduled", &self.unscheduled) + .field("woken_up", &self.woken_up) + .finish() } } @@ -1588,7 +1733,8 @@ 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 _) + f.debug_struct(&format!("GstClockPrivate @ {:?}", self as *const _)) + .finish() } } @@ -1597,11 +1743,13 @@ 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 _) + f.debug_struct(&format!("GstContext @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstControlBindingClass { pub parent_class: GstObjectClass, pub sync_values: Option gboolean>, @@ -1613,7 +1761,13 @@ pub struct GstControlBindingClass { impl ::std::fmt::Debug for GstControlBindingClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstControlBindingClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstControlBindingClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("sync_values", &self.sync_values) + .field("get_value", &self.get_value) + .field("get_value_array", &self.get_value_array) + .field("get_g_value_array", &self.get_g_value_array) + .finish() } } @@ -1622,11 +1776,27 @@ 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 _) + f.debug_struct(&format!("GstControlBindingPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] +pub struct GstControlBinding_ABI_abi { + pub priv_: *mut GstControlBindingPrivate, +} + +impl ::std::fmt::Debug for GstControlBinding_ABI_abi { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstControlBinding_ABI_abi @ {:?}", self as *const _)) + .field("priv_", &self.priv_) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] pub struct GstControlSourceClass { pub parent_class: GstObjectClass, pub _gst_reserved: [gpointer; 4], @@ -1634,7 +1804,9 @@ pub struct GstControlSourceClass { impl ::std::fmt::Debug for GstControlSourceClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstControlSourceClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstControlSourceClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -1643,11 +1815,13 @@ 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 _) + f.debug_struct(&format!("GstDateTime @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDebugCategory { pub threshold: c_int, pub color: c_uint, @@ -1657,7 +1831,8 @@ pub struct GstDebugCategory { impl ::std::fmt::Debug for GstDebugCategory { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstDebugCategory @ {:?}", self as *const _) + f.debug_struct(&format!("GstDebugCategory @ {:?}", self as *const _)) + .finish() } } @@ -1666,11 +1841,13 @@ 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 _) + f.debug_struct(&format!("GstDebugMessage @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDeviceClass { pub parent_class: GstObjectClass, pub create_element: Option *mut GstElement>, @@ -1680,11 +1857,16 @@ pub struct GstDeviceClass { impl ::std::fmt::Debug for GstDeviceClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstDeviceClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstDeviceClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("create_element", &self.create_element) + .field("reconfigure_element", &self.reconfigure_element) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDeviceMonitorClass { pub parent_class: GstObjectClass, pub _gst_reserved: [gpointer; 4], @@ -1692,7 +1874,9 @@ pub struct GstDeviceMonitorClass { impl ::std::fmt::Debug for GstDeviceMonitorClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstDeviceMonitorClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstDeviceMonitorClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -1701,7 +1885,8 @@ 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 _) + f.debug_struct(&format!("GstDeviceMonitorPrivate @ {:?}", self as *const _)) + .finish() } } @@ -1710,11 +1895,13 @@ 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 _) + f.debug_struct(&format!("GstDevicePrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstDeviceProviderClass { pub parent_class: GstObjectClass, pub factory: *mut GstDeviceProviderFactory, @@ -1727,7 +1914,13 @@ pub struct GstDeviceProviderClass { impl ::std::fmt::Debug for GstDeviceProviderClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstDeviceProviderClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstDeviceProviderClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("factory", &self.factory) + .field("probe", &self.probe) + .field("start", &self.start) + .field("stop", &self.stop) + .finish() } } @@ -1736,7 +1929,8 @@ 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 _) + f.debug_struct(&format!("GstDeviceProviderFactoryClass @ {:?}", self as *const _)) + .finish() } } @@ -1745,7 +1939,8 @@ 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 _) + f.debug_struct(&format!("GstDeviceProviderPrivate @ {:?}", self as *const _)) + .finish() } } @@ -1754,11 +1949,13 @@ 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 _) + f.debug_struct(&format!("GstDynamicTypeFactoryClass @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstElementClass { pub parent_class: GstObjectClass, pub metadata: gpointer, @@ -1787,7 +1984,30 @@ pub struct GstElementClass { impl ::std::fmt::Debug for GstElementClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstElementClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstElementClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("metadata", &self.metadata) + .field("elementfactory", &self.elementfactory) + .field("padtemplates", &self.padtemplates) + .field("numpadtemplates", &self.numpadtemplates) + .field("pad_templ_cookie", &self.pad_templ_cookie) + .field("pad_added", &self.pad_added) + .field("pad_removed", &self.pad_removed) + .field("no_more_pads", &self.no_more_pads) + .field("request_new_pad", &self.request_new_pad) + .field("release_pad", &self.release_pad) + .field("get_state", &self.get_state) + .field("set_state", &self.set_state) + .field("change_state", &self.change_state) + .field("state_changed", &self.state_changed) + .field("set_bus", &self.set_bus) + .field("provide_clock", &self.provide_clock) + .field("set_clock", &self.set_clock) + .field("send_event", &self.send_event) + .field("query", &self.query) + .field("post_message", &self.post_message) + .field("set_context", &self.set_context) + .finish() } } @@ -1796,11 +2016,13 @@ 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 _) + f.debug_struct(&format!("GstElementFactoryClass @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstEvent { pub mini_object: GstMiniObject, pub type_: GstEventType, @@ -1810,11 +2032,17 @@ pub struct GstEvent { impl ::std::fmt::Debug for GstEvent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstEvent @ {:?}", self as *const _) + f.debug_struct(&format!("GstEvent @ {:?}", self as *const _)) + .field("mini_object", &self.mini_object) + .field("type_", &self.type_) + .field("timestamp", &self.timestamp) + .field("seqnum", &self.seqnum) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstFormatDefinition { pub value: GstFormat, pub nick: *const c_char, @@ -1824,11 +2052,17 @@ pub struct GstFormatDefinition { impl ::std::fmt::Debug for GstFormatDefinition { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstFormatDefinition @ {:?}", self as *const _) + f.debug_struct(&format!("GstFormatDefinition @ {:?}", self as *const _)) + .field("value", &self.value) + .field("nick", &self.nick) + .field("description", &self.description) + .field("quark", &self.quark) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstGhostPadClass { pub parent_class: GstProxyPadClass, pub _gst_reserved: [gpointer; 4], @@ -1836,7 +2070,9 @@ pub struct GstGhostPadClass { impl ::std::fmt::Debug for GstGhostPadClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstGhostPadClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstGhostPadClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -1845,11 +2081,13 @@ 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 _) + f.debug_struct(&format!("GstGhostPadPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstIterator { pub copy: GstIteratorCopyFunction, pub next: GstIteratorNextFunction, @@ -1867,11 +2105,24 @@ pub struct GstIterator { impl ::std::fmt::Debug for GstIterator { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstIterator @ {:?}", self as *const _) + f.debug_struct(&format!("GstIterator @ {:?}", self as *const _)) + .field("copy", &self.copy) + .field("next", &self.next) + .field("item", &self.item) + .field("resync", &self.resync) + .field("free", &self.free) + .field("pushed", &self.pushed) + .field("type_", &self.type_) + .field("lock", &self.lock) + .field("cookie", &self.cookie) + .field("master_cookie", &self.master_cookie) + .field("size", &self.size) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMapInfo { pub memory: *mut GstMemory, pub flags: GstMapFlags, @@ -1884,11 +2135,19 @@ pub struct GstMapInfo { impl ::std::fmt::Debug for GstMapInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMapInfo @ {:?}", self as *const _) + f.debug_struct(&format!("GstMapInfo @ {:?}", self as *const _)) + .field("memory", &self.memory) + .field("flags", &self.flags) + .field("data", &self.data) + .field("size", &self.size) + .field("maxsize", &self.maxsize) + .field("user_data", &self.user_data) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMemory { pub mini_object: GstMiniObject, pub allocator: *mut GstAllocator, @@ -1901,11 +2160,20 @@ pub struct GstMemory { impl ::std::fmt::Debug for GstMemory { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMemory @ {:?}", self as *const _) + f.debug_struct(&format!("GstMemory @ {:?}", self as *const _)) + .field("mini_object", &self.mini_object) + .field("allocator", &self.allocator) + .field("parent", &self.parent) + .field("maxsize", &self.maxsize) + .field("align", &self.align) + .field("offset", &self.offset) + .field("size", &self.size) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMessage { pub mini_object: GstMiniObject, pub type_: GstMessageType, @@ -1918,11 +2186,18 @@ pub struct GstMessage { impl ::std::fmt::Debug for GstMessage { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMessage @ {:?}", self as *const _) + f.debug_struct(&format!("GstMessage @ {:?}", self as *const _)) + .field("mini_object", &self.mini_object) + .field("type_", &self.type_) + .field("timestamp", &self.timestamp) + .field("src", &self.src) + .field("seqnum", &self.seqnum) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMeta { pub flags: GstMetaFlags, pub info: *const GstMetaInfo, @@ -1930,11 +2205,15 @@ pub struct GstMeta { impl ::std::fmt::Debug for GstMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstMeta @ {:?}", self as *const _)) + .field("flags", &self.flags) + .field("info", &self.info) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMetaInfo { pub api: GType, pub type_: GType, @@ -1946,11 +2225,19 @@ pub struct GstMetaInfo { impl ::std::fmt::Debug for GstMetaInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMetaInfo @ {:?}", self as *const _) + f.debug_struct(&format!("GstMetaInfo @ {:?}", self as *const _)) + .field("api", &self.api) + .field("type_", &self.type_) + .field("size", &self.size) + .field("init_func", &self.init_func) + .field("free_func", &self.free_func) + .field("transform_func", &self.transform_func) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMetaTransformCopy { pub region: gboolean, pub offset: size_t, @@ -1959,11 +2246,16 @@ pub struct GstMetaTransformCopy { impl ::std::fmt::Debug for GstMetaTransformCopy { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMetaTransformCopy @ {:?}", self as *const _) + f.debug_struct(&format!("GstMetaTransformCopy @ {:?}", self as *const _)) + .field("region", &self.region) + .field("offset", &self.offset) + .field("size", &self.size) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstMiniObject { pub type_: GType, pub refcount: c_int, @@ -1978,11 +2270,20 @@ pub struct GstMiniObject { impl ::std::fmt::Debug for GstMiniObject { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstMiniObject @ {:?}", self as *const _) + f.debug_struct(&format!("GstMiniObject @ {:?}", self as *const _)) + .field("type_", &self.type_) + .field("refcount", &self.refcount) + .field("lockstate", &self.lockstate) + .field("flags", &self.flags) + .field("copy", &self.copy) + .field("dispose", &self.dispose) + .field("free", &self.free) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstObjectClass { pub parent_class: gobject::GInitiallyUnownedClass, pub path_string_separator: *const c_char, @@ -1992,11 +2293,16 @@ pub struct GstObjectClass { impl ::std::fmt::Debug for GstObjectClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstObjectClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstObjectClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("path_string_separator", &self.path_string_separator) + .field("deep_notify", &self.deep_notify) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPadClass { pub parent_class: GstObjectClass, pub linked: Option, @@ -2006,7 +2312,11 @@ pub struct GstPadClass { impl ::std::fmt::Debug for GstPadClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPadClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstPadClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("linked", &self.linked) + .field("unlinked", &self.unlinked) + .finish() } } @@ -2015,27 +2325,51 @@ 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 _) + f.debug_struct(&format!("GstPadPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPadProbeInfo { pub type_: GstPadProbeType, pub id: c_ulong, pub data: gpointer, pub offset: u64, pub size: c_uint, - pub _gst_reserved: [gpointer; 4], + pub ABI: GstPadProbeInfo_ABI, } impl ::std::fmt::Debug for GstPadProbeInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPadProbeInfo @ {:?}", self as *const _) + f.debug_struct(&format!("GstPadProbeInfo @ {:?}", self as *const _)) + .field("type_", &self.type_) + .field("id", &self.id) + .field("data", &self.data) + .field("offset", &self.offset) + .field("size", &self.size) + .field("ABI", &self.ABI) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] +pub struct GstPadProbeInfo_ABI_abi { + pub flow_ret: GstFlowReturn, +} + +impl ::std::fmt::Debug for GstPadProbeInfo_ABI_abi { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstPadProbeInfo_ABI_abi @ {:?}", self as *const _)) + .field("flow_ret", &self.flow_ret) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] pub struct GstPadTemplateClass { pub parent_class: GstObjectClass, pub pad_created: Option, @@ -2044,11 +2378,31 @@ pub struct GstPadTemplateClass { impl ::std::fmt::Debug for GstPadTemplateClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPadTemplateClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstPadTemplateClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("pad_created", &self.pad_created) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] +pub struct GstPad_ABI_abi { + pub last_flowret: GstFlowReturn, + pub eventfullfunc: GstPadEventFullFunction, +} + +impl ::std::fmt::Debug for GstPad_ABI_abi { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstPad_ABI_abi @ {:?}", self as *const _)) + .field("last_flowret", &self.last_flowret) + .field("eventfullfunc", &self.eventfullfunc) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] pub struct GstParamSpecArray { pub parent_instance: gobject::GParamSpec, pub element_spec: *mut gobject::GParamSpec, @@ -2056,11 +2410,15 @@ pub struct GstParamSpecArray { impl ::std::fmt::Debug for GstParamSpecArray { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstParamSpecArray @ {:?}", self as *const _) + f.debug_struct(&format!("GstParamSpecArray @ {:?}", self as *const _)) + .field("parent_instance", &self.parent_instance) + .field("element_spec", &self.element_spec) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstParamSpecFraction { pub parent_instance: gobject::GParamSpec, pub min_num: c_int, @@ -2073,11 +2431,20 @@ pub struct GstParamSpecFraction { impl ::std::fmt::Debug for GstParamSpecFraction { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstParamSpecFraction @ {:?}", self as *const _) + f.debug_struct(&format!("GstParamSpecFraction @ {:?}", self as *const _)) + .field("parent_instance", &self.parent_instance) + .field("min_num", &self.min_num) + .field("min_den", &self.min_den) + .field("max_num", &self.max_num) + .field("max_den", &self.max_den) + .field("def_num", &self.def_num) + .field("def_den", &self.def_den) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstParentBufferMeta { pub parent: GstMeta, pub buffer: *mut GstBuffer, @@ -2085,7 +2452,10 @@ pub struct GstParentBufferMeta { impl ::std::fmt::Debug for GstParentBufferMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstParentBufferMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstParentBufferMeta @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("buffer", &self.buffer) + .finish() } } @@ -2094,11 +2464,13 @@ 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 _) + f.debug_struct(&format!("GstParseContext @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPipelineClass { pub parent_class: GstBinClass, pub _gst_reserved: [gpointer; 4], @@ -2106,7 +2478,9 @@ pub struct GstPipelineClass { impl ::std::fmt::Debug for GstPipelineClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPipelineClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstPipelineClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -2115,7 +2489,8 @@ 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 _) + f.debug_struct(&format!("GstPipelinePrivate @ {:?}", self as *const _)) + .finish() } } @@ -2124,11 +2499,13 @@ 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 _) + f.debug_struct(&format!("GstPluginClass @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPluginDesc { pub major_version: c_int, pub minor_version: c_int, @@ -2146,7 +2523,19 @@ pub struct GstPluginDesc { impl ::std::fmt::Debug for GstPluginDesc { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPluginDesc @ {:?}", self as *const _) + f.debug_struct(&format!("GstPluginDesc @ {:?}", self as *const _)) + .field("major_version", &self.major_version) + .field("minor_version", &self.minor_version) + .field("name", &self.name) + .field("description", &self.description) + .field("plugin_init", &self.plugin_init) + .field("version", &self.version) + .field("license", &self.license) + .field("source", &self.source) + .field("package", &self.package) + .field("origin", &self.origin) + .field("release_datetime", &self.release_datetime) + .finish() } } @@ -2155,7 +2544,8 @@ 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 _) + f.debug_struct(&format!("GstPluginFeatureClass @ {:?}", self as *const _)) + .finish() } } @@ -2164,11 +2554,13 @@ 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 _) + f.debug_struct(&format!("GstPoll @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPollFD { pub fd: c_int, pub idx: c_int, @@ -2176,11 +2568,14 @@ pub struct GstPollFD { impl ::std::fmt::Debug for GstPollFD { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPollFD @ {:?}", self as *const _) + f.debug_struct(&format!("GstPollFD @ {:?}", self as *const _)) + .field("fd", &self.fd) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPresetInterface { pub parent: gobject::GTypeInterface, pub get_preset_names: Option *mut *mut c_char>, @@ -2196,11 +2591,22 @@ pub struct GstPresetInterface { impl ::std::fmt::Debug for GstPresetInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstPresetInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstPresetInterface @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("get_preset_names", &self.get_preset_names) + .field("get_property_names", &self.get_property_names) + .field("load_preset", &self.load_preset) + .field("save_preset", &self.save_preset) + .field("rename_preset", &self.rename_preset) + .field("delete_preset", &self.delete_preset) + .field("set_meta", &self.set_meta) + .field("get_meta", &self.get_meta) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstProtectionMeta { pub meta: GstMeta, pub info: *mut GstStructure, @@ -2208,11 +2614,15 @@ pub struct GstProtectionMeta { impl ::std::fmt::Debug for GstProtectionMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstProtectionMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstProtectionMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("info", &self.info) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstProxyPadClass { pub parent_class: GstPadClass, pub _gst_reserved: [gpointer; 1], @@ -2220,7 +2630,9 @@ pub struct GstProxyPadClass { impl ::std::fmt::Debug for GstProxyPadClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstProxyPadClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstProxyPadClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -2229,11 +2641,13 @@ 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 _) + f.debug_struct(&format!("GstProxyPadPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstQuery { pub mini_object: GstMiniObject, pub type_: GstQueryType, @@ -2241,18 +2655,24 @@ pub struct GstQuery { impl ::std::fmt::Debug for GstQuery { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstQuery @ {:?}", self as *const _) + f.debug_struct(&format!("GstQuery @ {:?}", self as *const _)) + .field("mini_object", &self.mini_object) + .field("type_", &self.type_) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstRegistryClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -2261,7 +2681,8 @@ 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 _) + f.debug_struct(&format!("GstRegistryPrivate @ {:?}", self as *const _)) + .finish() } } @@ -2270,11 +2691,13 @@ 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 _) + f.debug_struct(&format!("GstSample @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstSegment { pub flags: GstSegmentFlags, pub rate: c_double, @@ -2292,11 +2715,24 @@ pub struct GstSegment { impl ::std::fmt::Debug for GstSegment { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstSegment @ {:?}", self as *const _) + f.debug_struct(&format!("GstSegment @ {:?}", self as *const _)) + .field("flags", &self.flags) + .field("rate", &self.rate) + .field("applied_rate", &self.applied_rate) + .field("format", &self.format) + .field("base", &self.base) + .field("offset", &self.offset) + .field("start", &self.start) + .field("stop", &self.stop) + .field("time", &self.time) + .field("position", &self.position) + .field("duration", &self.duration) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstStaticCaps { pub caps: *mut GstCaps, pub string: *const c_char, @@ -2305,11 +2741,15 @@ pub struct GstStaticCaps { impl ::std::fmt::Debug for GstStaticCaps { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstStaticCaps @ {:?}", self as *const _) + f.debug_struct(&format!("GstStaticCaps @ {:?}", self as *const _)) + .field("caps", &self.caps) + .field("string", &self.string) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstStaticPadTemplate { pub name_template: *const c_char, pub direction: GstPadDirection, @@ -2319,11 +2759,17 @@ pub struct GstStaticPadTemplate { impl ::std::fmt::Debug for GstStaticPadTemplate { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstStaticPadTemplate @ {:?}", self as *const _) + f.debug_struct(&format!("GstStaticPadTemplate @ {:?}", self as *const _)) + .field("name_template", &self.name_template) + .field("direction", &self.direction) + .field("presence", &self.presence) + .field("static_caps", &self.static_caps) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstStreamClass { pub parent_class: GstObjectClass, pub _gst_reserved: [gpointer; 4], @@ -2331,11 +2777,14 @@ pub struct GstStreamClass { impl ::std::fmt::Debug for GstStreamClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstStreamClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstStreamClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstStreamCollectionClass { pub parent_class: GstObjectClass, pub stream_notify: Option, @@ -2344,7 +2793,10 @@ pub struct GstStreamCollectionClass { impl ::std::fmt::Debug for GstStreamCollectionClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstStreamCollectionClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstStreamCollectionClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("stream_notify", &self.stream_notify) + .finish() } } @@ -2353,7 +2805,8 @@ 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 _) + f.debug_struct(&format!("GstStreamCollectionPrivate @ {:?}", self as *const _)) + .finish() } } @@ -2362,11 +2815,13 @@ 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 _) + f.debug_struct(&format!("GstStreamPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstStructure { pub type_: GType, pub name: glib::GQuark, @@ -2374,11 +2829,14 @@ pub struct GstStructure { impl ::std::fmt::Debug for GstStructure { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstStructure @ {:?}", self as *const _) + f.debug_struct(&format!("GstStructure @ {:?}", self as *const _)) + .field("type_", &self.type_) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstSystemClockClass { pub parent_class: GstClockClass, pub _gst_reserved: [gpointer; 4], @@ -2386,7 +2844,9 @@ pub struct GstSystemClockClass { impl ::std::fmt::Debug for GstSystemClockClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstSystemClockClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstSystemClockClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -2395,33 +2855,41 @@ 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 _) + f.debug_struct(&format!("GstSystemClockPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstTagList @ {:?}", self as *const _)) + .field("mini_object", &self.mini_object) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstTagSetterInterface @ {:?}", self as *const _)) + .field("g_iface", &self.g_iface) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstTaskClass { pub parent_class: GstObjectClass, pub pool: *mut GstTaskPool, @@ -2430,11 +2898,14 @@ pub struct GstTaskClass { impl ::std::fmt::Debug for GstTaskClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstTaskClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstTaskClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstTaskPoolClass { pub parent_class: GstObjectClass, pub prepare: Option, @@ -2446,7 +2917,13 @@ pub struct GstTaskPoolClass { impl ::std::fmt::Debug for GstTaskPoolClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstTaskPoolClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstTaskPoolClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("prepare", &self.prepare) + .field("cleanup", &self.cleanup) + .field("push", &self.push) + .field("join", &self.join) + .finish() } } @@ -2455,11 +2932,13 @@ 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 _) + f.debug_struct(&format!("GstTaskPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstTimedValue { pub timestamp: GstClockTime, pub value: c_double, @@ -2467,7 +2946,10 @@ pub struct GstTimedValue { impl ::std::fmt::Debug for GstTimedValue { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstTimedValue @ {:?}", self as *const _) + f.debug_struct(&format!("GstTimedValue @ {:?}", self as *const _)) + .field("timestamp", &self.timestamp) + .field("value", &self.value) + .finish() } } @@ -2476,7 +2958,8 @@ 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 _) + f.debug_struct(&format!("GstToc @ {:?}", self as *const _)) + .finish() } } @@ -2485,22 +2968,27 @@ 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 _) + f.debug_struct(&format!("GstTocEntry @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstTocSetterInterface @ {:?}", self as *const _)) + .field("g_iface", &self.g_iface) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstTracerClass { pub parent_class: GstObjectClass, pub _gst_reserved: [gpointer; 4], @@ -2508,7 +2996,9 @@ pub struct GstTracerClass { impl ::std::fmt::Debug for GstTracerClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstTracerClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstTracerClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -2517,7 +3007,8 @@ 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 _) + f.debug_struct(&format!("GstTracerFactoryClass @ {:?}", self as *const _)) + .finish() } } @@ -2526,7 +3017,8 @@ 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 _) + f.debug_struct(&format!("GstTracerPrivate @ {:?}", self as *const _)) + .finish() } } @@ -2535,11 +3027,13 @@ 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 _) + f.debug_struct(&format!("GstTracerRecordClass @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstTypeFind { pub peek: Option *const u8>, pub suggest: Option, @@ -2550,7 +3044,12 @@ pub struct GstTypeFind { impl ::std::fmt::Debug for GstTypeFind { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstTypeFind @ {:?}", self as *const _) + f.debug_struct(&format!("GstTypeFind @ {:?}", self as *const _)) + .field("peek", &self.peek) + .field("suggest", &self.suggest) + .field("data", &self.data) + .field("get_length", &self.get_length) + .finish() } } @@ -2559,11 +3058,13 @@ 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 _) + f.debug_struct(&format!("GstTypeFindFactoryClass @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstURIHandlerInterface { pub parent: gobject::GTypeInterface, pub get_type: Option GstURIType>, @@ -2574,7 +3075,13 @@ pub struct GstURIHandlerInterface { impl ::std::fmt::Debug for GstURIHandlerInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstURIHandlerInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstURIHandlerInterface @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("get_type", &self.get_type) + .field("get_protocols", &self.get_protocols) + .field("get_uri", &self.get_uri) + .field("set_uri", &self.set_uri) + .finish() } } @@ -2583,11 +3090,13 @@ 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 _) + f.debug_struct(&format!("GstUri @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstValueTable { pub type_: GType, pub compare: GstValueCompareFunc, @@ -2598,12 +3107,18 @@ pub struct GstValueTable { impl ::std::fmt::Debug for GstValueTable { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstValueTable @ {:?}", self as *const _) + f.debug_struct(&format!("GstValueTable @ {:?}", self as *const _)) + .field("type_", &self.type_) + .field("compare", &self.compare) + .field("serialize", &self.serialize) + .field("deserialize", &self.deserialize) + .finish() } } // Classes #[repr(C)] +#[derive(Copy, Clone)] pub struct GstAllocator { pub object: GstObject, pub mem_type: *const c_char, @@ -2630,13 +3145,12 @@ impl ::std::fmt::Debug for GstAllocator { .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)] +#[derive(Copy, Clone)] pub struct GstBin { pub element: GstElement, pub numchildren: c_int, @@ -2667,8 +3181,6 @@ impl ::std::fmt::Debug for GstBin { .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() } } @@ -2678,11 +3190,13 @@ 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 _) + f.debug_struct(&format!("GstBitmask @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstBufferPool { pub object: GstObject, pub flushing: c_int, @@ -2695,13 +3209,12 @@ impl ::std::fmt::Debug for GstBufferPool { 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)] +#[derive(Copy, Clone)] pub struct GstBus { pub object: GstObject, pub priv_: *mut GstBusPrivate, @@ -2712,13 +3225,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstClock { pub object: GstObject, pub priv_: *mut GstClockPrivate, @@ -2729,20 +3241,19 @@ 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)] +#[derive(Copy, Clone)] pub struct GstControlBinding { pub parent: GstObject, pub name: *mut c_char, pub pspec: *mut gobject::GParamSpec, pub object: *mut GstObject, pub disabled: gboolean, - pub _gst_reserved: [gpointer; 4], + pub ABI: GstControlBinding_ABI, } impl ::std::fmt::Debug for GstControlBinding { @@ -2751,14 +3262,13 @@ impl ::std::fmt::Debug for GstControlBinding { .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) + .field("ABI", &self.ABI) .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstControlSource { pub parent: GstObject, pub get_value: GstControlSourceGetValue, @@ -2772,12 +3282,12 @@ impl ::std::fmt::Debug for GstControlSource { .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)] +#[derive(Copy, Clone)] pub struct GstDevice { pub parent: GstObject, pub priv_: *mut GstDevicePrivate, @@ -2788,13 +3298,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstDeviceMonitor { pub parent: GstObject, pub priv_: *mut GstDeviceMonitorPrivate, @@ -2805,13 +3314,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstDeviceProvider { pub parent: GstObject, pub devices: *mut glib::GList, @@ -2824,8 +3332,6 @@ impl ::std::fmt::Debug for GstDeviceProvider { 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() } } @@ -2835,7 +3341,8 @@ 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 _) + f.debug_struct(&format!("GstDeviceProviderFactory @ {:?}", self as *const _)) + .finish() } } @@ -2844,7 +3351,8 @@ 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 _) + f.debug_struct(&format!("GstDoubleRange @ {:?}", self as *const _)) + .finish() } } @@ -2853,11 +3361,13 @@ 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 _) + f.debug_struct(&format!("GstDynamicTypeFactory @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstElement { pub object: GstObject, pub state_lock: glib::GRecMutex, @@ -2907,7 +3417,6 @@ impl ::std::fmt::Debug for GstElement { .field("sinkpads", &self.sinkpads) .field("pads_cookie", &self.pads_cookie) .field("contexts", &self.contexts) - .field("_gst_reserved", &self._gst_reserved) .finish() } } @@ -2917,7 +3426,8 @@ 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 _) + f.debug_struct(&format!("GstElementFactory @ {:?}", self as *const _)) + .finish() } } @@ -2926,7 +3436,8 @@ 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 _) + f.debug_struct(&format!("GstFlagSet @ {:?}", self as *const _)) + .finish() } } @@ -2935,7 +3446,8 @@ 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 _) + f.debug_struct(&format!("GstFraction @ {:?}", self as *const _)) + .finish() } } @@ -2944,11 +3456,13 @@ 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 _) + f.debug_struct(&format!("GstFractionRange @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstGhostPad { pub pad: GstProxyPad, pub priv_: *mut GstGhostPadPrivate, @@ -2958,7 +3472,6 @@ 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() } } @@ -2968,7 +3481,8 @@ 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 _) + f.debug_struct(&format!("GstInt64Range @ {:?}", self as *const _)) + .finish() } } @@ -2977,11 +3491,13 @@ 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 _) + f.debug_struct(&format!("GstIntRange @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstObject { pub object: gobject::GInitiallyUnowned, pub lock: glib::GMutex, @@ -3002,15 +3518,12 @@ impl ::std::fmt::Debug for GstObject { .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)] +#[derive(Copy, Clone)] pub struct GstPad { pub object: GstObject, pub element_private: gpointer, @@ -3056,7 +3569,7 @@ pub struct GstPad { pub num_probes: c_int, pub num_blocked: c_int, pub priv_: *mut GstPadPrivate, - pub _gst_reserved: [gpointer; 4], + pub ABI: GstPad_ABI, } impl ::std::fmt::Debug for GstPad { @@ -3066,52 +3579,13 @@ impl ::std::fmt::Debug for GstPad { .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) + .field("ABI", &self.ABI) .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPadTemplate { pub object: GstObject, pub name_template: *mut c_char, @@ -3129,7 +3603,6 @@ impl ::std::fmt::Debug for GstPadTemplate { .field("direction", &self.direction) .field("presence", &self.presence) .field("caps", &self.caps) - .field("_gst_reserved", &self._gst_reserved) .finish() } } @@ -3139,7 +3612,8 @@ 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 _) + f.debug_struct(&format!("GstParamArray @ {:?}", self as *const _)) + .finish() } } @@ -3148,11 +3622,13 @@ 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 _) + f.debug_struct(&format!("GstParamFraction @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstPipeline { pub bin: GstBin, pub fixed_clock: *mut GstClock, @@ -3169,8 +3645,6 @@ impl ::std::fmt::Debug for GstPipeline { .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() } } @@ -3180,7 +3654,8 @@ 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 _) + f.debug_struct(&format!("GstPlugin @ {:?}", self as *const _)) + .finish() } } @@ -3189,11 +3664,13 @@ 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 _) + f.debug_struct(&format!("GstPluginFeature @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstProxyPad { pub pad: GstPad, pub priv_: *mut GstProxyPadPrivate, @@ -3203,12 +3680,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstRegistry { pub object: GstObject, pub priv_: *mut GstRegistryPrivate, @@ -3218,12 +3695,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstStream { pub object: GstObject, pub stream_id: *const c_char, @@ -3236,13 +3713,12 @@ impl ::std::fmt::Debug for GstStream { 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)] +#[derive(Copy, Clone)] pub struct GstStreamCollection { pub object: GstObject, pub upstream_id: *mut c_char, @@ -3254,14 +3730,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstSystemClock { pub clock: GstClock, pub priv_: *mut GstSystemClockPrivate, @@ -3272,13 +3746,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstTask { pub object: GstObject, pub state: GstTaskState, @@ -3304,14 +3777,12 @@ impl ::std::fmt::Debug for GstTask { .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)] +#[derive(Copy, Clone)] pub struct GstTaskPool { pub object: GstObject, pub pool: *mut glib::GThreadPool, @@ -3322,13 +3793,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstTracer { pub parent: GstObject, pub priv_: *mut GstTracerPrivate, @@ -3339,8 +3809,6 @@ 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() } } @@ -3350,7 +3818,8 @@ 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 _) + f.debug_struct(&format!("GstTracerFactory @ {:?}", self as *const _)) + .finish() } } @@ -3359,7 +3828,8 @@ 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 _) + f.debug_struct(&format!("GstTracerRecord @ {:?}", self as *const _)) + .finish() } } @@ -3368,7 +3838,8 @@ 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 _) + f.debug_struct(&format!("GstTypeFindFactory @ {:?}", self as *const _)) + .finish() } } @@ -3377,7 +3848,8 @@ 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 _) + f.debug_struct(&format!("GstValueArray @ {:?}", self as *const _)) + .finish() } } @@ -3386,7 +3858,8 @@ 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 _) + f.debug_struct(&format!("GstValueList @ {:?}", self as *const _)) + .finish() } } diff --git a/gstreamer-tag-sys/src/lib.rs b/gstreamer-tag-sys/src/lib.rs index 40c7dc35e..a5699ceaa 100644 --- a/gstreamer-tag-sys/src/lib.rs +++ b/gstreamer-tag-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; #[macro_use] extern crate bitflags; @@ -120,6 +120,7 @@ pub const GST_TAG_LICENSE_FREE_SOFTWARE_FOUNDATION_LICENSE: GstTagLicenseFlags = // Records #[repr(C)] +#[derive(Copy, Clone)] pub struct GstTagDemuxClass { pub parent_class: gst::GstElementClass, pub min_start_size: c_uint, @@ -132,7 +133,14 @@ pub struct GstTagDemuxClass { impl ::std::fmt::Debug for GstTagDemuxClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstTagDemuxClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstTagDemuxClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("min_start_size", &self.min_start_size) + .field("min_end_size", &self.min_end_size) + .field("identify_tag", &self.identify_tag) + .field("parse_tag", &self.parse_tag) + .field("merge_tags", &self.merge_tags) + .finish() } } @@ -141,11 +149,13 @@ 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 _) + f.debug_struct(&format!("GstTagDemuxPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstTagMuxClass { pub parent_class: gst::GstElementClass, pub render_start_tag: Option *mut gst::GstBuffer>, @@ -155,7 +165,11 @@ pub struct GstTagMuxClass { impl ::std::fmt::Debug for GstTagMuxClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstTagMuxClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstTagMuxClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("render_start_tag", &self.render_start_tag) + .field("render_end_tag", &self.render_end_tag) + .finish() } } @@ -164,23 +178,28 @@ 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 _) + f.debug_struct(&format!("GstTagMuxPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstTagXmpWriterInterface @ {:?}", self as *const _)) + .field("parent", &self.parent) + .finish() } } // Classes #[repr(C)] +#[derive(Copy, Clone)] pub struct GstTagDemux { pub element: gst::GstElement, pub priv_: *mut GstTagDemuxPrivate, @@ -191,13 +210,12 @@ 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)] +#[derive(Copy, Clone)] pub struct GstTagMux { pub element: gst::GstElement, pub priv_: *mut GstTagMuxPrivate, @@ -208,8 +226,6 @@ 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() } } diff --git a/gstreamer-video-sys/src/lib.rs b/gstreamer-video-sys/src/lib.rs index 3aacdc01a..3017b13a1 100644 --- a/gstreamer-video-sys/src/lib.rs +++ b/gstreamer-video-sys/src/lib.rs @@ -1,7 +1,7 @@ -// This file was generated by gir (0113735) from gir-files (???) +// This file was generated by gir (81a781f) from gir-files (???) // DO NOT EDIT -#![allow(non_camel_case_types, non_upper_case_globals)] +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] extern crate libc; #[macro_use] extern crate bitflags; @@ -588,6 +588,38 @@ pub const GST_VIDEO_TIME_CODE_FLAGS_NONE: GstVideoTimeCodeFlags = GstVideoTimeCo pub const GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME: GstVideoTimeCodeFlags = GstVideoTimeCodeFlags::DROP_FRAME; pub const GST_VIDEO_TIME_CODE_FLAGS_INTERLACED: GstVideoTimeCodeFlags = GstVideoTimeCodeFlags::INTERLACED; +// Unions +#[repr(C)] +#[derive(Copy, Clone)] +pub union GstVideoCodecFrame_abidata { + pub ABI: GstVideoCodecFrame_abidata_ABI, + pub padding: [gpointer; 20], +} + +impl ::std::fmt::Debug for GstVideoCodecFrame_abidata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstVideoCodecFrame_abidata @ {:?}", self as *const _)) + .field("ABI", unsafe { &self.ABI }) + .field("padding", unsafe { &self.padding }) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub union GstVideoInfo_ABI { + pub abi: GstVideoInfo_ABI_abi, + pub _gst_reserved: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstVideoInfo_ABI { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstVideoInfo_ABI @ {:?}", self as *const _)) + .field("abi", unsafe { &self.abi }) + .finish() + } +} + // Callbacks pub type GstVideoAffineTransformationGetMatrix = Option gboolean>; pub type GstVideoConvertSampleCallback = Option; @@ -597,6 +629,7 @@ pub type GstVideoGLTextureUpload = Option, @@ -605,11 +638,15 @@ pub struct GstColorBalanceChannelClass { impl ::std::fmt::Debug for GstColorBalanceChannelClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstColorBalanceChannelClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstColorBalanceChannelClass @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("value_changed", &self.value_changed) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstColorBalanceInterface { pub iface: gobject::GTypeInterface, pub list_channels: Option *const glib::GList>, @@ -622,11 +659,19 @@ pub struct GstColorBalanceInterface { impl ::std::fmt::Debug for GstColorBalanceInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstColorBalanceInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstColorBalanceInterface @ {:?}", self as *const _)) + .field("iface", &self.iface) + .field("list_channels", &self.list_channels) + .field("set_value", &self.set_value) + .field("get_value", &self.get_value) + .field("get_balance_type", &self.get_balance_type) + .field("value_changed", &self.value_changed) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstNavigationInterface { pub iface: gobject::GTypeInterface, pub send_event: Option, @@ -634,11 +679,15 @@ pub struct GstNavigationInterface { impl ::std::fmt::Debug for GstNavigationInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstNavigationInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstNavigationInterface @ {:?}", self as *const _)) + .field("iface", &self.iface) + .field("send_event", &self.send_event) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoAffineTransformationMeta { pub meta: gst::GstMeta, pub matrix: [c_float; 16], @@ -646,11 +695,15 @@ pub struct GstVideoAffineTransformationMeta { impl ::std::fmt::Debug for GstVideoAffineTransformationMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoAffineTransformationMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoAffineTransformationMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("matrix", &self.matrix) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoAlignment { pub padding_top: c_uint, pub padding_bottom: c_uint, @@ -661,18 +714,27 @@ pub struct GstVideoAlignment { impl ::std::fmt::Debug for GstVideoAlignment { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoAlignment @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoAlignment @ {:?}", self as *const _)) + .field("padding_top", &self.padding_top) + .field("padding_bottom", &self.padding_bottom) + .field("padding_left", &self.padding_left) + .field("padding_right", &self.padding_right) + .field("stride_align", &self.stride_align) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstVideoBufferPoolClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() } } @@ -681,7 +743,8 @@ 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 _) + f.debug_struct(&format!("GstVideoBufferPoolPrivate @ {:?}", self as *const _)) + .finish() } } @@ -690,11 +753,13 @@ 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 _) + f.debug_struct(&format!("GstVideoChromaResample @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoCodecFrame { pub ref_count: c_int, pub flags: u32, @@ -711,32 +776,67 @@ pub struct GstVideoCodecFrame { pub events: *mut glib::GList, pub user_data: gpointer, pub user_data_destroy_notify: glib::GDestroyNotify, - pub padding: [c_void; 20], + pub abidata: GstVideoCodecFrame_abidata, } impl ::std::fmt::Debug for GstVideoCodecFrame { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoCodecFrame @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoCodecFrame @ {:?}", self as *const _)) + .field("system_frame_number", &self.system_frame_number) + .field("decode_frame_number", &self.decode_frame_number) + .field("presentation_frame_number", &self.presentation_frame_number) + .field("dts", &self.dts) + .field("pts", &self.pts) + .field("duration", &self.duration) + .field("distance_from_sync", &self.distance_from_sync) + .field("input_buffer", &self.input_buffer) + .field("output_buffer", &self.output_buffer) + .field("deadline", &self.deadline) + .field("abidata", &self.abidata) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] +pub struct GstVideoCodecFrame_abidata_ABI { + pub ts: gst::GstClockTime, + pub ts2: gst::GstClockTime, +} + +impl ::std::fmt::Debug for GstVideoCodecFrame_abidata_ABI { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstVideoCodecFrame_abidata_ABI @ {:?}", self as *const _)) + .field("ts", &self.ts) + .field("ts2", &self.ts2) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoCodecState { pub ref_count: c_int, pub info: GstVideoInfo, pub caps: *mut gst::GstCaps, pub codec_data: *mut gst::GstBuffer, pub allocation_caps: *mut gst::GstCaps, - pub padding: [c_void; 19], + pub padding: [gpointer; 19], } impl ::std::fmt::Debug for GstVideoCodecState { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoCodecState @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoCodecState @ {:?}", self as *const _)) + .field("info", &self.info) + .field("caps", &self.caps) + .field("codec_data", &self.codec_data) + .field("allocation_caps", &self.allocation_caps) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoColorPrimariesInfo { pub primaries: GstVideoColorPrimaries, pub Wx: c_double, @@ -751,11 +851,22 @@ pub struct GstVideoColorPrimariesInfo { impl ::std::fmt::Debug for GstVideoColorPrimariesInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoColorPrimariesInfo @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoColorPrimariesInfo @ {:?}", self as *const _)) + .field("primaries", &self.primaries) + .field("Wx", &self.Wx) + .field("Wy", &self.Wy) + .field("Rx", &self.Rx) + .field("Ry", &self.Ry) + .field("Gx", &self.Gx) + .field("Gy", &self.Gy) + .field("Bx", &self.Bx) + .field("By", &self.By) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoColorimetry { pub range: GstVideoColorRange, pub matrix: GstVideoColorMatrix, @@ -765,7 +876,12 @@ pub struct GstVideoColorimetry { impl ::std::fmt::Debug for GstVideoColorimetry { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoColorimetry @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoColorimetry @ {:?}", self as *const _)) + .field("range", &self.range) + .field("matrix", &self.matrix) + .field("transfer", &self.transfer) + .field("primaries", &self.primaries) + .finish() } } @@ -774,11 +890,13 @@ 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 _) + f.debug_struct(&format!("GstVideoConverter @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoCropMeta { pub meta: gst::GstMeta, pub x: c_uint, @@ -789,11 +907,18 @@ pub struct GstVideoCropMeta { impl ::std::fmt::Debug for GstVideoCropMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoCropMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoCropMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("x", &self.x) + .field("y", &self.y) + .field("width", &self.width) + .field("height", &self.height) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoDecoderClass { pub element_class: gst::GstElementClass, pub open: Option gboolean>, @@ -816,12 +941,33 @@ pub struct GstVideoDecoderClass { pub getcaps: Option *mut gst::GstCaps>, pub drain: Option gst::GstFlowReturn>, pub transform_meta: Option gboolean>, - pub padding: [c_void; 14], + pub padding: [gpointer; 14], } impl ::std::fmt::Debug for GstVideoDecoderClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoDecoderClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoDecoderClass @ {:?}", self as *const _)) + .field("open", &self.open) + .field("close", &self.close) + .field("start", &self.start) + .field("stop", &self.stop) + .field("parse", &self.parse) + .field("set_format", &self.set_format) + .field("reset", &self.reset) + .field("finish", &self.finish) + .field("handle_frame", &self.handle_frame) + .field("sink_event", &self.sink_event) + .field("src_event", &self.src_event) + .field("negotiate", &self.negotiate) + .field("decide_allocation", &self.decide_allocation) + .field("propose_allocation", &self.propose_allocation) + .field("flush", &self.flush) + .field("sink_query", &self.sink_query) + .field("src_query", &self.src_query) + .field("getcaps", &self.getcaps) + .field("drain", &self.drain) + .field("transform_meta", &self.transform_meta) + .finish() } } @@ -830,18 +976,22 @@ 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 _) + f.debug_struct(&format!("GstVideoDecoderPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] 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 _) + f.debug_struct(&format!("GstVideoDirectionInterface @ {:?}", self as *const _)) + .field("iface", &self.iface) + .finish() } } @@ -850,11 +1000,13 @@ 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 _) + f.debug_struct(&format!("GstVideoDither @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoEncoderClass { pub element_class: gst::GstElementClass, pub open: Option gboolean>, @@ -881,7 +1033,27 @@ pub struct GstVideoEncoderClass { impl ::std::fmt::Debug for GstVideoEncoderClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoEncoderClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoEncoderClass @ {:?}", self as *const _)) + .field("open", &self.open) + .field("close", &self.close) + .field("start", &self.start) + .field("stop", &self.stop) + .field("set_format", &self.set_format) + .field("handle_frame", &self.handle_frame) + .field("reset", &self.reset) + .field("finish", &self.finish) + .field("pre_push", &self.pre_push) + .field("getcaps", &self.getcaps) + .field("sink_event", &self.sink_event) + .field("src_event", &self.src_event) + .field("negotiate", &self.negotiate) + .field("decide_allocation", &self.decide_allocation) + .field("propose_allocation", &self.propose_allocation) + .field("flush", &self.flush) + .field("sink_query", &self.sink_query) + .field("src_query", &self.src_query) + .field("transform_meta", &self.transform_meta) + .finish() } } @@ -890,11 +1062,13 @@ 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 _) + f.debug_struct(&format!("GstVideoEncoderPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoFilterClass { pub parent_class: gst_base::GstBaseTransformClass, pub set_info: Option gboolean>, @@ -905,11 +1079,17 @@ pub struct GstVideoFilterClass { impl ::std::fmt::Debug for GstVideoFilterClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoFilterClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoFilterClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("set_info", &self.set_info) + .field("transform_frame", &self.transform_frame) + .field("transform_frame_ip", &self.transform_frame_ip) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoFormatInfo { pub format: GstVideoFormat, pub name: *const c_char, @@ -937,11 +1117,34 @@ pub struct GstVideoFormatInfo { impl ::std::fmt::Debug for GstVideoFormatInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoFormatInfo @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoFormatInfo @ {:?}", self as *const _)) + .field("format", &self.format) + .field("name", &self.name) + .field("description", &self.description) + .field("flags", &self.flags) + .field("bits", &self.bits) + .field("n_components", &self.n_components) + .field("shift", &self.shift) + .field("depth", &self.depth) + .field("pixel_stride", &self.pixel_stride) + .field("n_planes", &self.n_planes) + .field("plane", &self.plane) + .field("poffset", &self.poffset) + .field("w_sub", &self.w_sub) + .field("h_sub", &self.h_sub) + .field("unpack_format", &self.unpack_format) + .field("unpack_func", &self.unpack_func) + .field("pack_lines", &self.pack_lines) + .field("pack_func", &self.pack_func) + .field("tile_mode", &self.tile_mode) + .field("tile_ws", &self.tile_ws) + .field("tile_hs", &self.tile_hs) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoFrame { pub info: GstVideoInfo, pub flags: GstVideoFrameFlags, @@ -955,11 +1158,20 @@ pub struct GstVideoFrame { impl ::std::fmt::Debug for GstVideoFrame { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoFrame @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoFrame @ {:?}", self as *const _)) + .field("info", &self.info) + .field("flags", &self.flags) + .field("buffer", &self.buffer) + .field("meta", &self.meta) + .field("id", &self.id) + .field("data", &self.data) + .field("map", &self.map) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoGLTextureUploadMeta { pub meta: gst::GstMeta, pub texture_orientation: GstVideoGLTextureOrientation, @@ -974,11 +1186,17 @@ pub struct GstVideoGLTextureUploadMeta { impl ::std::fmt::Debug for GstVideoGLTextureUploadMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoGLTextureUploadMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoGLTextureUploadMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("texture_orientation", &self.texture_orientation) + .field("n_textures", &self.n_textures) + .field("texture_type", &self.texture_type) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoInfo { pub finfo: *const GstVideoFormatInfo, pub interlace_mode: GstVideoInterlaceMode, @@ -995,16 +1213,52 @@ pub struct GstVideoInfo { pub fps_d: c_int, pub offset: [size_t; 4], pub stride: [c_int; 4], - pub _gst_reserved: [gpointer; 4], + pub ABI: GstVideoInfo_ABI, } impl ::std::fmt::Debug for GstVideoInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoInfo @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoInfo @ {:?}", self as *const _)) + .field("finfo", &self.finfo) + .field("interlace_mode", &self.interlace_mode) + .field("flags", &self.flags) + .field("width", &self.width) + .field("height", &self.height) + .field("size", &self.size) + .field("views", &self.views) + .field("chroma_site", &self.chroma_site) + .field("colorimetry", &self.colorimetry) + .field("par_n", &self.par_n) + .field("par_d", &self.par_d) + .field("fps_n", &self.fps_n) + .field("fps_d", &self.fps_d) + .field("offset", &self.offset) + .field("stride", &self.stride) + .field("ABI", &self.ABI) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] +pub struct GstVideoInfo_ABI_abi { + pub multiview_mode: GstVideoMultiviewMode, + pub multiview_flags: GstVideoMultiviewFlags, + pub field_order: GstVideoFieldOrder, +} + +impl ::std::fmt::Debug for GstVideoInfo_ABI_abi { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstVideoInfo_ABI_abi @ {:?}", self as *const _)) + .field("multiview_mode", &self.multiview_mode) + .field("multiview_flags", &self.multiview_flags) + .field("field_order", &self.field_order) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoMeta { pub meta: gst::GstMeta, pub buffer: *mut gst::GstBuffer, @@ -1022,11 +1276,25 @@ pub struct GstVideoMeta { impl ::std::fmt::Debug for GstVideoMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("buffer", &self.buffer) + .field("flags", &self.flags) + .field("format", &self.format) + .field("id", &self.id) + .field("width", &self.width) + .field("height", &self.height) + .field("n_planes", &self.n_planes) + .field("offset", &self.offset) + .field("stride", &self.stride) + .field("map", &self.map) + .field("unmap", &self.unmap) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoMetaTransform { pub in_info: *mut GstVideoInfo, pub out_info: *mut GstVideoInfo, @@ -1034,11 +1302,15 @@ pub struct GstVideoMetaTransform { impl ::std::fmt::Debug for GstVideoMetaTransform { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoMetaTransform @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoMetaTransform @ {:?}", self as *const _)) + .field("in_info", &self.in_info) + .field("out_info", &self.out_info) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoOrientationInterface { pub iface: gobject::GTypeInterface, pub get_hflip: Option gboolean>, @@ -1053,7 +1325,17 @@ pub struct GstVideoOrientationInterface { impl ::std::fmt::Debug for GstVideoOrientationInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoOrientationInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoOrientationInterface @ {:?}", self as *const _)) + .field("iface", &self.iface) + .field("get_hflip", &self.get_hflip) + .field("get_vflip", &self.get_vflip) + .field("get_hcenter", &self.get_hcenter) + .field("get_vcenter", &self.get_vcenter) + .field("set_hflip", &self.set_hflip) + .field("set_vflip", &self.set_vflip) + .field("set_hcenter", &self.set_hcenter) + .field("set_vcenter", &self.set_vcenter) + .finish() } } @@ -1062,11 +1344,13 @@ 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 _) + f.debug_struct(&format!("GstVideoOverlayComposition @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoOverlayCompositionMeta { pub meta: gst::GstMeta, pub overlay: *mut GstVideoOverlayComposition, @@ -1074,11 +1358,15 @@ pub struct GstVideoOverlayCompositionMeta { impl ::std::fmt::Debug for GstVideoOverlayCompositionMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoOverlayCompositionMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoOverlayCompositionMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("overlay", &self.overlay) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoOverlayInterface { pub iface: gobject::GTypeInterface, pub expose: Option, @@ -1089,7 +1377,13 @@ pub struct GstVideoOverlayInterface { impl ::std::fmt::Debug for GstVideoOverlayInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoOverlayInterface @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoOverlayInterface @ {:?}", self as *const _)) + .field("iface", &self.iface) + .field("expose", &self.expose) + .field("handle_events", &self.handle_events) + .field("set_render_rectangle", &self.set_render_rectangle) + .field("set_window_handle", &self.set_window_handle) + .finish() } } @@ -1098,11 +1392,13 @@ 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 _) + f.debug_struct(&format!("GstVideoOverlayRectangle @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoRectangle { pub x: c_int, pub y: c_int, @@ -1112,11 +1408,17 @@ pub struct GstVideoRectangle { impl ::std::fmt::Debug for GstVideoRectangle { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoRectangle @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoRectangle @ {:?}", self as *const _)) + .field("x", &self.x) + .field("y", &self.y) + .field("w", &self.w) + .field("h", &self.h) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoRegionOfInterestMeta { pub meta: gst::GstMeta, pub roi_type: glib::GQuark, @@ -1130,11 +1432,21 @@ pub struct GstVideoRegionOfInterestMeta { impl ::std::fmt::Debug for GstVideoRegionOfInterestMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoRegionOfInterestMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoRegionOfInterestMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("roi_type", &self.roi_type) + .field("id", &self.id) + .field("parent_id", &self.parent_id) + .field("x", &self.x) + .field("y", &self.y) + .field("w", &self.w) + .field("h", &self.h) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoResampler { pub in_size: c_int, pub out_size: c_int, @@ -1149,7 +1461,16 @@ pub struct GstVideoResampler { impl ::std::fmt::Debug for GstVideoResampler { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoResampler @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoResampler @ {:?}", self as *const _)) + .field("in_size", &self.in_size) + .field("out_size", &self.out_size) + .field("max_taps", &self.max_taps) + .field("n_phases", &self.n_phases) + .field("offset", &self.offset) + .field("phase", &self.phase) + .field("n_taps", &self.n_taps) + .field("taps", &self.taps) + .finish() } } @@ -1158,11 +1479,13 @@ 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 _) + f.debug_struct(&format!("GstVideoScaler @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoSinkClass { pub parent_class: gst_base::GstBaseSinkClass, pub show_frame: Option gst::GstFlowReturn>, @@ -1171,7 +1494,10 @@ pub struct GstVideoSinkClass { impl ::std::fmt::Debug for GstVideoSinkClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoSinkClass @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoSinkClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("show_frame", &self.show_frame) + .finish() } } @@ -1180,11 +1506,13 @@ 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 _) + f.debug_struct(&format!("GstVideoSinkPrivate @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoTimeCode { pub config: GstVideoTimeCodeConfig, pub hours: c_uint, @@ -1196,11 +1524,19 @@ pub struct GstVideoTimeCode { impl ::std::fmt::Debug for GstVideoTimeCode { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoTimeCode @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoTimeCode @ {:?}", self as *const _)) + .field("config", &self.config) + .field("hours", &self.hours) + .field("minutes", &self.minutes) + .field("seconds", &self.seconds) + .field("frames", &self.frames) + .field("field_count", &self.field_count) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoTimeCodeConfig { pub fps_n: c_uint, pub fps_d: c_uint, @@ -1210,11 +1546,17 @@ pub struct GstVideoTimeCodeConfig { impl ::std::fmt::Debug for GstVideoTimeCodeConfig { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoTimeCodeConfig @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoTimeCodeConfig @ {:?}", self as *const _)) + .field("fps_n", &self.fps_n) + .field("fps_d", &self.fps_d) + .field("flags", &self.flags) + .field("latest_daily_jam", &self.latest_daily_jam) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoTimeCodeInterval { pub hours: c_uint, pub minutes: c_uint, @@ -1224,11 +1566,17 @@ pub struct GstVideoTimeCodeInterval { impl ::std::fmt::Debug for GstVideoTimeCodeInterval { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoTimeCodeInterval @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoTimeCodeInterval @ {:?}", self as *const _)) + .field("hours", &self.hours) + .field("minutes", &self.minutes) + .field("seconds", &self.seconds) + .field("frames", &self.frames) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoTimeCodeMeta { pub meta: gst::GstMeta, pub tc: GstVideoTimeCode, @@ -1236,12 +1584,16 @@ pub struct GstVideoTimeCodeMeta { impl ::std::fmt::Debug for GstVideoTimeCodeMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "GstVideoTimeCodeMeta @ {:?}", self as *const _) + f.debug_struct(&format!("GstVideoTimeCodeMeta @ {:?}", self as *const _)) + .field("meta", &self.meta) + .field("tc", &self.tc) + .finish() } } // Classes #[repr(C)] +#[derive(Copy, Clone)] pub struct GstColorBalanceChannel { pub parent: gobject::GObject, pub label: *mut c_char, @@ -1257,12 +1609,12 @@ impl ::std::fmt::Debug for GstColorBalanceChannel { .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)] +#[derive(Copy, Clone)] pub struct GstVideoBufferPool { pub bufferpool: gst::GstBufferPool, pub priv_: *mut GstVideoBufferPoolPrivate, @@ -1278,6 +1630,7 @@ impl ::std::fmt::Debug for GstVideoBufferPool { } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoDecoder { pub element: gst::GstElement, pub sinkpad: *mut gst::GstPad, @@ -1286,26 +1639,18 @@ pub struct GstVideoDecoder { pub input_segment: gst::GstSegment, pub output_segment: gst::GstSegment, pub priv_: *mut GstVideoDecoderPrivate, - pub padding: [c_void; 20], + pub padding: [gpointer; 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)] +#[derive(Copy, Clone)] pub struct GstVideoEncoder { pub element: gst::GstElement, pub sinkpad: *mut gst::GstPad, @@ -1314,26 +1659,18 @@ pub struct GstVideoEncoder { pub input_segment: gst::GstSegment, pub output_segment: gst::GstSegment, pub priv_: *mut GstVideoEncoderPrivate, - pub padding: [c_void; 20], + pub padding: [gpointer; 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)] +#[derive(Copy, Clone)] pub struct GstVideoFilter { pub element: gst_base::GstBaseTransform, pub negotiated: gboolean, @@ -1349,7 +1686,6 @@ impl ::std::fmt::Debug for GstVideoFilter { .field("negotiated", &self.negotiated) .field("in_info", &self.in_info) .field("out_info", &self.out_info) - .field("_gst_reserved", &self._gst_reserved) .finish() } } @@ -1359,11 +1695,13 @@ 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 _) + f.debug_struct(&format!("GstVideoMultiviewFlagsSet @ {:?}", self as *const _)) + .finish() } } #[repr(C)] +#[derive(Copy, Clone)] pub struct GstVideoSink { pub element: gst_base::GstBaseSink, pub width: c_int, @@ -1378,8 +1716,6 @@ impl ::std::fmt::Debug for GstVideoSink { .field("element", &self.element) .field("width", &self.width) .field("height", &self.height) - .field("priv_", &self.priv_) - .field("_gst_reserved", &self._gst_reserved) .finish() } }