gstreamer_base_sys/
lib.rs

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

gstreamer_base_sys/
lib.rs
