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