gstreamer_base_sys/
lib.rs

Help
1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
4// DO NOT EDIT
5
6#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8    clippy::approx_constant,
9    clippy::type_complexity,
10    clippy::unreadable_literal,
11    clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use glib_sys as glib;
16use gobject_sys as gobject;
17use gstreamer_sys as gst;
18
19#[cfg(unix)]
20#[allow(unused_imports)]
21use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
22#[allow(unused_imports)]
23use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
24#[allow(unused_imports)]
25use std::ffi::{
26    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
27};
28
29#[allow(unused_imports)]
30use glib::{gboolean, gconstpointer, gpointer, GType};
31
32// Enums
33pub type GstAggregatorStartTimeSelection = c_int;
34pub const GST_AGGREGATOR_START_TIME_SELECTION_ZERO: GstAggregatorStartTimeSelection = 0;
35pub const GST_AGGREGATOR_START_TIME_SELECTION_FIRST: GstAggregatorStartTimeSelection = 1;
36pub const GST_AGGREGATOR_START_TIME_SELECTION_SET: GstAggregatorStartTimeSelection = 2;
37
38// Constants
39pub const GST_BASE_PARSE_FLAG_DRAINING: c_int = 2;
40pub const GST_BASE_PARSE_FLAG_LOST_SYNC: c_int = 1;
41pub const GST_BASE_TRANSFORM_SINK_NAME: &[u8] = b"sink\0";
42pub const GST_BASE_TRANSFORM_SRC_NAME: &[u8] = b"src\0";
43
44// Flags
45pub type GstBaseParseFrameFlags = c_uint;
46pub const GST_BASE_PARSE_FRAME_FLAG_NONE: GstBaseParseFrameFlags = 0;
47pub const GST_BASE_PARSE_FRAME_FLAG_NEW_FRAME: GstBaseParseFrameFlags = 1;
48pub const GST_BASE_PARSE_FRAME_FLAG_NO_FRAME: GstBaseParseFrameFlags = 2;
49pub const GST_BASE_PARSE_FRAME_FLAG_CLIP: GstBaseParseFrameFlags = 4;
50pub const GST_BASE_PARSE_FRAME_FLAG_DROP: GstBaseParseFrameFlags = 8;
51pub const GST_BASE_PARSE_FRAME_FLAG_QUEUE: GstBaseParseFrameFlags = 16;
52
53pub type GstBaseSrcFlags = c_uint;
54pub const GST_BASE_SRC_FLAG_STARTING: GstBaseSrcFlags = 16384;
55pub const GST_BASE_SRC_FLAG_STARTED: GstBaseSrcFlags = 32768;
56pub const GST_BASE_SRC_FLAG_LAST: GstBaseSrcFlags = 1048576;
57
58pub type GstCollectPadsStateFlags = c_uint;
59pub const GST_COLLECT_PADS_STATE_EOS: GstCollectPadsStateFlags = 1;
60pub const GST_COLLECT_PADS_STATE_FLUSHING: GstCollectPadsStateFlags = 2;
61pub const GST_COLLECT_PADS_STATE_NEW_SEGMENT: GstCollectPadsStateFlags = 4;
62pub const GST_COLLECT_PADS_STATE_WAITING: GstCollectPadsStateFlags = 8;
63pub const GST_COLLECT_PADS_STATE_LOCKED: GstCollectPadsStateFlags = 16;
64
65// Unions
66#[derive(Copy, Clone)]
67#[repr(C)]
68pub union GstCollectData_ABI {
69    pub abi: GstCollectData_ABI_abi,
70    pub _gst_reserved: [gpointer; 4],
71}
72
73impl ::std::fmt::Debug for GstCollectData_ABI {
74    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
75        f.debug_struct(&format!("GstCollectData_ABI @ {self:p}"))
76            .field("abi", unsafe { &self.abi })
77            .finish()
78    }
79}
80
81// Callbacks
82pub type GstCollectDataDestroyNotify = Option<unsafe extern "C" fn(*mut GstCollectData)>;
83pub type GstCollectPadsBufferFunction = Option<
84    unsafe extern "C" fn(
85        *mut GstCollectPads,
86        *mut GstCollectData,
87        *mut gst::GstBuffer,
88        gpointer,
89    ) -> gst::GstFlowReturn,
90>;
91pub type GstCollectPadsClipFunction = Option<
92    unsafe extern "C" fn(
93        *mut GstCollectPads,
94        *mut GstCollectData,
95        *mut gst::GstBuffer,
96        *mut *mut gst::GstBuffer,
97        gpointer,
98    ) -> gst::GstFlowReturn,
99>;
100pub type GstCollectPadsCompareFunction = Option<
101    unsafe extern "C" fn(
102        *mut GstCollectPads,
103        *mut GstCollectData,
104        gst::GstClockTime,
105        *mut GstCollectData,
106        gst::GstClockTime,
107        gpointer,
108    ) -> c_int,
109>;
110pub type GstCollectPadsEventFunction = Option<
111    unsafe extern "C" fn(
112        *mut GstCollectPads,
113        *mut GstCollectData,
114        *mut gst::GstEvent,
115        gpointer,
116    ) -> gboolean,
117>;
118pub type GstCollectPadsFlushFunction = Option<unsafe extern "C" fn(*mut GstCollectPads, gpointer)>;
119pub type GstCollectPadsFunction =
120    Option<unsafe extern "C" fn(*mut GstCollectPads, gpointer) -> gst::GstFlowReturn>;
121pub type GstCollectPadsQueryFunction = Option<
122    unsafe extern "C" fn(
123        *mut GstCollectPads,
124        *mut GstCollectData,
125        *mut gst::GstQuery,
126        gpointer,
127    ) -> gboolean,
128>;
129pub type GstDataQueueCheckFullFunction =
130    Option<unsafe extern "C" fn(*mut GstDataQueue, c_uint, c_uint, u64, gpointer) -> gboolean>;
131pub type GstDataQueueEmptyCallback = Option<unsafe extern "C" fn(*mut GstDataQueue, gpointer)>;
132pub type GstDataQueueFullCallback = Option<unsafe extern "C" fn(*mut GstDataQueue, gpointer)>;
133pub type GstTypeFindHelperGetRangeFunction = Option<
134    unsafe extern "C" fn(
135        *mut gst::GstObject,
136        *mut gst::GstObject,
137        u64,
138        c_uint,
139        *mut *mut gst::GstBuffer,
140    ) -> gst::GstFlowReturn,
141>;
142
143// Records
144#[repr(C)]
145#[allow(dead_code)]
146pub struct _GstAdapterClass {
147    _data: [u8; 0],
148    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
149}
150
151pub type GstAdapterClass = _GstAdapterClass;
152
153#[derive(Copy, Clone)]
154#[repr(C)]
155pub struct GstAggregatorClass {
156    pub parent_class: gst::GstElementClass,
157    pub flush: Option<unsafe extern "C" fn(*mut GstAggregator) -> gst::GstFlowReturn>,
158    pub clip: Option<
159        unsafe extern "C" fn(
160            *mut GstAggregator,
161            *mut GstAggregatorPad,
162            *mut gst::GstBuffer,
163        ) -> *mut gst::GstBuffer,
164    >,
165    pub finish_buffer:
166        Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
167    pub sink_event: Option<
168        unsafe extern "C" fn(
169            *mut GstAggregator,
170            *mut GstAggregatorPad,
171            *mut gst::GstEvent,
172        ) -> gboolean,
173    >,
174    pub sink_query: Option<
175        unsafe extern "C" fn(
176            *mut GstAggregator,
177            *mut GstAggregatorPad,
178            *mut gst::GstQuery,
179        ) -> gboolean,
180    >,
181    pub src_event: Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstEvent) -> gboolean>,
182    pub src_query: Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstQuery) -> gboolean>,
183    pub src_activate:
184        Option<unsafe extern "C" fn(*mut GstAggregator, gst::GstPadMode, gboolean) -> gboolean>,
185    pub aggregate: Option<unsafe extern "C" fn(*mut GstAggregator, gboolean) -> gst::GstFlowReturn>,
186    pub stop: Option<unsafe extern "C" fn(*mut GstAggregator) -> gboolean>,
187    pub start: Option<unsafe extern "C" fn(*mut GstAggregator) -> gboolean>,
188    pub get_next_time: Option<unsafe extern "C" fn(*mut GstAggregator) -> gst::GstClockTime>,
189    pub create_new_pad: Option<
190        unsafe extern "C" fn(
191            *mut GstAggregator,
192            *mut gst::GstPadTemplate,
193            *const c_char,
194            *const gst::GstCaps,
195        ) -> *mut GstAggregatorPad,
196    >,
197    pub update_src_caps: Option<
198        unsafe extern "C" fn(
199            *mut GstAggregator,
200            *mut gst::GstCaps,
201            *mut *mut gst::GstCaps,
202        ) -> gst::GstFlowReturn,
203    >,
204    pub fixate_src_caps:
205        Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstCaps) -> *mut gst::GstCaps>,
206    pub negotiated_src_caps:
207        Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstCaps) -> gboolean>,
208    pub decide_allocation:
209        Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstQuery) -> gboolean>,
210    pub propose_allocation: Option<
211        unsafe extern "C" fn(
212            *mut GstAggregator,
213            *mut GstAggregatorPad,
214            *mut gst::GstQuery,
215            *mut gst::GstQuery,
216        ) -> gboolean,
217    >,
218    pub negotiate: Option<unsafe extern "C" fn(*mut GstAggregator) -> gboolean>,
219    pub sink_event_pre_queue: Option<
220        unsafe extern "C" fn(
221            *mut GstAggregator,
222            *mut GstAggregatorPad,
223            *mut gst::GstEvent,
224        ) -> gst::GstFlowReturn,
225    >,
226    pub sink_query_pre_queue: Option<
227        unsafe extern "C" fn(
228            *mut GstAggregator,
229            *mut GstAggregatorPad,
230            *mut gst::GstQuery,
231        ) -> gboolean,
232    >,
233    pub finish_buffer_list: Option<
234        unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstBufferList) -> gst::GstFlowReturn,
235    >,
236    pub peek_next_sample: Option<
237        unsafe extern "C" fn(*mut GstAggregator, *mut GstAggregatorPad) -> *mut gst::GstSample,
238    >,
239    pub _gst_reserved: [gpointer; 15],
240}
241
242impl ::std::fmt::Debug for GstAggregatorClass {
243    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
244        f.debug_struct(&format!("GstAggregatorClass @ {self:p}"))
245            .field("parent_class", &self.parent_class)
246            .field("flush", &self.flush)
247            .field("clip", &self.clip)
248            .field("finish_buffer", &self.finish_buffer)
249            .field("sink_event", &self.sink_event)
250            .field("sink_query", &self.sink_query)
251            .field("src_event", &self.src_event)
252            .field("src_query", &self.src_query)
253            .field("src_activate", &self.src_activate)
254            .field("aggregate", &self.aggregate)
255            .field("stop", &self.stop)
256            .field("start", &self.start)
257            .field("get_next_time", &self.get_next_time)
258            .field("create_new_pad", &self.create_new_pad)
259            .field("update_src_caps", &self.update_src_caps)
260            .field("fixate_src_caps", &self.fixate_src_caps)
261            .field("negotiated_src_caps", &self.negotiated_src_caps)
262            .field("decide_allocation", &self.decide_allocation)
263            .field("propose_allocation", &self.propose_allocation)
264            .field("negotiate", &self.negotiate)
265            .field("sink_event_pre_queue", &self.sink_event_pre_queue)
266            .field("sink_query_pre_queue", &self.sink_query_pre_queue)
267            .field("finish_buffer_list", &self.finish_buffer_list)
268            .field("peek_next_sample", &self.peek_next_sample)
269            .finish()
270    }
271}
272
273#[derive(Copy, Clone)]
274#[repr(C)]
275pub struct GstAggregatorPadClass {
276    pub parent_class: gst::GstPadClass,
277    pub flush: Option<
278        unsafe extern "C" fn(*mut GstAggregatorPad, *mut GstAggregator) -> gst::GstFlowReturn,
279    >,
280    pub skip_buffer: Option<
281        unsafe extern "C" fn(
282            *mut GstAggregatorPad,
283            *mut GstAggregator,
284            *mut gst::GstBuffer,
285        ) -> gboolean,
286    >,
287    pub _gst_reserved: [gpointer; 20],
288}
289
290impl ::std::fmt::Debug for GstAggregatorPadClass {
291    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
292        f.debug_struct(&format!("GstAggregatorPadClass @ {self:p}"))
293            .field("parent_class", &self.parent_class)
294            .field("flush", &self.flush)
295            .field("skip_buffer", &self.skip_buffer)
296            .finish()
297    }
298}
299
300#[repr(C)]
301#[allow(dead_code)]
302pub struct _GstAggregatorPadPrivate {
303    _data: [u8; 0],
304    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
305}
306
307pub type GstAggregatorPadPrivate = _GstAggregatorPadPrivate;
308
309#[repr(C)]
310#[allow(dead_code)]
311pub struct _GstAggregatorPrivate {
312    _data: [u8; 0],
313    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
314}
315
316pub type GstAggregatorPrivate = _GstAggregatorPrivate;
317
318#[derive(Copy, Clone)]
319#[repr(C)]
320pub struct GstBaseParseClass {
321    pub parent_class: gst::GstElementClass,
322    pub start: Option<unsafe extern "C" fn(*mut GstBaseParse) -> gboolean>,
323    pub stop: Option<unsafe extern "C" fn(*mut GstBaseParse) -> gboolean>,
324    pub set_sink_caps:
325        Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstCaps) -> gboolean>,
326    pub handle_frame: Option<
327        unsafe extern "C" fn(
328            *mut GstBaseParse,
329            *mut GstBaseParseFrame,
330            *mut c_int,
331        ) -> gst::GstFlowReturn,
332    >,
333    pub pre_push_frame: Option<
334        unsafe extern "C" fn(*mut GstBaseParse, *mut GstBaseParseFrame) -> gst::GstFlowReturn,
335    >,
336    pub convert: Option<
337        unsafe extern "C" fn(
338            *mut GstBaseParse,
339            gst::GstFormat,
340            i64,
341            gst::GstFormat,
342            *mut i64,
343        ) -> gboolean,
344    >,
345    pub sink_event: Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstEvent) -> gboolean>,
346    pub src_event: Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstEvent) -> gboolean>,
347    pub get_sink_caps:
348        Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstCaps) -> *mut gst::GstCaps>,
349    pub detect:
350        Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
351    pub sink_query: Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstQuery) -> gboolean>,
352    pub src_query: Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstQuery) -> gboolean>,
353    pub _gst_reserved: [gpointer; 18],
354}
355
356impl ::std::fmt::Debug for GstBaseParseClass {
357    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
358        f.debug_struct(&format!("GstBaseParseClass @ {self:p}"))
359            .field("parent_class", &self.parent_class)
360            .field("start", &self.start)
361            .field("stop", &self.stop)
362            .field("set_sink_caps", &self.set_sink_caps)
363            .field("handle_frame", &self.handle_frame)
364            .field("pre_push_frame", &self.pre_push_frame)
365            .field("convert", &self.convert)
366            .field("sink_event", &self.sink_event)
367            .field("src_event", &self.src_event)
368            .field("get_sink_caps", &self.get_sink_caps)
369            .field("detect", &self.detect)
370            .field("sink_query", &self.sink_query)
371            .field("src_query", &self.src_query)
372            .finish()
373    }
374}
375
376#[derive(Copy, Clone)]
377#[repr(C)]
378pub struct GstBaseParseFrame {
379    pub buffer: *mut gst::GstBuffer,
380    pub out_buffer: *mut gst::GstBuffer,
381    pub flags: c_uint,
382    pub offset: u64,
383    pub overhead: c_int,
384    pub size: c_int,
385    pub _gst_reserved_i: [c_uint; 2],
386    pub _gst_reserved_p: [gpointer; 2],
387    pub _private_flags: c_uint,
388}
389
390impl ::std::fmt::Debug for GstBaseParseFrame {
391    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
392        f.debug_struct(&format!("GstBaseParseFrame @ {self:p}"))
393            .field("buffer", &self.buffer)
394            .field("out_buffer", &self.out_buffer)
395            .field("flags", &self.flags)
396            .field("offset", &self.offset)
397            .field("overhead", &self.overhead)
398            .finish()
399    }
400}
401
402#[repr(C)]
403#[allow(dead_code)]
404pub struct _GstBaseParsePrivate {
405    _data: [u8; 0],
406    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
407}
408
409pub type GstBaseParsePrivate = _GstBaseParsePrivate;
410
411#[derive(Copy, Clone)]
412#[repr(C)]
413pub struct GstBaseSinkClass {
414    pub parent_class: gst::GstElementClass,
415    pub get_caps:
416        Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstCaps) -> *mut gst::GstCaps>,
417    pub set_caps: Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstCaps) -> gboolean>,
418    pub fixate:
419        Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstCaps) -> *mut gst::GstCaps>,
420    pub activate_pull: Option<unsafe extern "C" fn(*mut GstBaseSink, gboolean) -> gboolean>,
421    pub get_times: Option<
422        unsafe extern "C" fn(
423            *mut GstBaseSink,
424            *mut gst::GstBuffer,
425            *mut gst::GstClockTime,
426            *mut gst::GstClockTime,
427        ),
428    >,
429    pub propose_allocation:
430        Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstQuery) -> gboolean>,
431    pub start: Option<unsafe extern "C" fn(*mut GstBaseSink) -> gboolean>,
432    pub stop: Option<unsafe extern "C" fn(*mut GstBaseSink) -> gboolean>,
433    pub unlock: Option<unsafe extern "C" fn(*mut GstBaseSink) -> gboolean>,
434    pub unlock_stop: Option<unsafe extern "C" fn(*mut GstBaseSink) -> gboolean>,
435    pub query: Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstQuery) -> gboolean>,
436    pub event: Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstEvent) -> gboolean>,
437    pub wait_event:
438        Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstEvent) -> gst::GstFlowReturn>,
439    pub prepare:
440        Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
441    pub prepare_list: Option<
442        unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBufferList) -> gst::GstFlowReturn,
443    >,
444    pub preroll:
445        Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
446    pub render:
447        Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
448    pub render_list: Option<
449        unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBufferList) -> gst::GstFlowReturn,
450    >,
451    pub _gst_reserved: [gpointer; 20],
452}
453
454impl ::std::fmt::Debug for GstBaseSinkClass {
455    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
456        f.debug_struct(&format!("GstBaseSinkClass @ {self:p}"))
457            .field("parent_class", &self.parent_class)
458            .field("get_caps", &self.get_caps)
459            .field("set_caps", &self.set_caps)
460            .field("fixate", &self.fixate)
461            .field("activate_pull", &self.activate_pull)
462            .field("get_times", &self.get_times)
463            .field("propose_allocation", &self.propose_allocation)
464            .field("start", &self.start)
465            .field("stop", &self.stop)
466            .field("unlock", &self.unlock)
467            .field("unlock_stop", &self.unlock_stop)
468            .field("query", &self.query)
469            .field("event", &self.event)
470            .field("wait_event", &self.wait_event)
471            .field("prepare", &self.prepare)
472            .field("prepare_list", &self.prepare_list)
473            .field("preroll", &self.preroll)
474            .field("render", &self.render)
475            .field("render_list", &self.render_list)
476            .finish()
477    }
478}
479
480#[repr(C)]
481#[allow(dead_code)]
482pub struct _GstBaseSinkPrivate {
483    _data: [u8; 0],
484    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
485}
486
487pub type GstBaseSinkPrivate = _GstBaseSinkPrivate;
488
489#[derive(Copy, Clone)]
490#[repr(C)]
491pub struct GstBaseSrcClass {
492    pub parent_class: gst::GstElementClass,
493    pub get_caps:
494        Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstCaps) -> *mut gst::GstCaps>,
495    pub negotiate: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>,
496    pub fixate:
497        Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstCaps) -> *mut gst::GstCaps>,
498    pub set_caps: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstCaps) -> gboolean>,
499    pub decide_allocation:
500        Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstQuery) -> gboolean>,
501    pub start: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>,
502    pub stop: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>,
503    pub get_times: Option<
504        unsafe extern "C" fn(
505            *mut GstBaseSrc,
506            *mut gst::GstBuffer,
507            *mut gst::GstClockTime,
508            *mut gst::GstClockTime,
509        ),
510    >,
511    pub get_size: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut u64) -> gboolean>,
512    pub is_seekable: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>,
513    pub prepare_seek_segment: Option<
514        unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstEvent, *mut gst::GstSegment) -> gboolean,
515    >,
516    pub do_seek: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstSegment) -> gboolean>,
517    pub unlock: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>,
518    pub unlock_stop: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>,
519    pub query: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstQuery) -> gboolean>,
520    pub event: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstEvent) -> gboolean>,
521    pub create: Option<
522        unsafe extern "C" fn(
523            *mut GstBaseSrc,
524            u64,
525            c_uint,
526            *mut gst::GstBuffer,
527        ) -> gst::GstFlowReturn,
528    >,
529    pub alloc: Option<
530        unsafe extern "C" fn(
531            *mut GstBaseSrc,
532            u64,
533            c_uint,
534            *mut gst::GstBuffer,
535        ) -> gst::GstFlowReturn,
536    >,
537    pub fill: Option<
538        unsafe extern "C" fn(
539            *mut GstBaseSrc,
540            u64,
541            c_uint,
542            *mut gst::GstBuffer,
543        ) -> gst::GstFlowReturn,
544    >,
545    pub _gst_reserved: [gpointer; 20],
546}
547
548impl ::std::fmt::Debug for GstBaseSrcClass {
549    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
550        f.debug_struct(&format!("GstBaseSrcClass @ {self:p}"))
551            .field("parent_class", &self.parent_class)
552            .field("get_caps", &self.get_caps)
553            .field("negotiate", &self.negotiate)
554            .field("fixate", &self.fixate)
555            .field("set_caps", &self.set_caps)
556            .field("decide_allocation", &self.decide_allocation)
557            .field("start", &self.start)
558            .field("stop", &self.stop)
559            .field("get_times", &self.get_times)
560            .field("get_size", &self.get_size)
561            .field("is_seekable", &self.is_seekable)
562            .field("prepare_seek_segment", &self.prepare_seek_segment)
563            .field("do_seek", &self.do_seek)
564            .field("unlock", &self.unlock)
565            .field("unlock_stop", &self.unlock_stop)
566            .field("query", &self.query)
567            .field("event", &self.event)
568            .field("create", &self.create)
569            .field("alloc", &self.alloc)
570            .field("fill", &self.fill)
571            .finish()
572    }
573}
574
575#[repr(C)]
576#[allow(dead_code)]
577pub struct _GstBaseSrcPrivate {
578    _data: [u8; 0],
579    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
580}
581
582pub type GstBaseSrcPrivate = _GstBaseSrcPrivate;
583
584#[derive(Copy, Clone)]
585#[repr(C)]
586pub struct GstBaseTransformClass {
587    pub parent_class: gst::GstElementClass,
588    pub passthrough_on_same_caps: gboolean,
589    pub transform_ip_on_passthrough: gboolean,
590    pub transform_caps: Option<
591        unsafe extern "C" fn(
592            *mut GstBaseTransform,
593            gst::GstPadDirection,
594            *mut gst::GstCaps,
595            *mut gst::GstCaps,
596        ) -> *mut gst::GstCaps,
597    >,
598    pub fixate_caps: Option<
599        unsafe extern "C" fn(
600            *mut GstBaseTransform,
601            gst::GstPadDirection,
602            *mut gst::GstCaps,
603            *mut gst::GstCaps,
604        ) -> *mut gst::GstCaps,
605    >,
606    pub accept_caps: Option<
607        unsafe extern "C" fn(
608            *mut GstBaseTransform,
609            gst::GstPadDirection,
610            *mut gst::GstCaps,
611        ) -> gboolean,
612    >,
613    pub set_caps: Option<
614        unsafe extern "C" fn(
615            *mut GstBaseTransform,
616            *mut gst::GstCaps,
617            *mut gst::GstCaps,
618        ) -> gboolean,
619    >,
620    pub query: Option<
621        unsafe extern "C" fn(
622            *mut GstBaseTransform,
623            gst::GstPadDirection,
624            *mut gst::GstQuery,
625        ) -> gboolean,
626    >,
627    pub decide_allocation:
628        Option<unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstQuery) -> gboolean>,
629    pub filter_meta: Option<
630        unsafe extern "C" fn(
631            *mut GstBaseTransform,
632            *mut gst::GstQuery,
633            GType,
634            *const gst::GstStructure,
635        ) -> gboolean,
636    >,
637    pub propose_allocation: Option<
638        unsafe extern "C" fn(
639            *mut GstBaseTransform,
640            *mut gst::GstQuery,
641            *mut gst::GstQuery,
642        ) -> gboolean,
643    >,
644    pub transform_size: Option<
645        unsafe extern "C" fn(
646            *mut GstBaseTransform,
647            gst::GstPadDirection,
648            *mut gst::GstCaps,
649            size_t,
650            *mut gst::GstCaps,
651            *mut size_t,
652        ) -> gboolean,
653    >,
654    pub get_unit_size: Option<
655        unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstCaps, *mut size_t) -> gboolean,
656    >,
657    pub start: Option<unsafe extern "C" fn(*mut GstBaseTransform) -> gboolean>,
658    pub stop: Option<unsafe extern "C" fn(*mut GstBaseTransform) -> gboolean>,
659    pub sink_event:
660        Option<unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstEvent) -> gboolean>,
661    pub src_event:
662        Option<unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstEvent) -> gboolean>,
663    pub prepare_output_buffer: Option<
664        unsafe extern "C" fn(
665            *mut GstBaseTransform,
666            *mut gst::GstBuffer,
667            *mut gst::GstBuffer,
668        ) -> gst::GstFlowReturn,
669    >,
670    pub copy_metadata: Option<
671        unsafe extern "C" fn(
672            *mut GstBaseTransform,
673            *mut gst::GstBuffer,
674            *mut gst::GstBuffer,
675        ) -> gboolean,
676    >,
677    pub transform_meta: Option<
678        unsafe extern "C" fn(
679            *mut GstBaseTransform,
680            *mut gst::GstBuffer,
681            *mut gst::GstMeta,
682            *mut gst::GstBuffer,
683        ) -> gboolean,
684    >,
685    pub before_transform: Option<unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstBuffer)>,
686    pub transform: Option<
687        unsafe extern "C" fn(
688            *mut GstBaseTransform,
689            *mut gst::GstBuffer,
690            *mut gst::GstBuffer,
691        ) -> gst::GstFlowReturn,
692    >,
693    pub transform_ip: Option<
694        unsafe extern "C" fn(*mut GstBaseTransform, *mut *mut gst::GstBuffer) -> gst::GstFlowReturn,
695    >,
696    pub submit_input_buffer: Option<
697        unsafe extern "C" fn(
698            *mut GstBaseTransform,
699            gboolean,
700            *mut gst::GstBuffer,
701        ) -> gst::GstFlowReturn,
702    >,
703    pub generate_output: Option<
704        unsafe extern "C" fn(*mut GstBaseTransform, *mut *mut gst::GstBuffer) -> gst::GstFlowReturn,
705    >,
706    pub _gst_reserved: [gpointer; 18],
707}
708
709impl ::std::fmt::Debug for GstBaseTransformClass {
710    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
711        f.debug_struct(&format!("GstBaseTransformClass @ {self:p}"))
712            .field("parent_class", &self.parent_class)
713            .field("passthrough_on_same_caps", &self.passthrough_on_same_caps)
714            .field(
715                "transform_ip_on_passthrough",
716                &self.transform_ip_on_passthrough,
717            )
718            .field("transform_caps", &self.transform_caps)
719            .field("fixate_caps", &self.fixate_caps)
720            .field("accept_caps", &self.accept_caps)
721            .field("set_caps", &self.set_caps)
722            .field("query", &self.query)
723            .field("decide_allocation", &self.decide_allocation)
724            .field("filter_meta", &self.filter_meta)
725            .field("propose_allocation", &self.propose_allocation)
726            .field("transform_size", &self.transform_size)
727            .field("get_unit_size", &self.get_unit_size)
728            .field("start", &self.start)
729            .field("stop", &self.stop)
730            .field("sink_event", &self.sink_event)
731            .field("src_event", &self.src_event)
732            .field("prepare_output_buffer", &self.prepare_output_buffer)
733            .field("copy_metadata", &self.copy_metadata)
734            .field("transform_meta", &self.transform_meta)
735            .field("before_transform", &self.before_transform)
736            .field("transform", &self.transform)
737            .field("transform_ip", &self.transform_ip)
738            .field("submit_input_buffer", &self.submit_input_buffer)
739            .field("generate_output", &self.generate_output)
740            .finish()
741    }
742}
743
744#[repr(C)]
745#[allow(dead_code)]
746pub struct _GstBaseTransformPrivate {
747    _data: [u8; 0],
748    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
749}
750
751pub type GstBaseTransformPrivate = _GstBaseTransformPrivate;
752
753#[derive(Copy, Clone)]
754#[repr(C)]
755pub struct GstBitReader {
756    pub data: *const u8,
757    pub size: c_uint,
758    pub byte: c_uint,
759    pub bit: c_uint,
760    pub _gst_reserved: [gpointer; 4],
761}
762
763impl ::std::fmt::Debug for GstBitReader {
764    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
765        f.debug_struct(&format!("GstBitReader @ {self:p}"))
766            .field("data", &self.data)
767            .field("size", &self.size)
768            .field("byte", &self.byte)
769            .field("bit", &self.bit)
770            .finish()
771    }
772}
773
774#[derive(Copy, Clone)]
775#[repr(C)]
776pub struct GstBitWriter {
777    pub data: *mut u8,
778    pub bit_size: c_uint,
779    pub bit_capacity: c_uint,
780    pub auto_grow: gboolean,
781    pub owned: gboolean,
782    pub _gst_reserved: [gpointer; 4],
783}
784
785impl ::std::fmt::Debug for GstBitWriter {
786    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
787        f.debug_struct(&format!("GstBitWriter @ {self:p}"))
788            .field("data", &self.data)
789            .field("bit_size", &self.bit_size)
790            .finish()
791    }
792}
793
794#[derive(Copy, Clone)]
795#[repr(C)]
796pub struct GstByteReader {
797    pub data: *const u8,
798    pub size: c_uint,
799    pub byte: c_uint,
800    pub _gst_reserved: [gpointer; 4],
801}
802
803impl ::std::fmt::Debug for GstByteReader {
804    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
805        f.debug_struct(&format!("GstByteReader @ {self:p}"))
806            .field("data", &self.data)
807            .field("size", &self.size)
808            .field("byte", &self.byte)
809            .finish()
810    }
811}
812
813#[derive(Copy, Clone)]
814#[repr(C)]
815pub struct GstByteWriter {
816    pub parent: GstByteReader,
817    pub alloc_size: c_uint,
818    pub fixed: gboolean,
819    pub owned: gboolean,
820    pub _gst_reserved: [gpointer; 4],
821}
822
823impl ::std::fmt::Debug for GstByteWriter {
824    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
825        f.debug_struct(&format!("GstByteWriter @ {self:p}"))
826            .field("parent", &self.parent)
827            .field("alloc_size", &self.alloc_size)
828            .field("fixed", &self.fixed)
829            .field("owned", &self.owned)
830            .finish()
831    }
832}
833
834#[derive(Copy, Clone)]
835#[repr(C)]
836pub struct GstCollectData {
837    pub collect: *mut GstCollectPads,
838    pub pad: *mut gst::GstPad,
839    pub buffer: *mut gst::GstBuffer,
840    pub pos: c_uint,
841    pub segment: gst::GstSegment,
842    pub state: GstCollectPadsStateFlags,
843    pub priv_: *mut GstCollectDataPrivate,
844    pub ABI: GstCollectData_ABI,
845}
846
847impl ::std::fmt::Debug for GstCollectData {
848    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
849        f.debug_struct(&format!("GstCollectData @ {self:p}"))
850            .field("collect", &self.collect)
851            .field("pad", &self.pad)
852            .field("buffer", &self.buffer)
853            .field("pos", &self.pos)
854            .field("segment", &self.segment)
855            .field("ABI", &self.ABI)
856            .finish()
857    }
858}
859
860#[repr(C)]
861#[allow(dead_code)]
862pub struct _GstCollectDataPrivate {
863    _data: [u8; 0],
864    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
865}
866
867pub type GstCollectDataPrivate = _GstCollectDataPrivate;
868
869#[derive(Copy, Clone)]
870#[repr(C)]
871pub struct GstCollectData_ABI_abi {
872    pub dts: i64,
873}
874
875impl ::std::fmt::Debug for GstCollectData_ABI_abi {
876    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
877        f.debug_struct(&format!("GstCollectData_ABI_abi @ {self:p}"))
878            .field("dts", &self.dts)
879            .finish()
880    }
881}
882
883#[derive(Copy, Clone)]
884#[repr(C)]
885pub struct GstCollectPadsClass {
886    pub parent_class: gst::GstObjectClass,
887    pub _gst_reserved: [gpointer; 4],
888}
889
890impl ::std::fmt::Debug for GstCollectPadsClass {
891    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
892        f.debug_struct(&format!("GstCollectPadsClass @ {self:p}"))
893            .field("parent_class", &self.parent_class)
894            .finish()
895    }
896}
897
898#[repr(C)]
899#[allow(dead_code)]
900pub struct _GstCollectPadsPrivate {
901    _data: [u8; 0],
902    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
903}
904
905pub type GstCollectPadsPrivate = _GstCollectPadsPrivate;
906
907#[derive(Copy, Clone)]
908#[repr(C)]
909pub struct GstDataQueueClass {
910    pub parent_class: gobject::GObjectClass,
911    pub empty: Option<unsafe extern "C" fn(*mut GstDataQueue)>,
912    pub full: Option<unsafe extern "C" fn(*mut GstDataQueue)>,
913    pub _gst_reserved: [gpointer; 4],
914}
915
916impl ::std::fmt::Debug for GstDataQueueClass {
917    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
918        f.debug_struct(&format!("GstDataQueueClass @ {self:p}"))
919            .field("parent_class", &self.parent_class)
920            .field("empty", &self.empty)
921            .field("full", &self.full)
922            .field("_gst_reserved", &self._gst_reserved)
923            .finish()
924    }
925}
926
927#[derive(Copy, Clone)]
928#[repr(C)]
929pub struct GstDataQueueItem {
930    pub object: *mut gst::GstMiniObject,
931    pub size: c_uint,
932    pub duration: u64,
933    pub visible: gboolean,
934    pub destroy: glib::GDestroyNotify,
935    pub _gst_reserved: [gpointer; 4],
936}
937
938impl ::std::fmt::Debug for GstDataQueueItem {
939    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
940        f.debug_struct(&format!("GstDataQueueItem @ {self:p}"))
941            .field("object", &self.object)
942            .field("size", &self.size)
943            .field("duration", &self.duration)
944            .field("visible", &self.visible)
945            .field("destroy", &self.destroy)
946            .finish()
947    }
948}
949
950#[repr(C)]
951#[allow(dead_code)]
952pub struct _GstDataQueuePrivate {
953    _data: [u8; 0],
954    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
955}
956
957pub type GstDataQueuePrivate = _GstDataQueuePrivate;
958
959#[derive(Copy, Clone)]
960#[repr(C)]
961pub struct GstDataQueueSize {
962    pub visible: c_uint,
963    pub bytes: c_uint,
964    pub time: u64,
965}
966
967impl ::std::fmt::Debug for GstDataQueueSize {
968    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
969        f.debug_struct(&format!("GstDataQueueSize @ {self:p}"))
970            .field("visible", &self.visible)
971            .field("bytes", &self.bytes)
972            .field("time", &self.time)
973            .finish()
974    }
975}
976
977#[repr(C)]
978#[allow(dead_code)]
979pub struct GstFlowCombiner {
980    _data: [u8; 0],
981    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
982}
983
984impl ::std::fmt::Debug for GstFlowCombiner {
985    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
986        f.debug_struct(&format!("GstFlowCombiner @ {self:p}"))
987            .finish()
988    }
989}
990
991#[derive(Copy, Clone)]
992#[repr(C)]
993pub struct GstPushSrcClass {
994    pub parent_class: GstBaseSrcClass,
995    pub create:
996        Option<unsafe extern "C" fn(*mut GstPushSrc, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
997    pub alloc:
998        Option<unsafe extern "C" fn(*mut GstPushSrc, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
999    pub fill:
1000        Option<unsafe extern "C" fn(*mut GstPushSrc, *mut gst::GstBuffer) -> gst::GstFlowReturn>,
1001    pub _gst_reserved: [gpointer; 4],
1002}
1003
1004impl ::std::fmt::Debug for GstPushSrcClass {
1005    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1006        f.debug_struct(&format!("GstPushSrcClass @ {self:p}"))
1007            .field("parent_class", &self.parent_class)
1008            .field("create", &self.create)
1009            .field("alloc", &self.alloc)
1010            .field("fill", &self.fill)
1011            .finish()
1012    }
1013}
1014
1015#[repr(C)]
1016#[allow(dead_code)]
1017pub struct _GstQueueArray {
1018    _data: [u8; 0],
1019    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1020}
1021
1022pub type GstQueueArray = _GstQueueArray;
1023
1024#[repr(C)]
1025#[allow(dead_code)]
1026pub struct _GstTypeFindData {
1027    _data: [u8; 0],
1028    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1029}
1030
1031pub type GstTypeFindData = _GstTypeFindData;
1032
1033// Classes
1034#[repr(C)]
1035#[allow(dead_code)]
1036pub struct GstAdapter {
1037    _data: [u8; 0],
1038    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1039}
1040
1041impl ::std::fmt::Debug for GstAdapter {
1042    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1043        f.debug_struct(&format!("GstAdapter @ {self:p}")).finish()
1044    }
1045}
1046
1047#[derive(Copy, Clone)]
1048#[repr(C)]
1049pub struct GstAggregator {
1050    pub parent: gst::GstElement,
1051    pub srcpad: *mut gst::GstPad,
1052    pub priv_: *mut GstAggregatorPrivate,
1053    pub _gst_reserved: [gpointer; 20],
1054}
1055
1056impl ::std::fmt::Debug for GstAggregator {
1057    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1058        f.debug_struct(&format!("GstAggregator @ {self:p}"))
1059            .field("parent", &self.parent)
1060            .field("srcpad", &self.srcpad)
1061            .finish()
1062    }
1063}
1064
1065#[derive(Copy, Clone)]
1066#[repr(C)]
1067pub struct GstAggregatorPad {
1068    pub parent: gst::GstPad,
1069    pub segment: gst::GstSegment,
1070    pub priv_: *mut GstAggregatorPadPrivate,
1071    pub _gst_reserved: [gpointer; 4],
1072}
1073
1074impl ::std::fmt::Debug for GstAggregatorPad {
1075    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1076        f.debug_struct(&format!("GstAggregatorPad @ {self:p}"))
1077            .field("parent", &self.parent)
1078            .field("segment", &self.segment)
1079            .finish()
1080    }
1081}
1082
1083#[derive(Copy, Clone)]
1084#[repr(C)]
1085pub struct GstBaseParse {
1086    pub element: gst::GstElement,
1087    pub sinkpad: *mut gst::GstPad,
1088    pub srcpad: *mut gst::GstPad,
1089    pub flags: c_uint,
1090    pub segment: gst::GstSegment,
1091    pub _gst_reserved: [gpointer; 20],
1092    pub priv_: *mut GstBaseParsePrivate,
1093}
1094
1095impl ::std::fmt::Debug for GstBaseParse {
1096    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1097        f.debug_struct(&format!("GstBaseParse @ {self:p}"))
1098            .field("element", &self.element)
1099            .field("sinkpad", &self.sinkpad)
1100            .field("srcpad", &self.srcpad)
1101            .field("flags", &self.flags)
1102            .field("segment", &self.segment)
1103            .finish()
1104    }
1105}
1106
1107#[derive(Copy, Clone)]
1108#[repr(C)]
1109pub struct GstBaseSink {
1110    pub element: gst::GstElement,
1111    pub sinkpad: *mut gst::GstPad,
1112    pub pad_mode: gst::GstPadMode,
1113    pub offset: u64,
1114    pub can_activate_pull: gboolean,
1115    pub can_activate_push: gboolean,
1116    pub preroll_lock: glib::GMutex,
1117    pub preroll_cond: glib::GCond,
1118    pub eos: gboolean,
1119    pub need_preroll: gboolean,
1120    pub have_preroll: gboolean,
1121    pub playing_async: gboolean,
1122    pub have_newsegment: gboolean,
1123    pub segment: gst::GstSegment,
1124    pub clock_id: gst::GstClockID,
1125    pub sync: gboolean,
1126    pub flushing: gboolean,
1127    pub running: gboolean,
1128    pub max_lateness: i64,
1129    pub priv_: *mut GstBaseSinkPrivate,
1130    pub _gst_reserved: [gpointer; 20],
1131}
1132
1133impl ::std::fmt::Debug for GstBaseSink {
1134    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1135        f.debug_struct(&format!("GstBaseSink @ {self:p}"))
1136            .field("element", &self.element)
1137            .field("sinkpad", &self.sinkpad)
1138            .field("pad_mode", &self.pad_mode)
1139            .field("offset", &self.offset)
1140            .field("can_activate_pull", &self.can_activate_pull)
1141            .field("can_activate_push", &self.can_activate_push)
1142            .field("preroll_lock", &self.preroll_lock)
1143            .field("preroll_cond", &self.preroll_cond)
1144            .field("eos", &self.eos)
1145            .field("need_preroll", &self.need_preroll)
1146            .field("have_preroll", &self.have_preroll)
1147            .field("playing_async", &self.playing_async)
1148            .field("have_newsegment", &self.have_newsegment)
1149            .field("segment", &self.segment)
1150            .finish()
1151    }
1152}
1153
1154#[derive(Copy, Clone)]
1155#[repr(C)]
1156pub struct GstBaseSrc {
1157    pub element: gst::GstElement,
1158    pub srcpad: *mut gst::GstPad,
1159    pub live_lock: glib::GMutex,
1160    pub live_cond: glib::GCond,
1161    pub is_live: gboolean,
1162    pub live_running: gboolean,
1163    pub blocksize: c_uint,
1164    pub can_activate_push: gboolean,
1165    pub random_access: gboolean,
1166    pub clock_id: gst::GstClockID,
1167    pub segment: gst::GstSegment,
1168    pub need_newsegment: gboolean,
1169    pub num_buffers: c_int,
1170    pub num_buffers_left: c_int,
1171    pub typefind: gboolean,
1172    pub running: gboolean,
1173    pub pending_seek: *mut gst::GstEvent,
1174    pub priv_: *mut GstBaseSrcPrivate,
1175    pub _gst_reserved: [gpointer; 20],
1176}
1177
1178impl ::std::fmt::Debug for GstBaseSrc {
1179    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1180        f.debug_struct(&format!("GstBaseSrc @ {self:p}"))
1181            .field("element", &self.element)
1182            .field("srcpad", &self.srcpad)
1183            .field("live_lock", &self.live_lock)
1184            .field("live_cond", &self.live_cond)
1185            .field("is_live", &self.is_live)
1186            .field("live_running", &self.live_running)
1187            .field("blocksize", &self.blocksize)
1188            .field("can_activate_push", &self.can_activate_push)
1189            .field("random_access", &self.random_access)
1190            .field("clock_id", &self.clock_id)
1191            .field("segment", &self.segment)
1192            .field("need_newsegment", &self.need_newsegment)
1193            .field("num_buffers", &self.num_buffers)
1194            .field("num_buffers_left", &self.num_buffers_left)
1195            .field("typefind", &self.typefind)
1196            .field("running", &self.running)
1197            .field("pending_seek", &self.pending_seek)
1198            .field("priv_", &self.priv_)
1199            .finish()
1200    }
1201}
1202
1203#[derive(Copy, Clone)]
1204#[repr(C)]
1205pub struct GstBaseTransform {
1206    pub element: gst::GstElement,
1207    pub sinkpad: *mut gst::GstPad,
1208    pub srcpad: *mut gst::GstPad,
1209    pub have_segment: gboolean,
1210    pub segment: gst::GstSegment,
1211    pub queued_buf: *mut gst::GstBuffer,
1212    pub priv_: *mut GstBaseTransformPrivate,
1213    pub _gst_reserved: [gpointer; 19],
1214}
1215
1216impl ::std::fmt::Debug for GstBaseTransform {
1217    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1218        f.debug_struct(&format!("GstBaseTransform @ {self:p}"))
1219            .field("element", &self.element)
1220            .field("sinkpad", &self.sinkpad)
1221            .field("srcpad", &self.srcpad)
1222            .field("have_segment", &self.have_segment)
1223            .field("segment", &self.segment)
1224            .field("queued_buf", &self.queued_buf)
1225            .finish()
1226    }
1227}
1228
1229#[derive(Copy, Clone)]
1230#[repr(C)]
1231pub struct GstCollectPads {
1232    pub object: gst::GstObject,
1233    pub data: *mut glib::GSList,
1234    pub stream_lock: glib::GRecMutex,
1235    pub priv_: *mut GstCollectPadsPrivate,
1236    pub _gst_reserved: [gpointer; 4],
1237}
1238
1239impl ::std::fmt::Debug for GstCollectPads {
1240    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1241        f.debug_struct(&format!("GstCollectPads @ {self:p}"))
1242            .field("object", &self.object)
1243            .field("data", &self.data)
1244            .finish()
1245    }
1246}
1247
1248#[derive(Copy, Clone)]
1249#[repr(C)]
1250pub struct GstDataQueue {
1251    pub object: gobject::GObject,
1252    pub priv_: *mut GstDataQueuePrivate,
1253    pub _gst_reserved: [gpointer; 4],
1254}
1255
1256impl ::std::fmt::Debug for GstDataQueue {
1257    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1258        f.debug_struct(&format!("GstDataQueue @ {self:p}"))
1259            .field("object", &self.object)
1260            .finish()
1261    }
1262}
1263
1264#[derive(Copy, Clone)]
1265#[repr(C)]
1266pub struct GstPushSrc {
1267    pub parent: GstBaseSrc,
1268    pub _gst_reserved: [gpointer; 4],
1269}
1270
1271impl ::std::fmt::Debug for GstPushSrc {
1272    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1273        f.debug_struct(&format!("GstPushSrc @ {self:p}"))
1274            .field("parent", &self.parent)
1275            .finish()
1276    }
1277}
1278
1279extern "C" {
1280
1281    //=========================================================================
1282    // GstAggregatorStartTimeSelection
1283    //=========================================================================
1284    #[cfg(feature = "v1_18")]
1285    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1286    pub fn gst_aggregator_start_time_selection_get_type() -> GType;
1287
1288    //=========================================================================
1289    // GstBaseParseFrame
1290    //=========================================================================
1291    pub fn gst_base_parse_frame_get_type() -> GType;
1292    pub fn gst_base_parse_frame_new(
1293        buffer: *mut gst::GstBuffer,
1294        flags: GstBaseParseFrameFlags,
1295        overhead: c_int,
1296    ) -> *mut GstBaseParseFrame;
1297    pub fn gst_base_parse_frame_copy(frame: *mut GstBaseParseFrame) -> *mut GstBaseParseFrame;
1298    pub fn gst_base_parse_frame_free(frame: *mut GstBaseParseFrame);
1299    pub fn gst_base_parse_frame_init(frame: *mut GstBaseParseFrame);
1300
1301    //=========================================================================
1302    // GstBitReader
1303    //=========================================================================
1304    pub fn gst_bit_reader_free(reader: *mut GstBitReader);
1305    pub fn gst_bit_reader_get_bits_uint16(
1306        reader: *mut GstBitReader,
1307        val: *mut u16,
1308        nbits: c_uint,
1309    ) -> gboolean;
1310    pub fn gst_bit_reader_get_bits_uint32(
1311        reader: *mut GstBitReader,
1312        val: *mut u32,
1313        nbits: c_uint,
1314    ) -> gboolean;
1315    pub fn gst_bit_reader_get_bits_uint64(
1316        reader: *mut GstBitReader,
1317        val: *mut u64,
1318        nbits: c_uint,
1319    ) -> gboolean;
1320    pub fn gst_bit_reader_get_bits_uint8(
1321        reader: *mut GstBitReader,
1322        val: *mut u8,
1323        nbits: c_uint,
1324    ) -> gboolean;
1325    pub fn gst_bit_reader_get_pos(reader: *const GstBitReader) -> c_uint;
1326    pub fn gst_bit_reader_get_remaining(reader: *const GstBitReader) -> c_uint;
1327    pub fn gst_bit_reader_get_size(reader: *const GstBitReader) -> c_uint;
1328    pub fn gst_bit_reader_init(reader: *mut GstBitReader, data: *const u8, size: c_uint);
1329    pub fn gst_bit_reader_peek_bits_uint16(
1330        reader: *const GstBitReader,
1331        val: *mut u16,
1332        nbits: c_uint,
1333    ) -> gboolean;
1334    pub fn gst_bit_reader_peek_bits_uint32(
1335        reader: *const GstBitReader,
1336        val: *mut u32,
1337        nbits: c_uint,
1338    ) -> gboolean;
1339    pub fn gst_bit_reader_peek_bits_uint64(
1340        reader: *const GstBitReader,
1341        val: *mut u64,
1342        nbits: c_uint,
1343    ) -> gboolean;
1344    pub fn gst_bit_reader_peek_bits_uint8(
1345        reader: *const GstBitReader,
1346        val: *mut u8,
1347        nbits: c_uint,
1348    ) -> gboolean;
1349    pub fn gst_bit_reader_set_pos(reader: *mut GstBitReader, pos: c_uint) -> gboolean;
1350    pub fn gst_bit_reader_skip(reader: *mut GstBitReader, nbits: c_uint) -> gboolean;
1351    pub fn gst_bit_reader_skip_to_byte(reader: *mut GstBitReader) -> gboolean;
1352    pub fn gst_bit_reader_new(data: *const u8, size: c_uint) -> *mut GstBitReader;
1353
1354    //=========================================================================
1355    // GstBitWriter
1356    //=========================================================================
1357    #[cfg(feature = "v1_16")]
1358    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1359    pub fn gst_bit_writer_align_bytes(bitwriter: *mut GstBitWriter, trailing_bit: u8) -> gboolean;
1360    #[cfg(feature = "v1_16")]
1361    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1362    pub fn gst_bit_writer_free(bitwriter: *mut GstBitWriter);
1363    #[cfg(feature = "v1_16")]
1364    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1365    pub fn gst_bit_writer_free_and_get_buffer(bitwriter: *mut GstBitWriter) -> *mut gst::GstBuffer;
1366    #[cfg(feature = "v1_16")]
1367    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1368    pub fn gst_bit_writer_free_and_get_data(bitwriter: *mut GstBitWriter) -> *mut u8;
1369    #[cfg(feature = "v1_16")]
1370    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1371    pub fn gst_bit_writer_get_data(bitwriter: *const GstBitWriter) -> *mut u8;
1372    #[cfg(feature = "v1_16")]
1373    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1374    pub fn gst_bit_writer_get_remaining(bitwriter: *const GstBitWriter) -> c_uint;
1375    #[cfg(feature = "v1_16")]
1376    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1377    pub fn gst_bit_writer_get_size(bitwriter: *const GstBitWriter) -> c_uint;
1378    #[cfg(feature = "v1_16")]
1379    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1380    pub fn gst_bit_writer_init(bitwriter: *mut GstBitWriter);
1381    #[cfg(feature = "v1_16")]
1382    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1383    pub fn gst_bit_writer_init_with_data(
1384        bitwriter: *mut GstBitWriter,
1385        data: *mut u8,
1386        size: c_uint,
1387        initialized: gboolean,
1388    );
1389    #[cfg(feature = "v1_16")]
1390    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1391    pub fn gst_bit_writer_init_with_size(bitwriter: *mut GstBitWriter, size: u32, fixed: gboolean);
1392    #[cfg(feature = "v1_16")]
1393    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1394    pub fn gst_bit_writer_put_bits_uint16(
1395        bitwriter: *mut GstBitWriter,
1396        value: u16,
1397        nbits: c_uint,
1398    ) -> gboolean;
1399    #[cfg(feature = "v1_16")]
1400    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1401    pub fn gst_bit_writer_put_bits_uint32(
1402        bitwriter: *mut GstBitWriter,
1403        value: u32,
1404        nbits: c_uint,
1405    ) -> gboolean;
1406    #[cfg(feature = "v1_16")]
1407    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1408    pub fn gst_bit_writer_put_bits_uint64(
1409        bitwriter: *mut GstBitWriter,
1410        value: u64,
1411        nbits: c_uint,
1412    ) -> gboolean;
1413    #[cfg(feature = "v1_16")]
1414    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1415    pub fn gst_bit_writer_put_bits_uint8(
1416        bitwriter: *mut GstBitWriter,
1417        value: u8,
1418        nbits: c_uint,
1419    ) -> gboolean;
1420    #[cfg(feature = "v1_16")]
1421    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1422    pub fn gst_bit_writer_put_bytes(
1423        bitwriter: *mut GstBitWriter,
1424        data: *const u8,
1425        nbytes: c_uint,
1426    ) -> gboolean;
1427    #[cfg(feature = "v1_16")]
1428    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1429    pub fn gst_bit_writer_reset(bitwriter: *mut GstBitWriter);
1430    #[cfg(feature = "v1_16")]
1431    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1432    pub fn gst_bit_writer_reset_and_get_buffer(bitwriter: *mut GstBitWriter)
1433        -> *mut gst::GstBuffer;
1434    #[cfg(feature = "v1_16")]
1435    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1436    pub fn gst_bit_writer_reset_and_get_data(bitwriter: *mut GstBitWriter) -> *mut u8;
1437    #[cfg(feature = "v1_16")]
1438    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1439    pub fn gst_bit_writer_set_pos(bitwriter: *mut GstBitWriter, pos: c_uint) -> gboolean;
1440    #[cfg(feature = "v1_16")]
1441    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1442    pub fn gst_bit_writer_new() -> *mut GstBitWriter;
1443    #[cfg(feature = "v1_16")]
1444    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1445    pub fn gst_bit_writer_new_with_data(
1446        data: *mut u8,
1447        size: c_uint,
1448        initialized: gboolean,
1449    ) -> *mut GstBitWriter;
1450    #[cfg(feature = "v1_16")]
1451    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1452    pub fn gst_bit_writer_new_with_size(size: u32, fixed: gboolean) -> *mut GstBitWriter;
1453
1454    //=========================================================================
1455    // GstByteReader
1456    //=========================================================================
1457    pub fn gst_byte_reader_dup_data(
1458        reader: *mut GstByteReader,
1459        size: c_uint,
1460        val: *mut *mut u8,
1461    ) -> gboolean;
1462    pub fn gst_byte_reader_dup_string_utf16(
1463        reader: *mut GstByteReader,
1464        str: *mut *mut u16,
1465    ) -> gboolean;
1466    pub fn gst_byte_reader_dup_string_utf32(
1467        reader: *mut GstByteReader,
1468        str: *mut *mut u32,
1469    ) -> gboolean;
1470    pub fn gst_byte_reader_dup_string_utf8(
1471        reader: *mut GstByteReader,
1472        str: *mut *mut c_char,
1473    ) -> gboolean;
1474    pub fn gst_byte_reader_free(reader: *mut GstByteReader);
1475    pub fn gst_byte_reader_get_data(
1476        reader: *mut GstByteReader,
1477        size: c_uint,
1478        val: *mut *const u8,
1479    ) -> gboolean;
1480    pub fn gst_byte_reader_get_float32_be(
1481        reader: *mut GstByteReader,
1482        val: *mut c_float,
1483    ) -> gboolean;
1484    pub fn gst_byte_reader_get_float32_le(
1485        reader: *mut GstByteReader,
1486        val: *mut c_float,
1487    ) -> gboolean;
1488    pub fn gst_byte_reader_get_float64_be(
1489        reader: *mut GstByteReader,
1490        val: *mut c_double,
1491    ) -> gboolean;
1492    pub fn gst_byte_reader_get_float64_le(
1493        reader: *mut GstByteReader,
1494        val: *mut c_double,
1495    ) -> gboolean;
1496    pub fn gst_byte_reader_get_int16_be(reader: *mut GstByteReader, val: *mut i16) -> gboolean;
1497    pub fn gst_byte_reader_get_int16_le(reader: *mut GstByteReader, val: *mut i16) -> gboolean;
1498    pub fn gst_byte_reader_get_int24_be(reader: *mut GstByteReader, val: *mut i32) -> gboolean;
1499    pub fn gst_byte_reader_get_int24_le(reader: *mut GstByteReader, val: *mut i32) -> gboolean;
1500    pub fn gst_byte_reader_get_int32_be(reader: *mut GstByteReader, val: *mut i32) -> gboolean;
1501    pub fn gst_byte_reader_get_int32_le(reader: *mut GstByteReader, val: *mut i32) -> gboolean;
1502    pub fn gst_byte_reader_get_int64_be(reader: *mut GstByteReader, val: *mut i64) -> gboolean;
1503    pub fn gst_byte_reader_get_int64_le(reader: *mut GstByteReader, val: *mut i64) -> gboolean;
1504    pub fn gst_byte_reader_get_int8(reader: *mut GstByteReader, val: *mut i8) -> gboolean;
1505    pub fn gst_byte_reader_get_pos(reader: *const GstByteReader) -> c_uint;
1506    pub fn gst_byte_reader_get_remaining(reader: *const GstByteReader) -> c_uint;
1507    pub fn gst_byte_reader_get_size(reader: *const GstByteReader) -> c_uint;
1508    pub fn gst_byte_reader_get_string_utf8(
1509        reader: *mut GstByteReader,
1510        str: *mut *const c_char,
1511    ) -> gboolean;
1512    pub fn gst_byte_reader_get_sub_reader(
1513        reader: *mut GstByteReader,
1514        sub_reader: *mut GstByteReader,
1515        size: c_uint,
1516    ) -> gboolean;
1517    pub fn gst_byte_reader_get_uint16_be(reader: *mut GstByteReader, val: *mut u16) -> gboolean;
1518    pub fn gst_byte_reader_get_uint16_le(reader: *mut GstByteReader, val: *mut u16) -> gboolean;
1519    pub fn gst_byte_reader_get_uint24_be(reader: *mut GstByteReader, val: *mut u32) -> gboolean;
1520    pub fn gst_byte_reader_get_uint24_le(reader: *mut GstByteReader, val: *mut u32) -> gboolean;
1521    pub fn gst_byte_reader_get_uint32_be(reader: *mut GstByteReader, val: *mut u32) -> gboolean;
1522    pub fn gst_byte_reader_get_uint32_le(reader: *mut GstByteReader, val: *mut u32) -> gboolean;
1523    pub fn gst_byte_reader_get_uint64_be(reader: *mut GstByteReader, val: *mut u64) -> gboolean;
1524    pub fn gst_byte_reader_get_uint64_le(reader: *mut GstByteReader, val: *mut u64) -> gboolean;
1525    pub fn gst_byte_reader_get_uint8(reader: *mut GstByteReader, val: *mut u8) -> gboolean;
1526    pub fn gst_byte_reader_init(reader: *mut GstByteReader, data: *const u8, size: c_uint);
1527    pub fn gst_byte_reader_masked_scan_uint32(
1528        reader: *const GstByteReader,
1529        mask: u32,
1530        pattern: u32,
1531        offset: c_uint,
1532        size: c_uint,
1533    ) -> c_uint;
1534    pub fn gst_byte_reader_masked_scan_uint32_peek(
1535        reader: *const GstByteReader,
1536        mask: u32,
1537        pattern: u32,
1538        offset: c_uint,
1539        size: c_uint,
1540        value: *mut u32,
1541    ) -> c_uint;
1542    pub fn gst_byte_reader_peek_data(
1543        reader: *const GstByteReader,
1544        size: c_uint,
1545        val: *mut *const u8,
1546    ) -> gboolean;
1547    pub fn gst_byte_reader_peek_float32_be(
1548        reader: *const GstByteReader,
1549        val: *mut c_float,
1550    ) -> gboolean;
1551    pub fn gst_byte_reader_peek_float32_le(
1552        reader: *const GstByteReader,
1553        val: *mut c_float,
1554    ) -> gboolean;
1555    pub fn gst_byte_reader_peek_float64_be(
1556        reader: *const GstByteReader,
1557        val: *mut c_double,
1558    ) -> gboolean;
1559    pub fn gst_byte_reader_peek_float64_le(
1560        reader: *const GstByteReader,
1561        val: *mut c_double,
1562    ) -> gboolean;
1563    pub fn gst_byte_reader_peek_int16_be(reader: *const GstByteReader, val: *mut i16) -> gboolean;
1564    pub fn gst_byte_reader_peek_int16_le(reader: *const GstByteReader, val: *mut i16) -> gboolean;
1565    pub fn gst_byte_reader_peek_int24_be(reader: *const GstByteReader, val: *mut i32) -> gboolean;
1566    pub fn gst_byte_reader_peek_int24_le(reader: *const GstByteReader, val: *mut i32) -> gboolean;
1567    pub fn gst_byte_reader_peek_int32_be(reader: *const GstByteReader, val: *mut i32) -> gboolean;
1568    pub fn gst_byte_reader_peek_int32_le(reader: *const GstByteReader, val: *mut i32) -> gboolean;
1569    pub fn gst_byte_reader_peek_int64_be(reader: *const GstByteReader, val: *mut i64) -> gboolean;
1570    pub fn gst_byte_reader_peek_int64_le(reader: *const GstByteReader, val: *mut i64) -> gboolean;
1571    pub fn gst_byte_reader_peek_int8(reader: *const GstByteReader, val: *mut i8) -> gboolean;
1572    pub fn gst_byte_reader_peek_string_utf8(
1573        reader: *const GstByteReader,
1574        str: *mut *const c_char,
1575    ) -> gboolean;
1576    pub fn gst_byte_reader_peek_sub_reader(
1577        reader: *mut GstByteReader,
1578        sub_reader: *mut GstByteReader,
1579        size: c_uint,
1580    ) -> gboolean;
1581    pub fn gst_byte_reader_peek_uint16_be(reader: *const GstByteReader, val: *mut u16) -> gboolean;
1582    pub fn gst_byte_reader_peek_uint16_le(reader: *const GstByteReader, val: *mut u16) -> gboolean;
1583    pub fn gst_byte_reader_peek_uint24_be(reader: *const GstByteReader, val: *mut u32) -> gboolean;
1584    pub fn gst_byte_reader_peek_uint24_le(reader: *const GstByteReader, val: *mut u32) -> gboolean;
1585    pub fn gst_byte_reader_peek_uint32_be(reader: *const GstByteReader, val: *mut u32) -> gboolean;
1586    pub fn gst_byte_reader_peek_uint32_le(reader: *const GstByteReader, val: *mut u32) -> gboolean;
1587    pub fn gst_byte_reader_peek_uint64_be(reader: *const GstByteReader, val: *mut u64) -> gboolean;
1588    pub fn gst_byte_reader_peek_uint64_le(reader: *const GstByteReader, val: *mut u64) -> gboolean;
1589    pub fn gst_byte_reader_peek_uint8(reader: *const GstByteReader, val: *mut u8) -> gboolean;
1590    pub fn gst_byte_reader_set_pos(reader: *mut GstByteReader, pos: c_uint) -> gboolean;
1591    pub fn gst_byte_reader_skip(reader: *mut GstByteReader, nbytes: c_uint) -> gboolean;
1592    pub fn gst_byte_reader_skip_string_utf16(reader: *mut GstByteReader) -> gboolean;
1593    pub fn gst_byte_reader_skip_string_utf32(reader: *mut GstByteReader) -> gboolean;
1594    pub fn gst_byte_reader_skip_string_utf8(reader: *mut GstByteReader) -> gboolean;
1595    pub fn gst_byte_reader_new(data: *const u8, size: c_uint) -> *mut GstByteReader;
1596
1597    //=========================================================================
1598    // GstByteWriter
1599    //=========================================================================
1600    pub fn gst_byte_writer_ensure_free_space(writer: *mut GstByteWriter, size: c_uint) -> gboolean;
1601    pub fn gst_byte_writer_fill(writer: *mut GstByteWriter, value: u8, size: c_uint) -> gboolean;
1602    pub fn gst_byte_writer_free(writer: *mut GstByteWriter);
1603    pub fn gst_byte_writer_free_and_get_buffer(writer: *mut GstByteWriter) -> *mut gst::GstBuffer;
1604    pub fn gst_byte_writer_free_and_get_data(writer: *mut GstByteWriter) -> *mut u8;
1605    pub fn gst_byte_writer_get_remaining(writer: *const GstByteWriter) -> c_uint;
1606    pub fn gst_byte_writer_init(writer: *mut GstByteWriter);
1607    pub fn gst_byte_writer_init_with_data(
1608        writer: *mut GstByteWriter,
1609        data: *mut u8,
1610        size: c_uint,
1611        initialized: gboolean,
1612    );
1613    pub fn gst_byte_writer_init_with_size(
1614        writer: *mut GstByteWriter,
1615        size: c_uint,
1616        fixed: gboolean,
1617    );
1618    pub fn gst_byte_writer_put_buffer(
1619        writer: *mut GstByteWriter,
1620        buffer: *mut gst::GstBuffer,
1621        offset: size_t,
1622        size: ssize_t,
1623    ) -> gboolean;
1624    pub fn gst_byte_writer_put_data(
1625        writer: *mut GstByteWriter,
1626        data: *const u8,
1627        size: c_uint,
1628    ) -> gboolean;
1629    pub fn gst_byte_writer_put_float32_be(writer: *mut GstByteWriter, val: c_float) -> gboolean;
1630    pub fn gst_byte_writer_put_float32_le(writer: *mut GstByteWriter, val: c_float) -> gboolean;
1631    pub fn gst_byte_writer_put_float64_be(writer: *mut GstByteWriter, val: c_double) -> gboolean;
1632    pub fn gst_byte_writer_put_float64_le(writer: *mut GstByteWriter, val: c_double) -> gboolean;
1633    pub fn gst_byte_writer_put_int16_be(writer: *mut GstByteWriter, val: i16) -> gboolean;
1634    pub fn gst_byte_writer_put_int16_le(writer: *mut GstByteWriter, val: i16) -> gboolean;
1635    pub fn gst_byte_writer_put_int24_be(writer: *mut GstByteWriter, val: i32) -> gboolean;
1636    pub fn gst_byte_writer_put_int24_le(writer: *mut GstByteWriter, val: i32) -> gboolean;
1637    pub fn gst_byte_writer_put_int32_be(writer: *mut GstByteWriter, val: i32) -> gboolean;
1638    pub fn gst_byte_writer_put_int32_le(writer: *mut GstByteWriter, val: i32) -> gboolean;
1639    pub fn gst_byte_writer_put_int64_be(writer: *mut GstByteWriter, val: i64) -> gboolean;
1640    pub fn gst_byte_writer_put_int64_le(writer: *mut GstByteWriter, val: i64) -> gboolean;
1641    pub fn gst_byte_writer_put_int8(writer: *mut GstByteWriter, val: i8) -> gboolean;
1642    pub fn gst_byte_writer_put_string_utf16(
1643        writer: *mut GstByteWriter,
1644        data: *const u16,
1645    ) -> gboolean;
1646    pub fn gst_byte_writer_put_string_utf32(
1647        writer: *mut GstByteWriter,
1648        data: *const u32,
1649    ) -> gboolean;
1650    pub fn gst_byte_writer_put_string_utf8(
1651        writer: *mut GstByteWriter,
1652        data: *const c_char,
1653    ) -> gboolean;
1654    pub fn gst_byte_writer_put_uint16_be(writer: *mut GstByteWriter, val: u16) -> gboolean;
1655    pub fn gst_byte_writer_put_uint16_le(writer: *mut GstByteWriter, val: u16) -> gboolean;
1656    pub fn gst_byte_writer_put_uint24_be(writer: *mut GstByteWriter, val: u32) -> gboolean;
1657    pub fn gst_byte_writer_put_uint24_le(writer: *mut GstByteWriter, val: u32) -> gboolean;
1658    pub fn gst_byte_writer_put_uint32_be(writer: *mut GstByteWriter, val: u32) -> gboolean;
1659    pub fn gst_byte_writer_put_uint32_le(writer: *mut GstByteWriter, val: u32) -> gboolean;
1660    pub fn gst_byte_writer_put_uint64_be(writer: *mut GstByteWriter, val: u64) -> gboolean;
1661    pub fn gst_byte_writer_put_uint64_le(writer: *mut GstByteWriter, val: u64) -> gboolean;
1662    pub fn gst_byte_writer_put_uint8(writer: *mut GstByteWriter, val: u8) -> gboolean;
1663    pub fn gst_byte_writer_reset(writer: *mut GstByteWriter);
1664    pub fn gst_byte_writer_reset_and_get_buffer(writer: *mut GstByteWriter) -> *mut gst::GstBuffer;
1665    pub fn gst_byte_writer_reset_and_get_data(writer: *mut GstByteWriter) -> *mut u8;
1666    pub fn gst_byte_writer_new() -> *mut GstByteWriter;
1667    pub fn gst_byte_writer_new_with_data(
1668        data: *mut u8,
1669        size: c_uint,
1670        initialized: gboolean,
1671    ) -> *mut GstByteWriter;
1672    pub fn gst_byte_writer_new_with_size(size: c_uint, fixed: gboolean) -> *mut GstByteWriter;
1673
1674    //=========================================================================
1675    // GstFlowCombiner
1676    //=========================================================================
1677    pub fn gst_flow_combiner_get_type() -> GType;
1678    pub fn gst_flow_combiner_new() -> *mut GstFlowCombiner;
1679    pub fn gst_flow_combiner_add_pad(combiner: *mut GstFlowCombiner, pad: *mut gst::GstPad);
1680    pub fn gst_flow_combiner_clear(combiner: *mut GstFlowCombiner);
1681    pub fn gst_flow_combiner_free(combiner: *mut GstFlowCombiner);
1682    pub fn gst_flow_combiner_ref(combiner: *mut GstFlowCombiner) -> *mut GstFlowCombiner;
1683    pub fn gst_flow_combiner_remove_pad(combiner: *mut GstFlowCombiner, pad: *mut gst::GstPad);
1684    pub fn gst_flow_combiner_reset(combiner: *mut GstFlowCombiner);
1685    pub fn gst_flow_combiner_unref(combiner: *mut GstFlowCombiner);
1686    pub fn gst_flow_combiner_update_flow(
1687        combiner: *mut GstFlowCombiner,
1688        fret: gst::GstFlowReturn,
1689    ) -> gst::GstFlowReturn;
1690    pub fn gst_flow_combiner_update_pad_flow(
1691        combiner: *mut GstFlowCombiner,
1692        pad: *mut gst::GstPad,
1693        fret: gst::GstFlowReturn,
1694    ) -> gst::GstFlowReturn;
1695
1696    //=========================================================================
1697    // GstQueueArray
1698    //=========================================================================
1699    #[cfg(feature = "v1_16")]
1700    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1701    pub fn gst_queue_array_clear(array: *mut GstQueueArray);
1702    pub fn gst_queue_array_drop_element(array: *mut GstQueueArray, idx: c_uint) -> gpointer;
1703    pub fn gst_queue_array_drop_struct(
1704        array: *mut GstQueueArray,
1705        idx: c_uint,
1706        p_struct: gpointer,
1707    ) -> gboolean;
1708    pub fn gst_queue_array_find(
1709        array: *mut GstQueueArray,
1710        func: glib::GCompareFunc,
1711        data: gpointer,
1712    ) -> c_uint;
1713    pub fn gst_queue_array_free(array: *mut GstQueueArray);
1714    pub fn gst_queue_array_get_length(array: *mut GstQueueArray) -> c_uint;
1715    pub fn gst_queue_array_is_empty(array: *mut GstQueueArray) -> gboolean;
1716    pub fn gst_queue_array_peek_head(array: *mut GstQueueArray) -> gpointer;
1717    pub fn gst_queue_array_peek_head_struct(array: *mut GstQueueArray) -> gpointer;
1718    #[cfg(feature = "v1_16")]
1719    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1720    pub fn gst_queue_array_peek_nth(array: *mut GstQueueArray, idx: c_uint) -> gpointer;
1721    #[cfg(feature = "v1_16")]
1722    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1723    pub fn gst_queue_array_peek_nth_struct(array: *mut GstQueueArray, idx: c_uint) -> gpointer;
1724    pub fn gst_queue_array_peek_tail(array: *mut GstQueueArray) -> gpointer;
1725    pub fn gst_queue_array_peek_tail_struct(array: *mut GstQueueArray) -> gpointer;
1726    pub fn gst_queue_array_pop_head(array: *mut GstQueueArray) -> gpointer;
1727    pub fn gst_queue_array_pop_head_struct(array: *mut GstQueueArray) -> gpointer;
1728    pub fn gst_queue_array_pop_tail(array: *mut GstQueueArray) -> gpointer;
1729    pub fn gst_queue_array_pop_tail_struct(array: *mut GstQueueArray) -> gpointer;
1730    #[cfg(feature = "v1_24")]
1731    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1732    pub fn gst_queue_array_push_sorted(
1733        array: *mut GstQueueArray,
1734        data: gpointer,
1735        func: glib::GCompareDataFunc,
1736        user_data: gpointer,
1737    );
1738    #[cfg(feature = "v1_24")]
1739    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1740    pub fn gst_queue_array_push_sorted_struct(
1741        array: *mut GstQueueArray,
1742        p_struct: gpointer,
1743        func: glib::GCompareDataFunc,
1744        user_data: gpointer,
1745    );
1746    pub fn gst_queue_array_push_tail(array: *mut GstQueueArray, data: gpointer);
1747    pub fn gst_queue_array_push_tail_struct(array: *mut GstQueueArray, p_struct: gpointer);
1748    #[cfg(feature = "v1_16")]
1749    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1750    pub fn gst_queue_array_set_clear_func(
1751        array: *mut GstQueueArray,
1752        clear_func: glib::GDestroyNotify,
1753    );
1754    #[cfg(feature = "v1_24")]
1755    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1756    pub fn gst_queue_array_sort(
1757        array: *mut GstQueueArray,
1758        compare_func: glib::GCompareDataFunc,
1759        user_data: gpointer,
1760    );
1761    pub fn gst_queue_array_new(initial_size: c_uint) -> *mut GstQueueArray;
1762    pub fn gst_queue_array_new_for_struct(
1763        struct_size: size_t,
1764        initial_size: c_uint,
1765    ) -> *mut GstQueueArray;
1766
1767    //=========================================================================
1768    // GstTypeFindData
1769    //=========================================================================
1770    #[cfg(feature = "v1_22")]
1771    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1772    pub fn gst_type_find_data_free(data: *mut GstTypeFindData);
1773    #[cfg(feature = "v1_22")]
1774    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1775    pub fn gst_type_find_data_get_caps(data: *mut GstTypeFindData) -> *mut gst::GstCaps;
1776    #[cfg(feature = "v1_22")]
1777    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1778    pub fn gst_type_find_data_get_probability(
1779        data: *mut GstTypeFindData,
1780    ) -> gst::GstTypeFindProbability;
1781    #[cfg(feature = "v1_22")]
1782    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1783    pub fn gst_type_find_data_get_typefind(data: *mut GstTypeFindData) -> *mut gst::GstTypeFind;
1784    #[cfg(feature = "v1_22")]
1785    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1786    pub fn gst_type_find_data_new(
1787        obj: *mut gst::GstObject,
1788        data: *const u8,
1789        size: size_t,
1790    ) -> *mut GstTypeFindData;
1791
1792    //=========================================================================
1793    // GstAdapter
1794    //=========================================================================
1795    pub fn gst_adapter_get_type() -> GType;
1796    pub fn gst_adapter_new() -> *mut GstAdapter;
1797    pub fn gst_adapter_available(adapter: *mut GstAdapter) -> size_t;
1798    pub fn gst_adapter_available_fast(adapter: *mut GstAdapter) -> size_t;
1799    pub fn gst_adapter_clear(adapter: *mut GstAdapter);
1800    pub fn gst_adapter_copy(adapter: *mut GstAdapter, dest: gpointer, offset: size_t, size: size_t);
1801    pub fn gst_adapter_copy_bytes(
1802        adapter: *mut GstAdapter,
1803        offset: size_t,
1804        size: size_t,
1805    ) -> *mut glib::GBytes;
1806    pub fn gst_adapter_distance_from_discont(adapter: *mut GstAdapter) -> u64;
1807    pub fn gst_adapter_dts_at_discont(adapter: *mut GstAdapter) -> gst::GstClockTime;
1808    pub fn gst_adapter_flush(adapter: *mut GstAdapter, flush: size_t);
1809    pub fn gst_adapter_get_buffer(adapter: *mut GstAdapter, nbytes: size_t) -> *mut gst::GstBuffer;
1810    pub fn gst_adapter_get_buffer_fast(
1811        adapter: *mut GstAdapter,
1812        nbytes: size_t,
1813    ) -> *mut gst::GstBuffer;
1814    pub fn gst_adapter_get_buffer_list(
1815        adapter: *mut GstAdapter,
1816        nbytes: size_t,
1817    ) -> *mut gst::GstBufferList;
1818    pub fn gst_adapter_get_list(adapter: *mut GstAdapter, nbytes: size_t) -> *mut glib::GList;
1819    pub fn gst_adapter_map(adapter: *mut GstAdapter, size: size_t) -> gconstpointer;
1820    pub fn gst_adapter_masked_scan_uint32(
1821        adapter: *mut GstAdapter,
1822        mask: u32,
1823        pattern: u32,
1824        offset: size_t,
1825        size: size_t,
1826    ) -> ssize_t;
1827    pub fn gst_adapter_masked_scan_uint32_peek(
1828        adapter: *mut GstAdapter,
1829        mask: u32,
1830        pattern: u32,
1831        offset: size_t,
1832        size: size_t,
1833        value: *mut u32,
1834    ) -> ssize_t;
1835    pub fn gst_adapter_offset_at_discont(adapter: *mut GstAdapter) -> u64;
1836    pub fn gst_adapter_prev_dts(adapter: *mut GstAdapter, distance: *mut u64) -> gst::GstClockTime;
1837    pub fn gst_adapter_prev_dts_at_offset(
1838        adapter: *mut GstAdapter,
1839        offset: size_t,
1840        distance: *mut u64,
1841    ) -> gst::GstClockTime;
1842    pub fn gst_adapter_prev_offset(adapter: *mut GstAdapter, distance: *mut u64) -> u64;
1843    pub fn gst_adapter_prev_pts(adapter: *mut GstAdapter, distance: *mut u64) -> gst::GstClockTime;
1844    pub fn gst_adapter_prev_pts_at_offset(
1845        adapter: *mut GstAdapter,
1846        offset: size_t,
1847        distance: *mut u64,
1848    ) -> gst::GstClockTime;
1849    pub fn gst_adapter_pts_at_discont(adapter: *mut GstAdapter) -> gst::GstClockTime;
1850    pub fn gst_adapter_push(adapter: *mut GstAdapter, buf: *mut gst::GstBuffer);
1851    pub fn gst_adapter_take(adapter: *mut GstAdapter, nbytes: size_t) -> gpointer;
1852    pub fn gst_adapter_take_buffer(adapter: *mut GstAdapter, nbytes: size_t)
1853        -> *mut gst::GstBuffer;
1854    pub fn gst_adapter_take_buffer_fast(
1855        adapter: *mut GstAdapter,
1856        nbytes: size_t,
1857    ) -> *mut gst::GstBuffer;
1858    pub fn gst_adapter_take_buffer_list(
1859        adapter: *mut GstAdapter,
1860        nbytes: size_t,
1861    ) -> *mut gst::GstBufferList;
1862    pub fn gst_adapter_take_list(adapter: *mut GstAdapter, nbytes: size_t) -> *mut glib::GList;
1863    pub fn gst_adapter_unmap(adapter: *mut GstAdapter);
1864
1865    //=========================================================================
1866    // GstAggregator
1867    //=========================================================================
1868    pub fn gst_aggregator_get_type() -> GType;
1869    pub fn gst_aggregator_finish_buffer(
1870        aggregator: *mut GstAggregator,
1871        buffer: *mut gst::GstBuffer,
1872    ) -> gst::GstFlowReturn;
1873    #[cfg(feature = "v1_18")]
1874    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1875    pub fn gst_aggregator_finish_buffer_list(
1876        aggregator: *mut GstAggregator,
1877        bufferlist: *mut gst::GstBufferList,
1878    ) -> gst::GstFlowReturn;
1879    pub fn gst_aggregator_get_allocator(
1880        self_: *mut GstAggregator,
1881        allocator: *mut *mut gst::GstAllocator,
1882        params: *mut gst::GstAllocationParams,
1883    );
1884    pub fn gst_aggregator_get_buffer_pool(self_: *mut GstAggregator) -> *mut gst::GstBufferPool;
1885    #[cfg(feature = "v1_22")]
1886    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1887    pub fn gst_aggregator_get_force_live(self_: *mut GstAggregator) -> gboolean;
1888    #[cfg(feature = "v1_20")]
1889    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1890    pub fn gst_aggregator_get_ignore_inactive_pads(self_: *mut GstAggregator) -> gboolean;
1891    pub fn gst_aggregator_get_latency(self_: *mut GstAggregator) -> gst::GstClockTime;
1892    #[cfg(feature = "v1_18")]
1893    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1894    pub fn gst_aggregator_negotiate(self_: *mut GstAggregator) -> gboolean;
1895    #[cfg(feature = "v1_18")]
1896    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1897    pub fn gst_aggregator_peek_next_sample(
1898        self_: *mut GstAggregator,
1899        pad: *mut GstAggregatorPad,
1900    ) -> *mut gst::GstSample;
1901    #[cfg(feature = "v1_26")]
1902    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1903    pub fn gst_aggregator_push_src_event(
1904        aggregator: *mut GstAggregator,
1905        event: *mut gst::GstEvent,
1906    ) -> gboolean;
1907    #[cfg(feature = "v1_18")]
1908    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1909    pub fn gst_aggregator_selected_samples(
1910        self_: *mut GstAggregator,
1911        pts: gst::GstClockTime,
1912        dts: gst::GstClockTime,
1913        duration: gst::GstClockTime,
1914        info: *mut gst::GstStructure,
1915    );
1916    #[cfg(feature = "v1_22")]
1917    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1918    pub fn gst_aggregator_set_force_live(self_: *mut GstAggregator, force_live: gboolean);
1919    #[cfg(feature = "v1_20")]
1920    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1921    pub fn gst_aggregator_set_ignore_inactive_pads(self_: *mut GstAggregator, ignore: gboolean);
1922    pub fn gst_aggregator_set_latency(
1923        self_: *mut GstAggregator,
1924        min_latency: gst::GstClockTime,
1925        max_latency: gst::GstClockTime,
1926    );
1927    pub fn gst_aggregator_set_src_caps(self_: *mut GstAggregator, caps: *mut gst::GstCaps);
1928    #[cfg(feature = "v1_16")]
1929    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1930    pub fn gst_aggregator_simple_get_next_time(self_: *mut GstAggregator) -> gst::GstClockTime;
1931    #[cfg(feature = "v1_18")]
1932    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1933    pub fn gst_aggregator_update_segment(
1934        self_: *mut GstAggregator,
1935        segment: *const gst::GstSegment,
1936    );
1937
1938    //=========================================================================
1939    // GstAggregatorPad
1940    //=========================================================================
1941    pub fn gst_aggregator_pad_get_type() -> GType;
1942    pub fn gst_aggregator_pad_drop_buffer(pad: *mut GstAggregatorPad) -> gboolean;
1943    #[cfg(feature = "v1_14_1")]
1944    #[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
1945    pub fn gst_aggregator_pad_has_buffer(pad: *mut GstAggregatorPad) -> gboolean;
1946    pub fn gst_aggregator_pad_is_eos(pad: *mut GstAggregatorPad) -> gboolean;
1947    #[cfg(feature = "v1_20")]
1948    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1949    pub fn gst_aggregator_pad_is_inactive(pad: *mut GstAggregatorPad) -> gboolean;
1950    pub fn gst_aggregator_pad_peek_buffer(pad: *mut GstAggregatorPad) -> *mut gst::GstBuffer;
1951    pub fn gst_aggregator_pad_pop_buffer(pad: *mut GstAggregatorPad) -> *mut gst::GstBuffer;
1952
1953    //=========================================================================
1954    // GstBaseParse
1955    //=========================================================================
1956    pub fn gst_base_parse_get_type() -> GType;
1957    pub fn gst_base_parse_add_index_entry(
1958        parse: *mut GstBaseParse,
1959        offset: u64,
1960        ts: gst::GstClockTime,
1961        key: gboolean,
1962        force: gboolean,
1963    ) -> gboolean;
1964    pub fn gst_base_parse_convert_default(
1965        parse: *mut GstBaseParse,
1966        src_format: gst::GstFormat,
1967        src_value: i64,
1968        dest_format: gst::GstFormat,
1969        dest_value: *mut i64,
1970    ) -> gboolean;
1971    pub fn gst_base_parse_drain(parse: *mut GstBaseParse);
1972    pub fn gst_base_parse_finish_frame(
1973        parse: *mut GstBaseParse,
1974        frame: *mut GstBaseParseFrame,
1975        size: c_int,
1976    ) -> gst::GstFlowReturn;
1977    pub fn gst_base_parse_merge_tags(
1978        parse: *mut GstBaseParse,
1979        tags: *mut gst::GstTagList,
1980        mode: gst::GstTagMergeMode,
1981    );
1982    pub fn gst_base_parse_push_frame(
1983        parse: *mut GstBaseParse,
1984        frame: *mut GstBaseParseFrame,
1985    ) -> gst::GstFlowReturn;
1986    pub fn gst_base_parse_set_average_bitrate(parse: *mut GstBaseParse, bitrate: c_uint);
1987    pub fn gst_base_parse_set_duration(
1988        parse: *mut GstBaseParse,
1989        fmt: gst::GstFormat,
1990        duration: i64,
1991        interval: c_int,
1992    );
1993    pub fn gst_base_parse_set_frame_rate(
1994        parse: *mut GstBaseParse,
1995        fps_num: c_uint,
1996        fps_den: c_uint,
1997        lead_in: c_uint,
1998        lead_out: c_uint,
1999    );
2000    pub fn gst_base_parse_set_has_timing_info(parse: *mut GstBaseParse, has_timing: gboolean);
2001    pub fn gst_base_parse_set_infer_ts(parse: *mut GstBaseParse, infer_ts: gboolean);
2002    pub fn gst_base_parse_set_latency(
2003        parse: *mut GstBaseParse,
2004        min_latency: gst::GstClockTime,
2005        max_latency: gst::GstClockTime,
2006    );
2007    pub fn gst_base_parse_set_min_frame_size(parse: *mut GstBaseParse, min_size: c_uint);
2008    pub fn gst_base_parse_set_passthrough(parse: *mut GstBaseParse, passthrough: gboolean);
2009    pub fn gst_base_parse_set_pts_interpolation(
2010        parse: *mut GstBaseParse,
2011        pts_interpolate: gboolean,
2012    );
2013    pub fn gst_base_parse_set_syncable(parse: *mut GstBaseParse, syncable: gboolean);
2014    pub fn gst_base_parse_set_ts_at_offset(parse: *mut GstBaseParse, offset: size_t);
2015
2016    //=========================================================================
2017    // GstBaseSink
2018    //=========================================================================
2019    pub fn gst_base_sink_get_type() -> GType;
2020    pub fn gst_base_sink_do_preroll(
2021        sink: *mut GstBaseSink,
2022        obj: *mut gst::GstMiniObject,
2023    ) -> gst::GstFlowReturn;
2024    pub fn gst_base_sink_get_blocksize(sink: *mut GstBaseSink) -> c_uint;
2025    pub fn gst_base_sink_get_drop_out_of_segment(sink: *mut GstBaseSink) -> gboolean;
2026    pub fn gst_base_sink_get_last_sample(sink: *mut GstBaseSink) -> *mut gst::GstSample;
2027    pub fn gst_base_sink_get_latency(sink: *mut GstBaseSink) -> gst::GstClockTime;
2028    pub fn gst_base_sink_get_max_bitrate(sink: *mut GstBaseSink) -> u64;
2029    pub fn gst_base_sink_get_max_lateness(sink: *mut GstBaseSink) -> i64;
2030    #[cfg(feature = "v1_16")]
2031    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2032    pub fn gst_base_sink_get_processing_deadline(sink: *mut GstBaseSink) -> gst::GstClockTime;
2033    pub fn gst_base_sink_get_render_delay(sink: *mut GstBaseSink) -> gst::GstClockTime;
2034    #[cfg(feature = "v1_18")]
2035    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2036    pub fn gst_base_sink_get_stats(sink: *mut GstBaseSink) -> *mut gst::GstStructure;
2037    pub fn gst_base_sink_get_sync(sink: *mut GstBaseSink) -> gboolean;
2038    pub fn gst_base_sink_get_throttle_time(sink: *mut GstBaseSink) -> u64;
2039    pub fn gst_base_sink_get_ts_offset(sink: *mut GstBaseSink) -> gst::GstClockTimeDiff;
2040    pub fn gst_base_sink_is_async_enabled(sink: *mut GstBaseSink) -> gboolean;
2041    pub fn gst_base_sink_is_last_sample_enabled(sink: *mut GstBaseSink) -> gboolean;
2042    pub fn gst_base_sink_is_qos_enabled(sink: *mut GstBaseSink) -> gboolean;
2043    pub fn gst_base_sink_query_latency(
2044        sink: *mut GstBaseSink,
2045        live: *mut gboolean,
2046        upstream_live: *mut gboolean,
2047        min_latency: *mut gst::GstClockTime,
2048        max_latency: *mut gst::GstClockTime,
2049    ) -> gboolean;
2050    pub fn gst_base_sink_set_async_enabled(sink: *mut GstBaseSink, enabled: gboolean);
2051    pub fn gst_base_sink_set_blocksize(sink: *mut GstBaseSink, blocksize: c_uint);
2052    pub fn gst_base_sink_set_drop_out_of_segment(
2053        sink: *mut GstBaseSink,
2054        drop_out_of_segment: gboolean,
2055    );
2056    pub fn gst_base_sink_set_last_sample_enabled(sink: *mut GstBaseSink, enabled: gboolean);
2057    pub fn gst_base_sink_set_max_bitrate(sink: *mut GstBaseSink, max_bitrate: u64);
2058    pub fn gst_base_sink_set_max_lateness(sink: *mut GstBaseSink, max_lateness: i64);
2059    #[cfg(feature = "v1_16")]
2060    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2061    pub fn gst_base_sink_set_processing_deadline(
2062        sink: *mut GstBaseSink,
2063        processing_deadline: gst::GstClockTime,
2064    );
2065    pub fn gst_base_sink_set_qos_enabled(sink: *mut GstBaseSink, enabled: gboolean);
2066    pub fn gst_base_sink_set_render_delay(sink: *mut GstBaseSink, delay: gst::GstClockTime);
2067    pub fn gst_base_sink_set_sync(sink: *mut GstBaseSink, sync: gboolean);
2068    pub fn gst_base_sink_set_throttle_time(sink: *mut GstBaseSink, throttle: u64);
2069    pub fn gst_base_sink_set_ts_offset(sink: *mut GstBaseSink, offset: gst::GstClockTimeDiff);
2070    pub fn gst_base_sink_wait(
2071        sink: *mut GstBaseSink,
2072        time: gst::GstClockTime,
2073        jitter: *mut gst::GstClockTimeDiff,
2074    ) -> gst::GstFlowReturn;
2075    pub fn gst_base_sink_wait_clock(
2076        sink: *mut GstBaseSink,
2077        time: gst::GstClockTime,
2078        jitter: *mut gst::GstClockTimeDiff,
2079    ) -> gst::GstClockReturn;
2080    pub fn gst_base_sink_wait_preroll(sink: *mut GstBaseSink) -> gst::GstFlowReturn;
2081
2082    //=========================================================================
2083    // GstBaseSrc
2084    //=========================================================================
2085    pub fn gst_base_src_get_type() -> GType;
2086    pub fn gst_base_src_get_allocator(
2087        src: *mut GstBaseSrc,
2088        allocator: *mut *mut gst::GstAllocator,
2089        params: *mut gst::GstAllocationParams,
2090    );
2091    pub fn gst_base_src_get_blocksize(src: *mut GstBaseSrc) -> c_uint;
2092    pub fn gst_base_src_get_buffer_pool(src: *mut GstBaseSrc) -> *mut gst::GstBufferPool;
2093    pub fn gst_base_src_get_do_timestamp(src: *mut GstBaseSrc) -> gboolean;
2094    pub fn gst_base_src_is_async(src: *mut GstBaseSrc) -> gboolean;
2095    pub fn gst_base_src_is_live(src: *mut GstBaseSrc) -> gboolean;
2096    #[cfg(feature = "v1_18")]
2097    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2098    pub fn gst_base_src_negotiate(src: *mut GstBaseSrc) -> gboolean;
2099    pub fn gst_base_src_new_seamless_segment(
2100        src: *mut GstBaseSrc,
2101        start: i64,
2102        stop: i64,
2103        time: i64,
2104    ) -> gboolean;
2105    #[cfg(feature = "v1_18")]
2106    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2107    pub fn gst_base_src_new_segment(
2108        src: *mut GstBaseSrc,
2109        segment: *const gst::GstSegment,
2110    ) -> gboolean;
2111    #[cfg(feature = "v1_24")]
2112    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2113    pub fn gst_base_src_push_segment(
2114        src: *mut GstBaseSrc,
2115        segment: *const gst::GstSegment,
2116    ) -> gboolean;
2117    pub fn gst_base_src_query_latency(
2118        src: *mut GstBaseSrc,
2119        live: *mut gboolean,
2120        min_latency: *mut gst::GstClockTime,
2121        max_latency: *mut gst::GstClockTime,
2122    ) -> gboolean;
2123    pub fn gst_base_src_set_async(src: *mut GstBaseSrc, async_: gboolean);
2124    pub fn gst_base_src_set_automatic_eos(src: *mut GstBaseSrc, automatic_eos: gboolean);
2125    pub fn gst_base_src_set_blocksize(src: *mut GstBaseSrc, blocksize: c_uint);
2126    pub fn gst_base_src_set_caps(src: *mut GstBaseSrc, caps: *mut gst::GstCaps) -> gboolean;
2127    pub fn gst_base_src_set_do_timestamp(src: *mut GstBaseSrc, timestamp: gboolean);
2128    pub fn gst_base_src_set_dynamic_size(src: *mut GstBaseSrc, dynamic: gboolean);
2129    pub fn gst_base_src_set_format(src: *mut GstBaseSrc, format: gst::GstFormat);
2130    pub fn gst_base_src_set_live(src: *mut GstBaseSrc, live: gboolean);
2131    pub fn gst_base_src_start_complete(basesrc: *mut GstBaseSrc, ret: gst::GstFlowReturn);
2132    pub fn gst_base_src_start_wait(basesrc: *mut GstBaseSrc) -> gst::GstFlowReturn;
2133    pub fn gst_base_src_submit_buffer_list(
2134        src: *mut GstBaseSrc,
2135        buffer_list: *mut gst::GstBufferList,
2136    );
2137    pub fn gst_base_src_wait_playing(src: *mut GstBaseSrc) -> gst::GstFlowReturn;
2138
2139    //=========================================================================
2140    // GstBaseTransform
2141    //=========================================================================
2142    pub fn gst_base_transform_get_type() -> GType;
2143    pub fn gst_base_transform_get_allocator(
2144        trans: *mut GstBaseTransform,
2145        allocator: *mut *mut gst::GstAllocator,
2146        params: *mut gst::GstAllocationParams,
2147    );
2148    pub fn gst_base_transform_get_buffer_pool(
2149        trans: *mut GstBaseTransform,
2150    ) -> *mut gst::GstBufferPool;
2151    pub fn gst_base_transform_is_in_place(trans: *mut GstBaseTransform) -> gboolean;
2152    pub fn gst_base_transform_is_passthrough(trans: *mut GstBaseTransform) -> gboolean;
2153    pub fn gst_base_transform_is_qos_enabled(trans: *mut GstBaseTransform) -> gboolean;
2154    #[cfg(feature = "v1_18")]
2155    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2156    pub fn gst_base_transform_reconfigure(trans: *mut GstBaseTransform) -> gboolean;
2157    pub fn gst_base_transform_reconfigure_sink(trans: *mut GstBaseTransform);
2158    pub fn gst_base_transform_reconfigure_src(trans: *mut GstBaseTransform);
2159    pub fn gst_base_transform_set_gap_aware(trans: *mut GstBaseTransform, gap_aware: gboolean);
2160    pub fn gst_base_transform_set_in_place(trans: *mut GstBaseTransform, in_place: gboolean);
2161    pub fn gst_base_transform_set_passthrough(trans: *mut GstBaseTransform, passthrough: gboolean);
2162    pub fn gst_base_transform_set_prefer_passthrough(
2163        trans: *mut GstBaseTransform,
2164        prefer_passthrough: gboolean,
2165    );
2166    pub fn gst_base_transform_set_qos_enabled(trans: *mut GstBaseTransform, enabled: gboolean);
2167    pub fn gst_base_transform_update_qos(
2168        trans: *mut GstBaseTransform,
2169        proportion: c_double,
2170        diff: gst::GstClockTimeDiff,
2171        timestamp: gst::GstClockTime,
2172    );
2173    pub fn gst_base_transform_update_src_caps(
2174        trans: *mut GstBaseTransform,
2175        updated_caps: *mut gst::GstCaps,
2176    ) -> gboolean;
2177
2178    //=========================================================================
2179    // GstCollectPads
2180    //=========================================================================
2181    pub fn gst_collect_pads_get_type() -> GType;
2182    pub fn gst_collect_pads_new() -> *mut GstCollectPads;
2183    pub fn gst_collect_pads_add_pad(
2184        pads: *mut GstCollectPads,
2185        pad: *mut gst::GstPad,
2186        size: c_uint,
2187        destroy_notify: GstCollectDataDestroyNotify,
2188        lock: gboolean,
2189    ) -> *mut GstCollectData;
2190    pub fn gst_collect_pads_available(pads: *mut GstCollectPads) -> c_uint;
2191    pub fn gst_collect_pads_clip_running_time(
2192        pads: *mut GstCollectPads,
2193        cdata: *mut GstCollectData,
2194        buf: *mut gst::GstBuffer,
2195        outbuf: *mut *mut gst::GstBuffer,
2196        user_data: gpointer,
2197    ) -> gst::GstFlowReturn;
2198    pub fn gst_collect_pads_event_default(
2199        pads: *mut GstCollectPads,
2200        data: *mut GstCollectData,
2201        event: *mut gst::GstEvent,
2202        discard: gboolean,
2203    ) -> gboolean;
2204    pub fn gst_collect_pads_flush(
2205        pads: *mut GstCollectPads,
2206        data: *mut GstCollectData,
2207        size: c_uint,
2208    ) -> c_uint;
2209    pub fn gst_collect_pads_peek(
2210        pads: *mut GstCollectPads,
2211        data: *mut GstCollectData,
2212    ) -> *mut gst::GstBuffer;
2213    pub fn gst_collect_pads_pop(
2214        pads: *mut GstCollectPads,
2215        data: *mut GstCollectData,
2216    ) -> *mut gst::GstBuffer;
2217    pub fn gst_collect_pads_query_default(
2218        pads: *mut GstCollectPads,
2219        data: *mut GstCollectData,
2220        query: *mut gst::GstQuery,
2221        discard: gboolean,
2222    ) -> gboolean;
2223    pub fn gst_collect_pads_read_buffer(
2224        pads: *mut GstCollectPads,
2225        data: *mut GstCollectData,
2226        size: c_uint,
2227    ) -> *mut gst::GstBuffer;
2228    pub fn gst_collect_pads_remove_pad(
2229        pads: *mut GstCollectPads,
2230        pad: *mut gst::GstPad,
2231    ) -> gboolean;
2232    pub fn gst_collect_pads_set_buffer_function(
2233        pads: *mut GstCollectPads,
2234        func: GstCollectPadsBufferFunction,
2235        user_data: gpointer,
2236    );
2237    pub fn gst_collect_pads_set_clip_function(
2238        pads: *mut GstCollectPads,
2239        clipfunc: GstCollectPadsClipFunction,
2240        user_data: gpointer,
2241    );
2242    pub fn gst_collect_pads_set_compare_function(
2243        pads: *mut GstCollectPads,
2244        func: GstCollectPadsCompareFunction,
2245        user_data: gpointer,
2246    );
2247    pub fn gst_collect_pads_set_event_function(
2248        pads: *mut GstCollectPads,
2249        func: GstCollectPadsEventFunction,
2250        user_data: gpointer,
2251    );
2252    pub fn gst_collect_pads_set_flush_function(
2253        pads: *mut GstCollectPads,
2254        func: GstCollectPadsFlushFunction,
2255        user_data: gpointer,
2256    );
2257    pub fn gst_collect_pads_set_flushing(pads: *mut GstCollectPads, flushing: gboolean);
2258    pub fn gst_collect_pads_set_function(
2259        pads: *mut GstCollectPads,
2260        func: GstCollectPadsFunction,
2261        user_data: gpointer,
2262    );
2263    pub fn gst_collect_pads_set_query_function(
2264        pads: *mut GstCollectPads,
2265        func: GstCollectPadsQueryFunction,
2266        user_data: gpointer,
2267    );
2268    pub fn gst_collect_pads_set_waiting(
2269        pads: *mut GstCollectPads,
2270        data: *mut GstCollectData,
2271        waiting: gboolean,
2272    );
2273    pub fn gst_collect_pads_src_event_default(
2274        pads: *mut GstCollectPads,
2275        pad: *mut gst::GstPad,
2276        event: *mut gst::GstEvent,
2277    ) -> gboolean;
2278    pub fn gst_collect_pads_start(pads: *mut GstCollectPads);
2279    pub fn gst_collect_pads_stop(pads: *mut GstCollectPads);
2280    pub fn gst_collect_pads_take_buffer(
2281        pads: *mut GstCollectPads,
2282        data: *mut GstCollectData,
2283        size: c_uint,
2284    ) -> *mut gst::GstBuffer;
2285
2286    //=========================================================================
2287    // GstDataQueue
2288    //=========================================================================
2289    pub fn gst_data_queue_get_type() -> GType;
2290    pub fn gst_data_queue_new(
2291        checkfull: GstDataQueueCheckFullFunction,
2292        fullcallback: GstDataQueueFullCallback,
2293        emptycallback: GstDataQueueEmptyCallback,
2294        checkdata: gpointer,
2295    ) -> *mut GstDataQueue;
2296    pub fn gst_data_queue_drop_head(queue: *mut GstDataQueue, type_: GType) -> gboolean;
2297    pub fn gst_data_queue_flush(queue: *mut GstDataQueue);
2298    pub fn gst_data_queue_get_level(queue: *mut GstDataQueue, level: *mut GstDataQueueSize);
2299    pub fn gst_data_queue_is_empty(queue: *mut GstDataQueue) -> gboolean;
2300    pub fn gst_data_queue_is_full(queue: *mut GstDataQueue) -> gboolean;
2301    pub fn gst_data_queue_limits_changed(queue: *mut GstDataQueue);
2302    pub fn gst_data_queue_peek(
2303        queue: *mut GstDataQueue,
2304        item: *mut *mut GstDataQueueItem,
2305    ) -> gboolean;
2306    pub fn gst_data_queue_pop(
2307        queue: *mut GstDataQueue,
2308        item: *mut *mut GstDataQueueItem,
2309    ) -> gboolean;
2310    pub fn gst_data_queue_push(queue: *mut GstDataQueue, item: *mut GstDataQueueItem) -> gboolean;
2311    pub fn gst_data_queue_push_force(
2312        queue: *mut GstDataQueue,
2313        item: *mut GstDataQueueItem,
2314    ) -> gboolean;
2315    pub fn gst_data_queue_set_flushing(queue: *mut GstDataQueue, flushing: gboolean);
2316
2317    //=========================================================================
2318    // GstPushSrc
2319    //=========================================================================
2320    pub fn gst_push_src_get_type() -> GType;
2321
2322    //=========================================================================
2323    // Other functions
2324    //=========================================================================
2325    pub fn gst_type_find_helper(src: *mut gst::GstPad, size: u64) -> *mut gst::GstCaps;
2326    pub fn gst_type_find_helper_for_buffer(
2327        obj: *mut gst::GstObject,
2328        buf: *mut gst::GstBuffer,
2329        prob: *mut gst::GstTypeFindProbability,
2330    ) -> *mut gst::GstCaps;
2331    #[cfg(feature = "v1_22")]
2332    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
2333    pub fn gst_type_find_helper_for_buffer_with_caps(
2334        obj: *mut gst::GstObject,
2335        buf: *mut gst::GstBuffer,
2336        caps: *mut gst::GstCaps,
2337        prob: *mut gst::GstTypeFindProbability,
2338    ) -> *mut gst::GstCaps;
2339    #[cfg(feature = "v1_16")]
2340    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2341    pub fn gst_type_find_helper_for_buffer_with_extension(
2342        obj: *mut gst::GstObject,
2343        buf: *mut gst::GstBuffer,
2344        extension: *const c_char,
2345        prob: *mut gst::GstTypeFindProbability,
2346    ) -> *mut gst::GstCaps;
2347    pub fn gst_type_find_helper_for_data(
2348        obj: *mut gst::GstObject,
2349        data: *const u8,
2350        size: size_t,
2351        prob: *mut gst::GstTypeFindProbability,
2352    ) -> *mut gst::GstCaps;
2353    #[cfg(feature = "v1_22")]
2354    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
2355    pub fn gst_type_find_helper_for_data_with_caps(
2356        obj: *mut gst::GstObject,
2357        data: *const u8,
2358        size: size_t,
2359        caps: *mut gst::GstCaps,
2360        prob: *mut gst::GstTypeFindProbability,
2361    ) -> *mut gst::GstCaps;
2362    #[cfg(feature = "v1_16")]
2363    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2364    pub fn gst_type_find_helper_for_data_with_extension(
2365        obj: *mut gst::GstObject,
2366        data: *const u8,
2367        size: size_t,
2368        extension: *const c_char,
2369        prob: *mut gst::GstTypeFindProbability,
2370    ) -> *mut gst::GstCaps;
2371    pub fn gst_type_find_helper_for_extension(
2372        obj: *mut gst::GstObject,
2373        extension: *const c_char,
2374    ) -> *mut gst::GstCaps;
2375    pub fn gst_type_find_helper_get_range(
2376        obj: *mut gst::GstObject,
2377        parent: *mut gst::GstObject,
2378        func: GstTypeFindHelperGetRangeFunction,
2379        size: u64,
2380        extension: *const c_char,
2381        prob: *mut gst::GstTypeFindProbability,
2382    ) -> *mut gst::GstCaps;
2383    #[cfg(feature = "v1_14_3")]
2384    #[cfg_attr(docsrs, doc(cfg(feature = "v1_14_3")))]
2385    pub fn gst_type_find_helper_get_range_full(
2386        obj: *mut gst::GstObject,
2387        parent: *mut gst::GstObject,
2388        func: GstTypeFindHelperGetRangeFunction,
2389        size: u64,
2390        extension: *const c_char,
2391        caps: *mut *mut gst::GstCaps,
2392        prob: *mut gst::GstTypeFindProbability,
2393    ) -> gst::GstFlowReturn;
2394    #[cfg(feature = "v1_22")]
2395    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
2396    pub fn gst_type_find_list_factories_for_caps(
2397        obj: *mut gst::GstObject,
2398        caps: *mut gst::GstCaps,
2399    ) -> *mut glib::GList;
2400
2401}
gstreamer_base_sys/lib.rs

gstreamer_base_sys/
lib.rs
