rafaelcaricio/gstreamer-rs
1
0
Fork 0
forked from mirrors/gstreamer-rs
Code Pull requests Activity

regen

Browse source
This commit is contained in:
Guillaume Gomez 2017-11-27 10:47:02 +01:00 committed by Sebastian Dröge
parent 8e49fa9f49
commit bcc17efdfb
10 changed files with 2719 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
gstreamer-app-sys/src/lib.rs
View file

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

312
gstreamer-audio-sys/src/lib.rs
View file

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

266
gstreamer-base-sys/src/lib.rs
View file

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

2
gstreamer-mpegts-sys/Cargo.toml
View file

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

290
gstreamer-mpegts-sys/src/lib.rs
View file

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

144
gstreamer-pbutils-sys/src/lib.rs
View file

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

130
gstreamer-player-sys/src/lib.rs
View file

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

1095
gstreamer-sys/src/lib.rs
View file

File diff suppressed because it is too large Load diff

60
gstreamer-tag-sys/src/lib.rs
View file

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

372
gstreamer-video-sys/src/lib.rs
View file

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