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