1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
8#![allow(
9 clippy::approx_constant,
10 clippy::type_complexity,
11 clippy::unreadable_literal,
12 clippy::upper_case_acronyms
13)]
14#![cfg_attr(docsrs, feature(doc_cfg))]
15
16use gio_sys as gio;
17use glib_sys as glib;
18use gobject_sys as gobject;
19use gstreamer_sys as gst;
20
21#[cfg(unix)]
22#[allow(unused_imports)]
23use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
24#[allow(unused_imports)]
25use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
26#[allow(unused_imports)]
27use std::ffi::{
28 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
29};
30
31#[allow(unused_imports)]
32use glib::{gboolean, gconstpointer, gpointer, GType};
33
34pub type ClapperDiscovererDiscoveryMode = c_int;
36pub const CLAPPER_DISCOVERER_DISCOVERY_ALWAYS: ClapperDiscovererDiscoveryMode = 0;
37pub const CLAPPER_DISCOVERER_DISCOVERY_NONCURRENT: ClapperDiscovererDiscoveryMode = 1;
38
39pub type ClapperMarkerType = c_int;
40pub const CLAPPER_MARKER_TYPE_UNKNOWN: ClapperMarkerType = 0;
41pub const CLAPPER_MARKER_TYPE_TITLE: ClapperMarkerType = 1;
42pub const CLAPPER_MARKER_TYPE_CHAPTER: ClapperMarkerType = 2;
43pub const CLAPPER_MARKER_TYPE_TRACK: ClapperMarkerType = 3;
44pub const CLAPPER_MARKER_TYPE_CUSTOM_1: ClapperMarkerType = 101;
45pub const CLAPPER_MARKER_TYPE_CUSTOM_2: ClapperMarkerType = 102;
46pub const CLAPPER_MARKER_TYPE_CUSTOM_3: ClapperMarkerType = 103;
47
48pub type ClapperPlayerMessageDestination = c_int;
49pub const CLAPPER_PLAYER_MESSAGE_DESTINATION_PLAYER: ClapperPlayerMessageDestination = 0;
50pub const CLAPPER_PLAYER_MESSAGE_DESTINATION_REACTABLES: ClapperPlayerMessageDestination = 1;
51pub const CLAPPER_PLAYER_MESSAGE_DESTINATION_APPLICATION: ClapperPlayerMessageDestination = 2;
52
53pub type ClapperPlayerSeekMethod = c_int;
54pub const CLAPPER_PLAYER_SEEK_METHOD_ACCURATE: ClapperPlayerSeekMethod = 0;
55pub const CLAPPER_PLAYER_SEEK_METHOD_NORMAL: ClapperPlayerSeekMethod = 1;
56pub const CLAPPER_PLAYER_SEEK_METHOD_FAST: ClapperPlayerSeekMethod = 2;
57
58pub type ClapperPlayerState = c_int;
59pub const CLAPPER_PLAYER_STATE_STOPPED: ClapperPlayerState = 0;
60pub const CLAPPER_PLAYER_STATE_BUFFERING: ClapperPlayerState = 1;
61pub const CLAPPER_PLAYER_STATE_PAUSED: ClapperPlayerState = 2;
62pub const CLAPPER_PLAYER_STATE_PLAYING: ClapperPlayerState = 3;
63
64pub type ClapperQueueProgressionMode = c_int;
65pub const CLAPPER_QUEUE_PROGRESSION_NONE: ClapperQueueProgressionMode = 0;
66pub const CLAPPER_QUEUE_PROGRESSION_CONSECUTIVE: ClapperQueueProgressionMode = 1;
67pub const CLAPPER_QUEUE_PROGRESSION_REPEAT_ITEM: ClapperQueueProgressionMode = 2;
68pub const CLAPPER_QUEUE_PROGRESSION_CAROUSEL: ClapperQueueProgressionMode = 3;
69pub const CLAPPER_QUEUE_PROGRESSION_SHUFFLE: ClapperQueueProgressionMode = 4;
70
71pub type ClapperStreamType = c_int;
72pub const CLAPPER_STREAM_TYPE_UNKNOWN: ClapperStreamType = 0;
73pub const CLAPPER_STREAM_TYPE_VIDEO: ClapperStreamType = 1;
74pub const CLAPPER_STREAM_TYPE_AUDIO: ClapperStreamType = 2;
75pub const CLAPPER_STREAM_TYPE_SUBTITLE: ClapperStreamType = 3;
76
77pub const CLAPPER_HAVE_DISCOVERER: gboolean = glib::GTRUE;
79pub const CLAPPER_HAVE_MPRIS: gboolean = glib::GTRUE;
80pub const CLAPPER_HAVE_SERVER: gboolean = glib::GTRUE;
81pub const CLAPPER_MAJOR_VERSION: c_int = 0;
82pub const CLAPPER_MARKER_NO_END: c_double = -1.0;
83pub const CLAPPER_MICRO_VERSION: c_int = 0;
84pub const CLAPPER_MINOR_VERSION: c_int = 10;
85pub const CLAPPER_QUEUE_INVALID_POSITION: c_uint = 4294967295;
86pub const CLAPPER_STREAM_LIST_INVALID_POSITION: c_uint = 4294967295;
87pub const CLAPPER_TIME_FORMAT: &[u8] = b"02u:%02u:%02u\0";
88pub const CLAPPER_TIME_MS_FORMAT: &[u8] = b"02u:%02u:%02u.%03u\0";
89pub const CLAPPER_VERSION_S: &[u8] = b"0.10.0\0";
90pub const CLAPPER_WITH_ENHANCERS_LOADER: gboolean = glib::GTRUE;
91
92pub type ClapperEnhancerParamFlags = c_uint;
94pub const CLAPPER_ENHANCER_PARAM_GLOBAL: ClapperEnhancerParamFlags = 131072;
95pub const CLAPPER_ENHANCER_PARAM_LOCAL: ClapperEnhancerParamFlags = 262144;
96pub const CLAPPER_ENHANCER_PARAM_FILEPATH: ClapperEnhancerParamFlags = 524288;
97pub const CLAPPER_ENHANCER_PARAM_DIRPATH: ClapperEnhancerParamFlags = 1048576;
98
99pub type ClapperReactableItemUpdatedFlags = c_uint;
100pub const CLAPPER_REACTABLE_ITEM_UPDATED_TITLE: ClapperReactableItemUpdatedFlags = 1;
101pub const CLAPPER_REACTABLE_ITEM_UPDATED_DURATION: ClapperReactableItemUpdatedFlags = 2;
102pub const CLAPPER_REACTABLE_ITEM_UPDATED_TIMELINE: ClapperReactableItemUpdatedFlags = 4;
103pub const CLAPPER_REACTABLE_ITEM_UPDATED_TAGS: ClapperReactableItemUpdatedFlags = 8;
104pub const CLAPPER_REACTABLE_ITEM_UPDATED_REDIRECT_URI: ClapperReactableItemUpdatedFlags = 16;
105pub const CLAPPER_REACTABLE_ITEM_UPDATED_CACHE_LOCATION: ClapperReactableItemUpdatedFlags = 32;
106
107#[derive(Copy, Clone)]
109#[repr(C)]
110pub struct ClapperAudioStreamClass {
111 pub parent_class: ClapperStreamClass,
112}
113
114impl ::std::fmt::Debug for ClapperAudioStreamClass {
115 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
116 f.debug_struct(&format!("ClapperAudioStreamClass @ {self:p}"))
117 .field("parent_class", &self.parent_class)
118 .finish()
119 }
120}
121
122#[derive(Copy, Clone)]
123#[repr(C)]
124pub struct ClapperDiscovererClass {
125 pub parent_class: ClapperFeatureClass,
126}
127
128impl ::std::fmt::Debug for ClapperDiscovererClass {
129 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
130 f.debug_struct(&format!("ClapperDiscovererClass @ {self:p}"))
131 .field("parent_class", &self.parent_class)
132 .finish()
133 }
134}
135
136#[derive(Copy, Clone)]
137#[repr(C)]
138pub struct ClapperEnhancerProxyClass {
139 pub parent_class: gst::GstObjectClass,
140}
141
142impl ::std::fmt::Debug for ClapperEnhancerProxyClass {
143 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
144 f.debug_struct(&format!("ClapperEnhancerProxyClass @ {self:p}"))
145 .field("parent_class", &self.parent_class)
146 .finish()
147 }
148}
149
150#[derive(Copy, Clone)]
151#[repr(C)]
152pub struct ClapperEnhancerProxyListClass {
153 pub parent_class: gst::GstObjectClass,
154}
155
156impl ::std::fmt::Debug for ClapperEnhancerProxyListClass {
157 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
158 f.debug_struct(&format!("ClapperEnhancerProxyListClass @ {self:p}"))
159 .field("parent_class", &self.parent_class)
160 .finish()
161 }
162}
163
164#[derive(Copy, Clone)]
165#[repr(C)]
166pub struct ClapperExtractableInterface {
167 pub parent_iface: gobject::GTypeInterface,
168 pub extract: Option<
169 unsafe extern "C" fn(
170 *mut ClapperExtractable,
171 *mut glib::GUri,
172 *mut ClapperHarvest,
173 *mut gio::GCancellable,
174 *mut *mut glib::GError,
175 ) -> gboolean,
176 >,
177 pub padding: [gpointer; 8],
178}
179
180impl ::std::fmt::Debug for ClapperExtractableInterface {
181 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
182 f.debug_struct(&format!("ClapperExtractableInterface @ {self:p}"))
183 .field("parent_iface", &self.parent_iface)
184 .field("extract", &self.extract)
185 .finish()
186 }
187}
188
189#[derive(Copy, Clone)]
190#[repr(C)]
191pub struct ClapperFeatureClass {
192 pub parent_class: gst::GstObjectClass,
193 pub prepare: Option<unsafe extern "C" fn(*mut ClapperFeature) -> gboolean>,
194 pub unprepare: Option<unsafe extern "C" fn(*mut ClapperFeature) -> gboolean>,
195 pub property_changed:
196 Option<unsafe extern "C" fn(*mut ClapperFeature, *mut gobject::GParamSpec)>,
197 pub state_changed: Option<unsafe extern "C" fn(*mut ClapperFeature, ClapperPlayerState)>,
198 pub position_changed: Option<unsafe extern "C" fn(*mut ClapperFeature, c_double)>,
199 pub speed_changed: Option<unsafe extern "C" fn(*mut ClapperFeature, c_double)>,
200 pub volume_changed: Option<unsafe extern "C" fn(*mut ClapperFeature, c_double)>,
201 pub mute_changed: Option<unsafe extern "C" fn(*mut ClapperFeature, gboolean)>,
202 pub played_item_changed:
203 Option<unsafe extern "C" fn(*mut ClapperFeature, *mut ClapperMediaItem)>,
204 pub item_updated: Option<unsafe extern "C" fn(*mut ClapperFeature, *mut ClapperMediaItem)>,
205 pub queue_item_added:
206 Option<unsafe extern "C" fn(*mut ClapperFeature, *mut ClapperMediaItem, c_uint)>,
207 pub queue_item_removed:
208 Option<unsafe extern "C" fn(*mut ClapperFeature, *mut ClapperMediaItem, c_uint)>,
209 pub queue_item_repositioned: Option<unsafe extern "C" fn(*mut ClapperFeature, c_uint, c_uint)>,
210 pub queue_cleared: Option<unsafe extern "C" fn(*mut ClapperFeature)>,
211 pub queue_progression_changed:
212 Option<unsafe extern "C" fn(*mut ClapperFeature, ClapperQueueProgressionMode)>,
213 pub padding: [gpointer; 8],
214}
215
216impl ::std::fmt::Debug for ClapperFeatureClass {
217 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
218 f.debug_struct(&format!("ClapperFeatureClass @ {self:p}"))
219 .field("parent_class", &self.parent_class)
220 .field("prepare", &self.prepare)
221 .field("unprepare", &self.unprepare)
222 .field("property_changed", &self.property_changed)
223 .field("state_changed", &self.state_changed)
224 .field("position_changed", &self.position_changed)
225 .field("speed_changed", &self.speed_changed)
226 .field("volume_changed", &self.volume_changed)
227 .field("mute_changed", &self.mute_changed)
228 .field("played_item_changed", &self.played_item_changed)
229 .field("item_updated", &self.item_updated)
230 .field("queue_item_added", &self.queue_item_added)
231 .field("queue_item_removed", &self.queue_item_removed)
232 .field("queue_item_repositioned", &self.queue_item_repositioned)
233 .field("queue_cleared", &self.queue_cleared)
234 .field("queue_progression_changed", &self.queue_progression_changed)
235 .finish()
236 }
237}
238
239#[derive(Copy, Clone)]
240#[repr(C)]
241pub struct ClapperHarvestClass {
242 pub parent_class: gst::GstObjectClass,
243}
244
245impl ::std::fmt::Debug for ClapperHarvestClass {
246 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
247 f.debug_struct(&format!("ClapperHarvestClass @ {self:p}"))
248 .field("parent_class", &self.parent_class)
249 .finish()
250 }
251}
252
253#[derive(Copy, Clone)]
254#[repr(C)]
255pub struct ClapperMarkerClass {
256 pub parent_class: gst::GstObjectClass,
257}
258
259impl ::std::fmt::Debug for ClapperMarkerClass {
260 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
261 f.debug_struct(&format!("ClapperMarkerClass @ {self:p}"))
262 .field("parent_class", &self.parent_class)
263 .finish()
264 }
265}
266
267#[derive(Copy, Clone)]
268#[repr(C)]
269pub struct ClapperMediaItemClass {
270 pub parent_class: gst::GstObjectClass,
271}
272
273impl ::std::fmt::Debug for ClapperMediaItemClass {
274 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
275 f.debug_struct(&format!("ClapperMediaItemClass @ {self:p}"))
276 .field("parent_class", &self.parent_class)
277 .finish()
278 }
279}
280
281#[derive(Copy, Clone)]
282#[repr(C)]
283pub struct ClapperMprisClass {
284 pub parent_class: ClapperFeatureClass,
285}
286
287impl ::std::fmt::Debug for ClapperMprisClass {
288 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
289 f.debug_struct(&format!("ClapperMprisClass @ {self:p}"))
290 .field("parent_class", &self.parent_class)
291 .finish()
292 }
293}
294
295#[derive(Copy, Clone)]
296#[repr(C)]
297pub struct ClapperPlayerClass {
298 pub parent_class: ClapperThreadedObjectClass,
299}
300
301impl ::std::fmt::Debug for ClapperPlayerClass {
302 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
303 f.debug_struct(&format!("ClapperPlayerClass @ {self:p}"))
304 .field("parent_class", &self.parent_class)
305 .finish()
306 }
307}
308
309#[derive(Copy, Clone)]
310#[repr(C)]
311pub struct ClapperPlaylistableInterface {
312 pub parent_iface: gobject::GTypeInterface,
313 pub parse: Option<
314 unsafe extern "C" fn(
315 *mut ClapperPlaylistable,
316 *mut glib::GUri,
317 *mut glib::GBytes,
318 *mut gio::GListStore,
319 *mut gio::GCancellable,
320 *mut *mut glib::GError,
321 ) -> gboolean,
322 >,
323 pub padding: [gpointer; 8],
324}
325
326impl ::std::fmt::Debug for ClapperPlaylistableInterface {
327 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
328 f.debug_struct(&format!("ClapperPlaylistableInterface @ {self:p}"))
329 .field("parent_iface", &self.parent_iface)
330 .field("parse", &self.parse)
331 .finish()
332 }
333}
334
335#[derive(Copy, Clone)]
336#[repr(C)]
337pub struct ClapperQueueClass {
338 pub parent_class: gst::GstObjectClass,
339}
340
341impl ::std::fmt::Debug for ClapperQueueClass {
342 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
343 f.debug_struct(&format!("ClapperQueueClass @ {self:p}"))
344 .field("parent_class", &self.parent_class)
345 .finish()
346 }
347}
348
349#[derive(Copy, Clone)]
350#[repr(C)]
351pub struct ClapperReactableInterface {
352 pub parent_iface: gobject::GTypeInterface,
353 pub state_changed: Option<unsafe extern "C" fn(*mut ClapperReactable, ClapperPlayerState)>,
354 pub position_changed: Option<unsafe extern "C" fn(*mut ClapperReactable, c_double)>,
355 pub speed_changed: Option<unsafe extern "C" fn(*mut ClapperReactable, c_double)>,
356 pub volume_changed: Option<unsafe extern "C" fn(*mut ClapperReactable, c_double)>,
357 pub mute_changed: Option<unsafe extern "C" fn(*mut ClapperReactable, gboolean)>,
358 pub played_item_changed:
359 Option<unsafe extern "C" fn(*mut ClapperReactable, *mut ClapperMediaItem)>,
360 pub item_updated: Option<
361 unsafe extern "C" fn(
362 *mut ClapperReactable,
363 *mut ClapperMediaItem,
364 ClapperReactableItemUpdatedFlags,
365 ),
366 >,
367 pub queue_item_added:
368 Option<unsafe extern "C" fn(*mut ClapperReactable, *mut ClapperMediaItem, c_uint)>,
369 pub queue_item_removed:
370 Option<unsafe extern "C" fn(*mut ClapperReactable, *mut ClapperMediaItem, c_uint)>,
371 pub queue_item_repositioned:
372 Option<unsafe extern "C" fn(*mut ClapperReactable, c_uint, c_uint)>,
373 pub queue_cleared: Option<unsafe extern "C" fn(*mut ClapperReactable)>,
374 pub queue_progression_changed:
375 Option<unsafe extern "C" fn(*mut ClapperReactable, ClapperQueueProgressionMode)>,
376 pub message_received: Option<unsafe extern "C" fn(*mut ClapperReactable, *mut gst::GstMessage)>,
377 pub padding: [gpointer; 8],
378}
379
380impl ::std::fmt::Debug for ClapperReactableInterface {
381 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
382 f.debug_struct(&format!("ClapperReactableInterface @ {self:p}"))
383 .field("parent_iface", &self.parent_iface)
384 .field("state_changed", &self.state_changed)
385 .field("position_changed", &self.position_changed)
386 .field("speed_changed", &self.speed_changed)
387 .field("volume_changed", &self.volume_changed)
388 .field("mute_changed", &self.mute_changed)
389 .field("played_item_changed", &self.played_item_changed)
390 .field("item_updated", &self.item_updated)
391 .field("queue_item_added", &self.queue_item_added)
392 .field("queue_item_removed", &self.queue_item_removed)
393 .field("queue_item_repositioned", &self.queue_item_repositioned)
394 .field("queue_cleared", &self.queue_cleared)
395 .field("queue_progression_changed", &self.queue_progression_changed)
396 .field("message_received", &self.message_received)
397 .finish()
398 }
399}
400
401#[derive(Copy, Clone)]
402#[repr(C)]
403pub struct ClapperServerClass {
404 pub parent_class: ClapperFeatureClass,
405}
406
407impl ::std::fmt::Debug for ClapperServerClass {
408 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
409 f.debug_struct(&format!("ClapperServerClass @ {self:p}"))
410 .field("parent_class", &self.parent_class)
411 .finish()
412 }
413}
414
415#[derive(Copy, Clone)]
416#[repr(C)]
417pub struct ClapperStreamClass {
418 pub parent_class: gst::GstObjectClass,
419 pub internal_stream_updated:
420 Option<unsafe extern "C" fn(*mut ClapperStream, *mut gst::GstCaps, *mut gst::GstTagList)>,
421 pub padding: [gpointer; 4],
422}
423
424impl ::std::fmt::Debug for ClapperStreamClass {
425 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
426 f.debug_struct(&format!("ClapperStreamClass @ {self:p}"))
427 .field("parent_class", &self.parent_class)
428 .field("internal_stream_updated", &self.internal_stream_updated)
429 .finish()
430 }
431}
432
433#[derive(Copy, Clone)]
434#[repr(C)]
435pub struct ClapperStreamListClass {
436 pub parent_class: gst::GstObjectClass,
437}
438
439impl ::std::fmt::Debug for ClapperStreamListClass {
440 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
441 f.debug_struct(&format!("ClapperStreamListClass @ {self:p}"))
442 .field("parent_class", &self.parent_class)
443 .finish()
444 }
445}
446
447#[derive(Copy, Clone)]
448#[repr(C)]
449pub struct ClapperSubtitleStreamClass {
450 pub parent_class: ClapperStreamClass,
451}
452
453impl ::std::fmt::Debug for ClapperSubtitleStreamClass {
454 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
455 f.debug_struct(&format!("ClapperSubtitleStreamClass @ {self:p}"))
456 .field("parent_class", &self.parent_class)
457 .finish()
458 }
459}
460
461#[derive(Copy, Clone)]
462#[repr(C)]
463pub struct ClapperThreadedObjectClass {
464 pub parent_class: gst::GstObjectClass,
465 pub thread_start: Option<unsafe extern "C" fn(*mut ClapperThreadedObject)>,
466 pub thread_stop: Option<unsafe extern "C" fn(*mut ClapperThreadedObject)>,
467 pub padding: [gpointer; 4],
468}
469
470impl ::std::fmt::Debug for ClapperThreadedObjectClass {
471 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
472 f.debug_struct(&format!("ClapperThreadedObjectClass @ {self:p}"))
473 .field("parent_class", &self.parent_class)
474 .field("thread_start", &self.thread_start)
475 .field("thread_stop", &self.thread_stop)
476 .finish()
477 }
478}
479
480#[derive(Copy, Clone)]
481#[repr(C)]
482pub struct ClapperTimelineClass {
483 pub parent_class: gst::GstObjectClass,
484}
485
486impl ::std::fmt::Debug for ClapperTimelineClass {
487 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
488 f.debug_struct(&format!("ClapperTimelineClass @ {self:p}"))
489 .field("parent_class", &self.parent_class)
490 .finish()
491 }
492}
493
494#[derive(Copy, Clone)]
495#[repr(C)]
496pub struct ClapperVideoStreamClass {
497 pub parent_class: ClapperStreamClass,
498}
499
500impl ::std::fmt::Debug for ClapperVideoStreamClass {
501 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
502 f.debug_struct(&format!("ClapperVideoStreamClass @ {self:p}"))
503 .field("parent_class", &self.parent_class)
504 .finish()
505 }
506}
507
508#[repr(C)]
510#[allow(dead_code)]
511pub struct ClapperAudioStream {
512 _data: [u8; 0],
513 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
514}
515
516impl ::std::fmt::Debug for ClapperAudioStream {
517 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
518 f.debug_struct(&format!("ClapperAudioStream @ {self:p}"))
519 .finish()
520 }
521}
522
523#[repr(C)]
524#[allow(dead_code)]
525pub struct ClapperDiscoverer {
526 _data: [u8; 0],
527 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
528}
529
530impl ::std::fmt::Debug for ClapperDiscoverer {
531 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
532 f.debug_struct(&format!("ClapperDiscoverer @ {self:p}"))
533 .finish()
534 }
535}
536
537#[repr(C)]
538#[allow(dead_code)]
539pub struct ClapperEnhancerProxy {
540 _data: [u8; 0],
541 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
542}
543
544impl ::std::fmt::Debug for ClapperEnhancerProxy {
545 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
546 f.debug_struct(&format!("ClapperEnhancerProxy @ {self:p}"))
547 .finish()
548 }
549}
550
551#[repr(C)]
552#[allow(dead_code)]
553pub struct ClapperEnhancerProxyList {
554 _data: [u8; 0],
555 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
556}
557
558impl ::std::fmt::Debug for ClapperEnhancerProxyList {
559 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
560 f.debug_struct(&format!("ClapperEnhancerProxyList @ {self:p}"))
561 .finish()
562 }
563}
564
565#[derive(Copy, Clone)]
566#[repr(C)]
567pub struct ClapperFeature {
568 pub parent_instance: gst::GstObject,
569}
570
571impl ::std::fmt::Debug for ClapperFeature {
572 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
573 f.debug_struct(&format!("ClapperFeature @ {self:p}"))
574 .field("parent_instance", &self.parent_instance)
575 .finish()
576 }
577}
578
579#[repr(C)]
580#[allow(dead_code)]
581pub struct ClapperHarvest {
582 _data: [u8; 0],
583 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
584}
585
586impl ::std::fmt::Debug for ClapperHarvest {
587 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
588 f.debug_struct(&format!("ClapperHarvest @ {self:p}"))
589 .finish()
590 }
591}
592
593#[repr(C)]
594#[allow(dead_code)]
595pub struct ClapperMarker {
596 _data: [u8; 0],
597 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
598}
599
600impl ::std::fmt::Debug for ClapperMarker {
601 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
602 f.debug_struct(&format!("ClapperMarker @ {self:p}"))
603 .finish()
604 }
605}
606
607#[repr(C)]
608#[allow(dead_code)]
609pub struct ClapperMediaItem {
610 _data: [u8; 0],
611 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
612}
613
614impl ::std::fmt::Debug for ClapperMediaItem {
615 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
616 f.debug_struct(&format!("ClapperMediaItem @ {self:p}"))
617 .finish()
618 }
619}
620
621#[repr(C)]
622#[allow(dead_code)]
623pub struct ClapperMpris {
624 _data: [u8; 0],
625 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
626}
627
628impl ::std::fmt::Debug for ClapperMpris {
629 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
630 f.debug_struct(&format!("ClapperMpris @ {self:p}")).finish()
631 }
632}
633
634#[repr(C)]
635#[allow(dead_code)]
636pub struct ClapperPlayer {
637 _data: [u8; 0],
638 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
639}
640
641impl ::std::fmt::Debug for ClapperPlayer {
642 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
643 f.debug_struct(&format!("ClapperPlayer @ {self:p}"))
644 .finish()
645 }
646}
647
648#[repr(C)]
649#[allow(dead_code)]
650pub struct ClapperQueue {
651 _data: [u8; 0],
652 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
653}
654
655impl ::std::fmt::Debug for ClapperQueue {
656 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
657 f.debug_struct(&format!("ClapperQueue @ {self:p}")).finish()
658 }
659}
660
661#[repr(C)]
662#[allow(dead_code)]
663pub struct ClapperServer {
664 _data: [u8; 0],
665 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
666}
667
668impl ::std::fmt::Debug for ClapperServer {
669 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
670 f.debug_struct(&format!("ClapperServer @ {self:p}"))
671 .finish()
672 }
673}
674
675#[derive(Copy, Clone)]
676#[repr(C)]
677pub struct ClapperStream {
678 pub parent_instance: gst::GstObject,
679}
680
681impl ::std::fmt::Debug for ClapperStream {
682 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
683 f.debug_struct(&format!("ClapperStream @ {self:p}"))
684 .field("parent_instance", &self.parent_instance)
685 .finish()
686 }
687}
688
689#[repr(C)]
690#[allow(dead_code)]
691pub struct ClapperStreamList {
692 _data: [u8; 0],
693 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
694}
695
696impl ::std::fmt::Debug for ClapperStreamList {
697 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
698 f.debug_struct(&format!("ClapperStreamList @ {self:p}"))
699 .finish()
700 }
701}
702
703#[repr(C)]
704#[allow(dead_code)]
705pub struct ClapperSubtitleStream {
706 _data: [u8; 0],
707 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
708}
709
710impl ::std::fmt::Debug for ClapperSubtitleStream {
711 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
712 f.debug_struct(&format!("ClapperSubtitleStream @ {self:p}"))
713 .finish()
714 }
715}
716
717#[derive(Copy, Clone)]
718#[repr(C)]
719pub struct ClapperThreadedObject {
720 pub parent_instance: gst::GstObject,
721}
722
723impl ::std::fmt::Debug for ClapperThreadedObject {
724 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
725 f.debug_struct(&format!("ClapperThreadedObject @ {self:p}"))
726 .field("parent_instance", &self.parent_instance)
727 .finish()
728 }
729}
730
731#[repr(C)]
732#[allow(dead_code)]
733pub struct ClapperTimeline {
734 _data: [u8; 0],
735 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
736}
737
738impl ::std::fmt::Debug for ClapperTimeline {
739 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
740 f.debug_struct(&format!("ClapperTimeline @ {self:p}"))
741 .finish()
742 }
743}
744
745#[repr(C)]
746#[allow(dead_code)]
747pub struct ClapperVideoStream {
748 _data: [u8; 0],
749 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
750}
751
752impl ::std::fmt::Debug for ClapperVideoStream {
753 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
754 f.debug_struct(&format!("ClapperVideoStream @ {self:p}"))
755 .finish()
756 }
757}
758
759#[repr(C)]
761#[allow(dead_code)]
762pub struct ClapperExtractable {
763 _data: [u8; 0],
764 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
765}
766
767impl ::std::fmt::Debug for ClapperExtractable {
768 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
769 write!(f, "ClapperExtractable @ {self:p}")
770 }
771}
772
773#[repr(C)]
774#[allow(dead_code)]
775pub struct ClapperPlaylistable {
776 _data: [u8; 0],
777 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
778}
779
780impl ::std::fmt::Debug for ClapperPlaylistable {
781 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
782 write!(f, "ClapperPlaylistable @ {self:p}")
783 }
784}
785
786#[repr(C)]
787#[allow(dead_code)]
788pub struct ClapperReactable {
789 _data: [u8; 0],
790 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
791}
792
793impl ::std::fmt::Debug for ClapperReactable {
794 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
795 write!(f, "ClapperReactable @ {self:p}")
796 }
797}
798
799extern "C" {
800
801 pub fn clapper_discoverer_discovery_mode_get_type() -> GType;
805
806 pub fn clapper_marker_type_get_type() -> GType;
810
811 #[cfg(feature = "v0_10")]
815 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
816 pub fn clapper_player_message_destination_get_type() -> GType;
817
818 pub fn clapper_player_seek_method_get_type() -> GType;
822
823 pub fn clapper_player_state_get_type() -> GType;
827
828 pub fn clapper_queue_progression_mode_get_type() -> GType;
832
833 pub fn clapper_stream_type_get_type() -> GType;
837
838 #[cfg(feature = "v0_10")]
842 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
843 pub fn clapper_enhancer_param_flags_get_type() -> GType;
844
845 #[cfg(feature = "v0_10")]
849 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
850 pub fn clapper_reactable_item_updated_flags_get_type() -> GType;
851
852 pub fn clapper_audio_stream_get_type() -> GType;
856 pub fn clapper_audio_stream_get_bitrate(stream: *mut ClapperAudioStream) -> c_uint;
857 pub fn clapper_audio_stream_get_channels(stream: *mut ClapperAudioStream) -> c_int;
858 pub fn clapper_audio_stream_get_codec(stream: *mut ClapperAudioStream) -> *mut c_char;
859 pub fn clapper_audio_stream_get_lang_code(stream: *mut ClapperAudioStream) -> *mut c_char;
860 pub fn clapper_audio_stream_get_lang_name(stream: *mut ClapperAudioStream) -> *mut c_char;
861 pub fn clapper_audio_stream_get_sample_format(stream: *mut ClapperAudioStream) -> *mut c_char;
862 pub fn clapper_audio_stream_get_sample_rate(stream: *mut ClapperAudioStream) -> c_int;
863
864 pub fn clapper_discoverer_get_type() -> GType;
868 pub fn clapper_discoverer_new() -> *mut ClapperDiscoverer;
869 pub fn clapper_discoverer_get_discovery_mode(
870 discoverer: *mut ClapperDiscoverer,
871 ) -> ClapperDiscovererDiscoveryMode;
872 pub fn clapper_discoverer_set_discovery_mode(
873 discoverer: *mut ClapperDiscoverer,
874 mode: ClapperDiscovererDiscoveryMode,
875 );
876
877 #[cfg(feature = "v0_10")]
881 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
882 pub fn clapper_enhancer_proxy_get_type() -> GType;
883 #[cfg(feature = "v0_10")]
884 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
885 pub fn clapper_enhancer_proxy_extra_data_lists_value(
886 proxy: *mut ClapperEnhancerProxy,
887 key: *const c_char,
888 value: *const c_char,
889 ) -> gboolean;
890 #[cfg(feature = "v0_10")]
891 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
892 pub fn clapper_enhancer_proxy_get_description(
893 proxy: *mut ClapperEnhancerProxy,
894 ) -> *const c_char;
895 #[cfg(feature = "v0_10")]
896 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
897 pub fn clapper_enhancer_proxy_get_extra_data(
898 proxy: *mut ClapperEnhancerProxy,
899 key: *const c_char,
900 ) -> *const c_char;
901 #[cfg(feature = "v0_10")]
902 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
903 pub fn clapper_enhancer_proxy_get_friendly_name(
904 proxy: *mut ClapperEnhancerProxy,
905 ) -> *const c_char;
906 #[cfg(feature = "v0_10")]
907 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
908 pub fn clapper_enhancer_proxy_get_module_dir(proxy: *mut ClapperEnhancerProxy)
909 -> *const c_char;
910 #[cfg(feature = "v0_10")]
911 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
912 pub fn clapper_enhancer_proxy_get_module_name(
913 proxy: *mut ClapperEnhancerProxy,
914 ) -> *const c_char;
915 #[cfg(feature = "v0_10")]
916 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
917 pub fn clapper_enhancer_proxy_get_settings(
918 proxy: *mut ClapperEnhancerProxy,
919 ) -> *mut gio::GSettings;
920 #[cfg(feature = "v0_10")]
921 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
922 pub fn clapper_enhancer_proxy_get_target_creation_allowed(
923 proxy: *mut ClapperEnhancerProxy,
924 ) -> gboolean;
925 #[cfg(feature = "v0_10")]
926 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
927 pub fn clapper_enhancer_proxy_get_target_interfaces(
928 proxy: *mut ClapperEnhancerProxy,
929 n_interfaces: *mut c_uint,
930 ) -> *mut GType;
931 #[cfg(feature = "v0_10")]
932 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
933 pub fn clapper_enhancer_proxy_get_target_properties(
934 proxy: *mut ClapperEnhancerProxy,
935 n_properties: *mut c_uint,
936 ) -> *mut *mut gobject::GParamSpec;
937 #[cfg(feature = "v0_10")]
938 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
939 pub fn clapper_enhancer_proxy_get_version(proxy: *mut ClapperEnhancerProxy) -> *const c_char;
940 #[cfg(feature = "v0_10")]
941 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
942 pub fn clapper_enhancer_proxy_set_locally(
943 proxy: *mut ClapperEnhancerProxy,
944 first_property_name: *const c_char,
945 ...
946 );
947 #[cfg(feature = "v0_10")]
948 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
949 pub fn clapper_enhancer_proxy_set_locally_with_table(
950 proxy: *mut ClapperEnhancerProxy,
951 table: *mut glib::GHashTable,
952 );
953 #[cfg(feature = "v0_10")]
954 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
955 pub fn clapper_enhancer_proxy_set_target_creation_allowed(
956 proxy: *mut ClapperEnhancerProxy,
957 allowed: gboolean,
958 );
959 #[cfg(feature = "v0_10")]
960 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
961 pub fn clapper_enhancer_proxy_target_has_interface(
962 proxy: *mut ClapperEnhancerProxy,
963 iface_type: GType,
964 ) -> gboolean;
965
966 #[cfg(feature = "v0_10")]
970 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
971 pub fn clapper_enhancer_proxy_list_get_type() -> GType;
972 #[cfg(feature = "v0_10")]
973 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
974 pub fn clapper_enhancer_proxy_list_get_n_proxies(list: *mut ClapperEnhancerProxyList)
975 -> c_uint;
976 #[cfg(feature = "v0_10")]
977 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
978 pub fn clapper_enhancer_proxy_list_get_proxy(
979 list: *mut ClapperEnhancerProxyList,
980 index: c_uint,
981 ) -> *mut ClapperEnhancerProxy;
982 #[cfg(feature = "v0_10")]
983 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
984 pub fn clapper_enhancer_proxy_list_get_proxy_by_module(
985 list: *mut ClapperEnhancerProxyList,
986 module_name: *const c_char,
987 ) -> *mut ClapperEnhancerProxy;
988 #[cfg(feature = "v0_10")]
989 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
990 pub fn clapper_enhancer_proxy_list_peek_proxy(
991 list: *mut ClapperEnhancerProxyList,
992 index: c_uint,
993 ) -> *mut ClapperEnhancerProxy;
994
995 pub fn clapper_feature_get_type() -> GType;
999
1000 #[cfg(feature = "v0_8")]
1004 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1005 pub fn clapper_harvest_get_type() -> GType;
1006 #[cfg(feature = "v0_8")]
1007 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1008 pub fn clapper_harvest_fill(
1009 harvest: *mut ClapperHarvest,
1010 media_type: *const c_char,
1011 data: gpointer,
1012 size: size_t,
1013 ) -> gboolean;
1014 #[cfg(feature = "v0_8")]
1015 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1016 pub fn clapper_harvest_fill_with_bytes(
1017 harvest: *mut ClapperHarvest,
1018 media_type: *const c_char,
1019 bytes: *mut glib::GBytes,
1020 ) -> gboolean;
1021 #[cfg(feature = "v0_8")]
1022 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1023 pub fn clapper_harvest_fill_with_text(
1024 harvest: *mut ClapperHarvest,
1025 media_type: *const c_char,
1026 text: *mut c_char,
1027 ) -> gboolean;
1028 #[cfg(feature = "v0_8")]
1029 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1030 pub fn clapper_harvest_headers_set(harvest: *mut ClapperHarvest, key: *const c_char, ...);
1031 #[cfg(feature = "v0_8")]
1032 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1033 pub fn clapper_harvest_headers_set_value(
1034 harvest: *mut ClapperHarvest,
1035 key: *const c_char,
1036 value: *const gobject::GValue,
1037 );
1038 #[cfg(feature = "v0_10")]
1039 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1040 pub fn clapper_harvest_set_expiration_date_utc(
1041 harvest: *mut ClapperHarvest,
1042 date_utc: *mut glib::GDateTime,
1043 );
1044 #[cfg(feature = "v0_10")]
1045 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1046 pub fn clapper_harvest_set_expiration_seconds(harvest: *mut ClapperHarvest, seconds: c_double);
1047 #[cfg(feature = "v0_8")]
1048 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1049 pub fn clapper_harvest_tags_add(harvest: *mut ClapperHarvest, tag: *const c_char, ...);
1050 #[cfg(feature = "v0_8")]
1051 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1052 pub fn clapper_harvest_tags_add_value(
1053 harvest: *mut ClapperHarvest,
1054 tag: *const c_char,
1055 value: *const gobject::GValue,
1056 );
1057 #[cfg(feature = "v0_8")]
1058 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1059 pub fn clapper_harvest_toc_add(
1060 harvest: *mut ClapperHarvest,
1061 type_: gst::GstTocEntryType,
1062 title: *const c_char,
1063 start: c_double,
1064 end: c_double,
1065 );
1066
1067 pub fn clapper_marker_get_type() -> GType;
1071 pub fn clapper_marker_new(
1072 marker_type: ClapperMarkerType,
1073 title: *const c_char,
1074 start: c_double,
1075 end: c_double,
1076 ) -> *mut ClapperMarker;
1077 pub fn clapper_marker_get_end(marker: *mut ClapperMarker) -> c_double;
1078 pub fn clapper_marker_get_marker_type(marker: *mut ClapperMarker) -> ClapperMarkerType;
1079 pub fn clapper_marker_get_start(marker: *mut ClapperMarker) -> c_double;
1080 pub fn clapper_marker_get_title(marker: *mut ClapperMarker) -> *const c_char;
1081
1082 pub fn clapper_media_item_get_type() -> GType;
1086 pub fn clapper_media_item_new(uri: *const c_char) -> *mut ClapperMediaItem;
1087 #[cfg(feature = "v0_8")]
1088 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1089 pub fn clapper_media_item_new_cached(
1090 uri: *const c_char,
1091 location: *const c_char,
1092 ) -> *mut ClapperMediaItem;
1093 pub fn clapper_media_item_new_from_file(file: *mut gio::GFile) -> *mut ClapperMediaItem;
1094 #[cfg(feature = "v0_10")]
1095 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1096 pub fn clapper_media_item_get_cache_location(item: *mut ClapperMediaItem) -> *mut c_char;
1097 pub fn clapper_media_item_get_container_format(item: *mut ClapperMediaItem) -> *mut c_char;
1098 pub fn clapper_media_item_get_duration(item: *mut ClapperMediaItem) -> c_double;
1099 pub fn clapper_media_item_get_id(item: *mut ClapperMediaItem) -> c_uint;
1100 #[cfg(feature = "v0_10")]
1101 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1102 pub fn clapper_media_item_get_redirect_uri(item: *mut ClapperMediaItem) -> *mut c_char;
1103 pub fn clapper_media_item_get_suburi(item: *mut ClapperMediaItem) -> *mut c_char;
1104 #[cfg(feature = "v0_10")]
1105 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1106 pub fn clapper_media_item_get_tags(item: *mut ClapperMediaItem) -> *mut gst::GstTagList;
1107 pub fn clapper_media_item_get_timeline(item: *mut ClapperMediaItem) -> *mut ClapperTimeline;
1108 pub fn clapper_media_item_get_title(item: *mut ClapperMediaItem) -> *mut c_char;
1109 pub fn clapper_media_item_get_uri(item: *mut ClapperMediaItem) -> *const c_char;
1110 #[cfg(feature = "v0_10")]
1111 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1112 pub fn clapper_media_item_populate_tags(
1113 item: *mut ClapperMediaItem,
1114 tags: *const gst::GstTagList,
1115 ) -> gboolean;
1116 pub fn clapper_media_item_set_suburi(item: *mut ClapperMediaItem, suburi: *const c_char);
1117
1118 pub fn clapper_mpris_get_type() -> GType;
1122 pub fn clapper_mpris_new(
1123 own_name: *const c_char,
1124 identity: *const c_char,
1125 desktop_entry: *const c_char,
1126 ) -> *mut ClapperMpris;
1127 pub fn clapper_mpris_get_fallback_art_url(mpris: *mut ClapperMpris) -> *mut c_char;
1128 pub fn clapper_mpris_get_queue_controllable(mpris: *mut ClapperMpris) -> gboolean;
1129 pub fn clapper_mpris_set_fallback_art_url(mpris: *mut ClapperMpris, art_url: *const c_char);
1130 pub fn clapper_mpris_set_queue_controllable(mpris: *mut ClapperMpris, controllable: gboolean);
1131
1132 pub fn clapper_player_get_type() -> GType;
1136 pub fn clapper_player_new() -> *mut ClapperPlayer;
1137 pub fn clapper_player_add_feature(player: *mut ClapperPlayer, feature: *mut ClapperFeature);
1138 #[cfg(feature = "v0_10")]
1139 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1140 pub fn clapper_player_advance_frame(player: *mut ClapperPlayer);
1141 #[cfg(feature = "v0_8")]
1142 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1143 pub fn clapper_player_get_adaptive_bandwidth(player: *mut ClapperPlayer) -> c_uint;
1144 #[cfg(feature = "v0_8")]
1145 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1146 pub fn clapper_player_get_adaptive_max_bitrate(player: *mut ClapperPlayer) -> c_uint;
1147 #[cfg(feature = "v0_8")]
1148 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1149 pub fn clapper_player_get_adaptive_min_bitrate(player: *mut ClapperPlayer) -> c_uint;
1150 #[cfg(feature = "v0_8")]
1151 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1152 pub fn clapper_player_get_adaptive_start_bitrate(player: *mut ClapperPlayer) -> c_uint;
1153 pub fn clapper_player_get_audio_enabled(player: *mut ClapperPlayer) -> gboolean;
1154 pub fn clapper_player_get_audio_filter(player: *mut ClapperPlayer) -> *mut gst::GstElement;
1155 pub fn clapper_player_get_audio_offset(player: *mut ClapperPlayer) -> c_double;
1156 pub fn clapper_player_get_audio_sink(player: *mut ClapperPlayer) -> *mut gst::GstElement;
1157 pub fn clapper_player_get_audio_streams(player: *mut ClapperPlayer) -> *mut ClapperStreamList;
1158 pub fn clapper_player_get_autoplay(player: *mut ClapperPlayer) -> gboolean;
1159 pub fn clapper_player_get_current_audio_decoder(
1160 player: *mut ClapperPlayer,
1161 ) -> *mut gst::GstElement;
1162 pub fn clapper_player_get_current_video_decoder(
1163 player: *mut ClapperPlayer,
1164 ) -> *mut gst::GstElement;
1165 #[cfg(feature = "v0_8")]
1166 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1167 pub fn clapper_player_get_download_dir(player: *mut ClapperPlayer) -> *mut c_char;
1168 #[cfg(feature = "v0_8")]
1169 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1170 pub fn clapper_player_get_download_enabled(player: *mut ClapperPlayer) -> gboolean;
1171 #[cfg(feature = "v0_10")]
1172 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1173 pub fn clapper_player_get_enhancer_proxies(
1174 player: *mut ClapperPlayer,
1175 ) -> *mut ClapperEnhancerProxyList;
1176 pub fn clapper_player_get_mute(player: *mut ClapperPlayer) -> gboolean;
1177 pub fn clapper_player_get_position(player: *mut ClapperPlayer) -> c_double;
1178 pub fn clapper_player_get_queue(player: *mut ClapperPlayer) -> *mut ClapperQueue;
1179 pub fn clapper_player_get_speed(player: *mut ClapperPlayer) -> c_double;
1180 pub fn clapper_player_get_state(player: *mut ClapperPlayer) -> ClapperPlayerState;
1181 pub fn clapper_player_get_subtitle_font_desc(player: *mut ClapperPlayer) -> *mut c_char;
1182 pub fn clapper_player_get_subtitle_offset(player: *mut ClapperPlayer) -> c_double;
1183 pub fn clapper_player_get_subtitle_streams(
1184 player: *mut ClapperPlayer,
1185 ) -> *mut ClapperStreamList;
1186 pub fn clapper_player_get_subtitles_enabled(player: *mut ClapperPlayer) -> gboolean;
1187 pub fn clapper_player_get_video_enabled(player: *mut ClapperPlayer) -> gboolean;
1188 pub fn clapper_player_get_video_filter(player: *mut ClapperPlayer) -> *mut gst::GstElement;
1189 pub fn clapper_player_get_video_sink(player: *mut ClapperPlayer) -> *mut gst::GstElement;
1190 pub fn clapper_player_get_video_streams(player: *mut ClapperPlayer) -> *mut ClapperStreamList;
1191 pub fn clapper_player_get_volume(player: *mut ClapperPlayer) -> c_double;
1192 #[cfg(feature = "v0_10")]
1193 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1194 pub fn clapper_player_make_pipeline_graph(
1195 player: *mut ClapperPlayer,
1196 details: gst::GstDebugGraphDetails,
1197 ) -> *mut c_char;
1198 pub fn clapper_player_pause(player: *mut ClapperPlayer);
1199 pub fn clapper_player_play(player: *mut ClapperPlayer);
1200 #[cfg(feature = "v0_10")]
1201 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1202 pub fn clapper_player_post_message(
1203 player: *mut ClapperPlayer,
1204 msg: *mut gst::GstMessage,
1205 destination: ClapperPlayerMessageDestination,
1206 );
1207 pub fn clapper_player_seek(player: *mut ClapperPlayer, position: c_double);
1208 pub fn clapper_player_seek_custom(
1209 player: *mut ClapperPlayer,
1210 position: c_double,
1211 method: ClapperPlayerSeekMethod,
1212 );
1213 #[cfg(feature = "v0_8")]
1214 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1215 pub fn clapper_player_set_adaptive_max_bitrate(player: *mut ClapperPlayer, bitrate: c_uint);
1216 #[cfg(feature = "v0_8")]
1217 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1218 pub fn clapper_player_set_adaptive_min_bitrate(player: *mut ClapperPlayer, bitrate: c_uint);
1219 #[cfg(feature = "v0_8")]
1220 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1221 pub fn clapper_player_set_adaptive_start_bitrate(player: *mut ClapperPlayer, bitrate: c_uint);
1222 pub fn clapper_player_set_audio_enabled(player: *mut ClapperPlayer, enabled: gboolean);
1223 pub fn clapper_player_set_audio_filter(
1224 player: *mut ClapperPlayer,
1225 element: *mut gst::GstElement,
1226 );
1227 pub fn clapper_player_set_audio_offset(player: *mut ClapperPlayer, offset: c_double);
1228 pub fn clapper_player_set_audio_sink(player: *mut ClapperPlayer, element: *mut gst::GstElement);
1229 pub fn clapper_player_set_autoplay(player: *mut ClapperPlayer, enabled: gboolean);
1230 #[cfg(feature = "v0_8")]
1231 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1232 pub fn clapper_player_set_download_dir(player: *mut ClapperPlayer, path: *const c_char);
1233 #[cfg(feature = "v0_8")]
1234 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1235 pub fn clapper_player_set_download_enabled(player: *mut ClapperPlayer, enabled: gboolean);
1236 pub fn clapper_player_set_mute(player: *mut ClapperPlayer, mute: gboolean);
1237 pub fn clapper_player_set_speed(player: *mut ClapperPlayer, speed: c_double);
1238 pub fn clapper_player_set_subtitle_font_desc(
1239 player: *mut ClapperPlayer,
1240 font_desc: *const c_char,
1241 );
1242 pub fn clapper_player_set_subtitle_offset(player: *mut ClapperPlayer, offset: c_double);
1243 pub fn clapper_player_set_subtitles_enabled(player: *mut ClapperPlayer, enabled: gboolean);
1244 pub fn clapper_player_set_video_enabled(player: *mut ClapperPlayer, enabled: gboolean);
1245 pub fn clapper_player_set_video_filter(
1246 player: *mut ClapperPlayer,
1247 element: *mut gst::GstElement,
1248 );
1249 pub fn clapper_player_set_video_sink(player: *mut ClapperPlayer, element: *mut gst::GstElement);
1250 pub fn clapper_player_set_volume(player: *mut ClapperPlayer, volume: c_double);
1251 pub fn clapper_player_stop(player: *mut ClapperPlayer);
1252
1253 pub fn clapper_queue_get_type() -> GType;
1257 pub fn clapper_queue_add_item(queue: *mut ClapperQueue, item: *mut ClapperMediaItem);
1258 pub fn clapper_queue_clear(queue: *mut ClapperQueue);
1259 pub fn clapper_queue_find_item(
1260 queue: *mut ClapperQueue,
1261 item: *mut ClapperMediaItem,
1262 index: *mut c_uint,
1263 ) -> gboolean;
1264 pub fn clapper_queue_get_current_index(queue: *mut ClapperQueue) -> c_uint;
1265 pub fn clapper_queue_get_current_item(queue: *mut ClapperQueue) -> *mut ClapperMediaItem;
1266 pub fn clapper_queue_get_gapless(queue: *mut ClapperQueue) -> gboolean;
1267 pub fn clapper_queue_get_instant(queue: *mut ClapperQueue) -> gboolean;
1268 pub fn clapper_queue_get_item(queue: *mut ClapperQueue, index: c_uint)
1269 -> *mut ClapperMediaItem;
1270 pub fn clapper_queue_get_n_items(queue: *mut ClapperQueue) -> c_uint;
1271 pub fn clapper_queue_get_progression_mode(
1272 queue: *mut ClapperQueue,
1273 ) -> ClapperQueueProgressionMode;
1274 pub fn clapper_queue_insert_item(
1275 queue: *mut ClapperQueue,
1276 item: *mut ClapperMediaItem,
1277 index: c_int,
1278 );
1279 #[cfg(feature = "v0_10")]
1280 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1281 pub fn clapper_queue_insert_item_after(
1282 queue: *mut ClapperQueue,
1283 item: *mut ClapperMediaItem,
1284 after_item: *mut ClapperMediaItem,
1285 );
1286 pub fn clapper_queue_item_is_current(
1287 queue: *mut ClapperQueue,
1288 item: *mut ClapperMediaItem,
1289 ) -> gboolean;
1290 pub fn clapper_queue_remove_index(queue: *mut ClapperQueue, index: c_uint);
1291 pub fn clapper_queue_remove_item(queue: *mut ClapperQueue, item: *mut ClapperMediaItem);
1292 pub fn clapper_queue_reposition_item(
1293 queue: *mut ClapperQueue,
1294 item: *mut ClapperMediaItem,
1295 index: c_int,
1296 );
1297 pub fn clapper_queue_select_index(queue: *mut ClapperQueue, index: c_uint) -> gboolean;
1298 pub fn clapper_queue_select_item(
1299 queue: *mut ClapperQueue,
1300 item: *mut ClapperMediaItem,
1301 ) -> gboolean;
1302 pub fn clapper_queue_select_next_item(queue: *mut ClapperQueue) -> gboolean;
1303 pub fn clapper_queue_select_previous_item(queue: *mut ClapperQueue) -> gboolean;
1304 pub fn clapper_queue_set_gapless(queue: *mut ClapperQueue, gapless: gboolean);
1305 pub fn clapper_queue_set_instant(queue: *mut ClapperQueue, instant: gboolean);
1306 pub fn clapper_queue_set_progression_mode(
1307 queue: *mut ClapperQueue,
1308 mode: ClapperQueueProgressionMode,
1309 );
1310 pub fn clapper_queue_steal_index(
1311 queue: *mut ClapperQueue,
1312 index: c_uint,
1313 ) -> *mut ClapperMediaItem;
1314
1315 pub fn clapper_server_get_type() -> GType;
1319 pub fn clapper_server_new() -> *mut ClapperServer;
1320 pub fn clapper_server_get_current_port(server: *mut ClapperServer) -> c_uint;
1321 pub fn clapper_server_get_enabled(server: *mut ClapperServer) -> gboolean;
1322 pub fn clapper_server_get_port(server: *mut ClapperServer) -> c_uint;
1323 pub fn clapper_server_get_queue_controllable(server: *mut ClapperServer) -> gboolean;
1324 pub fn clapper_server_get_running(server: *mut ClapperServer) -> gboolean;
1325 pub fn clapper_server_set_enabled(server: *mut ClapperServer, enabled: gboolean);
1326 pub fn clapper_server_set_port(server: *mut ClapperServer, port: c_uint);
1327 pub fn clapper_server_set_queue_controllable(
1328 server: *mut ClapperServer,
1329 controllable: gboolean,
1330 );
1331
1332 pub fn clapper_stream_get_type() -> GType;
1336 pub fn clapper_stream_get_stream_type(stream: *mut ClapperStream) -> ClapperStreamType;
1337 pub fn clapper_stream_get_title(stream: *mut ClapperStream) -> *mut c_char;
1338
1339 pub fn clapper_stream_list_get_type() -> GType;
1343 pub fn clapper_stream_list_get_current_index(list: *mut ClapperStreamList) -> c_uint;
1344 pub fn clapper_stream_list_get_current_stream(
1345 list: *mut ClapperStreamList,
1346 ) -> *mut ClapperStream;
1347 pub fn clapper_stream_list_get_n_streams(list: *mut ClapperStreamList) -> c_uint;
1348 pub fn clapper_stream_list_get_stream(
1349 list: *mut ClapperStreamList,
1350 index: c_uint,
1351 ) -> *mut ClapperStream;
1352 pub fn clapper_stream_list_select_index(
1353 list: *mut ClapperStreamList,
1354 index: c_uint,
1355 ) -> gboolean;
1356 pub fn clapper_stream_list_select_stream(
1357 list: *mut ClapperStreamList,
1358 stream: *mut ClapperStream,
1359 ) -> gboolean;
1360
1361 pub fn clapper_subtitle_stream_get_type() -> GType;
1365 pub fn clapper_subtitle_stream_get_lang_code(stream: *mut ClapperSubtitleStream)
1366 -> *mut c_char;
1367 pub fn clapper_subtitle_stream_get_lang_name(stream: *mut ClapperSubtitleStream)
1368 -> *mut c_char;
1369
1370 pub fn clapper_threaded_object_get_type() -> GType;
1374 pub fn clapper_threaded_object_get_context(
1375 threaded_object: *mut ClapperThreadedObject,
1376 ) -> *mut glib::GMainContext;
1377
1378 pub fn clapper_timeline_get_type() -> GType;
1382 pub fn clapper_timeline_get_marker(
1383 timeline: *mut ClapperTimeline,
1384 index: c_uint,
1385 ) -> *mut ClapperMarker;
1386 pub fn clapper_timeline_get_n_markers(timeline: *mut ClapperTimeline) -> c_uint;
1387 pub fn clapper_timeline_insert_marker(
1388 timeline: *mut ClapperTimeline,
1389 marker: *mut ClapperMarker,
1390 );
1391 pub fn clapper_timeline_remove_marker(
1392 timeline: *mut ClapperTimeline,
1393 marker: *mut ClapperMarker,
1394 );
1395
1396 pub fn clapper_video_stream_get_type() -> GType;
1400 pub fn clapper_video_stream_get_bitrate(stream: *mut ClapperVideoStream) -> c_uint;
1401 pub fn clapper_video_stream_get_codec(stream: *mut ClapperVideoStream) -> *mut c_char;
1402 pub fn clapper_video_stream_get_fps(stream: *mut ClapperVideoStream) -> c_double;
1403 pub fn clapper_video_stream_get_height(stream: *mut ClapperVideoStream) -> c_int;
1404 pub fn clapper_video_stream_get_pixel_format(stream: *mut ClapperVideoStream) -> *mut c_char;
1405 pub fn clapper_video_stream_get_width(stream: *mut ClapperVideoStream) -> c_int;
1406
1407 #[cfg(feature = "v0_8")]
1411 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1412 pub fn clapper_extractable_get_type() -> GType;
1413
1414 #[cfg(feature = "v0_10")]
1418 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1419 pub fn clapper_playlistable_get_type() -> GType;
1420
1421 #[cfg(feature = "v0_10")]
1425 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1426 pub fn clapper_reactable_get_type() -> GType;
1427 #[cfg(feature = "v0_10")]
1428 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1429 pub fn clapper_reactable_get_player(reactable: *mut ClapperReactable) -> *mut ClapperPlayer;
1430 #[cfg(feature = "v0_10")]
1431 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1432 pub fn clapper_reactable_queue_append_sync(
1433 reactable: *mut ClapperReactable,
1434 item: *mut ClapperMediaItem,
1435 );
1436 #[cfg(feature = "v0_10")]
1437 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1438 pub fn clapper_reactable_queue_clear_sync(reactable: *mut ClapperReactable);
1439 #[cfg(feature = "v0_10")]
1440 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1441 pub fn clapper_reactable_queue_insert_sync(
1442 reactable: *mut ClapperReactable,
1443 item: *mut ClapperMediaItem,
1444 after_item: *mut ClapperMediaItem,
1445 );
1446 #[cfg(feature = "v0_10")]
1447 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1448 pub fn clapper_reactable_queue_remove_sync(
1449 reactable: *mut ClapperReactable,
1450 item: *mut ClapperMediaItem,
1451 );
1452 #[cfg(feature = "v0_10")]
1453 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1454 pub fn clapper_reactable_timeline_insert_sync(
1455 reactable: *mut ClapperReactable,
1456 timeline: *mut ClapperTimeline,
1457 marker: *mut ClapperMarker,
1458 );
1459 #[cfg(feature = "v0_10")]
1460 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1461 pub fn clapper_reactable_timeline_remove_sync(
1462 reactable: *mut ClapperReactable,
1463 timeline: *mut ClapperTimeline,
1464 marker: *mut ClapperMarker,
1465 );
1466
1467 #[cfg(feature = "v0_8")]
1471 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8")))]
1472 pub fn clapper_enhancer_check(
1473 iface_type: GType,
1474 scheme: *const c_char,
1475 host: *const c_char,
1476 name: *mut *const c_char,
1477 ) -> gboolean;
1478 #[cfg(feature = "v0_10")]
1479 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1480 pub fn clapper_get_global_enhancer_proxies() -> *mut ClapperEnhancerProxyList;
1481 #[cfg(feature = "v0_10")]
1482 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1483 pub fn clapper_get_major_version() -> c_uint;
1484 #[cfg(feature = "v0_10")]
1485 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1486 pub fn clapper_get_micro_version() -> c_uint;
1487 #[cfg(feature = "v0_10")]
1488 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1489 pub fn clapper_get_minor_version() -> c_uint;
1490 #[cfg(feature = "v0_10")]
1491 #[cfg_attr(docsrs, doc(cfg(feature = "v0_10")))]
1492 pub fn clapper_get_version_s() -> *const c_char;
1493 pub fn clapper_init(argc: *mut c_int, argv: *mut *mut *mut c_char);
1494 pub fn clapper_init_check(argc: *mut c_int, argv: *mut *mut *mut c_char) -> gboolean;
1495
1496}