1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use glib_sys as glib;
16use gobject_sys as gobject;
17use gstreamer_sys as gst;
18
19#[cfg(unix)]
20#[allow(unused_imports)]
21use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
22#[allow(unused_imports)]
23use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
24#[allow(unused_imports)]
25use std::ffi::{
26 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
27};
28
29#[allow(unused_imports)]
30use glib::{gboolean, gconstpointer, gpointer, GType};
31
32pub type GstInterpolationMode = c_int;
34pub const GST_INTERPOLATION_MODE_NONE: GstInterpolationMode = 0;
35pub const GST_INTERPOLATION_MODE_LINEAR: GstInterpolationMode = 1;
36pub const GST_INTERPOLATION_MODE_CUBIC: GstInterpolationMode = 2;
37pub const GST_INTERPOLATION_MODE_CUBIC_MONOTONIC: GstInterpolationMode = 3;
38
39pub type GstLFOWaveform = c_int;
40pub const GST_LFO_WAVEFORM_SINE: GstLFOWaveform = 0;
41pub const GST_LFO_WAVEFORM_SQUARE: GstLFOWaveform = 1;
42pub const GST_LFO_WAVEFORM_SAW: GstLFOWaveform = 2;
43pub const GST_LFO_WAVEFORM_REVERSE_SAW: GstLFOWaveform = 3;
44pub const GST_LFO_WAVEFORM_TRIANGLE: GstLFOWaveform = 4;
45
46#[derive(Copy, Clone)]
48#[repr(C)]
49pub union GstControlPoint_cache {
50 pub cubic: GstControlPoint_cache_cubic,
51 pub cubic_monotonic: GstControlPoint_cache_cubic_monotonic,
52 pub _gst_reserved: [u8; 64],
53}
54
55impl ::std::fmt::Debug for GstControlPoint_cache {
56 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
57 f.debug_struct(&format!("GstControlPoint_cache @ {self:p}"))
58 .field("cubic", unsafe { &self.cubic })
59 .field("cubic_monotonic", unsafe { &self.cubic_monotonic })
60 .finish()
61 }
62}
63
64#[derive(Copy, Clone)]
65#[repr(C)]
66pub union GstDirectControlBinding_ABI {
67 pub _gst_reserved: [gpointer; 4],
68 pub abi: GstDirectControlBinding_ABI_abi,
69}
70
71impl ::std::fmt::Debug for GstDirectControlBinding_ABI {
72 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
73 f.debug_struct(&format!("GstDirectControlBinding_ABI @ {self:p}"))
74 .field("_gst_reserved", unsafe { &self._gst_reserved })
75 .field("abi", unsafe { &self.abi })
76 .finish()
77 }
78}
79
80pub type GstDirectControlBindingConvertGValue =
82 Option<unsafe extern "C" fn(*mut GstDirectControlBinding, c_double, *mut gobject::GValue)>;
83pub type GstDirectControlBindingConvertValue =
84 Option<unsafe extern "C" fn(*mut GstDirectControlBinding, c_double, gpointer)>;
85
86#[derive(Copy, Clone)]
88#[repr(C)]
89pub struct GstARGBControlBindingClass {
90 pub parent_class: gst::GstControlBindingClass,
91 pub _gst_reserved: [gpointer; 4],
92}
93
94impl ::std::fmt::Debug for GstARGBControlBindingClass {
95 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
96 f.debug_struct(&format!("GstARGBControlBindingClass @ {self:p}"))
97 .field("parent_class", &self.parent_class)
98 .finish()
99 }
100}
101
102#[derive(Copy, Clone)]
103#[repr(C)]
104pub struct GstControlPoint {
105 pub timestamp: gst::GstClockTime,
106 pub value: c_double,
107 pub cache: GstControlPoint_cache,
108}
109
110impl ::std::fmt::Debug for GstControlPoint {
111 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
112 f.debug_struct(&format!("GstControlPoint @ {self:p}"))
113 .field("timestamp", &self.timestamp)
114 .field("value", &self.value)
115 .field("cache", &self.cache)
116 .finish()
117 }
118}
119
120#[derive(Copy, Clone)]
121#[repr(C)]
122pub struct GstControlPoint_cache_cubic {
123 pub h: c_double,
124 pub z: c_double,
125}
126
127impl ::std::fmt::Debug for GstControlPoint_cache_cubic {
128 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
129 f.debug_struct(&format!("GstControlPoint_cache_cubic @ {self:p}"))
130 .field("h", &self.h)
131 .field("z", &self.z)
132 .finish()
133 }
134}
135
136#[derive(Copy, Clone)]
137#[repr(C)]
138pub struct GstControlPoint_cache_cubic_monotonic {
139 pub c1s: c_double,
140 pub c2s: c_double,
141 pub c3s: c_double,
142}
143
144impl ::std::fmt::Debug for GstControlPoint_cache_cubic_monotonic {
145 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
146 f.debug_struct(&format!("GstControlPoint_cache_cubic_monotonic @ {self:p}"))
147 .field("c1s", &self.c1s)
148 .field("c2s", &self.c2s)
149 .field("c3s", &self.c3s)
150 .finish()
151 }
152}
153
154#[derive(Copy, Clone)]
155#[repr(C)]
156pub struct GstDirectControlBindingClass {
157 pub parent_class: gst::GstControlBindingClass,
158 pub _gst_reserved: [gpointer; 4],
159}
160
161impl ::std::fmt::Debug for GstDirectControlBindingClass {
162 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
163 f.debug_struct(&format!("GstDirectControlBindingClass @ {self:p}"))
164 .field("parent_class", &self.parent_class)
165 .finish()
166 }
167}
168
169#[derive(Copy, Clone)]
170#[repr(C)]
171pub struct GstDirectControlBinding_ABI_abi {
172 pub want_absolute: gboolean,
173}
174
175impl ::std::fmt::Debug for GstDirectControlBinding_ABI_abi {
176 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
177 f.debug_struct(&format!("GstDirectControlBinding_ABI_abi @ {self:p}"))
178 .field("want_absolute", &self.want_absolute)
179 .finish()
180 }
181}
182
183#[derive(Copy, Clone)]
184#[repr(C)]
185pub struct GstInterpolationControlSourceClass {
186 pub parent_class: GstTimedValueControlSourceClass,
187 pub _gst_reserved: [gpointer; 4],
188}
189
190impl ::std::fmt::Debug for GstInterpolationControlSourceClass {
191 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
192 f.debug_struct(&format!("GstInterpolationControlSourceClass @ {self:p}"))
193 .field("parent_class", &self.parent_class)
194 .finish()
195 }
196}
197
198#[repr(C)]
199#[allow(dead_code)]
200pub struct _GstInterpolationControlSourcePrivate {
201 _data: [u8; 0],
202 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
203}
204
205pub type GstInterpolationControlSourcePrivate = _GstInterpolationControlSourcePrivate;
206
207#[derive(Copy, Clone)]
208#[repr(C)]
209pub struct GstLFOControlSourceClass {
210 pub parent_class: gst::GstControlSourceClass,
211 pub _gst_reserved: [gpointer; 4],
212}
213
214impl ::std::fmt::Debug for GstLFOControlSourceClass {
215 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
216 f.debug_struct(&format!("GstLFOControlSourceClass @ {self:p}"))
217 .field("parent_class", &self.parent_class)
218 .finish()
219 }
220}
221
222#[repr(C)]
223#[allow(dead_code)]
224pub struct _GstLFOControlSourcePrivate {
225 _data: [u8; 0],
226 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
227}
228
229pub type GstLFOControlSourcePrivate = _GstLFOControlSourcePrivate;
230
231#[derive(Copy, Clone)]
232#[repr(C)]
233pub struct GstProxyControlBindingClass {
234 pub parent_class: gst::GstControlBindingClass,
235 pub _padding: [gpointer; 4],
236}
237
238impl ::std::fmt::Debug for GstProxyControlBindingClass {
239 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
240 f.debug_struct(&format!("GstProxyControlBindingClass @ {self:p}"))
241 .finish()
242 }
243}
244
245#[derive(Copy, Clone)]
246#[repr(C)]
247pub struct GstTimedValueControlSourceClass {
248 pub parent_class: gst::GstControlSourceClass,
249 pub _gst_reserved: [gpointer; 4],
250}
251
252impl ::std::fmt::Debug for GstTimedValueControlSourceClass {
253 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
254 f.debug_struct(&format!("GstTimedValueControlSourceClass @ {self:p}"))
255 .field("parent_class", &self.parent_class)
256 .finish()
257 }
258}
259
260#[repr(C)]
261#[allow(dead_code)]
262pub struct _GstTimedValueControlSourcePrivate {
263 _data: [u8; 0],
264 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
265}
266
267pub type GstTimedValueControlSourcePrivate = _GstTimedValueControlSourcePrivate;
268
269#[derive(Copy, Clone)]
270#[repr(C)]
271pub struct GstTriggerControlSourceClass {
272 pub parent_class: GstTimedValueControlSourceClass,
273 pub _gst_reserved: [gpointer; 4],
274}
275
276impl ::std::fmt::Debug for GstTriggerControlSourceClass {
277 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
278 f.debug_struct(&format!("GstTriggerControlSourceClass @ {self:p}"))
279 .field("parent_class", &self.parent_class)
280 .finish()
281 }
282}
283
284#[repr(C)]
285#[allow(dead_code)]
286pub struct _GstTriggerControlSourcePrivate {
287 _data: [u8; 0],
288 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
289}
290
291pub type GstTriggerControlSourcePrivate = _GstTriggerControlSourcePrivate;
292
293#[derive(Copy, Clone)]
295#[repr(C)]
296pub struct GstARGBControlBinding {
297 pub parent: gst::GstControlBinding,
298 pub cs_a: *mut gst::GstControlSource,
299 pub cs_r: *mut gst::GstControlSource,
300 pub cs_g: *mut gst::GstControlSource,
301 pub cs_b: *mut gst::GstControlSource,
302 pub cur_value: gobject::GValue,
303 pub last_value: u32,
304 pub _gst_reserved: [gpointer; 4],
305}
306
307impl ::std::fmt::Debug for GstARGBControlBinding {
308 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
309 f.debug_struct(&format!("GstARGBControlBinding @ {self:p}"))
310 .field("parent", &self.parent)
311 .finish()
312 }
313}
314
315#[derive(Copy, Clone)]
316#[repr(C)]
317pub struct GstDirectControlBinding {
318 pub parent: gst::GstControlBinding,
319 pub cs: *mut gst::GstControlSource,
320 pub cur_value: gobject::GValue,
321 pub last_value: c_double,
322 pub byte_size: c_int,
323 pub convert_value: GstDirectControlBindingConvertValue,
324 pub convert_g_value: GstDirectControlBindingConvertGValue,
325 pub ABI: GstDirectControlBinding_ABI,
326}
327
328impl ::std::fmt::Debug for GstDirectControlBinding {
329 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
330 f.debug_struct(&format!("GstDirectControlBinding @ {self:p}"))
331 .field("parent", &self.parent)
332 .field("ABI", &self.ABI)
333 .finish()
334 }
335}
336
337#[derive(Copy, Clone)]
338#[repr(C)]
339pub struct GstInterpolationControlSource {
340 pub parent: GstTimedValueControlSource,
341 pub priv_: *mut GstInterpolationControlSourcePrivate,
342 pub _gst_reserved: [gpointer; 4],
343}
344
345impl ::std::fmt::Debug for GstInterpolationControlSource {
346 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
347 f.debug_struct(&format!("GstInterpolationControlSource @ {self:p}"))
348 .field("parent", &self.parent)
349 .finish()
350 }
351}
352
353#[derive(Copy, Clone)]
354#[repr(C)]
355pub struct GstLFOControlSource {
356 pub parent: gst::GstControlSource,
357 pub priv_: *mut GstLFOControlSourcePrivate,
358 pub lock: glib::GMutex,
359 pub _gst_reserved: [gpointer; 4],
360}
361
362impl ::std::fmt::Debug for GstLFOControlSource {
363 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
364 f.debug_struct(&format!("GstLFOControlSource @ {self:p}"))
365 .field("parent", &self.parent)
366 .finish()
367 }
368}
369
370#[derive(Copy, Clone)]
371#[repr(C)]
372pub struct GstProxyControlBinding {
373 pub parent: gst::GstControlBinding,
374 pub ref_object: gobject::GWeakRef,
375 pub property_name: *mut c_char,
376 pub _padding: [gpointer; 4],
377}
378
379impl ::std::fmt::Debug for GstProxyControlBinding {
380 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
381 f.debug_struct(&format!("GstProxyControlBinding @ {self:p}"))
382 .finish()
383 }
384}
385
386#[derive(Copy, Clone)]
387#[repr(C)]
388pub struct GstTimedValueControlSource {
389 pub parent: gst::GstControlSource,
390 pub lock: glib::GMutex,
391 pub values: *mut glib::GSequence,
392 pub nvalues: c_int,
393 pub valid_cache: gboolean,
394 pub priv_: *mut GstTimedValueControlSourcePrivate,
395 pub _gst_reserved: [gpointer; 4],
396}
397
398impl ::std::fmt::Debug for GstTimedValueControlSource {
399 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
400 f.debug_struct(&format!("GstTimedValueControlSource @ {self:p}"))
401 .field("parent", &self.parent)
402 .field("lock", &self.lock)
403 .field("values", &self.values)
404 .field("nvalues", &self.nvalues)
405 .field("valid_cache", &self.valid_cache)
406 .finish()
407 }
408}
409
410#[derive(Copy, Clone)]
411#[repr(C)]
412pub struct GstTriggerControlSource {
413 pub parent: GstTimedValueControlSource,
414 pub priv_: *mut GstTriggerControlSourcePrivate,
415 pub _gst_reserved: [gpointer; 4],
416}
417
418impl ::std::fmt::Debug for GstTriggerControlSource {
419 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
420 f.debug_struct(&format!("GstTriggerControlSource @ {self:p}"))
421 .field("parent", &self.parent)
422 .finish()
423 }
424}
425
426extern "C" {
427
428 pub fn gst_interpolation_mode_get_type() -> GType;
432
433 pub fn gst_lfo_waveform_get_type() -> GType;
437
438 pub fn gst_control_point_get_type() -> GType;
442 pub fn gst_control_point_copy(cp: *mut GstControlPoint) -> *mut GstControlPoint;
443 pub fn gst_control_point_free(cp: *mut GstControlPoint);
444
445 pub fn gst_argb_control_binding_get_type() -> GType;
449 pub fn gst_argb_control_binding_new(
450 object: *mut gst::GstObject,
451 property_name: *const c_char,
452 cs_a: *mut gst::GstControlSource,
453 cs_r: *mut gst::GstControlSource,
454 cs_g: *mut gst::GstControlSource,
455 cs_b: *mut gst::GstControlSource,
456 ) -> *mut gst::GstControlBinding;
457
458 pub fn gst_direct_control_binding_get_type() -> GType;
462 pub fn gst_direct_control_binding_new(
463 object: *mut gst::GstObject,
464 property_name: *const c_char,
465 cs: *mut gst::GstControlSource,
466 ) -> *mut gst::GstControlBinding;
467 pub fn gst_direct_control_binding_new_absolute(
468 object: *mut gst::GstObject,
469 property_name: *const c_char,
470 cs: *mut gst::GstControlSource,
471 ) -> *mut gst::GstControlBinding;
472
473 pub fn gst_interpolation_control_source_get_type() -> GType;
477 pub fn gst_interpolation_control_source_new() -> *mut gst::GstControlSource;
478
479 pub fn gst_lfo_control_source_get_type() -> GType;
483 pub fn gst_lfo_control_source_new() -> *mut gst::GstControlSource;
484
485 pub fn gst_proxy_control_binding_get_type() -> GType;
489 pub fn gst_proxy_control_binding_new(
490 object: *mut gst::GstObject,
491 property_name: *const c_char,
492 ref_object: *mut gst::GstObject,
493 ref_property_name: *const c_char,
494 ) -> *mut gst::GstControlBinding;
495
496 pub fn gst_timed_value_control_source_get_type() -> GType;
500 pub fn gst_timed_value_control_source_find_control_point_iter(
501 self_: *mut GstTimedValueControlSource,
502 timestamp: gst::GstClockTime,
503 ) -> *mut glib::GSequenceIter;
504 pub fn gst_timed_value_control_source_get_all(
505 self_: *mut GstTimedValueControlSource,
506 ) -> *mut glib::GList;
507 pub fn gst_timed_value_control_source_get_count(
508 self_: *mut GstTimedValueControlSource,
509 ) -> c_int;
510 pub fn gst_timed_value_control_source_set(
511 self_: *mut GstTimedValueControlSource,
512 timestamp: gst::GstClockTime,
513 value: c_double,
514 ) -> gboolean;
515 pub fn gst_timed_value_control_source_set_from_list(
516 self_: *mut GstTimedValueControlSource,
517 timedvalues: *const glib::GSList,
518 ) -> gboolean;
519 pub fn gst_timed_value_control_source_unset(
520 self_: *mut GstTimedValueControlSource,
521 timestamp: gst::GstClockTime,
522 ) -> gboolean;
523 pub fn gst_timed_value_control_source_unset_all(self_: *mut GstTimedValueControlSource);
524
525 pub fn gst_trigger_control_source_get_type() -> GType;
529 pub fn gst_trigger_control_source_new() -> *mut gst::GstControlSource;
530
531 pub fn gst_timed_value_control_invalidate_cache(self_: *mut GstTimedValueControlSource);
535
536}