This commit is contained in:
Guillaume Gomez 2017-11-27 10:47:02 +01:00 committed by Sebastian Dröge
parent 8e49fa9f49
commit bcc17efdfb
10 changed files with 2719 additions and 10 deletions

View file

@ -1,4 +1,4 @@
// This file was generated by gir (94e079d) from gir-files (???) // This file was generated by gir (0113735) from gir-files (???)
// DO NOT EDIT // DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)] #![allow(non_camel_case_types, non_upper_case_globals)]
@ -31,6 +31,12 @@ pub struct GstAppSinkCallbacks {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAppSinkCallbacks {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSinkCallbacks @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAppSinkClass { pub struct GstAppSinkClass {
pub basesink_class: gst_base::GstBaseSinkClass, pub basesink_class: gst_base::GstBaseSinkClass,
@ -44,9 +50,21 @@ pub struct GstAppSinkClass {
pub _gst_reserved: [gpointer; 2], pub _gst_reserved: [gpointer; 2],
} }
impl ::std::fmt::Debug for GstAppSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSinkClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAppSinkPrivate(c_void); pub struct GstAppSinkPrivate(c_void);
impl ::std::fmt::Debug for GstAppSinkPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSinkPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAppSrcCallbacks { pub struct GstAppSrcCallbacks {
pub need_data: Option<unsafe extern "C" fn(*mut GstAppSrc, c_uint, gpointer)>, pub need_data: Option<unsafe extern "C" fn(*mut GstAppSrc, c_uint, gpointer)>,
@ -55,6 +73,12 @@ pub struct GstAppSrcCallbacks {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAppSrcCallbacks {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSrcCallbacks @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAppSrcClass { pub struct GstAppSrcClass {
pub basesrc_class: gst_base::GstBaseSrcClass, pub basesrc_class: gst_base::GstBaseSrcClass,
@ -67,9 +91,21 @@ pub struct GstAppSrcClass {
pub _gst_reserved: [gpointer; 3], pub _gst_reserved: [gpointer; 3],
} }
impl ::std::fmt::Debug for GstAppSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSrcClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAppSrcPrivate(c_void); pub struct GstAppSrcPrivate(c_void);
impl ::std::fmt::Debug for GstAppSrcPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSrcPrivate @ {:?}", self as *const _)
}
}
// Classes // Classes
#[repr(C)] #[repr(C)]
pub struct GstAppSink { pub struct GstAppSink {
@ -78,6 +114,16 @@ pub struct GstAppSink {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAppSink {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAppSink @ {:?}", self as *const _))
.field("basesink", &self.basesink)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAppSrc { pub struct GstAppSrc {
pub basesrc: gst_base::GstBaseSrc, pub basesrc: gst_base::GstBaseSrc,
@ -85,6 +131,16 @@ pub struct GstAppSrc {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAppSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAppSrc @ {:?}", self as *const _))
.field("basesrc", &self.basesrc)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
extern "C" { extern "C" {
//========================================================================= //=========================================================================

View file

@ -1,4 +1,4 @@
// This file was generated by gir (94e079d) from gir-files (???) // This file was generated by gir (0113735) from gir-files (???)
// DO NOT EDIT // DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)] #![allow(non_camel_case_types, non_upper_case_globals)]
@ -311,9 +311,21 @@ pub struct GstAudioBaseSinkClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioBaseSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioBaseSinkClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioBaseSinkPrivate(c_void); pub struct GstAudioBaseSinkPrivate(c_void);
impl ::std::fmt::Debug for GstAudioBaseSinkPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioBaseSinkPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioBaseSrcClass { pub struct GstAudioBaseSrcClass {
pub parent_class: gst_base::GstPushSrcClass, pub parent_class: gst_base::GstPushSrcClass,
@ -321,9 +333,21 @@ pub struct GstAudioBaseSrcClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioBaseSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioBaseSrcClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioBaseSrcPrivate(c_void); pub struct GstAudioBaseSrcPrivate(c_void);
impl ::std::fmt::Debug for GstAudioBaseSrcPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioBaseSrcPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioCdSrcClass { pub struct GstAudioCdSrcClass {
pub pushsrc_class: gst_base::GstPushSrcClass, pub pushsrc_class: gst_base::GstPushSrcClass,
@ -333,9 +357,21 @@ pub struct GstAudioCdSrcClass {
pub _gst_reserved: [gpointer; 20], pub _gst_reserved: [gpointer; 20],
} }
impl ::std::fmt::Debug for GstAudioCdSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioCdSrcClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioCdSrcPrivate(c_void); pub struct GstAudioCdSrcPrivate(c_void);
impl ::std::fmt::Debug for GstAudioCdSrcPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioCdSrcPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioCdSrcTrack { pub struct GstAudioCdSrcTrack {
pub is_audio: gboolean, pub is_audio: gboolean,
@ -347,9 +383,21 @@ pub struct GstAudioCdSrcTrack {
pub _gst_reserved2: [gpointer; 2], pub _gst_reserved2: [gpointer; 2],
} }
impl ::std::fmt::Debug for GstAudioCdSrcTrack {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioCdSrcTrack @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioChannelMixer(c_void); pub struct GstAudioChannelMixer(c_void);
impl ::std::fmt::Debug for GstAudioChannelMixer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioChannelMixer @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioClippingMeta { pub struct GstAudioClippingMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
@ -358,15 +406,33 @@ pub struct GstAudioClippingMeta {
pub end: u64, pub end: u64,
} }
impl ::std::fmt::Debug for GstAudioClippingMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioClippingMeta @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioClockClass { pub struct GstAudioClockClass {
pub parent_class: gst::GstSystemClockClass, pub parent_class: gst::GstSystemClockClass,
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioClockClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioClockClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioConverter(c_void); pub struct GstAudioConverter(c_void);
impl ::std::fmt::Debug for GstAudioConverter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioConverter @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioDecoderClass { pub struct GstAudioDecoderClass {
pub element_class: gst::GstElementClass, pub element_class: gst::GstElementClass,
@ -391,9 +457,21 @@ pub struct GstAudioDecoderClass {
pub _gst_reserved: [gpointer; 16], pub _gst_reserved: [gpointer; 16],
} }
impl ::std::fmt::Debug for GstAudioDecoderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioDecoderClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioDecoderPrivate(c_void); pub struct GstAudioDecoderPrivate(c_void);
impl ::std::fmt::Debug for GstAudioDecoderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioDecoderPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioDownmixMeta { pub struct GstAudioDownmixMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
@ -404,6 +482,12 @@ pub struct GstAudioDownmixMeta {
pub matrix: *mut *mut c_float, pub matrix: *mut *mut c_float,
} }
impl ::std::fmt::Debug for GstAudioDownmixMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioDownmixMeta @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioEncoderClass { pub struct GstAudioEncoderClass {
pub element_class: gst::GstElementClass, pub element_class: gst::GstElementClass,
@ -427,9 +511,21 @@ pub struct GstAudioEncoderClass {
pub _gst_reserved: [gpointer; 17], pub _gst_reserved: [gpointer; 17],
} }
impl ::std::fmt::Debug for GstAudioEncoderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioEncoderClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioEncoderPrivate(c_void); pub struct GstAudioEncoderPrivate(c_void);
impl ::std::fmt::Debug for GstAudioEncoderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioEncoderPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioFilterClass { pub struct GstAudioFilterClass {
pub basetransformclass: gst_base::GstBaseTransformClass, pub basetransformclass: gst_base::GstBaseTransformClass,
@ -437,6 +533,12 @@ pub struct GstAudioFilterClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioFilterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioFilterClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioFormatInfo { pub struct GstAudioFormatInfo {
pub format: GstAudioFormat, pub format: GstAudioFormat,
@ -453,6 +555,12 @@ pub struct GstAudioFormatInfo {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioFormatInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioFormatInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioInfo { pub struct GstAudioInfo {
pub finfo: *const GstAudioFormatInfo, pub finfo: *const GstAudioFormatInfo,
@ -465,12 +573,30 @@ pub struct GstAudioInfo {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioQuantize(c_void); pub struct GstAudioQuantize(c_void);
impl ::std::fmt::Debug for GstAudioQuantize {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioQuantize @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioResampler(c_void); pub struct GstAudioResampler(c_void);
impl ::std::fmt::Debug for GstAudioResampler {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioResampler @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioRingBufferClass { pub struct GstAudioRingBufferClass {
pub parent_class: gst::GstObjectClass, pub parent_class: gst::GstObjectClass,
@ -489,6 +615,12 @@ pub struct GstAudioRingBufferClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioRingBufferClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioRingBufferClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioRingBufferSpec { pub struct GstAudioRingBufferSpec {
pub caps: *mut gst::GstCaps, pub caps: *mut gst::GstCaps,
@ -502,6 +634,12 @@ pub struct GstAudioRingBufferSpec {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioRingBufferSpec {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioRingBufferSpec @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioSinkClass { pub struct GstAudioSinkClass {
pub parent_class: GstAudioBaseSinkClass, pub parent_class: GstAudioBaseSinkClass,
@ -515,6 +653,12 @@ pub struct GstAudioSinkClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioSinkClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioSrcClass { pub struct GstAudioSrcClass {
pub parent_class: GstAudioBaseSrcClass, pub parent_class: GstAudioBaseSrcClass,
@ -528,11 +672,23 @@ pub struct GstAudioSrcClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioSrcClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstStreamVolumeInterface { pub struct GstStreamVolumeInterface {
pub iface: gobject::GTypeInterface, pub iface: gobject::GTypeInterface,
} }
impl ::std::fmt::Debug for GstStreamVolumeInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstStreamVolumeInterface @ {:?}", self as *const _)
}
}
// Classes // Classes
#[repr(C)] #[repr(C)]
pub struct GstAudioBaseSink { pub struct GstAudioBaseSink {
@ -547,6 +703,22 @@ pub struct GstAudioBaseSink {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioBaseSink {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioBaseSink @ {:?}", self as *const _))
.field("element", &self.element)
.field("ringbuffer", &self.ringbuffer)
.field("buffer_time", &self.buffer_time)
.field("latency_time", &self.latency_time)
.field("next_sample", &self.next_sample)
.field("provided_clock", &self.provided_clock)
.field("eos_rendering", &self.eos_rendering)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioBaseSrc { pub struct GstAudioBaseSrc {
pub element: gst_base::GstPushSrc, pub element: gst_base::GstPushSrc,
@ -559,6 +731,21 @@ pub struct GstAudioBaseSrc {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioBaseSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioBaseSrc @ {:?}", self as *const _))
.field("element", &self.element)
.field("ringbuffer", &self.ringbuffer)
.field("buffer_time", &self.buffer_time)
.field("latency_time", &self.latency_time)
.field("next_sample", &self.next_sample)
.field("clock", &self.clock)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioCdSrc { pub struct GstAudioCdSrc {
pub pushsrc: gst_base::GstPushSrc, pub pushsrc: gst_base::GstPushSrc,
@ -568,6 +755,18 @@ pub struct GstAudioCdSrc {
pub _gst_reserved2: [gpointer; 2], pub _gst_reserved2: [gpointer; 2],
} }
impl ::std::fmt::Debug for GstAudioCdSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioCdSrc @ {:?}", self as *const _))
.field("pushsrc", &self.pushsrc)
.field("tags", &self.tags)
.field("priv_", &self.priv_)
.field("_gst_reserved1", &self._gst_reserved1)
.field("_gst_reserved2", &self._gst_reserved2)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioClock { pub struct GstAudioClock {
pub clock: gst::GstSystemClock, pub clock: gst::GstSystemClock,
@ -579,6 +778,20 @@ pub struct GstAudioClock {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioClock {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioClock @ {:?}", self as *const _))
.field("clock", &self.clock)
.field("func", &self.func)
.field("user_data", &self.user_data)
.field("destroy_notify", &self.destroy_notify)
.field("last_time", &self.last_time)
.field("time_offset", &self.time_offset)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioDecoder { pub struct GstAudioDecoder {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -591,6 +804,21 @@ pub struct GstAudioDecoder {
pub _gst_reserved: [gpointer; 20], pub _gst_reserved: [gpointer; 20],
} }
impl ::std::fmt::Debug for GstAudioDecoder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioDecoder @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("srcpad", &self.srcpad)
.field("stream_lock", &self.stream_lock)
.field("input_segment", &self.input_segment)
.field("output_segment", &self.output_segment)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioEncoder { pub struct GstAudioEncoder {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -603,6 +831,21 @@ pub struct GstAudioEncoder {
pub _gst_reserved: [gpointer; 20], pub _gst_reserved: [gpointer; 20],
} }
impl ::std::fmt::Debug for GstAudioEncoder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioEncoder @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("srcpad", &self.srcpad)
.field("stream_lock", &self.stream_lock)
.field("input_segment", &self.input_segment)
.field("output_segment", &self.output_segment)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioFilter { pub struct GstAudioFilter {
pub basetransform: gst_base::GstBaseTransform, pub basetransform: gst_base::GstBaseTransform,
@ -610,6 +853,16 @@ pub struct GstAudioFilter {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioFilter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioFilter @ {:?}", self as *const _))
.field("basetransform", &self.basetransform)
.field("info", &self.info)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioRingBuffer { pub struct GstAudioRingBuffer {
pub object: gst::GstObject, pub object: gst::GstObject,
@ -637,6 +890,36 @@ pub struct GstAudioRingBuffer {
pub _gst_reserved: [gpointer; 3], pub _gst_reserved: [gpointer; 3],
} }
impl ::std::fmt::Debug for GstAudioRingBuffer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioRingBuffer @ {:?}", self as *const _))
.field("object", &self.object)
.field("cond", &self.cond)
.field("open", &self.open)
.field("acquired", &self.acquired)
.field("memory", &self.memory)
.field("size", &self.size)
.field("timestamps", &self.timestamps)
.field("spec", &self.spec)
.field("samples_per_seg", &self.samples_per_seg)
.field("empty_seg", &self.empty_seg)
.field("state", &self.state)
.field("segdone", &self.segdone)
.field("segbase", &self.segbase)
.field("waiting", &self.waiting)
.field("callback", &self.callback)
.field("cb_data", &self.cb_data)
.field("need_reorder", &self.need_reorder)
.field("channel_reorder_map", &format!("{:?}", &self.channel_reorder_map as *const _))
.field("flushing", &self.flushing)
.field("may_start", &self.may_start)
.field("active", &self.active)
.field("cb_data_notify", &self.cb_data_notify)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioSink { pub struct GstAudioSink {
pub element: GstAudioBaseSink, pub element: GstAudioBaseSink,
@ -644,6 +927,16 @@ pub struct GstAudioSink {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioSink {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioSink @ {:?}", self as *const _))
.field("element", &self.element)
.field("thread", &self.thread)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioSrc { pub struct GstAudioSrc {
pub element: GstAudioBaseSrc, pub element: GstAudioBaseSrc,
@ -651,10 +944,27 @@ pub struct GstAudioSrc {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstAudioSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioSrc @ {:?}", self as *const _))
.field("element", &self.element)
.field("thread", &self.thread)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
// Interfaces // Interfaces
#[repr(C)] #[repr(C)]
pub struct GstStreamVolume(c_void); pub struct GstStreamVolume(c_void);
impl ::std::fmt::Debug for GstStreamVolume {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstStreamVolume @ {:?}", self as *const _)
}
}
extern "C" { extern "C" {
//========================================================================= //=========================================================================

View file

@ -1,4 +1,4 @@
// This file was generated by gir (94e079d) from gir-files (???) // This file was generated by gir (0113735) from gir-files (???)
// DO NOT EDIT // DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)] #![allow(non_camel_case_types, non_upper_case_globals)]
@ -88,6 +88,12 @@ pub type GstTypeFindHelperGetRangeFunction = Option<unsafe extern "C" fn(*mut gs
#[repr(C)] #[repr(C)]
pub struct GstAdapterClass(c_void); pub struct GstAdapterClass(c_void);
impl ::std::fmt::Debug for GstAdapterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAdapterClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseParseClass { pub struct GstBaseParseClass {
pub parent_class: gst::GstElementClass, pub parent_class: gst::GstElementClass,
@ -106,6 +112,12 @@ pub struct GstBaseParseClass {
pub _gst_reserved: [gpointer; 18], pub _gst_reserved: [gpointer; 18],
} }
impl ::std::fmt::Debug for GstBaseParseClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseParseClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseParseFrame { pub struct GstBaseParseFrame {
pub buffer: *mut gst::GstBuffer, pub buffer: *mut gst::GstBuffer,
@ -119,9 +131,21 @@ pub struct GstBaseParseFrame {
pub _private_flags: c_uint, pub _private_flags: c_uint,
} }
impl ::std::fmt::Debug for GstBaseParseFrame {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseParseFrame @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseParsePrivate(c_void); pub struct GstBaseParsePrivate(c_void);
impl ::std::fmt::Debug for GstBaseParsePrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseParsePrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseSinkClass { pub struct GstBaseSinkClass {
pub parent_class: gst::GstElementClass, pub parent_class: gst::GstElementClass,
@ -146,9 +170,21 @@ pub struct GstBaseSinkClass {
pub _gst_reserved: [gpointer; 20], pub _gst_reserved: [gpointer; 20],
} }
impl ::std::fmt::Debug for GstBaseSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseSinkClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseSinkPrivate(c_void); pub struct GstBaseSinkPrivate(c_void);
impl ::std::fmt::Debug for GstBaseSinkPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseSinkPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseSrcClass { pub struct GstBaseSrcClass {
pub parent_class: gst::GstElementClass, pub parent_class: gst::GstElementClass,
@ -174,9 +210,21 @@ pub struct GstBaseSrcClass {
pub _gst_reserved: [gpointer; 20], pub _gst_reserved: [gpointer; 20],
} }
impl ::std::fmt::Debug for GstBaseSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseSrcClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseSrcPrivate(c_void); pub struct GstBaseSrcPrivate(c_void);
impl ::std::fmt::Debug for GstBaseSrcPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseSrcPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseTransformClass { pub struct GstBaseTransformClass {
pub parent_class: gst::GstElementClass, pub parent_class: gst::GstElementClass,
@ -207,9 +255,21 @@ pub struct GstBaseTransformClass {
pub _gst_reserved: [gpointer; 18], pub _gst_reserved: [gpointer; 18],
} }
impl ::std::fmt::Debug for GstBaseTransformClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseTransformClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseTransformPrivate(c_void); pub struct GstBaseTransformPrivate(c_void);
impl ::std::fmt::Debug for GstBaseTransformPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseTransformPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBitReader { pub struct GstBitReader {
pub data: *mut u8, pub data: *mut u8,
@ -219,6 +279,12 @@ pub struct GstBitReader {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstBitReader {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBitReader @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstByteReader { pub struct GstByteReader {
pub data: *mut u8, pub data: *mut u8,
@ -227,6 +293,12 @@ pub struct GstByteReader {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstByteReader {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstByteReader @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstByteWriter { pub struct GstByteWriter {
pub parent: GstByteReader, pub parent: GstByteReader,
@ -236,6 +308,12 @@ pub struct GstByteWriter {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstByteWriter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstByteWriter @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstCollectData { pub struct GstCollectData {
pub collect: *mut GstCollectPads, pub collect: *mut GstCollectPads,
@ -248,18 +326,42 @@ pub struct GstCollectData {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstCollectData {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstCollectData @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstCollectDataPrivate(c_void); pub struct GstCollectDataPrivate(c_void);
impl ::std::fmt::Debug for GstCollectDataPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstCollectDataPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstCollectPadsClass { pub struct GstCollectPadsClass {
pub parent_class: gst::GstObjectClass, pub parent_class: gst::GstObjectClass,
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstCollectPadsClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstCollectPadsClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstCollectPadsPrivate(c_void); pub struct GstCollectPadsPrivate(c_void);
impl ::std::fmt::Debug for GstCollectPadsPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstCollectPadsPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDataQueueClass { pub struct GstDataQueueClass {
pub parent_class: gobject::GObjectClass, pub parent_class: gobject::GObjectClass,
@ -268,6 +370,12 @@ pub struct GstDataQueueClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstDataQueueClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDataQueueClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDataQueueItem { pub struct GstDataQueueItem {
pub object: *mut gst::GstMiniObject, pub object: *mut gst::GstMiniObject,
@ -278,9 +386,21 @@ pub struct GstDataQueueItem {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstDataQueueItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDataQueueItem @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDataQueuePrivate(c_void); pub struct GstDataQueuePrivate(c_void);
impl ::std::fmt::Debug for GstDataQueuePrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDataQueuePrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDataQueueSize { pub struct GstDataQueueSize {
pub visible: c_uint, pub visible: c_uint,
@ -288,9 +408,21 @@ pub struct GstDataQueueSize {
pub time: u64, pub time: u64,
} }
impl ::std::fmt::Debug for GstDataQueueSize {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDataQueueSize @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstFlowCombiner(c_void); pub struct GstFlowCombiner(c_void);
impl ::std::fmt::Debug for GstFlowCombiner {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstFlowCombiner @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPushSrcClass { pub struct GstPushSrcClass {
pub parent_class: GstBaseSrcClass, pub parent_class: GstBaseSrcClass,
@ -300,13 +432,31 @@ pub struct GstPushSrcClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstPushSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPushSrcClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstQueueArray(c_void); pub struct GstQueueArray(c_void);
impl ::std::fmt::Debug for GstQueueArray {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstQueueArray @ {:?}", self as *const _)
}
}
// Classes // Classes
#[repr(C)] #[repr(C)]
pub struct GstAdapter(c_void); pub struct GstAdapter(c_void);
impl ::std::fmt::Debug for GstAdapter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAdapter @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseParse { pub struct GstBaseParse {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -318,6 +468,20 @@ pub struct GstBaseParse {
pub priv_: *mut GstBaseParsePrivate, pub priv_: *mut GstBaseParsePrivate,
} }
impl ::std::fmt::Debug for GstBaseParse {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstBaseParse @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("srcpad", &self.srcpad)
.field("flags", &self.flags)
.field("segment", &self.segment)
.field("_gst_reserved", &self._gst_reserved)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseSink { pub struct GstBaseSink {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -343,6 +507,34 @@ pub struct GstBaseSink {
pub _gst_reserved: [gpointer; 20], pub _gst_reserved: [gpointer; 20],
} }
impl ::std::fmt::Debug for GstBaseSink {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstBaseSink @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("pad_mode", &self.pad_mode)
.field("offset", &self.offset)
.field("can_activate_pull", &self.can_activate_pull)
.field("can_activate_push", &self.can_activate_push)
.field("preroll_lock", &self.preroll_lock)
.field("preroll_cond", &self.preroll_cond)
.field("eos", &self.eos)
.field("need_preroll", &self.need_preroll)
.field("have_preroll", &self.have_preroll)
.field("playing_async", &self.playing_async)
.field("have_newsegment", &self.have_newsegment)
.field("segment", &self.segment)
.field("clock_id", &self.clock_id)
.field("sync", &self.sync)
.field("flushing", &self.flushing)
.field("running", &self.running)
.field("max_lateness", &self.max_lateness)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseSrc { pub struct GstBaseSrc {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -366,6 +558,32 @@ pub struct GstBaseSrc {
pub _gst_reserved: [gpointer; 20], pub _gst_reserved: [gpointer; 20],
} }
impl ::std::fmt::Debug for GstBaseSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstBaseSrc @ {:?}", self as *const _))
.field("element", &self.element)
.field("srcpad", &self.srcpad)
.field("live_lock", &self.live_lock)
.field("live_cond", &self.live_cond)
.field("is_live", &self.is_live)
.field("live_running", &self.live_running)
.field("blocksize", &self.blocksize)
.field("can_activate_push", &self.can_activate_push)
.field("random_access", &self.random_access)
.field("clock_id", &self.clock_id)
.field("segment", &self.segment)
.field("need_newsegment", &self.need_newsegment)
.field("num_buffers", &self.num_buffers)
.field("num_buffers_left", &self.num_buffers_left)
.field("typefind", &self.typefind)
.field("running", &self.running)
.field("pending_seek", &self.pending_seek)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstBaseTransform { pub struct GstBaseTransform {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -378,6 +596,21 @@ pub struct GstBaseTransform {
pub _gst_reserved: [gpointer; 19], pub _gst_reserved: [gpointer; 19],
} }
impl ::std::fmt::Debug for GstBaseTransform {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstBaseTransform @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("srcpad", &self.srcpad)
.field("have_segment", &self.have_segment)
.field("segment", &self.segment)
.field("queued_buf", &self.queued_buf)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstCollectPads { pub struct GstCollectPads {
pub object: gst::GstObject, pub object: gst::GstObject,
@ -387,6 +620,18 @@ pub struct GstCollectPads {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstCollectPads {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstCollectPads @ {:?}", self as *const _))
.field("object", &self.object)
.field("data", &self.data)
.field("stream_lock", &self.stream_lock)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstDataQueue { pub struct GstDataQueue {
pub object: gobject::GObject, pub object: gobject::GObject,
@ -394,12 +639,31 @@ pub struct GstDataQueue {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstDataQueue {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstDataQueue @ {:?}", self as *const _))
.field("object", &self.object)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstPushSrc { pub struct GstPushSrc {
pub parent: GstBaseSrc, pub parent: GstBaseSrc,
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstPushSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstPushSrc @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
extern "C" { extern "C" {
//========================================================================= //=========================================================================

View file

@ -8,7 +8,7 @@ pkg-config = "0.3.7"
[dependencies] [dependencies]
libc = "0.2" libc = "0.2"
glib-sys = { git = "https://github.com/gtk-rs/sys" } glib-sys = { git = "https://github.com/gtk-rs/sys" }
gobject-sys = { git = "https://github.com/gtk-rs/sys" } gobject-sys = { git = "https://github.com/gtk-rs/sys" }
[dependencies.gstreamer-base-sys] [dependencies.gstreamer-base-sys]
path = "../gstreamer-base-sys" path = "../gstreamer-base-sys"

View file

@ -1,4 +1,4 @@
// This file was generated by gir (94e079d) from gir-files (???) // This file was generated by gir (0113735) from gir-files (???)
// DO NOT EDIT // DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)] #![allow(non_camel_case_types, non_upper_case_globals)]
@ -581,6 +581,12 @@ pub struct GstMpegtsAtscEIT {
pub events: *mut glib::GPtrArray, pub events: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsAtscEIT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscEIT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscEITEvent { pub struct GstMpegtsAtscEITEvent {
pub event_id: u16, pub event_id: u16,
@ -591,6 +597,12 @@ pub struct GstMpegtsAtscEITEvent {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsAtscEITEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscEITEvent @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscETT { pub struct GstMpegtsAtscETT {
pub ett_table_id_extension: u16, pub ett_table_id_extension: u16,
@ -599,6 +611,12 @@ pub struct GstMpegtsAtscETT {
pub messages: *mut glib::GPtrArray, pub messages: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsAtscETT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscETT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscMGT { pub struct GstMpegtsAtscMGT {
pub protocol_version: u8, pub protocol_version: u8,
@ -607,6 +625,12 @@ pub struct GstMpegtsAtscMGT {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsAtscMGT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscMGT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscMGTTable { pub struct GstMpegtsAtscMGTTable {
pub table_type: u16, pub table_type: u16,
@ -616,12 +640,24 @@ pub struct GstMpegtsAtscMGTTable {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsAtscMGTTable {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscMGTTable @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscMultString { pub struct GstMpegtsAtscMultString {
pub iso_639_langcode: [c_char; 4], pub iso_639_langcode: [c_char; 4],
pub segments: *mut glib::GPtrArray, pub segments: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsAtscMultString {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscMultString @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscSTT { pub struct GstMpegtsAtscSTT {
pub protocol_version: u8, pub protocol_version: u8,
@ -634,6 +670,12 @@ pub struct GstMpegtsAtscSTT {
pub utc_datetime: *mut gst::GstDateTime, pub utc_datetime: *mut gst::GstDateTime,
} }
impl ::std::fmt::Debug for GstMpegtsAtscSTT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscSTT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscStringSegment { pub struct GstMpegtsAtscStringSegment {
pub compression_type: u8, pub compression_type: u8,
@ -643,6 +685,12 @@ pub struct GstMpegtsAtscStringSegment {
pub cached_string: *mut c_char, pub cached_string: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsAtscStringSegment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscStringSegment @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscVCT { pub struct GstMpegtsAtscVCT {
pub transport_stream_id: u16, pub transport_stream_id: u16,
@ -651,6 +699,12 @@ pub struct GstMpegtsAtscVCT {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsAtscVCT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscVCT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsAtscVCTSource { pub struct GstMpegtsAtscVCTSource {
pub short_name: *mut c_char, pub short_name: *mut c_char,
@ -671,12 +725,24 @@ pub struct GstMpegtsAtscVCTSource {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsAtscVCTSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscVCTSource @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsBAT { pub struct GstMpegtsBAT {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
pub streams: *mut glib::GPtrArray, pub streams: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsBAT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsBAT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsBATStream { pub struct GstMpegtsBATStream {
pub transport_stream_id: u16, pub transport_stream_id: u16,
@ -684,6 +750,12 @@ pub struct GstMpegtsBATStream {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsBATStream {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsBATStream @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsCableDeliverySystemDescriptor { pub struct GstMpegtsCableDeliverySystemDescriptor {
pub frequency: u32, pub frequency: u32,
@ -693,6 +765,12 @@ pub struct GstMpegtsCableDeliverySystemDescriptor {
pub fec_inner: GstMpegtsDVBCodeRate, pub fec_inner: GstMpegtsDVBCodeRate,
} }
impl ::std::fmt::Debug for GstMpegtsCableDeliverySystemDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsCableDeliverySystemDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsComponentDescriptor { pub struct GstMpegtsComponentDescriptor {
pub stream_content: u8, pub stream_content: u8,
@ -702,6 +780,12 @@ pub struct GstMpegtsComponentDescriptor {
pub text: *mut c_char, pub text: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsComponentDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsComponentDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsContent { pub struct GstMpegtsContent {
pub content_nibble_1: GstMpegtsContentNibbleHi, pub content_nibble_1: GstMpegtsContentNibbleHi,
@ -709,6 +793,12 @@ pub struct GstMpegtsContent {
pub user_byte: u8, pub user_byte: u8,
} }
impl ::std::fmt::Debug for GstMpegtsContent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsContent @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDVBLinkageDescriptor { pub struct GstMpegtsDVBLinkageDescriptor {
pub transport_stream_id: u16, pub transport_stream_id: u16,
@ -720,6 +810,12 @@ pub struct GstMpegtsDVBLinkageDescriptor {
pub private_data_bytes: *mut u8, pub private_data_bytes: *mut u8,
} }
impl ::std::fmt::Debug for GstMpegtsDVBLinkageDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBLinkageDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDVBLinkageEvent { pub struct GstMpegtsDVBLinkageEvent {
pub target_event_id: u16, pub target_event_id: u16,
@ -727,6 +823,12 @@ pub struct GstMpegtsDVBLinkageEvent {
pub event_simulcast: gboolean, pub event_simulcast: gboolean,
} }
impl ::std::fmt::Debug for GstMpegtsDVBLinkageEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBLinkageEvent @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDVBLinkageExtendedEvent { pub struct GstMpegtsDVBLinkageExtendedEvent {
pub target_event_id: u16, pub target_event_id: u16,
@ -742,6 +844,12 @@ pub struct GstMpegtsDVBLinkageExtendedEvent {
pub target_service_id: u16, pub target_service_id: u16,
} }
impl ::std::fmt::Debug for GstMpegtsDVBLinkageExtendedEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBLinkageExtendedEvent @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDVBLinkageMobileHandOver { pub struct GstMpegtsDVBLinkageMobileHandOver {
pub hand_over_type: GstMpegtsDVBLinkageHandOverType, pub hand_over_type: GstMpegtsDVBLinkageHandOverType,
@ -750,18 +858,36 @@ pub struct GstMpegtsDVBLinkageMobileHandOver {
pub initial_service_id: u16, pub initial_service_id: u16,
} }
impl ::std::fmt::Debug for GstMpegtsDVBLinkageMobileHandOver {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBLinkageMobileHandOver @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDVBParentalRatingItem { pub struct GstMpegtsDVBParentalRatingItem {
pub country_code: *mut c_char, pub country_code: *mut c_char,
pub rating: u8, pub rating: u8,
} }
impl ::std::fmt::Debug for GstMpegtsDVBParentalRatingItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBParentalRatingItem @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDVBServiceListItem { pub struct GstMpegtsDVBServiceListItem {
pub service_id: u16, pub service_id: u16,
pub type_: GstMpegtsDVBServiceType, pub type_: GstMpegtsDVBServiceType,
} }
impl ::std::fmt::Debug for GstMpegtsDVBServiceListItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBServiceListItem @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDataBroadcastDescriptor { pub struct GstMpegtsDataBroadcastDescriptor {
pub data_broadcast_id: u16, pub data_broadcast_id: u16,
@ -772,6 +898,12 @@ pub struct GstMpegtsDataBroadcastDescriptor {
pub text: *mut c_char, pub text: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsDataBroadcastDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDataBroadcastDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDescriptor { pub struct GstMpegtsDescriptor {
pub tag: u8, pub tag: u8,
@ -781,24 +913,48 @@ pub struct GstMpegtsDescriptor {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstMpegtsDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDvbMultilingualBouquetNameItem { pub struct GstMpegtsDvbMultilingualBouquetNameItem {
pub language_code: *mut c_char, pub language_code: *mut c_char,
pub bouquet_name: *mut c_char, pub bouquet_name: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsDvbMultilingualBouquetNameItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDvbMultilingualBouquetNameItem @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDvbMultilingualComponentItem { pub struct GstMpegtsDvbMultilingualComponentItem {
pub language_code: *mut c_char, pub language_code: *mut c_char,
pub description: *mut c_char, pub description: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsDvbMultilingualComponentItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDvbMultilingualComponentItem @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDvbMultilingualNetworkNameItem { pub struct GstMpegtsDvbMultilingualNetworkNameItem {
pub language_code: *mut c_char, pub language_code: *mut c_char,
pub network_name: *mut c_char, pub network_name: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsDvbMultilingualNetworkNameItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDvbMultilingualNetworkNameItem @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsDvbMultilingualServiceNameItem { pub struct GstMpegtsDvbMultilingualServiceNameItem {
pub language_code: *mut c_char, pub language_code: *mut c_char,
@ -806,6 +962,12 @@ pub struct GstMpegtsDvbMultilingualServiceNameItem {
pub service_name: *mut c_char, pub service_name: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsDvbMultilingualServiceNameItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDvbMultilingualServiceNameItem @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsEIT { pub struct GstMpegtsEIT {
pub transport_stream_id: u16, pub transport_stream_id: u16,
@ -817,6 +979,12 @@ pub struct GstMpegtsEIT {
pub events: *mut glib::GPtrArray, pub events: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsEIT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsEIT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsEITEvent { pub struct GstMpegtsEITEvent {
pub event_id: u16, pub event_id: u16,
@ -827,6 +995,12 @@ pub struct GstMpegtsEITEvent {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsEITEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsEITEvent @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsExtendedEventDescriptor { pub struct GstMpegtsExtendedEventDescriptor {
pub descriptor_number: u8, pub descriptor_number: u8,
@ -836,12 +1010,24 @@ pub struct GstMpegtsExtendedEventDescriptor {
pub text: *mut c_char, pub text: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsExtendedEventDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsExtendedEventDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsExtendedEventItem { pub struct GstMpegtsExtendedEventItem {
pub item_description: *mut c_char, pub item_description: *mut c_char,
pub item: *mut c_char, pub item: *mut c_char,
} }
impl ::std::fmt::Debug for GstMpegtsExtendedEventItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsExtendedEventItem @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsISO639LanguageDescriptor { pub struct GstMpegtsISO639LanguageDescriptor {
pub nb_language: c_uint, pub nb_language: c_uint,
@ -849,6 +1035,12 @@ pub struct GstMpegtsISO639LanguageDescriptor {
pub audio_type: [GstMpegtsIso639AudioType; 64], pub audio_type: [GstMpegtsIso639AudioType; 64],
} }
impl ::std::fmt::Debug for GstMpegtsISO639LanguageDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsISO639LanguageDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsLogicalChannel { pub struct GstMpegtsLogicalChannel {
pub service_id: u16, pub service_id: u16,
@ -856,12 +1048,24 @@ pub struct GstMpegtsLogicalChannel {
pub logical_channel_number: u16, pub logical_channel_number: u16,
} }
impl ::std::fmt::Debug for GstMpegtsLogicalChannel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsLogicalChannel @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsLogicalChannelDescriptor { pub struct GstMpegtsLogicalChannelDescriptor {
pub nb_channels: c_uint, pub nb_channels: c_uint,
pub channels: [GstMpegtsLogicalChannel; 64], pub channels: [GstMpegtsLogicalChannel; 64],
} }
impl ::std::fmt::Debug for GstMpegtsLogicalChannelDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsLogicalChannelDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsNIT { pub struct GstMpegtsNIT {
pub actual_network: gboolean, pub actual_network: gboolean,
@ -870,6 +1074,12 @@ pub struct GstMpegtsNIT {
pub streams: *mut glib::GPtrArray, pub streams: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsNIT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsNIT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsNITStream { pub struct GstMpegtsNITStream {
pub transport_stream_id: u16, pub transport_stream_id: u16,
@ -877,6 +1087,12 @@ pub struct GstMpegtsNITStream {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsNITStream {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsNITStream @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsPMT { pub struct GstMpegtsPMT {
pub pcr_pid: u16, pub pcr_pid: u16,
@ -885,6 +1101,12 @@ pub struct GstMpegtsPMT {
pub streams: *mut glib::GPtrArray, pub streams: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsPMT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsPMT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsPMTStream { pub struct GstMpegtsPMTStream {
pub stream_type: u8, pub stream_type: u8,
@ -892,12 +1114,24 @@ pub struct GstMpegtsPMTStream {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsPMTStream {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsPMTStream @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsPatProgram { pub struct GstMpegtsPatProgram {
pub program_number: u16, pub program_number: u16,
pub network_or_program_map_PID: u16, pub network_or_program_map_PID: u16,
} }
impl ::std::fmt::Debug for GstMpegtsPatProgram {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsPatProgram @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsSDT { pub struct GstMpegtsSDT {
pub original_network_id: u16, pub original_network_id: u16,
@ -906,6 +1140,12 @@ pub struct GstMpegtsSDT {
pub services: *mut glib::GPtrArray, pub services: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsSDT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsSDT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsSDTService { pub struct GstMpegtsSDTService {
pub service_id: u16, pub service_id: u16,
@ -916,6 +1156,12 @@ pub struct GstMpegtsSDTService {
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsSDTService {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsSDTService @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsSatelliteDeliverySystemDescriptor { pub struct GstMpegtsSatelliteDeliverySystemDescriptor {
pub frequency: u32, pub frequency: u32,
@ -929,6 +1175,12 @@ pub struct GstMpegtsSatelliteDeliverySystemDescriptor {
pub fec_inner: GstMpegtsDVBCodeRate, pub fec_inner: GstMpegtsDVBCodeRate,
} }
impl ::std::fmt::Debug for GstMpegtsSatelliteDeliverySystemDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsSatelliteDeliverySystemDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsSection { pub struct GstMpegtsSection {
pub parent: gst::GstMiniObject, pub parent: gst::GstMiniObject,
@ -951,6 +1203,12 @@ pub struct GstMpegtsSection {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstMpegtsSection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsSection @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsT2DeliverySystemCell { pub struct GstMpegtsT2DeliverySystemCell {
pub cell_id: u16, pub cell_id: u16,
@ -958,12 +1216,24 @@ pub struct GstMpegtsT2DeliverySystemCell {
pub sub_cells: *mut glib::GPtrArray, pub sub_cells: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemCell {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsT2DeliverySystemCell @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsT2DeliverySystemCellExtension { pub struct GstMpegtsT2DeliverySystemCellExtension {
pub cell_id_extension: u8, pub cell_id_extension: u8,
pub transposer_frequency: u32, pub transposer_frequency: u32,
} }
impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemCellExtension {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsT2DeliverySystemCellExtension @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsT2DeliverySystemDescriptor { pub struct GstMpegtsT2DeliverySystemDescriptor {
pub plp_id: u8, pub plp_id: u8,
@ -977,12 +1247,24 @@ pub struct GstMpegtsT2DeliverySystemDescriptor {
pub cells: *mut glib::GPtrArray, pub cells: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsT2DeliverySystemDescriptor @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsTOT { pub struct GstMpegtsTOT {
pub utc_time: *mut gst::GstDateTime, pub utc_time: *mut gst::GstDateTime,
pub descriptors: *mut glib::GPtrArray, pub descriptors: *mut glib::GPtrArray,
} }
impl ::std::fmt::Debug for GstMpegtsTOT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsTOT @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstMpegtsTerrestrialDeliverySystemDescriptor { pub struct GstMpegtsTerrestrialDeliverySystemDescriptor {
pub frequency: u32, pub frequency: u32,
@ -999,6 +1281,12 @@ pub struct GstMpegtsTerrestrialDeliverySystemDescriptor {
pub other_frequency: gboolean, pub other_frequency: gboolean,
} }
impl ::std::fmt::Debug for GstMpegtsTerrestrialDeliverySystemDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsTerrestrialDeliverySystemDescriptor @ {:?}", self as *const _)
}
}
extern "C" { extern "C" {
//========================================================================= //=========================================================================

View file

@ -1,4 +1,4 @@
// This file was generated by gir (94e079d) from gir-files (???) // This file was generated by gir (0113735) from gir-files (???)
// DO NOT EDIT // DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)] #![allow(non_camel_case_types, non_upper_case_globals)]
@ -103,9 +103,21 @@ pub struct GstAudioVisualizerClass {
pub decide_allocation: Option<unsafe extern "C" fn(*mut GstAudioVisualizer, *mut gst::GstQuery) -> gboolean>, pub decide_allocation: Option<unsafe extern "C" fn(*mut GstAudioVisualizer, *mut gst::GstQuery) -> gboolean>,
} }
impl ::std::fmt::Debug for GstAudioVisualizerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioVisualizerClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstAudioVisualizerPrivate(c_void); pub struct GstAudioVisualizerPrivate(c_void);
impl ::std::fmt::Debug for GstAudioVisualizerPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioVisualizerPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscovererClass { pub struct GstDiscovererClass {
pub parentclass: gobject::GObjectClass, pub parentclass: gobject::GObjectClass,
@ -116,24 +128,66 @@ pub struct GstDiscovererClass {
pub _reserved: [gpointer; 4], pub _reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstDiscovererClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscovererPrivate(c_void); pub struct GstDiscovererPrivate(c_void);
impl ::std::fmt::Debug for GstDiscovererPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingAudioProfileClass(c_void); pub struct GstEncodingAudioProfileClass(c_void);
impl ::std::fmt::Debug for GstEncodingAudioProfileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingAudioProfileClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingContainerProfileClass(c_void); pub struct GstEncodingContainerProfileClass(c_void);
impl ::std::fmt::Debug for GstEncodingContainerProfileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingContainerProfileClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingProfileClass(c_void); pub struct GstEncodingProfileClass(c_void);
impl ::std::fmt::Debug for GstEncodingProfileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingProfileClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingVideoProfileClass(c_void); pub struct GstEncodingVideoProfileClass(c_void);
impl ::std::fmt::Debug for GstEncodingVideoProfileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingVideoProfileClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstInstallPluginsContext(c_void); pub struct GstInstallPluginsContext(c_void);
impl ::std::fmt::Debug for GstInstallPluginsContext {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstInstallPluginsContext @ {:?}", self as *const _)
}
}
// Classes // Classes
#[repr(C)] #[repr(C)]
pub struct GstAudioVisualizer { pub struct GstAudioVisualizer {
@ -144,6 +198,18 @@ pub struct GstAudioVisualizer {
pub priv_: *mut GstAudioVisualizerPrivate, pub priv_: *mut GstAudioVisualizerPrivate,
} }
impl ::std::fmt::Debug for GstAudioVisualizer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioVisualizer @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("req_spf", &self.req_spf)
.field("vinfo", &self.vinfo)
.field("ainfo", &self.ainfo)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscoverer { pub struct GstDiscoverer {
pub parent: gobject::GObject, pub parent: gobject::GObject,
@ -151,39 +217,115 @@ pub struct GstDiscoverer {
pub _reserved: [gpointer; 4], pub _reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstDiscoverer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstDiscoverer @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.field("_reserved", &self._reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscovererAudioInfo(c_void); pub struct GstDiscovererAudioInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererAudioInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererAudioInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscovererContainerInfo(c_void); pub struct GstDiscovererContainerInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererContainerInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererContainerInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscovererInfo(c_void); pub struct GstDiscovererInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscovererStreamInfo(c_void); pub struct GstDiscovererStreamInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererStreamInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererStreamInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscovererSubtitleInfo(c_void); pub struct GstDiscovererSubtitleInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererSubtitleInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererSubtitleInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstDiscovererVideoInfo(c_void); pub struct GstDiscovererVideoInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererVideoInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererVideoInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingAudioProfile(c_void); pub struct GstEncodingAudioProfile(c_void);
impl ::std::fmt::Debug for GstEncodingAudioProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingAudioProfile @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingContainerProfile(c_void); pub struct GstEncodingContainerProfile(c_void);
impl ::std::fmt::Debug for GstEncodingContainerProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingContainerProfile @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingProfile(c_void); pub struct GstEncodingProfile(c_void);
impl ::std::fmt::Debug for GstEncodingProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingProfile @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingTarget(c_void); pub struct GstEncodingTarget(c_void);
impl ::std::fmt::Debug for GstEncodingTarget {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingTarget @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstEncodingVideoProfile(c_void); pub struct GstEncodingVideoProfile(c_void);
impl ::std::fmt::Debug for GstEncodingVideoProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingVideoProfile @ {:?}", self as *const _)
}
}
extern "C" { extern "C" {
//========================================================================= //=========================================================================

View file

@ -1,4 +1,4 @@
// This file was generated by gir (94e079d) from gir-files (???) // This file was generated by gir (0113735) from gir-files (???)
// DO NOT EDIT // DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)] #![allow(non_camel_case_types, non_upper_case_globals)]
@ -48,76 +48,204 @@ pub type GstPlayerSignalDispatcherFunc = Option<unsafe extern "C" fn(gpointer)>;
#[repr(C)] #[repr(C)]
pub struct GstPlayerAudioInfoClass(c_void); pub struct GstPlayerAudioInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerAudioInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerAudioInfoClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerClass(c_void); pub struct GstPlayerClass(c_void);
impl ::std::fmt::Debug for GstPlayerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerGMainContextSignalDispatcherClass(c_void); pub struct GstPlayerGMainContextSignalDispatcherClass(c_void);
impl ::std::fmt::Debug for GstPlayerGMainContextSignalDispatcherClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerGMainContextSignalDispatcherClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerMediaInfoClass(c_void); pub struct GstPlayerMediaInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerMediaInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerMediaInfoClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerSignalDispatcherInterface { pub struct GstPlayerSignalDispatcherInterface {
pub parent_iface: gobject::GTypeInterface, pub parent_iface: gobject::GTypeInterface,
pub dispatch: Option<unsafe extern "C" fn(*mut GstPlayerSignalDispatcher, *mut GstPlayer, GstPlayerSignalDispatcherFunc, gpointer, glib::GDestroyNotify)>, pub dispatch: Option<unsafe extern "C" fn(*mut GstPlayerSignalDispatcher, *mut GstPlayer, GstPlayerSignalDispatcherFunc, gpointer, glib::GDestroyNotify)>,
} }
impl ::std::fmt::Debug for GstPlayerSignalDispatcherInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerSignalDispatcherInterface @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerStreamInfoClass(c_void); pub struct GstPlayerStreamInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerStreamInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerStreamInfoClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerSubtitleInfoClass(c_void); pub struct GstPlayerSubtitleInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerSubtitleInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerSubtitleInfoClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerVideoInfoClass(c_void); pub struct GstPlayerVideoInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerVideoInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoInfoClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerVideoOverlayVideoRendererClass(c_void); pub struct GstPlayerVideoOverlayVideoRendererClass(c_void);
impl ::std::fmt::Debug for GstPlayerVideoOverlayVideoRendererClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoOverlayVideoRendererClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerVideoRendererInterface { pub struct GstPlayerVideoRendererInterface {
pub parent_iface: gobject::GTypeInterface, pub parent_iface: gobject::GTypeInterface,
pub create_video_sink: Option<unsafe extern "C" fn(*mut GstPlayerVideoRenderer, *mut GstPlayer) -> *mut gst::GstElement>, pub create_video_sink: Option<unsafe extern "C" fn(*mut GstPlayerVideoRenderer, *mut GstPlayer) -> *mut gst::GstElement>,
} }
impl ::std::fmt::Debug for GstPlayerVideoRendererInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoRendererInterface @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerVisualization { pub struct GstPlayerVisualization {
pub name: *mut c_char, pub name: *mut c_char,
pub description: *mut c_char, pub description: *mut c_char,
} }
impl ::std::fmt::Debug for GstPlayerVisualization {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVisualization @ {:?}", self as *const _)
}
}
// Classes // Classes
#[repr(C)] #[repr(C)]
pub struct GstPlayer(c_void); pub struct GstPlayer(c_void);
impl ::std::fmt::Debug for GstPlayer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayer @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerAudioInfo(c_void); pub struct GstPlayerAudioInfo(c_void);
impl ::std::fmt::Debug for GstPlayerAudioInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerAudioInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerGMainContextSignalDispatcher(c_void); pub struct GstPlayerGMainContextSignalDispatcher(c_void);
impl ::std::fmt::Debug for GstPlayerGMainContextSignalDispatcher {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerGMainContextSignalDispatcher @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerMediaInfo(c_void); pub struct GstPlayerMediaInfo(c_void);
impl ::std::fmt::Debug for GstPlayerMediaInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerMediaInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerStreamInfo(c_void); pub struct GstPlayerStreamInfo(c_void);
impl ::std::fmt::Debug for GstPlayerStreamInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerStreamInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerSubtitleInfo(c_void); pub struct GstPlayerSubtitleInfo(c_void);
impl ::std::fmt::Debug for GstPlayerSubtitleInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerSubtitleInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerVideoInfo(c_void); pub struct GstPlayerVideoInfo(c_void);
impl ::std::fmt::Debug for GstPlayerVideoInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerVideoOverlayVideoRenderer(c_void); pub struct GstPlayerVideoOverlayVideoRenderer(c_void);
impl ::std::fmt::Debug for GstPlayerVideoOverlayVideoRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoOverlayVideoRenderer @ {:?}", self as *const _)
}
}
// Interfaces // Interfaces
#[repr(C)] #[repr(C)]
pub struct GstPlayerSignalDispatcher(c_void); pub struct GstPlayerSignalDispatcher(c_void);
impl ::std::fmt::Debug for GstPlayerSignalDispatcher {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerSignalDispatcher @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstPlayerVideoRenderer(c_void); pub struct GstPlayerVideoRenderer(c_void);
impl ::std::fmt::Debug for GstPlayerVideoRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoRenderer @ {:?}", self as *const _)
}
}
extern "C" { extern "C" {
//========================================================================= //=========================================================================

File diff suppressed because it is too large Load diff

View file

@ -1,4 +1,4 @@
// This file was generated by gir (94e079d) from gir-files (???) // This file was generated by gir (0113735) from gir-files (???)
// DO NOT EDIT // DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)] #![allow(non_camel_case_types, non_upper_case_globals)]
@ -8,6 +8,7 @@ extern crate libc;
extern crate glib_sys as glib; extern crate glib_sys as glib;
extern crate gobject_sys as gobject; extern crate gobject_sys as gobject;
extern crate gstreamer_sys as gst; extern crate gstreamer_sys as gst;
extern crate gstreamer_base_sys as gst_base;
#[allow(unused_imports)] #[allow(unused_imports)]
use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double, use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
@ -129,9 +130,21 @@ pub struct GstTagDemuxClass {
pub reserved: [gpointer; 4], pub reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstTagDemuxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagDemuxClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstTagDemuxPrivate(c_void); pub struct GstTagDemuxPrivate(c_void);
impl ::std::fmt::Debug for GstTagDemuxPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagDemuxPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstTagMuxClass { pub struct GstTagMuxClass {
pub parent_class: gst::GstElementClass, pub parent_class: gst::GstElementClass,
@ -140,14 +153,32 @@ pub struct GstTagMuxClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstTagMuxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagMuxClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstTagMuxPrivate(c_void); pub struct GstTagMuxPrivate(c_void);
impl ::std::fmt::Debug for GstTagMuxPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagMuxPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstTagXmpWriterInterface { pub struct GstTagXmpWriterInterface {
pub parent: gobject::GTypeInterface, pub parent: gobject::GTypeInterface,
} }
impl ::std::fmt::Debug for GstTagXmpWriterInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagXmpWriterInterface @ {:?}", self as *const _)
}
}
// Classes // Classes
#[repr(C)] #[repr(C)]
pub struct GstTagDemux { pub struct GstTagDemux {
@ -156,6 +187,16 @@ pub struct GstTagDemux {
pub reserved: [gpointer; 4], pub reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstTagDemux {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstTagDemux @ {:?}", self as *const _))
.field("element", &self.element)
.field("priv_", &self.priv_)
.field("reserved", &self.reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstTagMux { pub struct GstTagMux {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -163,10 +204,27 @@ pub struct GstTagMux {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstTagMux {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstTagMux @ {:?}", self as *const _))
.field("element", &self.element)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
// Interfaces // Interfaces
#[repr(C)] #[repr(C)]
pub struct GstTagXmpWriter(c_void); pub struct GstTagXmpWriter(c_void);
impl ::std::fmt::Debug for GstTagXmpWriter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagXmpWriter @ {:?}", self as *const _)
}
}
extern "C" { extern "C" {
//========================================================================= //=========================================================================

View file

@ -1,4 +1,4 @@
// This file was generated by gir (94e079d) from gir-files (???) // This file was generated by gir (0113735) from gir-files (???)
// DO NOT EDIT // DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)] #![allow(non_camel_case_types, non_upper_case_globals)]
@ -603,6 +603,12 @@ pub struct GstColorBalanceChannelClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstColorBalanceChannelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstColorBalanceChannelClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstColorBalanceInterface { pub struct GstColorBalanceInterface {
pub iface: gobject::GTypeInterface, pub iface: gobject::GTypeInterface,
@ -614,18 +620,36 @@ pub struct GstColorBalanceInterface {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstColorBalanceInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstColorBalanceInterface @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstNavigationInterface { pub struct GstNavigationInterface {
pub iface: gobject::GTypeInterface, pub iface: gobject::GTypeInterface,
pub send_event: Option<unsafe extern "C" fn(*mut GstNavigation, *mut gst::GstStructure)>, pub send_event: Option<unsafe extern "C" fn(*mut GstNavigation, *mut gst::GstStructure)>,
} }
impl ::std::fmt::Debug for GstNavigationInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNavigationInterface @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoAffineTransformationMeta { pub struct GstVideoAffineTransformationMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
pub matrix: [c_float; 16], pub matrix: [c_float; 16],
} }
impl ::std::fmt::Debug for GstVideoAffineTransformationMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoAffineTransformationMeta @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoAlignment { pub struct GstVideoAlignment {
pub padding_top: c_uint, pub padding_top: c_uint,
@ -635,17 +659,41 @@ pub struct GstVideoAlignment {
pub stride_align: [c_uint; 4], pub stride_align: [c_uint; 4],
} }
impl ::std::fmt::Debug for GstVideoAlignment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoAlignment @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoBufferPoolClass { pub struct GstVideoBufferPoolClass {
pub parent_class: gst::GstBufferPoolClass, pub parent_class: gst::GstBufferPoolClass,
} }
impl ::std::fmt::Debug for GstVideoBufferPoolClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoBufferPoolClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoBufferPoolPrivate(c_void); pub struct GstVideoBufferPoolPrivate(c_void);
impl ::std::fmt::Debug for GstVideoBufferPoolPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoBufferPoolPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoChromaResample(c_void); pub struct GstVideoChromaResample(c_void);
impl ::std::fmt::Debug for GstVideoChromaResample {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoChromaResample @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoCodecFrame { pub struct GstVideoCodecFrame {
pub ref_count: c_int, pub ref_count: c_int,
@ -666,6 +714,12 @@ pub struct GstVideoCodecFrame {
pub padding: [c_void; 20], pub padding: [c_void; 20],
} }
impl ::std::fmt::Debug for GstVideoCodecFrame {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoCodecFrame @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoCodecState { pub struct GstVideoCodecState {
pub ref_count: c_int, pub ref_count: c_int,
@ -676,6 +730,12 @@ pub struct GstVideoCodecState {
pub padding: [c_void; 19], pub padding: [c_void; 19],
} }
impl ::std::fmt::Debug for GstVideoCodecState {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoCodecState @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoColorPrimariesInfo { pub struct GstVideoColorPrimariesInfo {
pub primaries: GstVideoColorPrimaries, pub primaries: GstVideoColorPrimaries,
@ -689,6 +749,12 @@ pub struct GstVideoColorPrimariesInfo {
pub By: c_double, pub By: c_double,
} }
impl ::std::fmt::Debug for GstVideoColorPrimariesInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoColorPrimariesInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoColorimetry { pub struct GstVideoColorimetry {
pub range: GstVideoColorRange, pub range: GstVideoColorRange,
@ -697,9 +763,21 @@ pub struct GstVideoColorimetry {
pub primaries: GstVideoColorPrimaries, pub primaries: GstVideoColorPrimaries,
} }
impl ::std::fmt::Debug for GstVideoColorimetry {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoColorimetry @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoConverter(c_void); pub struct GstVideoConverter(c_void);
impl ::std::fmt::Debug for GstVideoConverter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoConverter @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoCropMeta { pub struct GstVideoCropMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
@ -709,6 +787,12 @@ pub struct GstVideoCropMeta {
pub height: c_uint, pub height: c_uint,
} }
impl ::std::fmt::Debug for GstVideoCropMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoCropMeta @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoDecoderClass { pub struct GstVideoDecoderClass {
pub element_class: gst::GstElementClass, pub element_class: gst::GstElementClass,
@ -735,17 +819,41 @@ pub struct GstVideoDecoderClass {
pub padding: [c_void; 14], pub padding: [c_void; 14],
} }
impl ::std::fmt::Debug for GstVideoDecoderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDecoderClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoDecoderPrivate(c_void); pub struct GstVideoDecoderPrivate(c_void);
impl ::std::fmt::Debug for GstVideoDecoderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDecoderPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoDirectionInterface { pub struct GstVideoDirectionInterface {
pub iface: gobject::GTypeInterface, pub iface: gobject::GTypeInterface,
} }
impl ::std::fmt::Debug for GstVideoDirectionInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDirectionInterface @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoDither(c_void); pub struct GstVideoDither(c_void);
impl ::std::fmt::Debug for GstVideoDither {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDither @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoEncoderClass { pub struct GstVideoEncoderClass {
pub element_class: gst::GstElementClass, pub element_class: gst::GstElementClass,
@ -771,9 +879,21 @@ pub struct GstVideoEncoderClass {
pub _gst_reserved: [gpointer; 16], pub _gst_reserved: [gpointer; 16],
} }
impl ::std::fmt::Debug for GstVideoEncoderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoEncoderClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoEncoderPrivate(c_void); pub struct GstVideoEncoderPrivate(c_void);
impl ::std::fmt::Debug for GstVideoEncoderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoEncoderPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoFilterClass { pub struct GstVideoFilterClass {
pub parent_class: gst_base::GstBaseTransformClass, pub parent_class: gst_base::GstBaseTransformClass,
@ -783,6 +903,12 @@ pub struct GstVideoFilterClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstVideoFilterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoFilterClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoFormatInfo { pub struct GstVideoFormatInfo {
pub format: GstVideoFormat, pub format: GstVideoFormat,
@ -809,6 +935,12 @@ pub struct GstVideoFormatInfo {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstVideoFormatInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoFormatInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoFrame { pub struct GstVideoFrame {
pub info: GstVideoInfo, pub info: GstVideoInfo,
@ -821,6 +953,12 @@ pub struct GstVideoFrame {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstVideoFrame {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoFrame @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoGLTextureUploadMeta { pub struct GstVideoGLTextureUploadMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
@ -834,6 +972,12 @@ pub struct GstVideoGLTextureUploadMeta {
pub user_data_free: gobject::GBoxedFreeFunc, pub user_data_free: gobject::GBoxedFreeFunc,
} }
impl ::std::fmt::Debug for GstVideoGLTextureUploadMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoGLTextureUploadMeta @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoInfo { pub struct GstVideoInfo {
pub finfo: *const GstVideoFormatInfo, pub finfo: *const GstVideoFormatInfo,
@ -854,6 +998,12 @@ pub struct GstVideoInfo {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstVideoInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoInfo @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoMeta { pub struct GstVideoMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
@ -870,12 +1020,24 @@ pub struct GstVideoMeta {
pub unmap: Option<unsafe extern "C" fn(*mut GstVideoMeta, c_uint, *mut gst::GstMapInfo) -> gboolean>, pub unmap: Option<unsafe extern "C" fn(*mut GstVideoMeta, c_uint, *mut gst::GstMapInfo) -> gboolean>,
} }
impl ::std::fmt::Debug for GstVideoMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoMeta @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoMetaTransform { pub struct GstVideoMetaTransform {
pub in_info: *mut GstVideoInfo, pub in_info: *mut GstVideoInfo,
pub out_info: *mut GstVideoInfo, pub out_info: *mut GstVideoInfo,
} }
impl ::std::fmt::Debug for GstVideoMetaTransform {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoMetaTransform @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoOrientationInterface { pub struct GstVideoOrientationInterface {
pub iface: gobject::GTypeInterface, pub iface: gobject::GTypeInterface,
@ -889,15 +1051,33 @@ pub struct GstVideoOrientationInterface {
pub set_vcenter: Option<unsafe extern "C" fn(*mut GstVideoOrientation, c_int) -> gboolean>, pub set_vcenter: Option<unsafe extern "C" fn(*mut GstVideoOrientation, c_int) -> gboolean>,
} }
impl ::std::fmt::Debug for GstVideoOrientationInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOrientationInterface @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoOverlayComposition(c_void); pub struct GstVideoOverlayComposition(c_void);
impl ::std::fmt::Debug for GstVideoOverlayComposition {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlayComposition @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoOverlayCompositionMeta { pub struct GstVideoOverlayCompositionMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
pub overlay: *mut GstVideoOverlayComposition, pub overlay: *mut GstVideoOverlayComposition,
} }
impl ::std::fmt::Debug for GstVideoOverlayCompositionMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlayCompositionMeta @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoOverlayInterface { pub struct GstVideoOverlayInterface {
pub iface: gobject::GTypeInterface, pub iface: gobject::GTypeInterface,
@ -907,9 +1087,21 @@ pub struct GstVideoOverlayInterface {
pub set_window_handle: Option<unsafe extern "C" fn(*mut GstVideoOverlay, uintptr_t)>, pub set_window_handle: Option<unsafe extern "C" fn(*mut GstVideoOverlay, uintptr_t)>,
} }
impl ::std::fmt::Debug for GstVideoOverlayInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlayInterface @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoOverlayRectangle(c_void); pub struct GstVideoOverlayRectangle(c_void);
impl ::std::fmt::Debug for GstVideoOverlayRectangle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlayRectangle @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoRectangle { pub struct GstVideoRectangle {
pub x: c_int, pub x: c_int,
@ -918,6 +1110,12 @@ pub struct GstVideoRectangle {
pub h: c_int, pub h: c_int,
} }
impl ::std::fmt::Debug for GstVideoRectangle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoRectangle @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoRegionOfInterestMeta { pub struct GstVideoRegionOfInterestMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
@ -930,6 +1128,12 @@ pub struct GstVideoRegionOfInterestMeta {
pub h: c_uint, pub h: c_uint,
} }
impl ::std::fmt::Debug for GstVideoRegionOfInterestMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoRegionOfInterestMeta @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoResampler { pub struct GstVideoResampler {
pub in_size: c_int, pub in_size: c_int,
@ -943,9 +1147,21 @@ pub struct GstVideoResampler {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstVideoResampler {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoResampler @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoScaler(c_void); pub struct GstVideoScaler(c_void);
impl ::std::fmt::Debug for GstVideoScaler {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoScaler @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoSinkClass { pub struct GstVideoSinkClass {
pub parent_class: gst_base::GstBaseSinkClass, pub parent_class: gst_base::GstBaseSinkClass,
@ -953,9 +1169,21 @@ pub struct GstVideoSinkClass {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstVideoSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoSinkClass @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoSinkPrivate(c_void); pub struct GstVideoSinkPrivate(c_void);
impl ::std::fmt::Debug for GstVideoSinkPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoSinkPrivate @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoTimeCode { pub struct GstVideoTimeCode {
pub config: GstVideoTimeCodeConfig, pub config: GstVideoTimeCodeConfig,
@ -966,6 +1194,12 @@ pub struct GstVideoTimeCode {
pub field_count: c_uint, pub field_count: c_uint,
} }
impl ::std::fmt::Debug for GstVideoTimeCode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoTimeCode @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoTimeCodeConfig { pub struct GstVideoTimeCodeConfig {
pub fps_n: c_uint, pub fps_n: c_uint,
@ -974,6 +1208,12 @@ pub struct GstVideoTimeCodeConfig {
pub latest_daily_jam: *mut glib::GDateTime, pub latest_daily_jam: *mut glib::GDateTime,
} }
impl ::std::fmt::Debug for GstVideoTimeCodeConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoTimeCodeConfig @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoTimeCodeInterval { pub struct GstVideoTimeCodeInterval {
pub hours: c_uint, pub hours: c_uint,
@ -982,12 +1222,24 @@ pub struct GstVideoTimeCodeInterval {
pub frames: c_uint, pub frames: c_uint,
} }
impl ::std::fmt::Debug for GstVideoTimeCodeInterval {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoTimeCodeInterval @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoTimeCodeMeta { pub struct GstVideoTimeCodeMeta {
pub meta: gst::GstMeta, pub meta: gst::GstMeta,
pub tc: GstVideoTimeCode, pub tc: GstVideoTimeCode,
} }
impl ::std::fmt::Debug for GstVideoTimeCodeMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoTimeCodeMeta @ {:?}", self as *const _)
}
}
// Classes // Classes
#[repr(C)] #[repr(C)]
pub struct GstColorBalanceChannel { pub struct GstColorBalanceChannel {
@ -998,12 +1250,33 @@ pub struct GstColorBalanceChannel {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstColorBalanceChannel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstColorBalanceChannel @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("label", &self.label)
.field("min_value", &self.min_value)
.field("max_value", &self.max_value)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoBufferPool { pub struct GstVideoBufferPool {
pub bufferpool: gst::GstBufferPool, pub bufferpool: gst::GstBufferPool,
pub priv_: *mut GstVideoBufferPoolPrivate, pub priv_: *mut GstVideoBufferPoolPrivate,
} }
impl ::std::fmt::Debug for GstVideoBufferPool {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoBufferPool @ {:?}", self as *const _))
.field("bufferpool", &self.bufferpool)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoDecoder { pub struct GstVideoDecoder {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -1016,6 +1289,22 @@ pub struct GstVideoDecoder {
pub padding: [c_void; 20], pub padding: [c_void; 20],
} }
impl ::std::fmt::Debug for GstVideoDecoder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoDecoder @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("srcpad", &self.srcpad)
.field("stream_lock", &self.stream_lock)
.field("input_segment", &self.input_segment)
.field("output_segment", &self.output_segment)
.field("priv_", &self.priv_)
.field("padding",
&format!("{:?}", &self.padding as *const _))
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoEncoder { pub struct GstVideoEncoder {
pub element: gst::GstElement, pub element: gst::GstElement,
@ -1028,6 +1317,22 @@ pub struct GstVideoEncoder {
pub padding: [c_void; 20], pub padding: [c_void; 20],
} }
impl ::std::fmt::Debug for GstVideoEncoder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoEncoder @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("srcpad", &self.srcpad)
.field("stream_lock", &self.stream_lock)
.field("input_segment", &self.input_segment)
.field("output_segment", &self.output_segment)
.field("priv_", &self.priv_)
.field("padding",
&format!("{:?}", &self.padding as *const _))
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoFilter { pub struct GstVideoFilter {
pub element: gst_base::GstBaseTransform, pub element: gst_base::GstBaseTransform,
@ -1037,9 +1342,27 @@ pub struct GstVideoFilter {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstVideoFilter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoFilter @ {:?}", self as *const _))
.field("element", &self.element)
.field("negotiated", &self.negotiated)
.field("in_info", &self.in_info)
.field("out_info", &self.out_info)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoMultiviewFlagsSet(c_void); pub struct GstVideoMultiviewFlagsSet(c_void);
impl ::std::fmt::Debug for GstVideoMultiviewFlagsSet {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoMultiviewFlagsSet @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoSink { pub struct GstVideoSink {
pub element: gst_base::GstBaseSink, pub element: gst_base::GstBaseSink,
@ -1049,18 +1372,65 @@ pub struct GstVideoSink {
pub _gst_reserved: [gpointer; 4], pub _gst_reserved: [gpointer; 4],
} }
impl ::std::fmt::Debug for GstVideoSink {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoSink @ {:?}", self as *const _))
.field("element", &self.element)
.field("width", &self.width)
.field("height", &self.height)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
// Interfaces // Interfaces
#[repr(C)] #[repr(C)]
pub struct GstColorBalance(c_void); pub struct GstColorBalance(c_void);
impl ::std::fmt::Debug for GstColorBalance {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstColorBalance @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstNavigation(c_void); pub struct GstNavigation(c_void);
impl ::std::fmt::Debug for GstNavigation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNavigation @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoDirection(c_void); pub struct GstVideoDirection(c_void);
impl ::std::fmt::Debug for GstVideoDirection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDirection @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoOrientation(c_void); pub struct GstVideoOrientation(c_void);
impl ::std::fmt::Debug for GstVideoOrientation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOrientation @ {:?}", self as *const _)
}
}
#[repr(C)] #[repr(C)]
pub struct GstVideoOverlay(c_void); pub struct GstVideoOverlay(c_void);
impl ::std::fmt::Debug for GstVideoOverlay {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlay @ {:?}", self as *const _)
}
}
extern "C" { extern "C" {
//========================================================================= //=========================================================================