Regenerate everything with latest gir

This commit is contained in:
Sebastian Dröge 2018-02-07 18:49:22 +02:00
parent ab27a1609e
commit 7a914c481b
11 changed files with 2095 additions and 525 deletions

2
gir

@ -1 +1 @@
Subproject commit 01137358493a9e19382045c84a141273f7e29b46
Subproject commit 81a781f2e852b0d2f58b3cf3da002e1ef5ed5bce

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
extern crate glib_sys as glib;
@ -24,6 +24,7 @@ pub const GST_APP_STREAM_TYPE_RANDOM_ACCESS: GstAppStreamType = 2;
// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAppSinkCallbacks {
pub eos: Option<unsafe extern "C" fn(*mut GstAppSink, gpointer)>,
pub new_preroll: Option<unsafe extern "C" fn(*mut GstAppSink, gpointer) -> gst::GstFlowReturn>,
@ -33,11 +34,16 @@ pub struct GstAppSinkCallbacks {
impl ::std::fmt::Debug for GstAppSinkCallbacks {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSinkCallbacks @ {:?}", self as *const _)
f.debug_struct(&format!("GstAppSinkCallbacks @ {:?}", self as *const _))
.field("eos", &self.eos)
.field("new_preroll", &self.new_preroll)
.field("new_sample", &self.new_sample)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAppSinkClass {
pub basesink_class: gst_base::GstBaseSinkClass,
pub eos: Option<unsafe extern "C" fn(*mut GstAppSink)>,
@ -52,7 +58,16 @@ pub struct GstAppSinkClass {
impl ::std::fmt::Debug for GstAppSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSinkClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAppSinkClass @ {:?}", self as *const _))
.field("basesink_class", &self.basesink_class)
.field("eos", &self.eos)
.field("new_preroll", &self.new_preroll)
.field("new_sample", &self.new_sample)
.field("pull_preroll", &self.pull_preroll)
.field("pull_sample", &self.pull_sample)
.field("try_pull_preroll", &self.try_pull_preroll)
.field("try_pull_sample", &self.try_pull_sample)
.finish()
}
}
@ -61,11 +76,13 @@ pub struct GstAppSinkPrivate(c_void);
impl ::std::fmt::Debug for GstAppSinkPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSinkPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstAppSinkPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAppSrcCallbacks {
pub need_data: Option<unsafe extern "C" fn(*mut GstAppSrc, c_uint, gpointer)>,
pub enough_data: Option<unsafe extern "C" fn(*mut GstAppSrc, gpointer)>,
@ -75,11 +92,16 @@ pub struct GstAppSrcCallbacks {
impl ::std::fmt::Debug for GstAppSrcCallbacks {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSrcCallbacks @ {:?}", self as *const _)
f.debug_struct(&format!("GstAppSrcCallbacks @ {:?}", self as *const _))
.field("need_data", &self.need_data)
.field("enough_data", &self.enough_data)
.field("seek_data", &self.seek_data)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAppSrcClass {
pub basesrc_class: gst_base::GstBaseSrcClass,
pub need_data: Option<unsafe extern "C" fn(*mut GstAppSrc, c_uint)>,
@ -93,7 +115,15 @@ pub struct GstAppSrcClass {
impl ::std::fmt::Debug for GstAppSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSrcClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAppSrcClass @ {:?}", self as *const _))
.field("basesrc_class", &self.basesrc_class)
.field("need_data", &self.need_data)
.field("enough_data", &self.enough_data)
.field("seek_data", &self.seek_data)
.field("push_buffer", &self.push_buffer)
.field("end_of_stream", &self.end_of_stream)
.field("push_sample", &self.push_sample)
.finish()
}
}
@ -102,12 +132,14 @@ pub struct GstAppSrcPrivate(c_void);
impl ::std::fmt::Debug for GstAppSrcPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAppSrcPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstAppSrcPrivate @ {:?}", self as *const _))
.finish()
}
}
// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAppSink {
pub basesink: gst_base::GstBaseSink,
pub priv_: *mut GstAppSinkPrivate,
@ -118,13 +150,12 @@ impl ::std::fmt::Debug for GstAppSink {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAppSink @ {:?}", self as *const _))
.field("basesink", &self.basesink)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAppSrc {
pub basesrc: gst_base::GstBaseSrc,
pub priv_: *mut GstAppSrcPrivate,
@ -135,8 +166,6 @@ impl ::std::fmt::Debug for GstAppSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAppSrc @ {:?}", self as *const _))
.field("basesrc", &self.basesrc)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
#[macro_use] extern crate bitflags;
@ -304,6 +304,7 @@ pub type GstAudioRingBufferCallback = Option<unsafe extern "C" fn(*mut GstAudioR
// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioBaseSinkClass {
pub parent_class: gst_base::GstBaseSinkClass,
pub create_ringbuffer: Option<unsafe extern "C" fn(*mut GstAudioBaseSink) -> *mut GstAudioRingBuffer>,
@ -313,7 +314,11 @@ pub struct GstAudioBaseSinkClass {
impl ::std::fmt::Debug for GstAudioBaseSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioBaseSinkClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioBaseSinkClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("create_ringbuffer", &self.create_ringbuffer)
.field("payload", &self.payload)
.finish()
}
}
@ -322,11 +327,13 @@ pub struct GstAudioBaseSinkPrivate(c_void);
impl ::std::fmt::Debug for GstAudioBaseSinkPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioBaseSinkPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioBaseSinkPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioBaseSrcClass {
pub parent_class: gst_base::GstPushSrcClass,
pub create_ringbuffer: Option<unsafe extern "C" fn(*mut GstAudioBaseSrc) -> *mut GstAudioRingBuffer>,
@ -335,7 +342,10 @@ pub struct GstAudioBaseSrcClass {
impl ::std::fmt::Debug for GstAudioBaseSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioBaseSrcClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioBaseSrcClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("create_ringbuffer", &self.create_ringbuffer)
.finish()
}
}
@ -344,11 +354,13 @@ pub struct GstAudioBaseSrcPrivate(c_void);
impl ::std::fmt::Debug for GstAudioBaseSrcPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioBaseSrcPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioBaseSrcPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioCdSrcClass {
pub pushsrc_class: gst_base::GstPushSrcClass,
pub open: Option<unsafe extern "C" fn(*mut GstAudioCdSrc, *const c_char) -> gboolean>,
@ -359,7 +371,12 @@ pub struct GstAudioCdSrcClass {
impl ::std::fmt::Debug for GstAudioCdSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioCdSrcClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioCdSrcClass @ {:?}", self as *const _))
.field("pushsrc_class", &self.pushsrc_class)
.field("open", &self.open)
.field("close", &self.close)
.field("read_sector", &self.read_sector)
.finish()
}
}
@ -368,11 +385,13 @@ pub struct GstAudioCdSrcPrivate(c_void);
impl ::std::fmt::Debug for GstAudioCdSrcPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioCdSrcPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioCdSrcPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioCdSrcTrack {
pub is_audio: gboolean,
pub num: c_uint,
@ -385,7 +404,13 @@ pub struct GstAudioCdSrcTrack {
impl ::std::fmt::Debug for GstAudioCdSrcTrack {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioCdSrcTrack @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioCdSrcTrack @ {:?}", self as *const _))
.field("is_audio", &self.is_audio)
.field("num", &self.num)
.field("start", &self.start)
.field("end", &self.end)
.field("tags", &self.tags)
.finish()
}
}
@ -394,11 +419,13 @@ pub struct GstAudioChannelMixer(c_void);
impl ::std::fmt::Debug for GstAudioChannelMixer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioChannelMixer @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioChannelMixer @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioClippingMeta {
pub meta: gst::GstMeta,
pub format: gst::GstFormat,
@ -408,11 +435,17 @@ pub struct GstAudioClippingMeta {
impl ::std::fmt::Debug for GstAudioClippingMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioClippingMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioClippingMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("format", &self.format)
.field("start", &self.start)
.field("end", &self.end)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioClockClass {
pub parent_class: gst::GstSystemClockClass,
pub _gst_reserved: [gpointer; 4],
@ -420,7 +453,9 @@ pub struct GstAudioClockClass {
impl ::std::fmt::Debug for GstAudioClockClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioClockClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioClockClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
@ -429,11 +464,13 @@ pub struct GstAudioConverter(c_void);
impl ::std::fmt::Debug for GstAudioConverter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioConverter @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioConverter @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioDecoderClass {
pub element_class: gst::GstElementClass,
pub start: Option<unsafe extern "C" fn(*mut GstAudioDecoder) -> gboolean>,
@ -459,7 +496,27 @@ pub struct GstAudioDecoderClass {
impl ::std::fmt::Debug for GstAudioDecoderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioDecoderClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioDecoderClass @ {:?}", self as *const _))
.field("element_class", &self.element_class)
.field("start", &self.start)
.field("stop", &self.stop)
.field("set_format", &self.set_format)
.field("parse", &self.parse)
.field("handle_frame", &self.handle_frame)
.field("flush", &self.flush)
.field("pre_push", &self.pre_push)
.field("sink_event", &self.sink_event)
.field("src_event", &self.src_event)
.field("open", &self.open)
.field("close", &self.close)
.field("negotiate", &self.negotiate)
.field("decide_allocation", &self.decide_allocation)
.field("propose_allocation", &self.propose_allocation)
.field("sink_query", &self.sink_query)
.field("src_query", &self.src_query)
.field("getcaps", &self.getcaps)
.field("transform_meta", &self.transform_meta)
.finish()
}
}
@ -468,11 +525,13 @@ pub struct GstAudioDecoderPrivate(c_void);
impl ::std::fmt::Debug for GstAudioDecoderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioDecoderPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioDecoderPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioDownmixMeta {
pub meta: gst::GstMeta,
pub from_position: *mut GstAudioChannelPosition,
@ -484,11 +543,19 @@ pub struct GstAudioDownmixMeta {
impl ::std::fmt::Debug for GstAudioDownmixMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioDownmixMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioDownmixMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("from_position", &self.from_position)
.field("to_position", &self.to_position)
.field("from_channels", &self.from_channels)
.field("to_channels", &self.to_channels)
.field("matrix", &self.matrix)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioEncoderClass {
pub element_class: gst::GstElementClass,
pub start: Option<unsafe extern "C" fn(*mut GstAudioEncoder) -> gboolean>,
@ -513,7 +580,26 @@ pub struct GstAudioEncoderClass {
impl ::std::fmt::Debug for GstAudioEncoderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioEncoderClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioEncoderClass @ {:?}", self as *const _))
.field("element_class", &self.element_class)
.field("start", &self.start)
.field("stop", &self.stop)
.field("set_format", &self.set_format)
.field("handle_frame", &self.handle_frame)
.field("flush", &self.flush)
.field("pre_push", &self.pre_push)
.field("sink_event", &self.sink_event)
.field("src_event", &self.src_event)
.field("getcaps", &self.getcaps)
.field("open", &self.open)
.field("close", &self.close)
.field("negotiate", &self.negotiate)
.field("decide_allocation", &self.decide_allocation)
.field("propose_allocation", &self.propose_allocation)
.field("transform_meta", &self.transform_meta)
.field("sink_query", &self.sink_query)
.field("src_query", &self.src_query)
.finish()
}
}
@ -522,11 +608,13 @@ pub struct GstAudioEncoderPrivate(c_void);
impl ::std::fmt::Debug for GstAudioEncoderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioEncoderPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioEncoderPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioFilterClass {
pub basetransformclass: gst_base::GstBaseTransformClass,
pub setup: Option<unsafe extern "C" fn(*mut GstAudioFilter, *const GstAudioInfo) -> gboolean>,
@ -535,11 +623,15 @@ pub struct GstAudioFilterClass {
impl ::std::fmt::Debug for GstAudioFilterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioFilterClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioFilterClass @ {:?}", self as *const _))
.field("basetransformclass", &self.basetransformclass)
.field("setup", &self.setup)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioFormatInfo {
pub format: GstAudioFormat,
pub name: *const c_char,
@ -557,11 +649,24 @@ pub struct GstAudioFormatInfo {
impl ::std::fmt::Debug for GstAudioFormatInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioFormatInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioFormatInfo @ {:?}", self as *const _))
.field("format", &self.format)
.field("name", &self.name)
.field("description", &self.description)
.field("flags", &self.flags)
.field("endianness", &self.endianness)
.field("width", &self.width)
.field("depth", &self.depth)
.field("silence", &self.silence)
.field("unpack_format", &self.unpack_format)
.field("unpack_func", &self.unpack_func)
.field("pack_func", &self.pack_func)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioInfo {
pub finfo: *const GstAudioFormatInfo,
pub flags: GstAudioFlags,
@ -575,7 +680,14 @@ pub struct GstAudioInfo {
impl ::std::fmt::Debug for GstAudioInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioInfo @ {:?}", self as *const _))
.field("finfo", &self.finfo)
.field("flags", &self.flags)
.field("layout", &self.layout)
.field("rate", &self.rate)
.field("channels", &self.channels)
.field("bpf", &self.bpf)
.finish()
}
}
@ -584,7 +696,8 @@ pub struct GstAudioQuantize(c_void);
impl ::std::fmt::Debug for GstAudioQuantize {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioQuantize @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioQuantize @ {:?}", self as *const _))
.finish()
}
}
@ -593,11 +706,13 @@ pub struct GstAudioResampler(c_void);
impl ::std::fmt::Debug for GstAudioResampler {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioResampler @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioResampler @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioRingBufferClass {
pub parent_class: gst::GstObjectClass,
pub open_device: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> gboolean>,
@ -617,11 +732,26 @@ pub struct GstAudioRingBufferClass {
impl ::std::fmt::Debug for GstAudioRingBufferClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioRingBufferClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioRingBufferClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("open_device", &self.open_device)
.field("acquire", &self.acquire)
.field("release", &self.release)
.field("close_device", &self.close_device)
.field("start", &self.start)
.field("pause", &self.pause)
.field("resume", &self.resume)
.field("stop", &self.stop)
.field("delay", &self.delay)
.field("activate", &self.activate)
.field("commit", &self.commit)
.field("clear_all", &self.clear_all)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioRingBufferSpec {
pub caps: *mut gst::GstCaps,
pub type_: GstAudioRingBufferFormatType,
@ -636,11 +766,21 @@ pub struct GstAudioRingBufferSpec {
impl ::std::fmt::Debug for GstAudioRingBufferSpec {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioRingBufferSpec @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioRingBufferSpec @ {:?}", self as *const _))
.field("caps", &self.caps)
.field("type_", &self.type_)
.field("info", &self.info)
.field("latency_time", &self.latency_time)
.field("buffer_time", &self.buffer_time)
.field("segsize", &self.segsize)
.field("segtotal", &self.segtotal)
.field("seglatency", &self.seglatency)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioSinkClass {
pub parent_class: GstAudioBaseSinkClass,
pub open: Option<unsafe extern "C" fn(*mut GstAudioSink) -> gboolean>,
@ -655,11 +795,21 @@ pub struct GstAudioSinkClass {
impl ::std::fmt::Debug for GstAudioSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioSinkClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioSinkClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("open", &self.open)
.field("prepare", &self.prepare)
.field("unprepare", &self.unprepare)
.field("close", &self.close)
.field("write", &self.write)
.field("delay", &self.delay)
.field("reset", &self.reset)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioSrcClass {
pub parent_class: GstAudioBaseSrcClass,
pub open: Option<unsafe extern "C" fn(*mut GstAudioSrc) -> gboolean>,
@ -674,23 +824,36 @@ pub struct GstAudioSrcClass {
impl ::std::fmt::Debug for GstAudioSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioSrcClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioSrcClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("open", &self.open)
.field("prepare", &self.prepare)
.field("unprepare", &self.unprepare)
.field("close", &self.close)
.field("read", &self.read)
.field("delay", &self.delay)
.field("reset", &self.reset)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstStreamVolumeInterface {
pub iface: gobject::GTypeInterface,
}
impl ::std::fmt::Debug for GstStreamVolumeInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstStreamVolumeInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstStreamVolumeInterface @ {:?}", self as *const _))
.field("iface", &self.iface)
.finish()
}
}
// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioBaseSink {
pub element: gst_base::GstBaseSink,
pub ringbuffer: *mut GstAudioRingBuffer,
@ -713,13 +876,12 @@ impl ::std::fmt::Debug for GstAudioBaseSink {
.field("next_sample", &self.next_sample)
.field("provided_clock", &self.provided_clock)
.field("eos_rendering", &self.eos_rendering)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioBaseSrc {
pub element: gst_base::GstPushSrc,
pub ringbuffer: *mut GstAudioRingBuffer,
@ -740,13 +902,12 @@ impl ::std::fmt::Debug for GstAudioBaseSrc {
.field("latency_time", &self.latency_time)
.field("next_sample", &self.next_sample)
.field("clock", &self.clock)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioCdSrc {
pub pushsrc: gst_base::GstPushSrc,
pub tags: *mut gst::GstTagList,
@ -760,14 +921,12 @@ impl ::std::fmt::Debug for GstAudioCdSrc {
f.debug_struct(&format!("GstAudioCdSrc @ {:?}", self as *const _))
.field("pushsrc", &self.pushsrc)
.field("tags", &self.tags)
.field("priv_", &self.priv_)
.field("_gst_reserved1", &self._gst_reserved1)
.field("_gst_reserved2", &self._gst_reserved2)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioClock {
pub clock: gst::GstSystemClock,
pub func: GstAudioClockGetTimeFunc,
@ -785,14 +944,12 @@ impl ::std::fmt::Debug for GstAudioClock {
.field("func", &self.func)
.field("user_data", &self.user_data)
.field("destroy_notify", &self.destroy_notify)
.field("last_time", &self.last_time)
.field("time_offset", &self.time_offset)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioDecoder {
pub element: gst::GstElement,
pub sinkpad: *mut gst::GstPad,
@ -813,13 +970,12 @@ impl ::std::fmt::Debug for GstAudioDecoder {
.field("stream_lock", &self.stream_lock)
.field("input_segment", &self.input_segment)
.field("output_segment", &self.output_segment)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioEncoder {
pub element: gst::GstElement,
pub sinkpad: *mut gst::GstPad,
@ -840,13 +996,12 @@ impl ::std::fmt::Debug for GstAudioEncoder {
.field("stream_lock", &self.stream_lock)
.field("input_segment", &self.input_segment)
.field("output_segment", &self.output_segment)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioFilter {
pub basetransform: gst_base::GstBaseTransform,
pub info: GstAudioInfo,
@ -858,12 +1013,12 @@ impl ::std::fmt::Debug for GstAudioFilter {
f.debug_struct(&format!("GstAudioFilter @ {:?}", self as *const _))
.field("basetransform", &self.basetransform)
.field("info", &self.info)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioRingBuffer {
pub object: gst::GstObject,
pub cond: glib::GCond,
@ -907,20 +1062,12 @@ impl ::std::fmt::Debug for GstAudioRingBuffer {
.field("segdone", &self.segdone)
.field("segbase", &self.segbase)
.field("waiting", &self.waiting)
.field("callback", &self.callback)
.field("cb_data", &self.cb_data)
.field("need_reorder", &self.need_reorder)
.field("channel_reorder_map", &format!("{:?}", &self.channel_reorder_map as *const _))
.field("flushing", &self.flushing)
.field("may_start", &self.may_start)
.field("active", &self.active)
.field("cb_data_notify", &self.cb_data_notify)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioSink {
pub element: GstAudioBaseSink,
pub thread: *mut glib::GThread,
@ -931,13 +1078,12 @@ impl ::std::fmt::Debug for GstAudioSink {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioSink @ {:?}", self as *const _))
.field("element", &self.element)
.field("thread", &self.thread)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioSrc {
pub element: GstAudioBaseSrc,
pub thread: *mut glib::GThread,
@ -948,8 +1094,6 @@ impl ::std::fmt::Debug for GstAudioSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstAudioSrc @ {:?}", self as *const _))
.field("element", &self.element)
.field("thread", &self.thread)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
#[macro_use] extern crate bitflags;
@ -70,6 +70,22 @@ pub const GST_COLLECT_PADS_STATE_NEW_SEGMENT: GstCollectPadsStateFlags = GstColl
pub const GST_COLLECT_PADS_STATE_WAITING: GstCollectPadsStateFlags = GstCollectPadsStateFlags::WAITING;
pub const GST_COLLECT_PADS_STATE_LOCKED: GstCollectPadsStateFlags = GstCollectPadsStateFlags::LOCKED;
// Unions
#[repr(C)]
#[derive(Copy, Clone)]
pub union GstCollectData_ABI {
pub abi: GstCollectData_ABI_abi,
pub _gst_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GstCollectData_ABI {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstCollectData_ABI @ {:?}", self as *const _))
.field("abi", unsafe { &self.abi })
.finish()
}
}
// Callbacks
pub type GstCollectDataDestroyNotify = Option<unsafe extern "C" fn(*mut GstCollectData)>;
pub type GstCollectPadsBufferFunction = Option<unsafe extern "C" fn(*mut GstCollectPads, *mut GstCollectData, *mut gst::GstBuffer, gpointer) -> gst::GstFlowReturn>;
@ -90,11 +106,13 @@ pub struct GstAdapterClass(c_void);
impl ::std::fmt::Debug for GstAdapterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAdapterClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAdapterClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseParseClass {
pub parent_class: gst::GstElementClass,
pub start: Option<unsafe extern "C" fn(*mut GstBaseParse) -> gboolean>,
@ -114,11 +132,26 @@ pub struct GstBaseParseClass {
impl ::std::fmt::Debug for GstBaseParseClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseParseClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseParseClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("start", &self.start)
.field("stop", &self.stop)
.field("set_sink_caps", &self.set_sink_caps)
.field("handle_frame", &self.handle_frame)
.field("pre_push_frame", &self.pre_push_frame)
.field("convert", &self.convert)
.field("sink_event", &self.sink_event)
.field("src_event", &self.src_event)
.field("get_sink_caps", &self.get_sink_caps)
.field("detect", &self.detect)
.field("sink_query", &self.sink_query)
.field("src_query", &self.src_query)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseParseFrame {
pub buffer: *mut gst::GstBuffer,
pub out_buffer: *mut gst::GstBuffer,
@ -133,7 +166,13 @@ pub struct GstBaseParseFrame {
impl ::std::fmt::Debug for GstBaseParseFrame {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseParseFrame @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseParseFrame @ {:?}", self as *const _))
.field("buffer", &self.buffer)
.field("out_buffer", &self.out_buffer)
.field("flags", &self.flags)
.field("offset", &self.offset)
.field("overhead", &self.overhead)
.finish()
}
}
@ -142,11 +181,13 @@ pub struct GstBaseParsePrivate(c_void);
impl ::std::fmt::Debug for GstBaseParsePrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseParsePrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseParsePrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseSinkClass {
pub parent_class: gst::GstElementClass,
pub get_caps: Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstCaps) -> *mut gst::GstCaps>,
@ -172,7 +213,27 @@ pub struct GstBaseSinkClass {
impl ::std::fmt::Debug for GstBaseSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseSinkClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseSinkClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("get_caps", &self.get_caps)
.field("set_caps", &self.set_caps)
.field("fixate", &self.fixate)
.field("activate_pull", &self.activate_pull)
.field("get_times", &self.get_times)
.field("propose_allocation", &self.propose_allocation)
.field("start", &self.start)
.field("stop", &self.stop)
.field("unlock", &self.unlock)
.field("unlock_stop", &self.unlock_stop)
.field("query", &self.query)
.field("event", &self.event)
.field("wait_event", &self.wait_event)
.field("prepare", &self.prepare)
.field("prepare_list", &self.prepare_list)
.field("preroll", &self.preroll)
.field("render", &self.render)
.field("render_list", &self.render_list)
.finish()
}
}
@ -181,11 +242,13 @@ pub struct GstBaseSinkPrivate(c_void);
impl ::std::fmt::Debug for GstBaseSinkPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseSinkPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseSinkPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseSrcClass {
pub parent_class: gst::GstElementClass,
pub get_caps: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstCaps) -> *mut gst::GstCaps>,
@ -212,7 +275,28 @@ pub struct GstBaseSrcClass {
impl ::std::fmt::Debug for GstBaseSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseSrcClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseSrcClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("get_caps", &self.get_caps)
.field("negotiate", &self.negotiate)
.field("fixate", &self.fixate)
.field("set_caps", &self.set_caps)
.field("decide_allocation", &self.decide_allocation)
.field("start", &self.start)
.field("stop", &self.stop)
.field("get_times", &self.get_times)
.field("get_size", &self.get_size)
.field("is_seekable", &self.is_seekable)
.field("prepare_seek_segment", &self.prepare_seek_segment)
.field("do_seek", &self.do_seek)
.field("unlock", &self.unlock)
.field("unlock_stop", &self.unlock_stop)
.field("query", &self.query)
.field("event", &self.event)
.field("create", &self.create)
.field("alloc", &self.alloc)
.field("fill", &self.fill)
.finish()
}
}
@ -221,11 +305,13 @@ pub struct GstBaseSrcPrivate(c_void);
impl ::std::fmt::Debug for GstBaseSrcPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseSrcPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseSrcPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseTransformClass {
pub parent_class: gst::GstElementClass,
pub passthrough_on_same_caps: gboolean,
@ -257,7 +343,33 @@ pub struct GstBaseTransformClass {
impl ::std::fmt::Debug for GstBaseTransformClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseTransformClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseTransformClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("passthrough_on_same_caps", &self.passthrough_on_same_caps)
.field("transform_ip_on_passthrough", &self.transform_ip_on_passthrough)
.field("transform_caps", &self.transform_caps)
.field("fixate_caps", &self.fixate_caps)
.field("accept_caps", &self.accept_caps)
.field("set_caps", &self.set_caps)
.field("query", &self.query)
.field("decide_allocation", &self.decide_allocation)
.field("filter_meta", &self.filter_meta)
.field("propose_allocation", &self.propose_allocation)
.field("transform_size", &self.transform_size)
.field("get_unit_size", &self.get_unit_size)
.field("start", &self.start)
.field("stop", &self.stop)
.field("sink_event", &self.sink_event)
.field("src_event", &self.src_event)
.field("prepare_output_buffer", &self.prepare_output_buffer)
.field("copy_metadata", &self.copy_metadata)
.field("transform_meta", &self.transform_meta)
.field("before_transform", &self.before_transform)
.field("transform", &self.transform)
.field("transform_ip", &self.transform_ip)
.field("submit_input_buffer", &self.submit_input_buffer)
.field("generate_output", &self.generate_output)
.finish()
}
}
@ -266,11 +378,13 @@ pub struct GstBaseTransformPrivate(c_void);
impl ::std::fmt::Debug for GstBaseTransformPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBaseTransformPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstBaseTransformPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBitReader {
pub data: *mut u8,
pub size: c_uint,
@ -281,11 +395,17 @@ pub struct GstBitReader {
impl ::std::fmt::Debug for GstBitReader {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstBitReader @ {:?}", self as *const _)
f.debug_struct(&format!("GstBitReader @ {:?}", self as *const _))
.field("data", &self.data)
.field("size", &self.size)
.field("byte", &self.byte)
.field("bit", &self.bit)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstByteReader {
pub data: *mut u8,
pub size: c_uint,
@ -295,11 +415,16 @@ pub struct GstByteReader {
impl ::std::fmt::Debug for GstByteReader {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstByteReader @ {:?}", self as *const _)
f.debug_struct(&format!("GstByteReader @ {:?}", self as *const _))
.field("data", &self.data)
.field("size", &self.size)
.field("byte", &self.byte)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstByteWriter {
pub parent: GstByteReader,
pub alloc_size: c_uint,
@ -310,11 +435,17 @@ pub struct GstByteWriter {
impl ::std::fmt::Debug for GstByteWriter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstByteWriter @ {:?}", self as *const _)
f.debug_struct(&format!("GstByteWriter @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("alloc_size", &self.alloc_size)
.field("fixed", &self.fixed)
.field("owned", &self.owned)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstCollectData {
pub collect: *mut GstCollectPads,
pub pad: *mut gst::GstPad,
@ -323,12 +454,19 @@ pub struct GstCollectData {
pub segment: gst::GstSegment,
pub state: GstCollectPadsStateFlags,
pub priv_: *mut GstCollectDataPrivate,
pub _gst_reserved: [gpointer; 4],
pub ABI: GstCollectData_ABI,
}
impl ::std::fmt::Debug for GstCollectData {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstCollectData @ {:?}", self as *const _)
f.debug_struct(&format!("GstCollectData @ {:?}", self as *const _))
.field("collect", &self.collect)
.field("pad", &self.pad)
.field("buffer", &self.buffer)
.field("pos", &self.pos)
.field("segment", &self.segment)
.field("ABI", &self.ABI)
.finish()
}
}
@ -337,11 +475,27 @@ pub struct GstCollectDataPrivate(c_void);
impl ::std::fmt::Debug for GstCollectDataPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstCollectDataPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstCollectDataPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstCollectData_ABI_abi {
pub dts: i64,
}
impl ::std::fmt::Debug for GstCollectData_ABI_abi {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstCollectData_ABI_abi @ {:?}", self as *const _))
.field("dts", &self.dts)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstCollectPadsClass {
pub parent_class: gst::GstObjectClass,
pub _gst_reserved: [gpointer; 4],
@ -349,7 +503,9 @@ pub struct GstCollectPadsClass {
impl ::std::fmt::Debug for GstCollectPadsClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstCollectPadsClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstCollectPadsClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
@ -358,11 +514,13 @@ pub struct GstCollectPadsPrivate(c_void);
impl ::std::fmt::Debug for GstCollectPadsPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstCollectPadsPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstCollectPadsPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstDataQueueClass {
pub parent_class: gobject::GObjectClass,
pub empty: Option<unsafe extern "C" fn(*mut GstDataQueue)>,
@ -372,11 +530,17 @@ pub struct GstDataQueueClass {
impl ::std::fmt::Debug for GstDataQueueClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDataQueueClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstDataQueueClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("empty", &self.empty)
.field("full", &self.full)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstDataQueueItem {
pub object: *mut gst::GstMiniObject,
pub size: c_uint,
@ -388,7 +552,13 @@ pub struct GstDataQueueItem {
impl ::std::fmt::Debug for GstDataQueueItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDataQueueItem @ {:?}", self as *const _)
f.debug_struct(&format!("GstDataQueueItem @ {:?}", self as *const _))
.field("object", &self.object)
.field("size", &self.size)
.field("duration", &self.duration)
.field("visible", &self.visible)
.field("destroy", &self.destroy)
.finish()
}
}
@ -397,11 +567,13 @@ pub struct GstDataQueuePrivate(c_void);
impl ::std::fmt::Debug for GstDataQueuePrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDataQueuePrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstDataQueuePrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstDataQueueSize {
pub visible: c_uint,
pub bytes: c_uint,
@ -410,7 +582,11 @@ pub struct GstDataQueueSize {
impl ::std::fmt::Debug for GstDataQueueSize {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDataQueueSize @ {:?}", self as *const _)
f.debug_struct(&format!("GstDataQueueSize @ {:?}", self as *const _))
.field("visible", &self.visible)
.field("bytes", &self.bytes)
.field("time", &self.time)
.finish()
}
}
@ -419,11 +595,13 @@ pub struct GstFlowCombiner(c_void);
impl ::std::fmt::Debug for GstFlowCombiner {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstFlowCombiner @ {:?}", self as *const _)
f.debug_struct(&format!("GstFlowCombiner @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstPushSrcClass {
pub parent_class: GstBaseSrcClass,
pub create: Option<unsafe extern "C" fn(*mut GstPushSrc, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
@ -434,7 +612,12 @@ pub struct GstPushSrcClass {
impl ::std::fmt::Debug for GstPushSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPushSrcClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPushSrcClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("create", &self.create)
.field("alloc", &self.alloc)
.field("fill", &self.fill)
.finish()
}
}
@ -443,7 +626,8 @@ pub struct GstQueueArray(c_void);
impl ::std::fmt::Debug for GstQueueArray {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstQueueArray @ {:?}", self as *const _)
f.debug_struct(&format!("GstQueueArray @ {:?}", self as *const _))
.finish()
}
}
@ -453,11 +637,13 @@ pub struct GstAdapter(c_void);
impl ::std::fmt::Debug for GstAdapter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAdapter @ {:?}", self as *const _)
f.debug_struct(&format!("GstAdapter @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseParse {
pub element: gst::GstElement,
pub sinkpad: *mut gst::GstPad,
@ -476,13 +662,12 @@ impl ::std::fmt::Debug for GstBaseParse {
.field("srcpad", &self.srcpad)
.field("flags", &self.flags)
.field("segment", &self.segment)
.field("_gst_reserved", &self._gst_reserved)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseSink {
pub element: gst::GstElement,
pub sinkpad: *mut gst::GstPad,
@ -524,18 +709,12 @@ impl ::std::fmt::Debug for GstBaseSink {
.field("playing_async", &self.playing_async)
.field("have_newsegment", &self.have_newsegment)
.field("segment", &self.segment)
.field("clock_id", &self.clock_id)
.field("sync", &self.sync)
.field("flushing", &self.flushing)
.field("running", &self.running)
.field("max_lateness", &self.max_lateness)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseSrc {
pub element: gst::GstElement,
pub srcpad: *mut gst::GstPad,
@ -579,12 +758,12 @@ impl ::std::fmt::Debug for GstBaseSrc {
.field("running", &self.running)
.field("pending_seek", &self.pending_seek)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstBaseTransform {
pub element: gst::GstElement,
pub sinkpad: *mut gst::GstPad,
@ -605,13 +784,12 @@ impl ::std::fmt::Debug for GstBaseTransform {
.field("have_segment", &self.have_segment)
.field("segment", &self.segment)
.field("queued_buf", &self.queued_buf)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstCollectPads {
pub object: gst::GstObject,
pub data: *mut glib::GSList,
@ -625,14 +803,12 @@ impl ::std::fmt::Debug for GstCollectPads {
f.debug_struct(&format!("GstCollectPads @ {:?}", self as *const _))
.field("object", &self.object)
.field("data", &self.data)
.field("stream_lock", &self.stream_lock)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstDataQueue {
pub object: gobject::GObject,
pub priv_: *mut GstDataQueuePrivate,
@ -643,13 +819,12 @@ impl ::std::fmt::Debug for GstDataQueue {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstDataQueue @ {:?}", self as *const _))
.field("object", &self.object)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstPushSrc {
pub parent: GstBaseSrc,
pub _gst_reserved: [gpointer; 4],
@ -659,7 +834,6 @@ impl ::std::fmt::Debug for GstPushSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstPushSrc @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
extern crate glib_sys as glib;
@ -575,6 +575,7 @@ pub type GstMpegtsPacketizeFunc = Option<unsafe extern "C" fn(*mut GstMpegtsSect
// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscEIT {
pub source_id: u16,
pub protocol_version: u8,
@ -583,11 +584,16 @@ pub struct GstMpegtsAtscEIT {
impl ::std::fmt::Debug for GstMpegtsAtscEIT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscEIT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscEIT @ {:?}", self as *const _))
.field("source_id", &self.source_id)
.field("protocol_version", &self.protocol_version)
.field("events", &self.events)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscEITEvent {
pub event_id: u16,
pub start_time: u32,
@ -599,11 +605,19 @@ pub struct GstMpegtsAtscEITEvent {
impl ::std::fmt::Debug for GstMpegtsAtscEITEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscEITEvent @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscEITEvent @ {:?}", self as *const _))
.field("event_id", &self.event_id)
.field("start_time", &self.start_time)
.field("etm_location", &self.etm_location)
.field("length_in_seconds", &self.length_in_seconds)
.field("titles", &self.titles)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscETT {
pub ett_table_id_extension: u16,
pub protocol_version: u16,
@ -613,11 +627,17 @@ pub struct GstMpegtsAtscETT {
impl ::std::fmt::Debug for GstMpegtsAtscETT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscETT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscETT @ {:?}", self as *const _))
.field("ett_table_id_extension", &self.ett_table_id_extension)
.field("protocol_version", &self.protocol_version)
.field("etm_id", &self.etm_id)
.field("messages", &self.messages)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscMGT {
pub protocol_version: u8,
pub tables_defined: u16,
@ -627,11 +647,17 @@ pub struct GstMpegtsAtscMGT {
impl ::std::fmt::Debug for GstMpegtsAtscMGT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscMGT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscMGT @ {:?}", self as *const _))
.field("protocol_version", &self.protocol_version)
.field("tables_defined", &self.tables_defined)
.field("tables", &self.tables)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscMGTTable {
pub table_type: u16,
pub pid: u16,
@ -642,11 +668,18 @@ pub struct GstMpegtsAtscMGTTable {
impl ::std::fmt::Debug for GstMpegtsAtscMGTTable {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscMGTTable @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscMGTTable @ {:?}", self as *const _))
.field("table_type", &self.table_type)
.field("pid", &self.pid)
.field("version_number", &self.version_number)
.field("number_bytes", &self.number_bytes)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscMultString {
pub iso_639_langcode: [c_char; 4],
pub segments: *mut glib::GPtrArray,
@ -654,11 +687,15 @@ pub struct GstMpegtsAtscMultString {
impl ::std::fmt::Debug for GstMpegtsAtscMultString {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscMultString @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscMultString @ {:?}", self as *const _))
.field("iso_639_langcode", &self.iso_639_langcode)
.field("segments", &self.segments)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscSTT {
pub protocol_version: u8,
pub system_time: u32,
@ -672,11 +709,21 @@ pub struct GstMpegtsAtscSTT {
impl ::std::fmt::Debug for GstMpegtsAtscSTT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscSTT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscSTT @ {:?}", self as *const _))
.field("protocol_version", &self.protocol_version)
.field("system_time", &self.system_time)
.field("gps_utc_offset", &self.gps_utc_offset)
.field("ds_status", &self.ds_status)
.field("ds_dayofmonth", &self.ds_dayofmonth)
.field("ds_hour", &self.ds_hour)
.field("descriptors", &self.descriptors)
.field("utc_datetime", &self.utc_datetime)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscStringSegment {
pub compression_type: u8,
pub mode: u8,
@ -687,11 +734,18 @@ pub struct GstMpegtsAtscStringSegment {
impl ::std::fmt::Debug for GstMpegtsAtscStringSegment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscStringSegment @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscStringSegment @ {:?}", self as *const _))
.field("compression_type", &self.compression_type)
.field("mode", &self.mode)
.field("compressed_data_size", &self.compressed_data_size)
.field("compressed_data", &self.compressed_data)
.field("cached_string", &self.cached_string)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscVCT {
pub transport_stream_id: u16,
pub protocol_version: u8,
@ -701,11 +755,17 @@ pub struct GstMpegtsAtscVCT {
impl ::std::fmt::Debug for GstMpegtsAtscVCT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscVCT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscVCT @ {:?}", self as *const _))
.field("transport_stream_id", &self.transport_stream_id)
.field("protocol_version", &self.protocol_version)
.field("sources", &self.sources)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsAtscVCTSource {
pub short_name: *mut c_char,
pub major_channel_number: u16,
@ -727,11 +787,29 @@ pub struct GstMpegtsAtscVCTSource {
impl ::std::fmt::Debug for GstMpegtsAtscVCTSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsAtscVCTSource @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsAtscVCTSource @ {:?}", self as *const _))
.field("short_name", &self.short_name)
.field("major_channel_number", &self.major_channel_number)
.field("minor_channel_number", &self.minor_channel_number)
.field("modulation_mode", &self.modulation_mode)
.field("carrier_frequency", &self.carrier_frequency)
.field("channel_TSID", &self.channel_TSID)
.field("program_number", &self.program_number)
.field("ETM_location", &self.ETM_location)
.field("access_controlled", &self.access_controlled)
.field("hidden", &self.hidden)
.field("path_select", &self.path_select)
.field("out_of_band", &self.out_of_band)
.field("hide_guide", &self.hide_guide)
.field("service_type", &self.service_type)
.field("source_id", &self.source_id)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsBAT {
pub descriptors: *mut glib::GPtrArray,
pub streams: *mut glib::GPtrArray,
@ -739,11 +817,15 @@ pub struct GstMpegtsBAT {
impl ::std::fmt::Debug for GstMpegtsBAT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsBAT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsBAT @ {:?}", self as *const _))
.field("descriptors", &self.descriptors)
.field("streams", &self.streams)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsBATStream {
pub transport_stream_id: u16,
pub original_network_id: u16,
@ -752,11 +834,16 @@ pub struct GstMpegtsBATStream {
impl ::std::fmt::Debug for GstMpegtsBATStream {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsBATStream @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsBATStream @ {:?}", self as *const _))
.field("transport_stream_id", &self.transport_stream_id)
.field("original_network_id", &self.original_network_id)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsCableDeliverySystemDescriptor {
pub frequency: u32,
pub outer_fec: GstMpegtsCableOuterFECScheme,
@ -767,11 +854,18 @@ pub struct GstMpegtsCableDeliverySystemDescriptor {
impl ::std::fmt::Debug for GstMpegtsCableDeliverySystemDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsCableDeliverySystemDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsCableDeliverySystemDescriptor @ {:?}", self as *const _))
.field("frequency", &self.frequency)
.field("outer_fec", &self.outer_fec)
.field("modulation", &self.modulation)
.field("symbol_rate", &self.symbol_rate)
.field("fec_inner", &self.fec_inner)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsComponentDescriptor {
pub stream_content: u8,
pub component_type: u8,
@ -782,11 +876,18 @@ pub struct GstMpegtsComponentDescriptor {
impl ::std::fmt::Debug for GstMpegtsComponentDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsComponentDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsComponentDescriptor @ {:?}", self as *const _))
.field("stream_content", &self.stream_content)
.field("component_type", &self.component_type)
.field("component_tag", &self.component_tag)
.field("language_code", &self.language_code)
.field("text", &self.text)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsContent {
pub content_nibble_1: GstMpegtsContentNibbleHi,
pub content_nibble_2: u8,
@ -795,11 +896,16 @@ pub struct GstMpegtsContent {
impl ::std::fmt::Debug for GstMpegtsContent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsContent @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsContent @ {:?}", self as *const _))
.field("content_nibble_1", &self.content_nibble_1)
.field("content_nibble_2", &self.content_nibble_2)
.field("user_byte", &self.user_byte)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDVBLinkageDescriptor {
pub transport_stream_id: u16,
pub original_network_id: u16,
@ -812,11 +918,19 @@ pub struct GstMpegtsDVBLinkageDescriptor {
impl ::std::fmt::Debug for GstMpegtsDVBLinkageDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBLinkageDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDVBLinkageDescriptor @ {:?}", self as *const _))
.field("transport_stream_id", &self.transport_stream_id)
.field("original_network_id", &self.original_network_id)
.field("service_id", &self.service_id)
.field("linkage_type", &self.linkage_type)
.field("private_data_length", &self.private_data_length)
.field("private_data_bytes", &self.private_data_bytes)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDVBLinkageEvent {
pub target_event_id: u16,
pub target_listed: gboolean,
@ -825,11 +939,16 @@ pub struct GstMpegtsDVBLinkageEvent {
impl ::std::fmt::Debug for GstMpegtsDVBLinkageEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBLinkageEvent @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDVBLinkageEvent @ {:?}", self as *const _))
.field("target_event_id", &self.target_event_id)
.field("target_listed", &self.target_listed)
.field("event_simulcast", &self.event_simulcast)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDVBLinkageExtendedEvent {
pub target_event_id: u16,
pub target_listed: gboolean,
@ -846,11 +965,24 @@ pub struct GstMpegtsDVBLinkageExtendedEvent {
impl ::std::fmt::Debug for GstMpegtsDVBLinkageExtendedEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBLinkageExtendedEvent @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDVBLinkageExtendedEvent @ {:?}", self as *const _))
.field("target_event_id", &self.target_event_id)
.field("target_listed", &self.target_listed)
.field("event_simulcast", &self.event_simulcast)
.field("link_type", &self.link_type)
.field("target_id_type", &self.target_id_type)
.field("original_network_id_flag", &self.original_network_id_flag)
.field("service_id_flag", &self.service_id_flag)
.field("user_defined_id", &self.user_defined_id)
.field("target_transport_stream_id", &self.target_transport_stream_id)
.field("target_original_network_id", &self.target_original_network_id)
.field("target_service_id", &self.target_service_id)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDVBLinkageMobileHandOver {
pub hand_over_type: GstMpegtsDVBLinkageHandOverType,
pub origin_type: gboolean,
@ -860,11 +992,17 @@ pub struct GstMpegtsDVBLinkageMobileHandOver {
impl ::std::fmt::Debug for GstMpegtsDVBLinkageMobileHandOver {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBLinkageMobileHandOver @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDVBLinkageMobileHandOver @ {:?}", self as *const _))
.field("hand_over_type", &self.hand_over_type)
.field("origin_type", &self.origin_type)
.field("network_id", &self.network_id)
.field("initial_service_id", &self.initial_service_id)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDVBParentalRatingItem {
pub country_code: *mut c_char,
pub rating: u8,
@ -872,11 +1010,15 @@ pub struct GstMpegtsDVBParentalRatingItem {
impl ::std::fmt::Debug for GstMpegtsDVBParentalRatingItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBParentalRatingItem @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDVBParentalRatingItem @ {:?}", self as *const _))
.field("country_code", &self.country_code)
.field("rating", &self.rating)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDVBServiceListItem {
pub service_id: u16,
pub type_: GstMpegtsDVBServiceType,
@ -884,11 +1026,15 @@ pub struct GstMpegtsDVBServiceListItem {
impl ::std::fmt::Debug for GstMpegtsDVBServiceListItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDVBServiceListItem @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDVBServiceListItem @ {:?}", self as *const _))
.field("service_id", &self.service_id)
.field("type_", &self.type_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDataBroadcastDescriptor {
pub data_broadcast_id: u16,
pub component_tag: u8,
@ -900,11 +1046,19 @@ pub struct GstMpegtsDataBroadcastDescriptor {
impl ::std::fmt::Debug for GstMpegtsDataBroadcastDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDataBroadcastDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDataBroadcastDescriptor @ {:?}", self as *const _))
.field("data_broadcast_id", &self.data_broadcast_id)
.field("component_tag", &self.component_tag)
.field("length", &self.length)
.field("selector_bytes", &self.selector_bytes)
.field("language_code", &self.language_code)
.field("text", &self.text)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDescriptor {
pub tag: u8,
pub tag_extension: u8,
@ -915,11 +1069,17 @@ pub struct GstMpegtsDescriptor {
impl ::std::fmt::Debug for GstMpegtsDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDescriptor @ {:?}", self as *const _))
.field("tag", &self.tag)
.field("tag_extension", &self.tag_extension)
.field("length", &self.length)
.field("data", &self.data)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDvbMultilingualBouquetNameItem {
pub language_code: *mut c_char,
pub bouquet_name: *mut c_char,
@ -927,11 +1087,15 @@ pub struct GstMpegtsDvbMultilingualBouquetNameItem {
impl ::std::fmt::Debug for GstMpegtsDvbMultilingualBouquetNameItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDvbMultilingualBouquetNameItem @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDvbMultilingualBouquetNameItem @ {:?}", self as *const _))
.field("language_code", &self.language_code)
.field("bouquet_name", &self.bouquet_name)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDvbMultilingualComponentItem {
pub language_code: *mut c_char,
pub description: *mut c_char,
@ -939,11 +1103,15 @@ pub struct GstMpegtsDvbMultilingualComponentItem {
impl ::std::fmt::Debug for GstMpegtsDvbMultilingualComponentItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDvbMultilingualComponentItem @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDvbMultilingualComponentItem @ {:?}", self as *const _))
.field("language_code", &self.language_code)
.field("description", &self.description)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDvbMultilingualNetworkNameItem {
pub language_code: *mut c_char,
pub network_name: *mut c_char,
@ -951,11 +1119,15 @@ pub struct GstMpegtsDvbMultilingualNetworkNameItem {
impl ::std::fmt::Debug for GstMpegtsDvbMultilingualNetworkNameItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDvbMultilingualNetworkNameItem @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDvbMultilingualNetworkNameItem @ {:?}", self as *const _))
.field("language_code", &self.language_code)
.field("network_name", &self.network_name)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsDvbMultilingualServiceNameItem {
pub language_code: *mut c_char,
pub provider_name: *mut c_char,
@ -964,11 +1136,16 @@ pub struct GstMpegtsDvbMultilingualServiceNameItem {
impl ::std::fmt::Debug for GstMpegtsDvbMultilingualServiceNameItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsDvbMultilingualServiceNameItem @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsDvbMultilingualServiceNameItem @ {:?}", self as *const _))
.field("language_code", &self.language_code)
.field("provider_name", &self.provider_name)
.field("service_name", &self.service_name)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsEIT {
pub transport_stream_id: u16,
pub original_network_id: u16,
@ -981,11 +1158,20 @@ pub struct GstMpegtsEIT {
impl ::std::fmt::Debug for GstMpegtsEIT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsEIT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsEIT @ {:?}", self as *const _))
.field("transport_stream_id", &self.transport_stream_id)
.field("original_network_id", &self.original_network_id)
.field("segment_last_section_number", &self.segment_last_section_number)
.field("last_table_id", &self.last_table_id)
.field("actual_stream", &self.actual_stream)
.field("present_following", &self.present_following)
.field("events", &self.events)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsEITEvent {
pub event_id: u16,
pub start_time: *mut gst::GstDateTime,
@ -997,11 +1183,19 @@ pub struct GstMpegtsEITEvent {
impl ::std::fmt::Debug for GstMpegtsEITEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsEITEvent @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsEITEvent @ {:?}", self as *const _))
.field("event_id", &self.event_id)
.field("start_time", &self.start_time)
.field("duration", &self.duration)
.field("running_status", &self.running_status)
.field("free_CA_mode", &self.free_CA_mode)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsExtendedEventDescriptor {
pub descriptor_number: u8,
pub last_descriptor_number: u8,
@ -1012,11 +1206,18 @@ pub struct GstMpegtsExtendedEventDescriptor {
impl ::std::fmt::Debug for GstMpegtsExtendedEventDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsExtendedEventDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsExtendedEventDescriptor @ {:?}", self as *const _))
.field("descriptor_number", &self.descriptor_number)
.field("last_descriptor_number", &self.last_descriptor_number)
.field("language_code", &self.language_code)
.field("items", &self.items)
.field("text", &self.text)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsExtendedEventItem {
pub item_description: *mut c_char,
pub item: *mut c_char,
@ -1024,11 +1225,15 @@ pub struct GstMpegtsExtendedEventItem {
impl ::std::fmt::Debug for GstMpegtsExtendedEventItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsExtendedEventItem @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsExtendedEventItem @ {:?}", self as *const _))
.field("item_description", &self.item_description)
.field("item", &self.item)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsISO639LanguageDescriptor {
pub nb_language: c_uint,
pub language: [c_char; 64],
@ -1037,11 +1242,14 @@ pub struct GstMpegtsISO639LanguageDescriptor {
impl ::std::fmt::Debug for GstMpegtsISO639LanguageDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsISO639LanguageDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsISO639LanguageDescriptor @ {:?}", self as *const _))
.field("nb_language", &self.nb_language)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsLogicalChannel {
pub service_id: u16,
pub visible_service: gboolean,
@ -1050,11 +1258,16 @@ pub struct GstMpegtsLogicalChannel {
impl ::std::fmt::Debug for GstMpegtsLogicalChannel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsLogicalChannel @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsLogicalChannel @ {:?}", self as *const _))
.field("service_id", &self.service_id)
.field("visible_service", &self.visible_service)
.field("logical_channel_number", &self.logical_channel_number)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsLogicalChannelDescriptor {
pub nb_channels: c_uint,
pub channels: [GstMpegtsLogicalChannel; 64],
@ -1062,11 +1275,14 @@ pub struct GstMpegtsLogicalChannelDescriptor {
impl ::std::fmt::Debug for GstMpegtsLogicalChannelDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsLogicalChannelDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsLogicalChannelDescriptor @ {:?}", self as *const _))
.field("nb_channels", &self.nb_channels)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsNIT {
pub actual_network: gboolean,
pub network_id: u16,
@ -1076,11 +1292,17 @@ pub struct GstMpegtsNIT {
impl ::std::fmt::Debug for GstMpegtsNIT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsNIT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsNIT @ {:?}", self as *const _))
.field("actual_network", &self.actual_network)
.field("network_id", &self.network_id)
.field("descriptors", &self.descriptors)
.field("streams", &self.streams)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsNITStream {
pub transport_stream_id: u16,
pub original_network_id: u16,
@ -1089,11 +1311,16 @@ pub struct GstMpegtsNITStream {
impl ::std::fmt::Debug for GstMpegtsNITStream {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsNITStream @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsNITStream @ {:?}", self as *const _))
.field("transport_stream_id", &self.transport_stream_id)
.field("original_network_id", &self.original_network_id)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsPMT {
pub pcr_pid: u16,
pub program_number: u16,
@ -1103,11 +1330,17 @@ pub struct GstMpegtsPMT {
impl ::std::fmt::Debug for GstMpegtsPMT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsPMT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsPMT @ {:?}", self as *const _))
.field("pcr_pid", &self.pcr_pid)
.field("program_number", &self.program_number)
.field("descriptors", &self.descriptors)
.field("streams", &self.streams)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsPMTStream {
pub stream_type: u8,
pub pid: u16,
@ -1116,11 +1349,16 @@ pub struct GstMpegtsPMTStream {
impl ::std::fmt::Debug for GstMpegtsPMTStream {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsPMTStream @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsPMTStream @ {:?}", self as *const _))
.field("stream_type", &self.stream_type)
.field("pid", &self.pid)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsPatProgram {
pub program_number: u16,
pub network_or_program_map_PID: u16,
@ -1128,11 +1366,15 @@ pub struct GstMpegtsPatProgram {
impl ::std::fmt::Debug for GstMpegtsPatProgram {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsPatProgram @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsPatProgram @ {:?}", self as *const _))
.field("program_number", &self.program_number)
.field("network_or_program_map_PID", &self.network_or_program_map_PID)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsSDT {
pub original_network_id: u16,
pub actual_ts: gboolean,
@ -1142,11 +1384,17 @@ pub struct GstMpegtsSDT {
impl ::std::fmt::Debug for GstMpegtsSDT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsSDT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsSDT @ {:?}", self as *const _))
.field("original_network_id", &self.original_network_id)
.field("actual_ts", &self.actual_ts)
.field("transport_stream_id", &self.transport_stream_id)
.field("services", &self.services)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsSDTService {
pub service_id: u16,
pub EIT_schedule_flag: gboolean,
@ -1158,11 +1406,19 @@ pub struct GstMpegtsSDTService {
impl ::std::fmt::Debug for GstMpegtsSDTService {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsSDTService @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsSDTService @ {:?}", self as *const _))
.field("service_id", &self.service_id)
.field("EIT_schedule_flag", &self.EIT_schedule_flag)
.field("EIT_present_following_flag", &self.EIT_present_following_flag)
.field("running_status", &self.running_status)
.field("free_CA_mode", &self.free_CA_mode)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsSatelliteDeliverySystemDescriptor {
pub frequency: u32,
pub orbital_position: c_float,
@ -1177,11 +1433,22 @@ pub struct GstMpegtsSatelliteDeliverySystemDescriptor {
impl ::std::fmt::Debug for GstMpegtsSatelliteDeliverySystemDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsSatelliteDeliverySystemDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsSatelliteDeliverySystemDescriptor @ {:?}", self as *const _))
.field("frequency", &self.frequency)
.field("orbital_position", &self.orbital_position)
.field("west_east", &self.west_east)
.field("polarization", &self.polarization)
.field("roll_off", &self.roll_off)
.field("modulation_system", &self.modulation_system)
.field("modulation_type", &self.modulation_type)
.field("symbol_rate", &self.symbol_rate)
.field("fec_inner", &self.fec_inner)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsSection {
pub parent: gst::GstMiniObject,
pub section_type: GstMpegtsSectionType,
@ -1205,11 +1472,22 @@ pub struct GstMpegtsSection {
impl ::std::fmt::Debug for GstMpegtsSection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsSection @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsSection @ {:?}", self as *const _))
.field("section_type", &self.section_type)
.field("pid", &self.pid)
.field("table_id", &self.table_id)
.field("subtable_extension", &self.subtable_extension)
.field("version_number", &self.version_number)
.field("current_next_indicator", &self.current_next_indicator)
.field("section_number", &self.section_number)
.field("last_section_number", &self.last_section_number)
.field("crc", &self.crc)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsT2DeliverySystemCell {
pub cell_id: u16,
pub centre_frequencies: *mut glib::GArray,
@ -1218,11 +1496,16 @@ pub struct GstMpegtsT2DeliverySystemCell {
impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemCell {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsT2DeliverySystemCell @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsT2DeliverySystemCell @ {:?}", self as *const _))
.field("cell_id", &self.cell_id)
.field("centre_frequencies", &self.centre_frequencies)
.field("sub_cells", &self.sub_cells)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsT2DeliverySystemCellExtension {
pub cell_id_extension: u8,
pub transposer_frequency: u32,
@ -1230,11 +1513,15 @@ pub struct GstMpegtsT2DeliverySystemCellExtension {
impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemCellExtension {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsT2DeliverySystemCellExtension @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsT2DeliverySystemCellExtension @ {:?}", self as *const _))
.field("cell_id_extension", &self.cell_id_extension)
.field("transposer_frequency", &self.transposer_frequency)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsT2DeliverySystemDescriptor {
pub plp_id: u8,
pub t2_system_id: u16,
@ -1249,11 +1536,22 @@ pub struct GstMpegtsT2DeliverySystemDescriptor {
impl ::std::fmt::Debug for GstMpegtsT2DeliverySystemDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsT2DeliverySystemDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsT2DeliverySystemDescriptor @ {:?}", self as *const _))
.field("plp_id", &self.plp_id)
.field("t2_system_id", &self.t2_system_id)
.field("siso_miso", &self.siso_miso)
.field("bandwidth", &self.bandwidth)
.field("guard_interval", &self.guard_interval)
.field("transmission_mode", &self.transmission_mode)
.field("other_frequency", &self.other_frequency)
.field("tfs", &self.tfs)
.field("cells", &self.cells)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsTOT {
pub utc_time: *mut gst::GstDateTime,
pub descriptors: *mut glib::GPtrArray,
@ -1261,11 +1559,15 @@ pub struct GstMpegtsTOT {
impl ::std::fmt::Debug for GstMpegtsTOT {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsTOT @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsTOT @ {:?}", self as *const _))
.field("utc_time", &self.utc_time)
.field("descriptors", &self.descriptors)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstMpegtsTerrestrialDeliverySystemDescriptor {
pub frequency: u32,
pub bandwidth: u32,
@ -1283,7 +1585,20 @@ pub struct GstMpegtsTerrestrialDeliverySystemDescriptor {
impl ::std::fmt::Debug for GstMpegtsTerrestrialDeliverySystemDescriptor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstMpegtsTerrestrialDeliverySystemDescriptor @ {:?}", self as *const _)
f.debug_struct(&format!("GstMpegtsTerrestrialDeliverySystemDescriptor @ {:?}", self as *const _))
.field("frequency", &self.frequency)
.field("bandwidth", &self.bandwidth)
.field("priority", &self.priority)
.field("time_slicing", &self.time_slicing)
.field("mpe_fec", &self.mpe_fec)
.field("constellation", &self.constellation)
.field("hierarchy", &self.hierarchy)
.field("code_rate_hp", &self.code_rate_hp)
.field("code_rate_lp", &self.code_rate_lp)
.field("guard_interval", &self.guard_interval)
.field("transmission_mode", &self.transmission_mode)
.field("other_frequency", &self.other_frequency)
.finish()
}
}

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
extern crate glib_sys as glib;
@ -30,6 +30,7 @@ pub type GstPtpStatisticsCallback = Option<unsafe extern "C" fn(u8, *const gst::
// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNetAddressMeta {
pub meta: gst::GstMeta,
pub addr: *mut gio::GSocketAddress,
@ -37,11 +38,15 @@ pub struct GstNetAddressMeta {
impl ::std::fmt::Debug for GstNetAddressMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNetAddressMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstNetAddressMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("addr", &self.addr)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNetClientClockClass {
pub parent_class: gst::GstSystemClockClass,
pub _gst_reserved: [gpointer; 4],
@ -49,7 +54,9 @@ pub struct GstNetClientClockClass {
impl ::std::fmt::Debug for GstNetClientClockClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNetClientClockClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstNetClientClockClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
@ -58,11 +65,13 @@ pub struct GstNetClientClockPrivate(c_void);
impl ::std::fmt::Debug for GstNetClientClockPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNetClientClockPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstNetClientClockPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNetControlMessageMeta {
pub meta: gst::GstMeta,
pub message: *mut gio::GSocketControlMessage,
@ -70,11 +79,15 @@ pub struct GstNetControlMessageMeta {
impl ::std::fmt::Debug for GstNetControlMessageMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNetControlMessageMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstNetControlMessageMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("message", &self.message)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNetTimePacket {
pub local_time: gst::GstClockTime,
pub remote_time: gst::GstClockTime,
@ -82,11 +95,15 @@ pub struct GstNetTimePacket {
impl ::std::fmt::Debug for GstNetTimePacket {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNetTimePacket @ {:?}", self as *const _)
f.debug_struct(&format!("GstNetTimePacket @ {:?}", self as *const _))
.field("local_time", &self.local_time)
.field("remote_time", &self.remote_time)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNetTimeProviderClass {
pub parent_class: gst::GstObjectClass,
pub _gst_reserved: [gpointer; 4],
@ -94,7 +111,10 @@ pub struct GstNetTimeProviderClass {
impl ::std::fmt::Debug for GstNetTimeProviderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNetTimeProviderClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstNetTimeProviderClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
@ -103,11 +123,13 @@ pub struct GstNetTimeProviderPrivate(c_void);
impl ::std::fmt::Debug for GstNetTimeProviderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNetTimeProviderPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstNetTimeProviderPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNtpClockClass {
pub parent_class: gst::GstSystemClockClass,
pub _gst_reserved: [gpointer; 4],
@ -115,11 +137,14 @@ pub struct GstNtpClockClass {
impl ::std::fmt::Debug for GstNtpClockClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNtpClockClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstNtpClockClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstPtpClockClass {
pub parent_class: gst::GstSystemClockClass,
pub _gst_reserved: [gpointer; 4],
@ -127,7 +152,9 @@ pub struct GstPtpClockClass {
impl ::std::fmt::Debug for GstPtpClockClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPtpClockClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPtpClockClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
@ -136,12 +163,14 @@ pub struct GstPtpClockPrivate(c_void);
impl ::std::fmt::Debug for GstPtpClockPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPtpClockPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstPtpClockPrivate @ {:?}", self as *const _))
.finish()
}
}
// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNetClientClock {
pub clock: gst::GstSystemClock,
pub priv_: *mut GstNetClientClockPrivate,
@ -152,13 +181,12 @@ impl ::std::fmt::Debug for GstNetClientClock {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstNetClientClock @ {:?}", self as *const _))
.field("clock", &self.clock)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNetTimeProvider {
pub parent: gst::GstObject,
pub priv_: *mut GstNetTimeProviderPrivate,
@ -169,13 +197,12 @@ impl ::std::fmt::Debug for GstNetTimeProvider {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstNetTimeProvider @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNtpClock {
pub clock: gst::GstSystemClock,
pub priv_: *mut GstNetClientClockPrivate,
@ -186,13 +213,12 @@ impl ::std::fmt::Debug for GstNtpClock {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstNtpClock @ {:?}", self as *const _))
.field("clock", &self.clock)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstPtpClock {
pub clock: gst::GstSystemClock,
pub priv_: *mut GstPtpClockPrivate,
@ -203,8 +229,6 @@ impl ::std::fmt::Debug for GstPtpClock {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstPtpClock @ {:?}", self as *const _))
.field("clock", &self.clock)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
#[macro_use] extern crate bitflags;
@ -96,6 +96,7 @@ pub type GstInstallPluginsResultFunc = Option<unsafe extern "C" fn(GstInstallPlu
// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioVisualizerClass {
pub parent_class: gst::GstElementClass,
pub setup: Option<unsafe extern "C" fn(*mut GstAudioVisualizer) -> gboolean>,
@ -105,7 +106,12 @@ pub struct GstAudioVisualizerClass {
impl ::std::fmt::Debug for GstAudioVisualizerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioVisualizerClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioVisualizerClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("setup", &self.setup)
.field("render", &self.render)
.field("decide_allocation", &self.decide_allocation)
.finish()
}
}
@ -114,11 +120,13 @@ pub struct GstAudioVisualizerPrivate(c_void);
impl ::std::fmt::Debug for GstAudioVisualizerPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstAudioVisualizerPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstAudioVisualizerPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstDiscovererClass {
pub parentclass: gobject::GObjectClass,
pub finished: Option<unsafe extern "C" fn(*mut GstDiscoverer)>,
@ -130,7 +138,14 @@ pub struct GstDiscovererClass {
impl ::std::fmt::Debug for GstDiscovererClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstDiscovererClass @ {:?}", self as *const _))
.field("parentclass", &self.parentclass)
.field("finished", &self.finished)
.field("starting", &self.starting)
.field("discovered", &self.discovered)
.field("source_setup", &self.source_setup)
.field("_reserved", &self._reserved)
.finish()
}
}
@ -139,7 +154,8 @@ pub struct GstDiscovererPrivate(c_void);
impl ::std::fmt::Debug for GstDiscovererPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstDiscovererPrivate @ {:?}", self as *const _))
.finish()
}
}
@ -148,7 +164,8 @@ pub struct GstEncodingAudioProfileClass(c_void);
impl ::std::fmt::Debug for GstEncodingAudioProfileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingAudioProfileClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingAudioProfileClass @ {:?}", self as *const _))
.finish()
}
}
@ -157,7 +174,8 @@ pub struct GstEncodingContainerProfileClass(c_void);
impl ::std::fmt::Debug for GstEncodingContainerProfileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingContainerProfileClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingContainerProfileClass @ {:?}", self as *const _))
.finish()
}
}
@ -166,7 +184,8 @@ pub struct GstEncodingProfileClass(c_void);
impl ::std::fmt::Debug for GstEncodingProfileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingProfileClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingProfileClass @ {:?}", self as *const _))
.finish()
}
}
@ -175,7 +194,8 @@ pub struct GstEncodingVideoProfileClass(c_void);
impl ::std::fmt::Debug for GstEncodingVideoProfileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingVideoProfileClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingVideoProfileClass @ {:?}", self as *const _))
.finish()
}
}
@ -184,12 +204,14 @@ pub struct GstInstallPluginsContext(c_void);
impl ::std::fmt::Debug for GstInstallPluginsContext {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstInstallPluginsContext @ {:?}", self as *const _)
f.debug_struct(&format!("GstInstallPluginsContext @ {:?}", self as *const _))
.finish()
}
}
// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstAudioVisualizer {
pub parent: gst::GstElement,
pub req_spf: c_uint,
@ -205,12 +227,12 @@ impl ::std::fmt::Debug for GstAudioVisualizer {
.field("req_spf", &self.req_spf)
.field("vinfo", &self.vinfo)
.field("ainfo", &self.ainfo)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstDiscoverer {
pub parent: gobject::GObject,
pub priv_: *mut GstDiscovererPrivate,
@ -221,8 +243,6 @@ impl ::std::fmt::Debug for GstDiscoverer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstDiscoverer @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.field("_reserved", &self._reserved)
.finish()
}
}
@ -232,7 +252,8 @@ pub struct GstDiscovererAudioInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererAudioInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererAudioInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstDiscovererAudioInfo @ {:?}", self as *const _))
.finish()
}
}
@ -241,7 +262,8 @@ pub struct GstDiscovererContainerInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererContainerInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererContainerInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstDiscovererContainerInfo @ {:?}", self as *const _))
.finish()
}
}
@ -250,7 +272,8 @@ pub struct GstDiscovererInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstDiscovererInfo @ {:?}", self as *const _))
.finish()
}
}
@ -259,7 +282,8 @@ pub struct GstDiscovererStreamInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererStreamInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererStreamInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstDiscovererStreamInfo @ {:?}", self as *const _))
.finish()
}
}
@ -268,7 +292,8 @@ pub struct GstDiscovererSubtitleInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererSubtitleInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererSubtitleInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstDiscovererSubtitleInfo @ {:?}", self as *const _))
.finish()
}
}
@ -277,7 +302,8 @@ pub struct GstDiscovererVideoInfo(c_void);
impl ::std::fmt::Debug for GstDiscovererVideoInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstDiscovererVideoInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstDiscovererVideoInfo @ {:?}", self as *const _))
.finish()
}
}
@ -286,7 +312,8 @@ pub struct GstEncodingAudioProfile(c_void);
impl ::std::fmt::Debug for GstEncodingAudioProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingAudioProfile @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingAudioProfile @ {:?}", self as *const _))
.finish()
}
}
@ -295,7 +322,8 @@ pub struct GstEncodingContainerProfile(c_void);
impl ::std::fmt::Debug for GstEncodingContainerProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingContainerProfile @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingContainerProfile @ {:?}", self as *const _))
.finish()
}
}
@ -304,7 +332,8 @@ pub struct GstEncodingProfile(c_void);
impl ::std::fmt::Debug for GstEncodingProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingProfile @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingProfile @ {:?}", self as *const _))
.finish()
}
}
@ -313,7 +342,8 @@ pub struct GstEncodingTarget(c_void);
impl ::std::fmt::Debug for GstEncodingTarget {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingTarget @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingTarget @ {:?}", self as *const _))
.finish()
}
}
@ -322,7 +352,8 @@ pub struct GstEncodingVideoProfile(c_void);
impl ::std::fmt::Debug for GstEncodingVideoProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstEncodingVideoProfile @ {:?}", self as *const _)
f.debug_struct(&format!("GstEncodingVideoProfile @ {:?}", self as *const _))
.finish()
}
}

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
extern crate glib_sys as glib;
@ -50,7 +50,8 @@ pub struct GstPlayerAudioInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerAudioInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerAudioInfoClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerAudioInfoClass @ {:?}", self as *const _))
.finish()
}
}
@ -59,7 +60,8 @@ pub struct GstPlayerClass(c_void);
impl ::std::fmt::Debug for GstPlayerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerClass @ {:?}", self as *const _))
.finish()
}
}
@ -68,7 +70,8 @@ pub struct GstPlayerGMainContextSignalDispatcherClass(c_void);
impl ::std::fmt::Debug for GstPlayerGMainContextSignalDispatcherClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerGMainContextSignalDispatcherClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerGMainContextSignalDispatcherClass @ {:?}", self as *const _))
.finish()
}
}
@ -77,11 +80,13 @@ pub struct GstPlayerMediaInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerMediaInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerMediaInfoClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerMediaInfoClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstPlayerSignalDispatcherInterface {
pub parent_iface: gobject::GTypeInterface,
pub dispatch: Option<unsafe extern "C" fn(*mut GstPlayerSignalDispatcher, *mut GstPlayer, GstPlayerSignalDispatcherFunc, gpointer, glib::GDestroyNotify)>,
@ -89,7 +94,10 @@ pub struct GstPlayerSignalDispatcherInterface {
impl ::std::fmt::Debug for GstPlayerSignalDispatcherInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerSignalDispatcherInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerSignalDispatcherInterface @ {:?}", self as *const _))
.field("parent_iface", &self.parent_iface)
.field("dispatch", &self.dispatch)
.finish()
}
}
@ -98,7 +106,8 @@ pub struct GstPlayerStreamInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerStreamInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerStreamInfoClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerStreamInfoClass @ {:?}", self as *const _))
.finish()
}
}
@ -107,7 +116,8 @@ pub struct GstPlayerSubtitleInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerSubtitleInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerSubtitleInfoClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerSubtitleInfoClass @ {:?}", self as *const _))
.finish()
}
}
@ -116,7 +126,8 @@ pub struct GstPlayerVideoInfoClass(c_void);
impl ::std::fmt::Debug for GstPlayerVideoInfoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoInfoClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerVideoInfoClass @ {:?}", self as *const _))
.finish()
}
}
@ -125,11 +136,13 @@ pub struct GstPlayerVideoOverlayVideoRendererClass(c_void);
impl ::std::fmt::Debug for GstPlayerVideoOverlayVideoRendererClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoOverlayVideoRendererClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerVideoOverlayVideoRendererClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstPlayerVideoRendererInterface {
pub parent_iface: gobject::GTypeInterface,
pub create_video_sink: Option<unsafe extern "C" fn(*mut GstPlayerVideoRenderer, *mut GstPlayer) -> *mut gst::GstElement>,
@ -137,11 +150,15 @@ pub struct GstPlayerVideoRendererInterface {
impl ::std::fmt::Debug for GstPlayerVideoRendererInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoRendererInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerVideoRendererInterface @ {:?}", self as *const _))
.field("parent_iface", &self.parent_iface)
.field("create_video_sink", &self.create_video_sink)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstPlayerVisualization {
pub name: *mut c_char,
pub description: *mut c_char,
@ -149,7 +166,10 @@ pub struct GstPlayerVisualization {
impl ::std::fmt::Debug for GstPlayerVisualization {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVisualization @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerVisualization @ {:?}", self as *const _))
.field("name", &self.name)
.field("description", &self.description)
.finish()
}
}
@ -159,7 +179,8 @@ pub struct GstPlayer(c_void);
impl ::std::fmt::Debug for GstPlayer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayer @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayer @ {:?}", self as *const _))
.finish()
}
}
@ -168,7 +189,8 @@ pub struct GstPlayerAudioInfo(c_void);
impl ::std::fmt::Debug for GstPlayerAudioInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerAudioInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerAudioInfo @ {:?}", self as *const _))
.finish()
}
}
@ -177,7 +199,8 @@ pub struct GstPlayerGMainContextSignalDispatcher(c_void);
impl ::std::fmt::Debug for GstPlayerGMainContextSignalDispatcher {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerGMainContextSignalDispatcher @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerGMainContextSignalDispatcher @ {:?}", self as *const _))
.finish()
}
}
@ -186,7 +209,8 @@ pub struct GstPlayerMediaInfo(c_void);
impl ::std::fmt::Debug for GstPlayerMediaInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerMediaInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerMediaInfo @ {:?}", self as *const _))
.finish()
}
}
@ -195,7 +219,8 @@ pub struct GstPlayerStreamInfo(c_void);
impl ::std::fmt::Debug for GstPlayerStreamInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerStreamInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerStreamInfo @ {:?}", self as *const _))
.finish()
}
}
@ -204,7 +229,8 @@ pub struct GstPlayerSubtitleInfo(c_void);
impl ::std::fmt::Debug for GstPlayerSubtitleInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerSubtitleInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerSubtitleInfo @ {:?}", self as *const _))
.finish()
}
}
@ -213,7 +239,8 @@ pub struct GstPlayerVideoInfo(c_void);
impl ::std::fmt::Debug for GstPlayerVideoInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerVideoInfo @ {:?}", self as *const _))
.finish()
}
}
@ -222,7 +249,8 @@ pub struct GstPlayerVideoOverlayVideoRenderer(c_void);
impl ::std::fmt::Debug for GstPlayerVideoOverlayVideoRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstPlayerVideoOverlayVideoRenderer @ {:?}", self as *const _)
f.debug_struct(&format!("GstPlayerVideoOverlayVideoRenderer @ {:?}", self as *const _))
.finish()
}
}

File diff suppressed because it is too large Load diff

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
#[macro_use] extern crate bitflags;
@ -120,6 +120,7 @@ pub const GST_TAG_LICENSE_FREE_SOFTWARE_FOUNDATION_LICENSE: GstTagLicenseFlags =
// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstTagDemuxClass {
pub parent_class: gst::GstElementClass,
pub min_start_size: c_uint,
@ -132,7 +133,14 @@ pub struct GstTagDemuxClass {
impl ::std::fmt::Debug for GstTagDemuxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagDemuxClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstTagDemuxClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("min_start_size", &self.min_start_size)
.field("min_end_size", &self.min_end_size)
.field("identify_tag", &self.identify_tag)
.field("parse_tag", &self.parse_tag)
.field("merge_tags", &self.merge_tags)
.finish()
}
}
@ -141,11 +149,13 @@ pub struct GstTagDemuxPrivate(c_void);
impl ::std::fmt::Debug for GstTagDemuxPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagDemuxPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstTagDemuxPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstTagMuxClass {
pub parent_class: gst::GstElementClass,
pub render_start_tag: Option<unsafe extern "C" fn(*mut GstTagMux, *const gst::GstTagList) -> *mut gst::GstBuffer>,
@ -155,7 +165,11 @@ pub struct GstTagMuxClass {
impl ::std::fmt::Debug for GstTagMuxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagMuxClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstTagMuxClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("render_start_tag", &self.render_start_tag)
.field("render_end_tag", &self.render_end_tag)
.finish()
}
}
@ -164,23 +178,28 @@ pub struct GstTagMuxPrivate(c_void);
impl ::std::fmt::Debug for GstTagMuxPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagMuxPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstTagMuxPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstTagXmpWriterInterface {
pub parent: gobject::GTypeInterface,
}
impl ::std::fmt::Debug for GstTagXmpWriterInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstTagXmpWriterInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstTagXmpWriterInterface @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstTagDemux {
pub element: gst::GstElement,
pub priv_: *mut GstTagDemuxPrivate,
@ -191,13 +210,12 @@ impl ::std::fmt::Debug for GstTagDemux {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstTagDemux @ {:?}", self as *const _))
.field("element", &self.element)
.field("priv_", &self.priv_)
.field("reserved", &self.reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstTagMux {
pub element: gst::GstElement,
pub priv_: *mut GstTagMuxPrivate,
@ -208,8 +226,6 @@ impl ::std::fmt::Debug for GstTagMux {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstTagMux @ {:?}", self as *const _))
.field("element", &self.element)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}

View file

@ -1,7 +1,7 @@
// This file was generated by gir (0113735) from gir-files (???)
// This file was generated by gir (81a781f) from gir-files (???)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals)]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
extern crate libc;
#[macro_use] extern crate bitflags;
@ -588,6 +588,38 @@ pub const GST_VIDEO_TIME_CODE_FLAGS_NONE: GstVideoTimeCodeFlags = GstVideoTimeCo
pub const GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME: GstVideoTimeCodeFlags = GstVideoTimeCodeFlags::DROP_FRAME;
pub const GST_VIDEO_TIME_CODE_FLAGS_INTERLACED: GstVideoTimeCodeFlags = GstVideoTimeCodeFlags::INTERLACED;
// Unions
#[repr(C)]
#[derive(Copy, Clone)]
pub union GstVideoCodecFrame_abidata {
pub ABI: GstVideoCodecFrame_abidata_ABI,
pub padding: [gpointer; 20],
}
impl ::std::fmt::Debug for GstVideoCodecFrame_abidata {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoCodecFrame_abidata @ {:?}", self as *const _))
.field("ABI", unsafe { &self.ABI })
.field("padding", unsafe { &self.padding })
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union GstVideoInfo_ABI {
pub abi: GstVideoInfo_ABI_abi,
pub _gst_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GstVideoInfo_ABI {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoInfo_ABI @ {:?}", self as *const _))
.field("abi", unsafe { &self.abi })
.finish()
}
}
// Callbacks
pub type GstVideoAffineTransformationGetMatrix = Option<unsafe extern "C" fn(*mut GstVideoAffineTransformationMeta, *mut c_float) -> gboolean>;
pub type GstVideoConvertSampleCallback = Option<unsafe extern "C" fn(*mut gst::GstSample, *mut glib::GError, gpointer)>;
@ -597,6 +629,7 @@ pub type GstVideoGLTextureUpload = Option<unsafe extern "C" fn(*mut GstVideoGLTe
// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstColorBalanceChannelClass {
pub parent: gobject::GObjectClass,
pub value_changed: Option<unsafe extern "C" fn(*mut GstColorBalanceChannel, c_int)>,
@ -605,11 +638,15 @@ pub struct GstColorBalanceChannelClass {
impl ::std::fmt::Debug for GstColorBalanceChannelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstColorBalanceChannelClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstColorBalanceChannelClass @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("value_changed", &self.value_changed)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstColorBalanceInterface {
pub iface: gobject::GTypeInterface,
pub list_channels: Option<unsafe extern "C" fn(*mut GstColorBalance) -> *const glib::GList>,
@ -622,11 +659,19 @@ pub struct GstColorBalanceInterface {
impl ::std::fmt::Debug for GstColorBalanceInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstColorBalanceInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstColorBalanceInterface @ {:?}", self as *const _))
.field("iface", &self.iface)
.field("list_channels", &self.list_channels)
.field("set_value", &self.set_value)
.field("get_value", &self.get_value)
.field("get_balance_type", &self.get_balance_type)
.field("value_changed", &self.value_changed)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstNavigationInterface {
pub iface: gobject::GTypeInterface,
pub send_event: Option<unsafe extern "C" fn(*mut GstNavigation, *mut gst::GstStructure)>,
@ -634,11 +679,15 @@ pub struct GstNavigationInterface {
impl ::std::fmt::Debug for GstNavigationInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstNavigationInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstNavigationInterface @ {:?}", self as *const _))
.field("iface", &self.iface)
.field("send_event", &self.send_event)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoAffineTransformationMeta {
pub meta: gst::GstMeta,
pub matrix: [c_float; 16],
@ -646,11 +695,15 @@ pub struct GstVideoAffineTransformationMeta {
impl ::std::fmt::Debug for GstVideoAffineTransformationMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoAffineTransformationMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoAffineTransformationMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("matrix", &self.matrix)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoAlignment {
pub padding_top: c_uint,
pub padding_bottom: c_uint,
@ -661,18 +714,27 @@ pub struct GstVideoAlignment {
impl ::std::fmt::Debug for GstVideoAlignment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoAlignment @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoAlignment @ {:?}", self as *const _))
.field("padding_top", &self.padding_top)
.field("padding_bottom", &self.padding_bottom)
.field("padding_left", &self.padding_left)
.field("padding_right", &self.padding_right)
.field("stride_align", &self.stride_align)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoBufferPoolClass {
pub parent_class: gst::GstBufferPoolClass,
}
impl ::std::fmt::Debug for GstVideoBufferPoolClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoBufferPoolClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoBufferPoolClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
@ -681,7 +743,8 @@ pub struct GstVideoBufferPoolPrivate(c_void);
impl ::std::fmt::Debug for GstVideoBufferPoolPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoBufferPoolPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoBufferPoolPrivate @ {:?}", self as *const _))
.finish()
}
}
@ -690,11 +753,13 @@ pub struct GstVideoChromaResample(c_void);
impl ::std::fmt::Debug for GstVideoChromaResample {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoChromaResample @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoChromaResample @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoCodecFrame {
pub ref_count: c_int,
pub flags: u32,
@ -711,32 +776,67 @@ pub struct GstVideoCodecFrame {
pub events: *mut glib::GList,
pub user_data: gpointer,
pub user_data_destroy_notify: glib::GDestroyNotify,
pub padding: [c_void; 20],
pub abidata: GstVideoCodecFrame_abidata,
}
impl ::std::fmt::Debug for GstVideoCodecFrame {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoCodecFrame @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoCodecFrame @ {:?}", self as *const _))
.field("system_frame_number", &self.system_frame_number)
.field("decode_frame_number", &self.decode_frame_number)
.field("presentation_frame_number", &self.presentation_frame_number)
.field("dts", &self.dts)
.field("pts", &self.pts)
.field("duration", &self.duration)
.field("distance_from_sync", &self.distance_from_sync)
.field("input_buffer", &self.input_buffer)
.field("output_buffer", &self.output_buffer)
.field("deadline", &self.deadline)
.field("abidata", &self.abidata)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoCodecFrame_abidata_ABI {
pub ts: gst::GstClockTime,
pub ts2: gst::GstClockTime,
}
impl ::std::fmt::Debug for GstVideoCodecFrame_abidata_ABI {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoCodecFrame_abidata_ABI @ {:?}", self as *const _))
.field("ts", &self.ts)
.field("ts2", &self.ts2)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoCodecState {
pub ref_count: c_int,
pub info: GstVideoInfo,
pub caps: *mut gst::GstCaps,
pub codec_data: *mut gst::GstBuffer,
pub allocation_caps: *mut gst::GstCaps,
pub padding: [c_void; 19],
pub padding: [gpointer; 19],
}
impl ::std::fmt::Debug for GstVideoCodecState {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoCodecState @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoCodecState @ {:?}", self as *const _))
.field("info", &self.info)
.field("caps", &self.caps)
.field("codec_data", &self.codec_data)
.field("allocation_caps", &self.allocation_caps)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoColorPrimariesInfo {
pub primaries: GstVideoColorPrimaries,
pub Wx: c_double,
@ -751,11 +851,22 @@ pub struct GstVideoColorPrimariesInfo {
impl ::std::fmt::Debug for GstVideoColorPrimariesInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoColorPrimariesInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoColorPrimariesInfo @ {:?}", self as *const _))
.field("primaries", &self.primaries)
.field("Wx", &self.Wx)
.field("Wy", &self.Wy)
.field("Rx", &self.Rx)
.field("Ry", &self.Ry)
.field("Gx", &self.Gx)
.field("Gy", &self.Gy)
.field("Bx", &self.Bx)
.field("By", &self.By)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoColorimetry {
pub range: GstVideoColorRange,
pub matrix: GstVideoColorMatrix,
@ -765,7 +876,12 @@ pub struct GstVideoColorimetry {
impl ::std::fmt::Debug for GstVideoColorimetry {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoColorimetry @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoColorimetry @ {:?}", self as *const _))
.field("range", &self.range)
.field("matrix", &self.matrix)
.field("transfer", &self.transfer)
.field("primaries", &self.primaries)
.finish()
}
}
@ -774,11 +890,13 @@ pub struct GstVideoConverter(c_void);
impl ::std::fmt::Debug for GstVideoConverter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoConverter @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoConverter @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoCropMeta {
pub meta: gst::GstMeta,
pub x: c_uint,
@ -789,11 +907,18 @@ pub struct GstVideoCropMeta {
impl ::std::fmt::Debug for GstVideoCropMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoCropMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoCropMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("x", &self.x)
.field("y", &self.y)
.field("width", &self.width)
.field("height", &self.height)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoDecoderClass {
pub element_class: gst::GstElementClass,
pub open: Option<unsafe extern "C" fn(*mut GstVideoDecoder) -> gboolean>,
@ -816,12 +941,33 @@ pub struct GstVideoDecoderClass {
pub getcaps: Option<unsafe extern "C" fn(*mut GstVideoDecoder, *mut gst::GstCaps) -> *mut gst::GstCaps>,
pub drain: Option<unsafe extern "C" fn(*mut GstVideoDecoder) -> gst::GstFlowReturn>,
pub transform_meta: Option<unsafe extern "C" fn(*mut GstVideoDecoder, *mut GstVideoCodecFrame, *mut gst::GstMeta) -> gboolean>,
pub padding: [c_void; 14],
pub padding: [gpointer; 14],
}
impl ::std::fmt::Debug for GstVideoDecoderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDecoderClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoDecoderClass @ {:?}", self as *const _))
.field("open", &self.open)
.field("close", &self.close)
.field("start", &self.start)
.field("stop", &self.stop)
.field("parse", &self.parse)
.field("set_format", &self.set_format)
.field("reset", &self.reset)
.field("finish", &self.finish)
.field("handle_frame", &self.handle_frame)
.field("sink_event", &self.sink_event)
.field("src_event", &self.src_event)
.field("negotiate", &self.negotiate)
.field("decide_allocation", &self.decide_allocation)
.field("propose_allocation", &self.propose_allocation)
.field("flush", &self.flush)
.field("sink_query", &self.sink_query)
.field("src_query", &self.src_query)
.field("getcaps", &self.getcaps)
.field("drain", &self.drain)
.field("transform_meta", &self.transform_meta)
.finish()
}
}
@ -830,18 +976,22 @@ pub struct GstVideoDecoderPrivate(c_void);
impl ::std::fmt::Debug for GstVideoDecoderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDecoderPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoDecoderPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoDirectionInterface {
pub iface: gobject::GTypeInterface,
}
impl ::std::fmt::Debug for GstVideoDirectionInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDirectionInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoDirectionInterface @ {:?}", self as *const _))
.field("iface", &self.iface)
.finish()
}
}
@ -850,11 +1000,13 @@ pub struct GstVideoDither(c_void);
impl ::std::fmt::Debug for GstVideoDither {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoDither @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoDither @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoEncoderClass {
pub element_class: gst::GstElementClass,
pub open: Option<unsafe extern "C" fn(*mut GstVideoEncoder) -> gboolean>,
@ -881,7 +1033,27 @@ pub struct GstVideoEncoderClass {
impl ::std::fmt::Debug for GstVideoEncoderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoEncoderClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoEncoderClass @ {:?}", self as *const _))
.field("open", &self.open)
.field("close", &self.close)
.field("start", &self.start)
.field("stop", &self.stop)
.field("set_format", &self.set_format)
.field("handle_frame", &self.handle_frame)
.field("reset", &self.reset)
.field("finish", &self.finish)
.field("pre_push", &self.pre_push)
.field("getcaps", &self.getcaps)
.field("sink_event", &self.sink_event)
.field("src_event", &self.src_event)
.field("negotiate", &self.negotiate)
.field("decide_allocation", &self.decide_allocation)
.field("propose_allocation", &self.propose_allocation)
.field("flush", &self.flush)
.field("sink_query", &self.sink_query)
.field("src_query", &self.src_query)
.field("transform_meta", &self.transform_meta)
.finish()
}
}
@ -890,11 +1062,13 @@ pub struct GstVideoEncoderPrivate(c_void);
impl ::std::fmt::Debug for GstVideoEncoderPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoEncoderPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoEncoderPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoFilterClass {
pub parent_class: gst_base::GstBaseTransformClass,
pub set_info: Option<unsafe extern "C" fn(*mut GstVideoFilter, *mut gst::GstCaps, *mut GstVideoInfo, *mut gst::GstCaps, *mut GstVideoInfo) -> gboolean>,
@ -905,11 +1079,17 @@ pub struct GstVideoFilterClass {
impl ::std::fmt::Debug for GstVideoFilterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoFilterClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoFilterClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("set_info", &self.set_info)
.field("transform_frame", &self.transform_frame)
.field("transform_frame_ip", &self.transform_frame_ip)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoFormatInfo {
pub format: GstVideoFormat,
pub name: *const c_char,
@ -937,11 +1117,34 @@ pub struct GstVideoFormatInfo {
impl ::std::fmt::Debug for GstVideoFormatInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoFormatInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoFormatInfo @ {:?}", self as *const _))
.field("format", &self.format)
.field("name", &self.name)
.field("description", &self.description)
.field("flags", &self.flags)
.field("bits", &self.bits)
.field("n_components", &self.n_components)
.field("shift", &self.shift)
.field("depth", &self.depth)
.field("pixel_stride", &self.pixel_stride)
.field("n_planes", &self.n_planes)
.field("plane", &self.plane)
.field("poffset", &self.poffset)
.field("w_sub", &self.w_sub)
.field("h_sub", &self.h_sub)
.field("unpack_format", &self.unpack_format)
.field("unpack_func", &self.unpack_func)
.field("pack_lines", &self.pack_lines)
.field("pack_func", &self.pack_func)
.field("tile_mode", &self.tile_mode)
.field("tile_ws", &self.tile_ws)
.field("tile_hs", &self.tile_hs)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoFrame {
pub info: GstVideoInfo,
pub flags: GstVideoFrameFlags,
@ -955,11 +1158,20 @@ pub struct GstVideoFrame {
impl ::std::fmt::Debug for GstVideoFrame {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoFrame @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoFrame @ {:?}", self as *const _))
.field("info", &self.info)
.field("flags", &self.flags)
.field("buffer", &self.buffer)
.field("meta", &self.meta)
.field("id", &self.id)
.field("data", &self.data)
.field("map", &self.map)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoGLTextureUploadMeta {
pub meta: gst::GstMeta,
pub texture_orientation: GstVideoGLTextureOrientation,
@ -974,11 +1186,17 @@ pub struct GstVideoGLTextureUploadMeta {
impl ::std::fmt::Debug for GstVideoGLTextureUploadMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoGLTextureUploadMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoGLTextureUploadMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("texture_orientation", &self.texture_orientation)
.field("n_textures", &self.n_textures)
.field("texture_type", &self.texture_type)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoInfo {
pub finfo: *const GstVideoFormatInfo,
pub interlace_mode: GstVideoInterlaceMode,
@ -995,16 +1213,52 @@ pub struct GstVideoInfo {
pub fps_d: c_int,
pub offset: [size_t; 4],
pub stride: [c_int; 4],
pub _gst_reserved: [gpointer; 4],
pub ABI: GstVideoInfo_ABI,
}
impl ::std::fmt::Debug for GstVideoInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoInfo @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoInfo @ {:?}", self as *const _))
.field("finfo", &self.finfo)
.field("interlace_mode", &self.interlace_mode)
.field("flags", &self.flags)
.field("width", &self.width)
.field("height", &self.height)
.field("size", &self.size)
.field("views", &self.views)
.field("chroma_site", &self.chroma_site)
.field("colorimetry", &self.colorimetry)
.field("par_n", &self.par_n)
.field("par_d", &self.par_d)
.field("fps_n", &self.fps_n)
.field("fps_d", &self.fps_d)
.field("offset", &self.offset)
.field("stride", &self.stride)
.field("ABI", &self.ABI)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoInfo_ABI_abi {
pub multiview_mode: GstVideoMultiviewMode,
pub multiview_flags: GstVideoMultiviewFlags,
pub field_order: GstVideoFieldOrder,
}
impl ::std::fmt::Debug for GstVideoInfo_ABI_abi {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoInfo_ABI_abi @ {:?}", self as *const _))
.field("multiview_mode", &self.multiview_mode)
.field("multiview_flags", &self.multiview_flags)
.field("field_order", &self.field_order)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoMeta {
pub meta: gst::GstMeta,
pub buffer: *mut gst::GstBuffer,
@ -1022,11 +1276,25 @@ pub struct GstVideoMeta {
impl ::std::fmt::Debug for GstVideoMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("buffer", &self.buffer)
.field("flags", &self.flags)
.field("format", &self.format)
.field("id", &self.id)
.field("width", &self.width)
.field("height", &self.height)
.field("n_planes", &self.n_planes)
.field("offset", &self.offset)
.field("stride", &self.stride)
.field("map", &self.map)
.field("unmap", &self.unmap)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoMetaTransform {
pub in_info: *mut GstVideoInfo,
pub out_info: *mut GstVideoInfo,
@ -1034,11 +1302,15 @@ pub struct GstVideoMetaTransform {
impl ::std::fmt::Debug for GstVideoMetaTransform {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoMetaTransform @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoMetaTransform @ {:?}", self as *const _))
.field("in_info", &self.in_info)
.field("out_info", &self.out_info)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoOrientationInterface {
pub iface: gobject::GTypeInterface,
pub get_hflip: Option<unsafe extern "C" fn(*mut GstVideoOrientation, gboolean) -> gboolean>,
@ -1053,7 +1325,17 @@ pub struct GstVideoOrientationInterface {
impl ::std::fmt::Debug for GstVideoOrientationInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOrientationInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoOrientationInterface @ {:?}", self as *const _))
.field("iface", &self.iface)
.field("get_hflip", &self.get_hflip)
.field("get_vflip", &self.get_vflip)
.field("get_hcenter", &self.get_hcenter)
.field("get_vcenter", &self.get_vcenter)
.field("set_hflip", &self.set_hflip)
.field("set_vflip", &self.set_vflip)
.field("set_hcenter", &self.set_hcenter)
.field("set_vcenter", &self.set_vcenter)
.finish()
}
}
@ -1062,11 +1344,13 @@ pub struct GstVideoOverlayComposition(c_void);
impl ::std::fmt::Debug for GstVideoOverlayComposition {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlayComposition @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoOverlayComposition @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoOverlayCompositionMeta {
pub meta: gst::GstMeta,
pub overlay: *mut GstVideoOverlayComposition,
@ -1074,11 +1358,15 @@ pub struct GstVideoOverlayCompositionMeta {
impl ::std::fmt::Debug for GstVideoOverlayCompositionMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlayCompositionMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoOverlayCompositionMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("overlay", &self.overlay)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoOverlayInterface {
pub iface: gobject::GTypeInterface,
pub expose: Option<unsafe extern "C" fn(*mut GstVideoOverlay)>,
@ -1089,7 +1377,13 @@ pub struct GstVideoOverlayInterface {
impl ::std::fmt::Debug for GstVideoOverlayInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlayInterface @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoOverlayInterface @ {:?}", self as *const _))
.field("iface", &self.iface)
.field("expose", &self.expose)
.field("handle_events", &self.handle_events)
.field("set_render_rectangle", &self.set_render_rectangle)
.field("set_window_handle", &self.set_window_handle)
.finish()
}
}
@ -1098,11 +1392,13 @@ pub struct GstVideoOverlayRectangle(c_void);
impl ::std::fmt::Debug for GstVideoOverlayRectangle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoOverlayRectangle @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoOverlayRectangle @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoRectangle {
pub x: c_int,
pub y: c_int,
@ -1112,11 +1408,17 @@ pub struct GstVideoRectangle {
impl ::std::fmt::Debug for GstVideoRectangle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoRectangle @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoRectangle @ {:?}", self as *const _))
.field("x", &self.x)
.field("y", &self.y)
.field("w", &self.w)
.field("h", &self.h)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoRegionOfInterestMeta {
pub meta: gst::GstMeta,
pub roi_type: glib::GQuark,
@ -1130,11 +1432,21 @@ pub struct GstVideoRegionOfInterestMeta {
impl ::std::fmt::Debug for GstVideoRegionOfInterestMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoRegionOfInterestMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoRegionOfInterestMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("roi_type", &self.roi_type)
.field("id", &self.id)
.field("parent_id", &self.parent_id)
.field("x", &self.x)
.field("y", &self.y)
.field("w", &self.w)
.field("h", &self.h)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoResampler {
pub in_size: c_int,
pub out_size: c_int,
@ -1149,7 +1461,16 @@ pub struct GstVideoResampler {
impl ::std::fmt::Debug for GstVideoResampler {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoResampler @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoResampler @ {:?}", self as *const _))
.field("in_size", &self.in_size)
.field("out_size", &self.out_size)
.field("max_taps", &self.max_taps)
.field("n_phases", &self.n_phases)
.field("offset", &self.offset)
.field("phase", &self.phase)
.field("n_taps", &self.n_taps)
.field("taps", &self.taps)
.finish()
}
}
@ -1158,11 +1479,13 @@ pub struct GstVideoScaler(c_void);
impl ::std::fmt::Debug for GstVideoScaler {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoScaler @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoScaler @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoSinkClass {
pub parent_class: gst_base::GstBaseSinkClass,
pub show_frame: Option<unsafe extern "C" fn(*mut GstVideoSink, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
@ -1171,7 +1494,10 @@ pub struct GstVideoSinkClass {
impl ::std::fmt::Debug for GstVideoSinkClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoSinkClass @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoSinkClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("show_frame", &self.show_frame)
.finish()
}
}
@ -1180,11 +1506,13 @@ pub struct GstVideoSinkPrivate(c_void);
impl ::std::fmt::Debug for GstVideoSinkPrivate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoSinkPrivate @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoSinkPrivate @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoTimeCode {
pub config: GstVideoTimeCodeConfig,
pub hours: c_uint,
@ -1196,11 +1524,19 @@ pub struct GstVideoTimeCode {
impl ::std::fmt::Debug for GstVideoTimeCode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoTimeCode @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoTimeCode @ {:?}", self as *const _))
.field("config", &self.config)
.field("hours", &self.hours)
.field("minutes", &self.minutes)
.field("seconds", &self.seconds)
.field("frames", &self.frames)
.field("field_count", &self.field_count)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoTimeCodeConfig {
pub fps_n: c_uint,
pub fps_d: c_uint,
@ -1210,11 +1546,17 @@ pub struct GstVideoTimeCodeConfig {
impl ::std::fmt::Debug for GstVideoTimeCodeConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoTimeCodeConfig @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoTimeCodeConfig @ {:?}", self as *const _))
.field("fps_n", &self.fps_n)
.field("fps_d", &self.fps_d)
.field("flags", &self.flags)
.field("latest_daily_jam", &self.latest_daily_jam)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoTimeCodeInterval {
pub hours: c_uint,
pub minutes: c_uint,
@ -1224,11 +1566,17 @@ pub struct GstVideoTimeCodeInterval {
impl ::std::fmt::Debug for GstVideoTimeCodeInterval {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoTimeCodeInterval @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoTimeCodeInterval @ {:?}", self as *const _))
.field("hours", &self.hours)
.field("minutes", &self.minutes)
.field("seconds", &self.seconds)
.field("frames", &self.frames)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoTimeCodeMeta {
pub meta: gst::GstMeta,
pub tc: GstVideoTimeCode,
@ -1236,12 +1584,16 @@ pub struct GstVideoTimeCodeMeta {
impl ::std::fmt::Debug for GstVideoTimeCodeMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoTimeCodeMeta @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoTimeCodeMeta @ {:?}", self as *const _))
.field("meta", &self.meta)
.field("tc", &self.tc)
.finish()
}
}
// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstColorBalanceChannel {
pub parent: gobject::GObject,
pub label: *mut c_char,
@ -1257,12 +1609,12 @@ impl ::std::fmt::Debug for GstColorBalanceChannel {
.field("label", &self.label)
.field("min_value", &self.min_value)
.field("max_value", &self.max_value)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoBufferPool {
pub bufferpool: gst::GstBufferPool,
pub priv_: *mut GstVideoBufferPoolPrivate,
@ -1278,6 +1630,7 @@ impl ::std::fmt::Debug for GstVideoBufferPool {
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoDecoder {
pub element: gst::GstElement,
pub sinkpad: *mut gst::GstPad,
@ -1286,26 +1639,18 @@ pub struct GstVideoDecoder {
pub input_segment: gst::GstSegment,
pub output_segment: gst::GstSegment,
pub priv_: *mut GstVideoDecoderPrivate,
pub padding: [c_void; 20],
pub padding: [gpointer; 20],
}
impl ::std::fmt::Debug for GstVideoDecoder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoDecoder @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("srcpad", &self.srcpad)
.field("stream_lock", &self.stream_lock)
.field("input_segment", &self.input_segment)
.field("output_segment", &self.output_segment)
.field("priv_", &self.priv_)
.field("padding",
&format!("{:?}", &self.padding as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoEncoder {
pub element: gst::GstElement,
pub sinkpad: *mut gst::GstPad,
@ -1314,26 +1659,18 @@ pub struct GstVideoEncoder {
pub input_segment: gst::GstSegment,
pub output_segment: gst::GstSegment,
pub priv_: *mut GstVideoEncoderPrivate,
pub padding: [c_void; 20],
pub padding: [gpointer; 20],
}
impl ::std::fmt::Debug for GstVideoEncoder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstVideoEncoder @ {:?}", self as *const _))
.field("element", &self.element)
.field("sinkpad", &self.sinkpad)
.field("srcpad", &self.srcpad)
.field("stream_lock", &self.stream_lock)
.field("input_segment", &self.input_segment)
.field("output_segment", &self.output_segment)
.field("priv_", &self.priv_)
.field("padding",
&format!("{:?}", &self.padding as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoFilter {
pub element: gst_base::GstBaseTransform,
pub negotiated: gboolean,
@ -1349,7 +1686,6 @@ impl ::std::fmt::Debug for GstVideoFilter {
.field("negotiated", &self.negotiated)
.field("in_info", &self.in_info)
.field("out_info", &self.out_info)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}
@ -1359,11 +1695,13 @@ pub struct GstVideoMultiviewFlagsSet(c_void);
impl ::std::fmt::Debug for GstVideoMultiviewFlagsSet {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GstVideoMultiviewFlagsSet @ {:?}", self as *const _)
f.debug_struct(&format!("GstVideoMultiviewFlagsSet @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstVideoSink {
pub element: gst_base::GstBaseSink,
pub width: c_int,
@ -1378,8 +1716,6 @@ impl ::std::fmt::Debug for GstVideoSink {
.field("element", &self.element)
.field("width", &self.width)
.field("height", &self.height)
.field("priv_", &self.priv_)
.field("_gst_reserved", &self._gst_reserved)
.finish()
}
}