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