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_audio_sys as gst_audio;
18use gstreamer_sys as gst;
19use gstreamer_video_sys as gst_video;
20
21#[allow(unused_imports)]
22use libc::{FILE, intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t};
23#[cfg(unix)]
24#[allow(unused_imports)]
25use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
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::{GType, gboolean, gconstpointer, gpointer};
33
34pub type GstDiscovererAudioInfoClass = gobject::GObjectClass;
36pub type GstDiscovererContainerInfoClass = gobject::GObjectClass;
37pub type GstDiscovererInfoClass = gobject::GObjectClass;
38pub type GstDiscovererStreamInfoClass = gobject::GObjectClass;
39pub type GstDiscovererSubtitleInfoClass = gobject::GObjectClass;
40pub type GstDiscovererVideoInfoClass = gobject::GObjectClass;
41pub type GstEncodingTargetClass = gobject::GObjectClass;
42
43pub type GstAudioVisualizerShader = c_int;
45pub const GST_AUDIO_VISUALIZER_SHADER_NONE: GstAudioVisualizerShader = 0;
46pub const GST_AUDIO_VISUALIZER_SHADER_FADE: GstAudioVisualizerShader = 1;
47pub const GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_UP: GstAudioVisualizerShader = 2;
48pub const GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_DOWN: GstAudioVisualizerShader = 3;
49pub const GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_LEFT: GstAudioVisualizerShader = 4;
50pub const GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_RIGHT: GstAudioVisualizerShader = 5;
51pub const GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_HORIZ_OUT: GstAudioVisualizerShader = 6;
52pub const GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_HORIZ_IN: GstAudioVisualizerShader = 7;
53pub const GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_VERT_OUT: GstAudioVisualizerShader = 8;
54pub const GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_VERT_IN: GstAudioVisualizerShader = 9;
55
56pub type GstDiscovererResult = c_int;
57pub const GST_DISCOVERER_OK: GstDiscovererResult = 0;
58pub const GST_DISCOVERER_URI_INVALID: GstDiscovererResult = 1;
59pub const GST_DISCOVERER_ERROR: GstDiscovererResult = 2;
60pub const GST_DISCOVERER_TIMEOUT: GstDiscovererResult = 3;
61pub const GST_DISCOVERER_BUSY: GstDiscovererResult = 4;
62pub const GST_DISCOVERER_MISSING_PLUGINS: GstDiscovererResult = 5;
63
64pub type GstInstallPluginsReturn = c_int;
65pub const GST_INSTALL_PLUGINS_SUCCESS: GstInstallPluginsReturn = 0;
66pub const GST_INSTALL_PLUGINS_NOT_FOUND: GstInstallPluginsReturn = 1;
67pub const GST_INSTALL_PLUGINS_ERROR: GstInstallPluginsReturn = 2;
68pub const GST_INSTALL_PLUGINS_PARTIAL_SUCCESS: GstInstallPluginsReturn = 3;
69pub const GST_INSTALL_PLUGINS_USER_ABORT: GstInstallPluginsReturn = 4;
70pub const GST_INSTALL_PLUGINS_CRASHED: GstInstallPluginsReturn = 100;
71pub const GST_INSTALL_PLUGINS_INVALID: GstInstallPluginsReturn = 101;
72pub const GST_INSTALL_PLUGINS_STARTED_OK: GstInstallPluginsReturn = 200;
73pub const GST_INSTALL_PLUGINS_INTERNAL_FAILURE: GstInstallPluginsReturn = 201;
74pub const GST_INSTALL_PLUGINS_HELPER_MISSING: GstInstallPluginsReturn = 202;
75pub const GST_INSTALL_PLUGINS_INSTALL_IN_PROGRESS: GstInstallPluginsReturn = 203;
76
77pub const GST_ENCODING_CATEGORY_CAPTURE: &[u8] = b"capture\0";
79pub const GST_ENCODING_CATEGORY_DEVICE: &[u8] = b"device\0";
80pub const GST_ENCODING_CATEGORY_FILE_EXTENSION: &[u8] = b"file-extension\0";
81pub const GST_ENCODING_CATEGORY_ONLINE_SERVICE: &[u8] = b"online-service\0";
82pub const GST_ENCODING_CATEGORY_STORAGE_EDITING: &[u8] = b"storage-editing\0";
83
84pub type GstDiscovererSerializeFlags = c_uint;
86pub const GST_DISCOVERER_SERIALIZE_BASIC: GstDiscovererSerializeFlags = 0;
87pub const GST_DISCOVERER_SERIALIZE_CAPS: GstDiscovererSerializeFlags = 1;
88pub const GST_DISCOVERER_SERIALIZE_TAGS: GstDiscovererSerializeFlags = 2;
89pub const GST_DISCOVERER_SERIALIZE_MISC: GstDiscovererSerializeFlags = 4;
90pub const GST_DISCOVERER_SERIALIZE_ALL: GstDiscovererSerializeFlags = 7;
91
92pub type GstPbUtilsCapsDescriptionFlags = c_uint;
93pub const GST_PBUTILS_CAPS_DESCRIPTION_FLAG_CONTAINER: GstPbUtilsCapsDescriptionFlags = 1;
94pub const GST_PBUTILS_CAPS_DESCRIPTION_FLAG_AUDIO: GstPbUtilsCapsDescriptionFlags = 2;
95pub const GST_PBUTILS_CAPS_DESCRIPTION_FLAG_VIDEO: GstPbUtilsCapsDescriptionFlags = 4;
96pub const GST_PBUTILS_CAPS_DESCRIPTION_FLAG_IMAGE: GstPbUtilsCapsDescriptionFlags = 8;
97pub const GST_PBUTILS_CAPS_DESCRIPTION_FLAG_SUBTITLE: GstPbUtilsCapsDescriptionFlags = 16;
98pub const GST_PBUTILS_CAPS_DESCRIPTION_FLAG_TAG: GstPbUtilsCapsDescriptionFlags = 32;
99pub const GST_PBUTILS_CAPS_DESCRIPTION_FLAG_GENERIC: GstPbUtilsCapsDescriptionFlags = 64;
100#[cfg(feature = "v1_22")]
101#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
102pub const GST_PBUTILS_CAPS_DESCRIPTION_FLAG_METADATA: GstPbUtilsCapsDescriptionFlags = 128;
103
104pub type GstAudioVisualizerShaderFunc = Option<
106 unsafe extern "C" fn(
107 *mut GstAudioVisualizer,
108 *const gst_video::GstVideoFrame,
109 *mut gst_video::GstVideoFrame,
110 ),
111>;
112pub type GstInstallPluginsResultFunc =
113 Option<unsafe extern "C" fn(GstInstallPluginsReturn, gpointer)>;
114
115#[derive(Copy, Clone)]
117#[repr(C)]
118pub struct GstAudioVisualizerClass {
119 pub parent_class: gst::GstElementClass,
120 pub setup: Option<unsafe extern "C" fn(*mut GstAudioVisualizer) -> gboolean>,
121 pub render: Option<
122 unsafe extern "C" fn(
123 *mut GstAudioVisualizer,
124 *mut gst::GstBuffer,
125 *mut gst_video::GstVideoFrame,
126 ) -> gboolean,
127 >,
128 pub decide_allocation:
129 Option<unsafe extern "C" fn(*mut GstAudioVisualizer, *mut gst::GstQuery) -> gboolean>,
130}
131
132impl ::std::fmt::Debug for GstAudioVisualizerClass {
133 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
134 f.debug_struct(&format!("GstAudioVisualizerClass @ {self:p}"))
135 .field("setup", &self.setup)
136 .field("render", &self.render)
137 .field("decide_allocation", &self.decide_allocation)
138 .finish()
139 }
140}
141
142#[repr(C)]
143#[allow(dead_code)]
144pub struct _GstAudioVisualizerPrivate {
145 _data: [u8; 0],
146 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
147}
148
149pub type GstAudioVisualizerPrivate = _GstAudioVisualizerPrivate;
150
151#[repr(C)]
152#[allow(dead_code)]
153pub struct _GstDiscovererAudioInfoBuilder {
154 _data: [u8; 0],
155 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
156}
157
158pub type GstDiscovererAudioInfoBuilder = _GstDiscovererAudioInfoBuilder;
159
160#[derive(Copy, Clone)]
161#[repr(C)]
162pub struct GstDiscovererClass {
163 pub parentclass: gobject::GObjectClass,
164 pub finished: Option<unsafe extern "C" fn(*mut GstDiscoverer)>,
165 pub starting: Option<unsafe extern "C" fn(*mut GstDiscoverer)>,
166 pub discovered: Option<
167 unsafe extern "C" fn(*mut GstDiscoverer, *mut GstDiscovererInfo, *const glib::GError),
168 >,
169 pub source_setup: Option<unsafe extern "C" fn(*mut GstDiscoverer, *mut gst::GstElement)>,
170 pub load_serialize_info:
171 Option<unsafe extern "C" fn(*mut GstDiscoverer, *mut c_char) -> *mut GstDiscovererInfo>,
172 pub _reserved: [gpointer; 3],
173}
174
175impl ::std::fmt::Debug for GstDiscovererClass {
176 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
177 f.debug_struct(&format!("GstDiscovererClass @ {self:p}"))
178 .field("parentclass", &self.parentclass)
179 .field("finished", &self.finished)
180 .field("starting", &self.starting)
181 .field("discovered", &self.discovered)
182 .field("source_setup", &self.source_setup)
183 .field("load_serialize_info", &self.load_serialize_info)
184 .field("_reserved", &self._reserved)
185 .finish()
186 }
187}
188
189#[repr(C)]
190#[allow(dead_code)]
191pub struct _GstDiscovererContainerInfoBuilder {
192 _data: [u8; 0],
193 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
194}
195
196pub type GstDiscovererContainerInfoBuilder = _GstDiscovererContainerInfoBuilder;
197
198#[repr(C)]
199#[allow(dead_code)]
200pub struct _GstDiscovererInfoBuilder {
201 _data: [u8; 0],
202 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
203}
204
205pub type GstDiscovererInfoBuilder = _GstDiscovererInfoBuilder;
206
207#[repr(C)]
208#[allow(dead_code)]
209pub struct _GstDiscovererPrivate {
210 _data: [u8; 0],
211 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
212}
213
214pub type GstDiscovererPrivate = _GstDiscovererPrivate;
215
216#[repr(C)]
217#[allow(dead_code)]
218pub struct _GstDiscovererSubtitleInfoBuilder {
219 _data: [u8; 0],
220 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
221}
222
223pub type GstDiscovererSubtitleInfoBuilder = _GstDiscovererSubtitleInfoBuilder;
224
225#[repr(C)]
226#[allow(dead_code)]
227pub struct _GstDiscovererVideoInfoBuilder {
228 _data: [u8; 0],
229 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
230}
231
232pub type GstDiscovererVideoInfoBuilder = _GstDiscovererVideoInfoBuilder;
233
234#[repr(C)]
235#[allow(dead_code)]
236pub struct _GstEncodingAudioProfileClass {
237 _data: [u8; 0],
238 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
239}
240
241pub type GstEncodingAudioProfileClass = _GstEncodingAudioProfileClass;
242
243#[repr(C)]
244#[allow(dead_code)]
245pub struct _GstEncodingContainerProfileClass {
246 _data: [u8; 0],
247 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
248}
249
250pub type GstEncodingContainerProfileClass = _GstEncodingContainerProfileClass;
251
252#[repr(C)]
253#[allow(dead_code)]
254pub struct _GstEncodingProfileClass {
255 _data: [u8; 0],
256 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
257}
258
259pub type GstEncodingProfileClass = _GstEncodingProfileClass;
260
261#[repr(C)]
262#[allow(dead_code)]
263pub struct _GstEncodingVideoProfileClass {
264 _data: [u8; 0],
265 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
266}
267
268pub type GstEncodingVideoProfileClass = _GstEncodingVideoProfileClass;
269
270#[derive(Copy, Clone)]
271#[repr(C)]
272pub struct GstH264LevelLimits {
273 pub name: *const c_char,
274 pub level_idc: u8,
275 pub max_mbps: u32,
276 pub max_fs: u32,
277 pub max_dpb_mbs: u32,
278 pub max_br: u32,
279 pub max_cpb: u32,
280 pub min_cr: u32,
281}
282
283impl ::std::fmt::Debug for GstH264LevelLimits {
284 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
285 f.debug_struct(&format!("GstH264LevelLimits @ {self:p}"))
286 .field("name", &self.name)
287 .field("level_idc", &self.level_idc)
288 .field("max_mbps", &self.max_mbps)
289 .field("max_fs", &self.max_fs)
290 .field("max_dpb_mbs", &self.max_dpb_mbs)
291 .field("max_br", &self.max_br)
292 .field("max_cpb", &self.max_cpb)
293 .field("min_cr", &self.min_cr)
294 .finish()
295 }
296}
297
298#[repr(C)]
299#[allow(dead_code)]
300pub struct GstInstallPluginsContext {
301 _data: [u8; 0],
302 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
303}
304
305impl ::std::fmt::Debug for GstInstallPluginsContext {
306 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
307 f.debug_struct(&format!("GstInstallPluginsContext @ {self:p}"))
308 .finish()
309 }
310}
311
312#[derive(Copy, Clone)]
314#[repr(C)]
315pub struct GstAudioVisualizer {
316 pub parent: gst::GstElement,
317 pub req_spf: c_uint,
318 pub vinfo: gst_video::GstVideoInfo,
319 pub ainfo: gst_audio::GstAudioInfo,
320 pub priv_: *mut GstAudioVisualizerPrivate,
321}
322
323impl ::std::fmt::Debug for GstAudioVisualizer {
324 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
325 f.debug_struct(&format!("GstAudioVisualizer @ {self:p}"))
326 .field("parent", &self.parent)
327 .field("req_spf", &self.req_spf)
328 .field("vinfo", &self.vinfo)
329 .field("ainfo", &self.ainfo)
330 .finish()
331 }
332}
333
334#[derive(Copy, Clone)]
335#[repr(C)]
336pub struct GstDiscoverer {
337 pub parent: gobject::GObject,
338 pub priv_: *mut GstDiscovererPrivate,
339 pub _reserved: [gpointer; 4],
340}
341
342impl ::std::fmt::Debug for GstDiscoverer {
343 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
344 f.debug_struct(&format!("GstDiscoverer @ {self:p}"))
345 .field("parent", &self.parent)
346 .finish()
347 }
348}
349
350#[repr(C)]
351#[allow(dead_code)]
352pub struct GstDiscovererAudioInfo {
353 _data: [u8; 0],
354 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
355}
356
357impl ::std::fmt::Debug for GstDiscovererAudioInfo {
358 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
359 f.debug_struct(&format!("GstDiscovererAudioInfo @ {self:p}"))
360 .finish()
361 }
362}
363
364#[repr(C)]
365#[allow(dead_code)]
366pub struct GstDiscovererContainerInfo {
367 _data: [u8; 0],
368 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
369}
370
371impl ::std::fmt::Debug for GstDiscovererContainerInfo {
372 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
373 f.debug_struct(&format!("GstDiscovererContainerInfo @ {self:p}"))
374 .finish()
375 }
376}
377
378#[repr(C)]
379#[allow(dead_code)]
380pub struct GstDiscovererInfo {
381 _data: [u8; 0],
382 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
383}
384
385impl ::std::fmt::Debug for GstDiscovererInfo {
386 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
387 f.debug_struct(&format!("GstDiscovererInfo @ {self:p}"))
388 .finish()
389 }
390}
391
392#[repr(C)]
393#[allow(dead_code)]
394pub struct GstDiscovererStreamInfo {
395 _data: [u8; 0],
396 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
397}
398
399impl ::std::fmt::Debug for GstDiscovererStreamInfo {
400 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
401 f.debug_struct(&format!("GstDiscovererStreamInfo @ {self:p}"))
402 .finish()
403 }
404}
405
406#[repr(C)]
407#[allow(dead_code)]
408pub struct GstDiscovererSubtitleInfo {
409 _data: [u8; 0],
410 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
411}
412
413impl ::std::fmt::Debug for GstDiscovererSubtitleInfo {
414 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
415 f.debug_struct(&format!("GstDiscovererSubtitleInfo @ {self:p}"))
416 .finish()
417 }
418}
419
420#[repr(C)]
421#[allow(dead_code)]
422pub struct GstDiscovererVideoInfo {
423 _data: [u8; 0],
424 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
425}
426
427impl ::std::fmt::Debug for GstDiscovererVideoInfo {
428 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
429 f.debug_struct(&format!("GstDiscovererVideoInfo @ {self:p}"))
430 .finish()
431 }
432}
433
434#[repr(C)]
435#[allow(dead_code)]
436pub struct GstEncodingAudioProfile {
437 _data: [u8; 0],
438 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
439}
440
441impl ::std::fmt::Debug for GstEncodingAudioProfile {
442 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
443 f.debug_struct(&format!("GstEncodingAudioProfile @ {self:p}"))
444 .finish()
445 }
446}
447
448#[repr(C)]
449#[allow(dead_code)]
450pub struct GstEncodingContainerProfile {
451 _data: [u8; 0],
452 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
453}
454
455impl ::std::fmt::Debug for GstEncodingContainerProfile {
456 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
457 f.debug_struct(&format!("GstEncodingContainerProfile @ {self:p}"))
458 .finish()
459 }
460}
461
462#[repr(C)]
463#[allow(dead_code)]
464pub struct GstEncodingProfile {
465 _data: [u8; 0],
466 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
467}
468
469impl ::std::fmt::Debug for GstEncodingProfile {
470 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
471 f.debug_struct(&format!("GstEncodingProfile @ {self:p}"))
472 .finish()
473 }
474}
475
476#[repr(C)]
477#[allow(dead_code)]
478pub struct GstEncodingTarget {
479 _data: [u8; 0],
480 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
481}
482
483impl ::std::fmt::Debug for GstEncodingTarget {
484 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
485 f.debug_struct(&format!("GstEncodingTarget @ {self:p}"))
486 .finish()
487 }
488}
489
490#[repr(C)]
491#[allow(dead_code)]
492pub struct GstEncodingVideoProfile {
493 _data: [u8; 0],
494 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
495}
496
497impl ::std::fmt::Debug for GstEncodingVideoProfile {
498 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
499 f.debug_struct(&format!("GstEncodingVideoProfile @ {self:p}"))
500 .finish()
501 }
502}
503
504unsafe extern "C" {
505
506 pub fn gst_audio_visualizer_shader_get_type() -> GType;
510
511 pub fn gst_discoverer_result_get_type() -> GType;
515
516 pub fn gst_install_plugins_return_get_type() -> GType;
520 pub fn gst_install_plugins_return_get_name(ret: GstInstallPluginsReturn) -> *const c_char;
521
522 pub fn gst_discoverer_serialize_flags_get_type() -> GType;
526
527 #[cfg(feature = "v1_20")]
531 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
532 pub fn gst_pb_utils_caps_description_flags_get_type() -> GType;
533
534 #[cfg(feature = "v1_30")]
538 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
539 pub fn gst_discoverer_audio_info_builder_build(
540 builder: *mut GstDiscovererAudioInfoBuilder,
541 ) -> *mut GstDiscovererAudioInfo;
542 #[cfg(feature = "v1_30")]
543 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
544 pub fn gst_discoverer_audio_info_builder_free(builder: *mut GstDiscovererAudioInfoBuilder);
545 #[cfg(feature = "v1_30")]
546 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
547 pub fn gst_discoverer_audio_info_builder_set_bitrate(
548 builder: *mut GstDiscovererAudioInfoBuilder,
549 bitrate: c_uint,
550 ) -> *mut GstDiscovererAudioInfoBuilder;
551 #[cfg(feature = "v1_30")]
552 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
553 pub fn gst_discoverer_audio_info_builder_set_language(
554 builder: *mut GstDiscovererAudioInfoBuilder,
555 language: *const c_char,
556 ) -> *mut GstDiscovererAudioInfoBuilder;
557 #[cfg(feature = "v1_30")]
558 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
559 pub fn gst_discoverer_audio_info_builder_set_max_bitrate(
560 builder: *mut GstDiscovererAudioInfoBuilder,
561 max_bitrate: c_uint,
562 ) -> *mut GstDiscovererAudioInfoBuilder;
563 #[cfg(feature = "v1_30")]
564 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
565 pub fn gst_discoverer_audio_info_builder_set_tags(
566 builder: *mut GstDiscovererAudioInfoBuilder,
567 tags: *mut gst::GstTagList,
568 ) -> *mut GstDiscovererAudioInfoBuilder;
569 #[cfg(feature = "v1_30")]
570 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
571 pub fn gst_discoverer_audio_info_builder_new(
572 stream_id: *const c_char,
573 caps: *mut gst::GstCaps,
574 ) -> *mut GstDiscovererAudioInfoBuilder;
575
576 #[cfg(feature = "v1_30")]
580 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
581 pub fn gst_discoverer_container_info_builder_add_stream(
582 builder: *mut GstDiscovererContainerInfoBuilder,
583 stream_info: *mut GstDiscovererStreamInfo,
584 ) -> *mut GstDiscovererContainerInfoBuilder;
585 #[cfg(feature = "v1_30")]
586 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
587 pub fn gst_discoverer_container_info_builder_build(
588 builder: *mut GstDiscovererContainerInfoBuilder,
589 ) -> *mut GstDiscovererContainerInfo;
590 #[cfg(feature = "v1_30")]
591 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
592 pub fn gst_discoverer_container_info_builder_free(
593 builder: *mut GstDiscovererContainerInfoBuilder,
594 );
595 #[cfg(feature = "v1_30")]
596 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
597 pub fn gst_discoverer_container_info_builder_set_tags(
598 builder: *mut GstDiscovererContainerInfoBuilder,
599 tags: *mut gst::GstTagList,
600 ) -> *mut GstDiscovererContainerInfoBuilder;
601 #[cfg(feature = "v1_30")]
602 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
603 pub fn gst_discoverer_container_info_builder_new(
604 caps: *mut gst::GstCaps,
605 ) -> *mut GstDiscovererContainerInfoBuilder;
606
607 #[cfg(feature = "v1_30")]
611 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
612 pub fn gst_discoverer_info_builder_build(
613 builder: *mut GstDiscovererInfoBuilder,
614 ) -> *mut GstDiscovererInfo;
615 #[cfg(feature = "v1_30")]
616 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
617 pub fn gst_discoverer_info_builder_free(builder: *mut GstDiscovererInfoBuilder);
618 #[cfg(feature = "v1_30")]
619 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
620 pub fn gst_discoverer_info_builder_set_duration(
621 builder: *mut GstDiscovererInfoBuilder,
622 duration: gst::GstClockTime,
623 ) -> *mut GstDiscovererInfoBuilder;
624 #[cfg(feature = "v1_30")]
625 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
626 pub fn gst_discoverer_info_builder_set_live(
627 builder: *mut GstDiscovererInfoBuilder,
628 live: gboolean,
629 ) -> *mut GstDiscovererInfoBuilder;
630 #[cfg(feature = "v1_30")]
631 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
632 pub fn gst_discoverer_info_builder_set_result(
633 builder: *mut GstDiscovererInfoBuilder,
634 result: GstDiscovererResult,
635 ) -> *mut GstDiscovererInfoBuilder;
636 #[cfg(feature = "v1_30")]
637 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
638 pub fn gst_discoverer_info_builder_set_seekable(
639 builder: *mut GstDiscovererInfoBuilder,
640 seekable: gboolean,
641 ) -> *mut GstDiscovererInfoBuilder;
642 #[cfg(feature = "v1_30")]
643 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
644 pub fn gst_discoverer_info_builder_set_tags(
645 builder: *mut GstDiscovererInfoBuilder,
646 tags: *mut gst::GstTagList,
647 ) -> *mut GstDiscovererInfoBuilder;
648 #[cfg(feature = "v1_30")]
649 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
650 pub fn gst_discoverer_info_builder_new(
651 uri: *const c_char,
652 stream_info: *mut GstDiscovererStreamInfo,
653 ) -> *mut GstDiscovererInfoBuilder;
654
655 #[cfg(feature = "v1_30")]
659 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
660 pub fn gst_discoverer_subtitle_info_builder_build(
661 builder: *mut GstDiscovererSubtitleInfoBuilder,
662 ) -> *mut GstDiscovererSubtitleInfo;
663 #[cfg(feature = "v1_30")]
664 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
665 pub fn gst_discoverer_subtitle_info_builder_free(
666 builder: *mut GstDiscovererSubtitleInfoBuilder,
667 );
668 #[cfg(feature = "v1_30")]
669 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
670 pub fn gst_discoverer_subtitle_info_builder_set_language(
671 builder: *mut GstDiscovererSubtitleInfoBuilder,
672 language: *const c_char,
673 ) -> *mut GstDiscovererSubtitleInfoBuilder;
674 #[cfg(feature = "v1_30")]
675 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
676 pub fn gst_discoverer_subtitle_info_builder_set_tags(
677 builder: *mut GstDiscovererSubtitleInfoBuilder,
678 tags: *mut gst::GstTagList,
679 ) -> *mut GstDiscovererSubtitleInfoBuilder;
680 #[cfg(feature = "v1_30")]
681 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
682 pub fn gst_discoverer_subtitle_info_builder_new(
683 stream_id: *const c_char,
684 caps: *mut gst::GstCaps,
685 ) -> *mut GstDiscovererSubtitleInfoBuilder;
686
687 #[cfg(feature = "v1_30")]
691 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
692 pub fn gst_discoverer_video_info_builder_build(
693 builder: *mut GstDiscovererVideoInfoBuilder,
694 ) -> *mut GstDiscovererVideoInfo;
695 #[cfg(feature = "v1_30")]
696 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
697 pub fn gst_discoverer_video_info_builder_free(builder: *mut GstDiscovererVideoInfoBuilder);
698 #[cfg(feature = "v1_30")]
699 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
700 pub fn gst_discoverer_video_info_builder_set_bitrate(
701 builder: *mut GstDiscovererVideoInfoBuilder,
702 bitrate: c_uint,
703 ) -> *mut GstDiscovererVideoInfoBuilder;
704 #[cfg(feature = "v1_30")]
705 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
706 pub fn gst_discoverer_video_info_builder_set_interlaced(
707 builder: *mut GstDiscovererVideoInfoBuilder,
708 interlaced: gboolean,
709 ) -> *mut GstDiscovererVideoInfoBuilder;
710 #[cfg(feature = "v1_30")]
711 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
712 pub fn gst_discoverer_video_info_builder_set_is_image(
713 builder: *mut GstDiscovererVideoInfoBuilder,
714 is_image: gboolean,
715 ) -> *mut GstDiscovererVideoInfoBuilder;
716 #[cfg(feature = "v1_30")]
717 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
718 pub fn gst_discoverer_video_info_builder_set_max_bitrate(
719 builder: *mut GstDiscovererVideoInfoBuilder,
720 max_bitrate: c_uint,
721 ) -> *mut GstDiscovererVideoInfoBuilder;
722 #[cfg(feature = "v1_30")]
723 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
724 pub fn gst_discoverer_video_info_builder_set_tags(
725 builder: *mut GstDiscovererVideoInfoBuilder,
726 tags: *mut gst::GstTagList,
727 ) -> *mut GstDiscovererVideoInfoBuilder;
728 #[cfg(feature = "v1_30")]
729 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
730 pub fn gst_discoverer_video_info_builder_new(
731 stream_id: *const c_char,
732 caps: *mut gst::GstCaps,
733 ) -> *mut GstDiscovererVideoInfoBuilder;
734
735 pub fn gst_install_plugins_context_get_type() -> GType;
739 pub fn gst_install_plugins_context_new() -> *mut GstInstallPluginsContext;
740 pub fn gst_install_plugins_context_copy(
741 ctx: *mut GstInstallPluginsContext,
742 ) -> *mut GstInstallPluginsContext;
743 pub fn gst_install_plugins_context_free(ctx: *mut GstInstallPluginsContext);
744 pub fn gst_install_plugins_context_set_confirm_search(
745 ctx: *mut GstInstallPluginsContext,
746 confirm_search: gboolean,
747 );
748 pub fn gst_install_plugins_context_set_desktop_id(
749 ctx: *mut GstInstallPluginsContext,
750 desktop_id: *const c_char,
751 );
752 pub fn gst_install_plugins_context_set_startup_notification_id(
753 ctx: *mut GstInstallPluginsContext,
754 startup_id: *const c_char,
755 );
756 pub fn gst_install_plugins_context_set_xid(ctx: *mut GstInstallPluginsContext, xid: c_uint);
757
758 pub fn gst_audio_visualizer_get_type() -> GType;
762
763 pub fn gst_discoverer_get_type() -> GType;
767 pub fn gst_discoverer_new(
768 timeout: gst::GstClockTime,
769 error: *mut *mut glib::GError,
770 ) -> *mut GstDiscoverer;
771 pub fn gst_discoverer_discover_uri(
772 discoverer: *mut GstDiscoverer,
773 uri: *const c_char,
774 error: *mut *mut glib::GError,
775 ) -> *mut GstDiscovererInfo;
776 pub fn gst_discoverer_discover_uri_async(
777 discoverer: *mut GstDiscoverer,
778 uri: *const c_char,
779 ) -> gboolean;
780 pub fn gst_discoverer_start(discoverer: *mut GstDiscoverer);
781 pub fn gst_discoverer_stop(discoverer: *mut GstDiscoverer);
782
783 pub fn gst_discoverer_audio_info_get_type() -> GType;
787 pub fn gst_discoverer_audio_info_get_bitrate(info: *const GstDiscovererAudioInfo) -> c_uint;
788 pub fn gst_discoverer_audio_info_get_channel_mask(info: *const GstDiscovererAudioInfo) -> u64;
789 pub fn gst_discoverer_audio_info_get_channels(info: *const GstDiscovererAudioInfo) -> c_uint;
790 pub fn gst_discoverer_audio_info_get_depth(info: *const GstDiscovererAudioInfo) -> c_uint;
791 pub fn gst_discoverer_audio_info_get_language(
792 info: *const GstDiscovererAudioInfo,
793 ) -> *const c_char;
794 pub fn gst_discoverer_audio_info_get_max_bitrate(info: *const GstDiscovererAudioInfo)
795 -> c_uint;
796 pub fn gst_discoverer_audio_info_get_sample_rate(info: *const GstDiscovererAudioInfo)
797 -> c_uint;
798
799 pub fn gst_discoverer_container_info_get_type() -> GType;
803 pub fn gst_discoverer_container_info_get_streams(
804 info: *mut GstDiscovererContainerInfo,
805 ) -> *mut glib::GList;
806 #[cfg(feature = "v1_20")]
807 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
808 pub fn gst_discoverer_container_info_get_tags(
809 info: *const GstDiscovererContainerInfo,
810 ) -> *const gst::GstTagList;
811
812 pub fn gst_discoverer_info_get_type() -> GType;
816 pub fn gst_discoverer_info_from_variant(variant: *mut glib::GVariant)
817 -> *mut GstDiscovererInfo;
818 pub fn gst_discoverer_info_copy(ptr: *mut GstDiscovererInfo) -> *mut GstDiscovererInfo;
819 pub fn gst_discoverer_info_get_audio_streams(info: *mut GstDiscovererInfo) -> *mut glib::GList;
820 pub fn gst_discoverer_info_get_container_streams(
821 info: *mut GstDiscovererInfo,
822 ) -> *mut glib::GList;
823 pub fn gst_discoverer_info_get_duration(info: *const GstDiscovererInfo) -> gst::GstClockTime;
824 pub fn gst_discoverer_info_get_live(info: *const GstDiscovererInfo) -> gboolean;
825 pub fn gst_discoverer_info_get_misc(info: *const GstDiscovererInfo)
826 -> *const gst::GstStructure;
827 pub fn gst_discoverer_info_get_missing_elements_installer_details(
828 info: *const GstDiscovererInfo,
829 ) -> *mut *const c_char;
830 pub fn gst_discoverer_info_get_result(info: *const GstDiscovererInfo) -> GstDiscovererResult;
831 pub fn gst_discoverer_info_get_seekable(info: *const GstDiscovererInfo) -> gboolean;
832 pub fn gst_discoverer_info_get_stream_info(
833 info: *mut GstDiscovererInfo,
834 ) -> *mut GstDiscovererStreamInfo;
835 pub fn gst_discoverer_info_get_stream_list(info: *mut GstDiscovererInfo) -> *mut glib::GList;
836 pub fn gst_discoverer_info_get_streams(
837 info: *mut GstDiscovererInfo,
838 streamtype: GType,
839 ) -> *mut glib::GList;
840 pub fn gst_discoverer_info_get_subtitle_streams(
841 info: *mut GstDiscovererInfo,
842 ) -> *mut glib::GList;
843 pub fn gst_discoverer_info_get_tags(info: *const GstDiscovererInfo) -> *const gst::GstTagList;
844 pub fn gst_discoverer_info_get_toc(info: *const GstDiscovererInfo) -> *const gst::GstToc;
845 pub fn gst_discoverer_info_get_uri(info: *const GstDiscovererInfo) -> *const c_char;
846 pub fn gst_discoverer_info_get_video_streams(info: *mut GstDiscovererInfo) -> *mut glib::GList;
847 pub fn gst_discoverer_info_to_variant(
848 info: *mut GstDiscovererInfo,
849 flags: GstDiscovererSerializeFlags,
850 ) -> *mut glib::GVariant;
851
852 pub fn gst_discoverer_stream_info_get_type() -> GType;
856 pub fn gst_discoverer_stream_info_list_free(infos: *mut glib::GList);
857 pub fn gst_discoverer_stream_info_get_caps(
858 info: *mut GstDiscovererStreamInfo,
859 ) -> *mut gst::GstCaps;
860 pub fn gst_discoverer_stream_info_get_misc(
861 info: *mut GstDiscovererStreamInfo,
862 ) -> *const gst::GstStructure;
863 pub fn gst_discoverer_stream_info_get_next(
864 info: *mut GstDiscovererStreamInfo,
865 ) -> *mut GstDiscovererStreamInfo;
866 pub fn gst_discoverer_stream_info_get_previous(
867 info: *mut GstDiscovererStreamInfo,
868 ) -> *mut GstDiscovererStreamInfo;
869 pub fn gst_discoverer_stream_info_get_stream_id(
870 info: *mut GstDiscovererStreamInfo,
871 ) -> *const c_char;
872 #[cfg(feature = "v1_20")]
873 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
874 pub fn gst_discoverer_stream_info_get_stream_number(
875 info: *mut GstDiscovererStreamInfo,
876 ) -> c_int;
877 pub fn gst_discoverer_stream_info_get_stream_type_nick(
878 info: *mut GstDiscovererStreamInfo,
879 ) -> *const c_char;
880 pub fn gst_discoverer_stream_info_get_tags(
881 info: *mut GstDiscovererStreamInfo,
882 ) -> *const gst::GstTagList;
883 pub fn gst_discoverer_stream_info_get_toc(
884 info: *mut GstDiscovererStreamInfo,
885 ) -> *const gst::GstToc;
886
887 pub fn gst_discoverer_subtitle_info_get_type() -> GType;
891 pub fn gst_discoverer_subtitle_info_get_language(
892 info: *const GstDiscovererSubtitleInfo,
893 ) -> *const c_char;
894
895 pub fn gst_discoverer_video_info_get_type() -> GType;
899 pub fn gst_discoverer_video_info_get_bitrate(info: *const GstDiscovererVideoInfo) -> c_uint;
900 pub fn gst_discoverer_video_info_get_depth(info: *const GstDiscovererVideoInfo) -> c_uint;
901 pub fn gst_discoverer_video_info_get_framerate_denom(
902 info: *const GstDiscovererVideoInfo,
903 ) -> c_uint;
904 pub fn gst_discoverer_video_info_get_framerate_num(
905 info: *const GstDiscovererVideoInfo,
906 ) -> c_uint;
907 pub fn gst_discoverer_video_info_get_height(info: *const GstDiscovererVideoInfo) -> c_uint;
908 pub fn gst_discoverer_video_info_get_max_bitrate(info: *const GstDiscovererVideoInfo)
909 -> c_uint;
910 pub fn gst_discoverer_video_info_get_par_denom(info: *const GstDiscovererVideoInfo) -> c_uint;
911 pub fn gst_discoverer_video_info_get_par_num(info: *const GstDiscovererVideoInfo) -> c_uint;
912 pub fn gst_discoverer_video_info_get_width(info: *const GstDiscovererVideoInfo) -> c_uint;
913 pub fn gst_discoverer_video_info_is_image(info: *const GstDiscovererVideoInfo) -> gboolean;
914 pub fn gst_discoverer_video_info_is_interlaced(info: *const GstDiscovererVideoInfo)
915 -> gboolean;
916
917 pub fn gst_encoding_audio_profile_get_type() -> GType;
921 pub fn gst_encoding_audio_profile_new(
922 format: *mut gst::GstCaps,
923 preset: *const c_char,
924 restriction: *mut gst::GstCaps,
925 presence: c_uint,
926 ) -> *mut GstEncodingAudioProfile;
927
928 pub fn gst_encoding_container_profile_get_type() -> GType;
932 pub fn gst_encoding_container_profile_new(
933 name: *const c_char,
934 description: *const c_char,
935 format: *mut gst::GstCaps,
936 preset: *const c_char,
937 ) -> *mut GstEncodingContainerProfile;
938 pub fn gst_encoding_container_profile_add_profile(
939 container: *mut GstEncodingContainerProfile,
940 profile: *mut GstEncodingProfile,
941 ) -> gboolean;
942 pub fn gst_encoding_container_profile_contains_profile(
943 container: *mut GstEncodingContainerProfile,
944 profile: *mut GstEncodingProfile,
945 ) -> gboolean;
946 pub fn gst_encoding_container_profile_get_profiles(
947 profile: *mut GstEncodingContainerProfile,
948 ) -> *const glib::GList;
949
950 pub fn gst_encoding_profile_get_type() -> GType;
954 pub fn gst_encoding_profile_find(
955 targetname: *const c_char,
956 profilename: *const c_char,
957 category: *const c_char,
958 ) -> *mut GstEncodingProfile;
959 pub fn gst_encoding_profile_from_discoverer(
960 info: *mut GstDiscovererInfo,
961 ) -> *mut GstEncodingProfile;
962 #[cfg(feature = "v1_26")]
963 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
964 pub fn gst_encoding_profile_from_string(string: *const c_char) -> *mut GstEncodingProfile;
965 pub fn gst_encoding_profile_copy(self_: *mut GstEncodingProfile) -> *mut GstEncodingProfile;
966 pub fn gst_encoding_profile_get_allow_dynamic_output(
967 profile: *mut GstEncodingProfile,
968 ) -> gboolean;
969 pub fn gst_encoding_profile_get_description(profile: *mut GstEncodingProfile) -> *const c_char;
970 #[cfg(feature = "v1_20")]
971 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
972 pub fn gst_encoding_profile_get_element_properties(
973 self_: *mut GstEncodingProfile,
974 ) -> *mut gst::GstStructure;
975 pub fn gst_encoding_profile_get_file_extension(
976 profile: *mut GstEncodingProfile,
977 ) -> *const c_char;
978 pub fn gst_encoding_profile_get_format(profile: *mut GstEncodingProfile) -> *mut gst::GstCaps;
979 pub fn gst_encoding_profile_get_input_caps(
980 profile: *mut GstEncodingProfile,
981 ) -> *mut gst::GstCaps;
982 pub fn gst_encoding_profile_get_name(profile: *mut GstEncodingProfile) -> *const c_char;
983 pub fn gst_encoding_profile_get_presence(profile: *mut GstEncodingProfile) -> c_uint;
984 pub fn gst_encoding_profile_get_preset(profile: *mut GstEncodingProfile) -> *const c_char;
985 pub fn gst_encoding_profile_get_preset_name(profile: *mut GstEncodingProfile) -> *const c_char;
986 pub fn gst_encoding_profile_get_restriction(
987 profile: *mut GstEncodingProfile,
988 ) -> *mut gst::GstCaps;
989 #[cfg(feature = "v1_18")]
990 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
991 pub fn gst_encoding_profile_get_single_segment(profile: *mut GstEncodingProfile) -> gboolean;
992 pub fn gst_encoding_profile_get_type_nick(profile: *mut GstEncodingProfile) -> *const c_char;
993 pub fn gst_encoding_profile_is_enabled(profile: *mut GstEncodingProfile) -> gboolean;
994 pub fn gst_encoding_profile_is_equal(
995 a: *mut GstEncodingProfile,
996 b: *mut GstEncodingProfile,
997 ) -> gboolean;
998 pub fn gst_encoding_profile_set_allow_dynamic_output(
999 profile: *mut GstEncodingProfile,
1000 allow_dynamic_output: gboolean,
1001 );
1002 pub fn gst_encoding_profile_set_description(
1003 profile: *mut GstEncodingProfile,
1004 description: *const c_char,
1005 );
1006 #[cfg(feature = "v1_20")]
1007 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1008 pub fn gst_encoding_profile_set_element_properties(
1009 self_: *mut GstEncodingProfile,
1010 element_properties: *mut gst::GstStructure,
1011 );
1012 pub fn gst_encoding_profile_set_enabled(profile: *mut GstEncodingProfile, enabled: gboolean);
1013 pub fn gst_encoding_profile_set_format(
1014 profile: *mut GstEncodingProfile,
1015 format: *mut gst::GstCaps,
1016 );
1017 pub fn gst_encoding_profile_set_name(profile: *mut GstEncodingProfile, name: *const c_char);
1018 pub fn gst_encoding_profile_set_presence(profile: *mut GstEncodingProfile, presence: c_uint);
1019 pub fn gst_encoding_profile_set_preset(profile: *mut GstEncodingProfile, preset: *const c_char);
1020 pub fn gst_encoding_profile_set_preset_name(
1021 profile: *mut GstEncodingProfile,
1022 preset_name: *const c_char,
1023 );
1024 pub fn gst_encoding_profile_set_restriction(
1025 profile: *mut GstEncodingProfile,
1026 restriction: *mut gst::GstCaps,
1027 );
1028 #[cfg(feature = "v1_18")]
1029 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1030 pub fn gst_encoding_profile_set_single_segment(
1031 profile: *mut GstEncodingProfile,
1032 single_segment: gboolean,
1033 );
1034 #[cfg(feature = "v1_26")]
1035 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1036 pub fn gst_encoding_profile_to_string(profile: *mut GstEncodingProfile) -> *mut c_char;
1037
1038 pub fn gst_encoding_target_get_type() -> GType;
1042 pub fn gst_encoding_target_new(
1043 name: *const c_char,
1044 category: *const c_char,
1045 description: *const c_char,
1046 profiles: *const glib::GList,
1047 ) -> *mut GstEncodingTarget;
1048 pub fn gst_encoding_target_load(
1049 name: *const c_char,
1050 category: *const c_char,
1051 error: *mut *mut glib::GError,
1052 ) -> *mut GstEncodingTarget;
1053 pub fn gst_encoding_target_load_from_file(
1054 filepath: *const c_char,
1055 error: *mut *mut glib::GError,
1056 ) -> *mut GstEncodingTarget;
1057 pub fn gst_encoding_target_add_profile(
1058 target: *mut GstEncodingTarget,
1059 profile: *mut GstEncodingProfile,
1060 ) -> gboolean;
1061 pub fn gst_encoding_target_get_category(target: *mut GstEncodingTarget) -> *const c_char;
1062 pub fn gst_encoding_target_get_description(target: *mut GstEncodingTarget) -> *const c_char;
1063 pub fn gst_encoding_target_get_name(target: *mut GstEncodingTarget) -> *const c_char;
1064 #[cfg(feature = "v1_18")]
1065 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1066 pub fn gst_encoding_target_get_path(target: *mut GstEncodingTarget) -> *const c_char;
1067 pub fn gst_encoding_target_get_profile(
1068 target: *mut GstEncodingTarget,
1069 name: *const c_char,
1070 ) -> *mut GstEncodingProfile;
1071 pub fn gst_encoding_target_get_profiles(target: *mut GstEncodingTarget) -> *const glib::GList;
1072 pub fn gst_encoding_target_save(
1073 target: *mut GstEncodingTarget,
1074 error: *mut *mut glib::GError,
1075 ) -> gboolean;
1076 pub fn gst_encoding_target_save_to_file(
1077 target: *mut GstEncodingTarget,
1078 filepath: *const c_char,
1079 error: *mut *mut glib::GError,
1080 ) -> gboolean;
1081
1082 pub fn gst_encoding_video_profile_get_type() -> GType;
1086 pub fn gst_encoding_video_profile_new(
1087 format: *mut gst::GstCaps,
1088 preset: *const c_char,
1089 restriction: *mut gst::GstCaps,
1090 presence: c_uint,
1091 ) -> *mut GstEncodingVideoProfile;
1092 pub fn gst_encoding_video_profile_get_pass(prof: *mut GstEncodingVideoProfile) -> c_uint;
1093 pub fn gst_encoding_video_profile_get_variableframerate(
1094 prof: *mut GstEncodingVideoProfile,
1095 ) -> gboolean;
1096 pub fn gst_encoding_video_profile_set_pass(prof: *mut GstEncodingVideoProfile, pass: c_uint);
1097 pub fn gst_encoding_video_profile_set_variableframerate(
1098 prof: *mut GstEncodingVideoProfile,
1099 variableframerate: gboolean,
1100 );
1101
1102 pub fn gst_codec_utils_aac_caps_set_level_and_profile(
1106 caps: *mut gst::GstCaps,
1107 audio_config: *const u8,
1108 len: c_uint,
1109 ) -> gboolean;
1110 pub fn gst_codec_utils_aac_get_channels(audio_config: *const u8, len: c_uint) -> c_uint;
1111 pub fn gst_codec_utils_aac_get_index_from_sample_rate(rate: c_uint) -> c_int;
1112 pub fn gst_codec_utils_aac_get_level(audio_config: *const u8, len: c_uint) -> *const c_char;
1113 pub fn gst_codec_utils_aac_get_profile(audio_config: *const u8, len: c_uint) -> *const c_char;
1114 pub fn gst_codec_utils_aac_get_sample_rate(audio_config: *const u8, len: c_uint) -> c_uint;
1115 pub fn gst_codec_utils_aac_get_sample_rate_from_index(sr_idx: c_uint) -> c_uint;
1116 #[cfg(feature = "v1_26")]
1117 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1118 pub fn gst_codec_utils_av1_create_av1c_from_caps(
1119 caps: *mut gst::GstCaps,
1120 ) -> *mut gst::GstBuffer;
1121 #[cfg(feature = "v1_26")]
1122 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1123 pub fn gst_codec_utils_av1_create_caps_from_av1c(
1124 av1c: *mut gst::GstBuffer,
1125 ) -> *mut gst::GstCaps;
1126 #[cfg(feature = "v1_26")]
1127 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1128 pub fn gst_codec_utils_av1_get_level(seq_level_idx: u8) -> *const c_char;
1129 #[cfg(feature = "v1_26")]
1130 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1131 pub fn gst_codec_utils_av1_get_seq_level_idx(level: *const c_char) -> u8;
1132 #[cfg(feature = "v1_22")]
1133 #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1134 pub fn gst_codec_utils_caps_from_mime_codec(codecs_field: *const c_char) -> *mut gst::GstCaps;
1135 #[cfg(feature = "v1_20")]
1136 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1137 pub fn gst_codec_utils_caps_get_mime_codec(caps: *mut gst::GstCaps) -> *mut c_char;
1138 pub fn gst_codec_utils_h264_caps_set_level_and_profile(
1139 caps: *mut gst::GstCaps,
1140 sps: *const u8,
1141 len: c_uint,
1142 ) -> gboolean;
1143 pub fn gst_codec_utils_h264_get_level(sps: *const u8, len: c_uint) -> *const c_char;
1144 pub fn gst_codec_utils_h264_get_level_idc(level: *const c_char) -> u8;
1145 #[cfg(feature = "v1_30")]
1146 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
1147 pub fn gst_codec_utils_h264_get_level_limits(
1148 width: c_int,
1149 height: c_int,
1150 fps_n: c_int,
1151 fps_d: c_int,
1152 bitrate: c_uint,
1153 max_dec_frame_buffering: c_uint,
1154 profile_idc: u8,
1155 ) -> *const GstH264LevelLimits;
1156 pub fn gst_codec_utils_h264_get_profile(sps: *const u8, len: c_uint) -> *const c_char;
1157 #[cfg(feature = "v1_20")]
1158 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1159 pub fn gst_codec_utils_h264_get_profile_flags_level(
1160 codec_data: *const u8,
1161 len: c_uint,
1162 profile: *mut u8,
1163 flags: *mut u8,
1164 level: *mut u8,
1165 ) -> gboolean;
1166 pub fn gst_codec_utils_h265_caps_set_level_tier_and_profile(
1167 caps: *mut gst::GstCaps,
1168 profile_tier_level: *const u8,
1169 len: c_uint,
1170 ) -> gboolean;
1171 pub fn gst_codec_utils_h265_get_level(
1172 profile_tier_level: *const u8,
1173 len: c_uint,
1174 ) -> *const c_char;
1175 pub fn gst_codec_utils_h265_get_level_idc(level: *const c_char) -> u8;
1176 pub fn gst_codec_utils_h265_get_profile(
1177 profile_tier_level: *const u8,
1178 len: c_uint,
1179 ) -> *const c_char;
1180 pub fn gst_codec_utils_h265_get_tier(
1181 profile_tier_level: *const u8,
1182 len: c_uint,
1183 ) -> *const c_char;
1184 #[cfg(feature = "v1_26")]
1185 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1186 pub fn gst_codec_utils_h266_caps_set_level_tier_and_profile(
1187 caps: *mut gst::GstCaps,
1188 decoder_configuration: *const u8,
1189 len: c_uint,
1190 ) -> gboolean;
1191 #[cfg(feature = "v1_26")]
1192 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1193 pub fn gst_codec_utils_h266_get_level(ptl_record: *const u8, len: c_uint) -> *const c_char;
1194 #[cfg(feature = "v1_26")]
1195 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1196 pub fn gst_codec_utils_h266_get_level_idc(level: *const c_char) -> u8;
1197 #[cfg(feature = "v1_26")]
1198 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1199 pub fn gst_codec_utils_h266_get_profile(ptl_record: *const u8, len: c_uint) -> *const c_char;
1200 #[cfg(feature = "v1_26")]
1201 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1202 pub fn gst_codec_utils_h266_get_tier(ptl_record: *const u8, len: c_uint) -> *const c_char;
1203 pub fn gst_codec_utils_mpeg4video_caps_set_level_and_profile(
1204 caps: *mut gst::GstCaps,
1205 vis_obj_seq: *const u8,
1206 len: c_uint,
1207 ) -> gboolean;
1208 pub fn gst_codec_utils_mpeg4video_get_level(
1209 vis_obj_seq: *const u8,
1210 len: c_uint,
1211 ) -> *const c_char;
1212 pub fn gst_codec_utils_mpeg4video_get_profile(
1213 vis_obj_seq: *const u8,
1214 len: c_uint,
1215 ) -> *const c_char;
1216 pub fn gst_codec_utils_opus_create_caps(
1217 rate: u32,
1218 channels: u8,
1219 channel_mapping_family: u8,
1220 stream_count: u8,
1221 coupled_count: u8,
1222 channel_mapping: *const u8,
1223 ) -> *mut gst::GstCaps;
1224 pub fn gst_codec_utils_opus_create_caps_from_header(
1225 header: *mut gst::GstBuffer,
1226 comments: *mut gst::GstBuffer,
1227 ) -> *mut gst::GstCaps;
1228 pub fn gst_codec_utils_opus_create_header(
1229 rate: u32,
1230 channels: u8,
1231 channel_mapping_family: u8,
1232 stream_count: u8,
1233 coupled_count: u8,
1234 channel_mapping: *const u8,
1235 pre_skip: u16,
1236 output_gain: i16,
1237 ) -> *mut gst::GstBuffer;
1238 pub fn gst_codec_utils_opus_parse_caps(
1239 caps: *mut gst::GstCaps,
1240 rate: *mut u32,
1241 channels: *mut u8,
1242 channel_mapping_family: *mut u8,
1243 stream_count: *mut u8,
1244 coupled_count: *mut u8,
1245 channel_mapping: *mut [u8; 256],
1246 ) -> gboolean;
1247 pub fn gst_codec_utils_opus_parse_header(
1248 header: *mut gst::GstBuffer,
1249 rate: *mut u32,
1250 channels: *mut u8,
1251 channel_mapping_family: *mut u8,
1252 stream_count: *mut u8,
1253 coupled_count: *mut u8,
1254 channel_mapping: *mut [u8; 256],
1255 pre_skip: *mut u16,
1256 output_gain: *mut i16,
1257 ) -> gboolean;
1258 #[cfg(feature = "v1_30")]
1259 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
1260 pub fn gst_codec_utils_vp9_estimate_level_idc_from_caps(caps: *const gst::GstCaps) -> u8;
1261 #[cfg(feature = "v1_30")]
1262 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
1263 pub fn gst_codec_utils_vp9_get_level(level_idc: u8) -> *const c_char;
1264 #[cfg(feature = "v1_30")]
1265 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
1266 pub fn gst_codec_utils_vp9_get_level_idc(level: *const c_char) -> u8;
1267 #[cfg(feature = "v1_30")]
1268 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
1269 pub fn gst_codec_utils_vpx_caps_get_config(
1270 caps: *mut gst::GstCaps,
1271 vpx_version: *mut c_int,
1272 profile: *mut u8,
1273 level: *mut u8,
1274 bit_depth: *mut u8,
1275 chroma_subsampling: *mut u8,
1276 video_full_range: *mut gboolean,
1277 colour_primaries: *mut u8,
1278 transfer_characteristics: *mut u8,
1279 matrix_coefficients: *mut u8,
1280 ) -> gboolean;
1281 #[cfg(feature = "v1_30")]
1282 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
1283 pub fn gst_codec_utils_vpx_caps_set_format_fields(
1284 caps: *mut gst::GstCaps,
1285 profile: c_int,
1286 level: c_int,
1287 bit_depth: c_int,
1288 chroma_subsampling: c_int,
1289 ) -> gboolean;
1290 #[cfg(feature = "v1_30")]
1291 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
1292 pub fn gst_codec_utils_vpx_create_vpcc_from_caps(
1293 caps: *mut gst::GstCaps,
1294 ) -> *mut gst::GstBuffer;
1295 pub fn gst_encoding_list_all_targets(categoryname: *const c_char) -> *mut glib::GList;
1296 pub fn gst_encoding_list_available_categories() -> *mut glib::GList;
1297 pub fn gst_install_plugins_async(
1298 details: *const *const c_char,
1299 ctx: *mut GstInstallPluginsContext,
1300 func: GstInstallPluginsResultFunc,
1301 user_data: gpointer,
1302 ) -> GstInstallPluginsReturn;
1303 pub fn gst_install_plugins_installation_in_progress() -> gboolean;
1304 pub fn gst_install_plugins_supported() -> gboolean;
1305 pub fn gst_install_plugins_sync(
1306 details: *const *const c_char,
1307 ctx: *mut GstInstallPluginsContext,
1308 ) -> GstInstallPluginsReturn;
1309 pub fn gst_is_missing_plugin_message(msg: *mut gst::GstMessage) -> gboolean;
1310 pub fn gst_missing_decoder_installer_detail_new(
1311 decode_caps: *const gst::GstCaps,
1312 ) -> *mut c_char;
1313 pub fn gst_missing_decoder_message_new(
1314 element: *mut gst::GstElement,
1315 decode_caps: *const gst::GstCaps,
1316 ) -> *mut gst::GstMessage;
1317 pub fn gst_missing_element_installer_detail_new(factory_name: *const c_char) -> *mut c_char;
1318 pub fn gst_missing_element_message_new(
1319 element: *mut gst::GstElement,
1320 factory_name: *const c_char,
1321 ) -> *mut gst::GstMessage;
1322 pub fn gst_missing_encoder_installer_detail_new(
1323 encode_caps: *const gst::GstCaps,
1324 ) -> *mut c_char;
1325 pub fn gst_missing_encoder_message_new(
1326 element: *mut gst::GstElement,
1327 encode_caps: *const gst::GstCaps,
1328 ) -> *mut gst::GstMessage;
1329 pub fn gst_missing_plugin_message_get_description(msg: *mut gst::GstMessage) -> *mut c_char;
1330 pub fn gst_missing_plugin_message_get_installer_detail(
1331 msg: *mut gst::GstMessage,
1332 ) -> *mut c_char;
1333 #[cfg(feature = "v1_26")]
1334 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1335 pub fn gst_missing_plugin_message_get_stream_id(msg: *mut gst::GstMessage) -> *const c_char;
1336 #[cfg(feature = "v1_26")]
1337 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1338 pub fn gst_missing_plugin_message_set_stream_id(
1339 msg: *mut gst::GstMessage,
1340 stream_id: *const c_char,
1341 );
1342 pub fn gst_missing_uri_sink_installer_detail_new(protocol: *const c_char) -> *mut c_char;
1343 pub fn gst_missing_uri_sink_message_new(
1344 element: *mut gst::GstElement,
1345 protocol: *const c_char,
1346 ) -> *mut gst::GstMessage;
1347 pub fn gst_missing_uri_source_installer_detail_new(protocol: *const c_char) -> *mut c_char;
1348 pub fn gst_missing_uri_source_message_new(
1349 element: *mut gst::GstElement,
1350 protocol: *const c_char,
1351 ) -> *mut gst::GstMessage;
1352 pub fn gst_pb_utils_add_codec_description_to_tag_list(
1353 taglist: *mut gst::GstTagList,
1354 codec_tag: *const c_char,
1355 caps: *const gst::GstCaps,
1356 ) -> gboolean;
1357 #[cfg(feature = "v1_20")]
1358 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1359 pub fn gst_pb_utils_get_caps_description_flags(
1360 caps: *const gst::GstCaps,
1361 ) -> GstPbUtilsCapsDescriptionFlags;
1362 pub fn gst_pb_utils_get_codec_description(caps: *const gst::GstCaps) -> *mut c_char;
1363 pub fn gst_pb_utils_get_decoder_description(caps: *const gst::GstCaps) -> *mut c_char;
1364 pub fn gst_pb_utils_get_element_description(factory_name: *const c_char) -> *mut c_char;
1365 pub fn gst_pb_utils_get_encoder_description(caps: *const gst::GstCaps) -> *mut c_char;
1366 #[cfg(feature = "v1_20")]
1367 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1368 pub fn gst_pb_utils_get_file_extension_from_caps(caps: *const gst::GstCaps) -> *mut c_char;
1369 pub fn gst_pb_utils_get_sink_description(protocol: *const c_char) -> *mut c_char;
1370 pub fn gst_pb_utils_get_source_description(protocol: *const c_char) -> *mut c_char;
1371 pub fn gst_pb_utils_init();
1372 pub fn gst_plugins_base_version(
1373 major: *mut c_uint,
1374 minor: *mut c_uint,
1375 micro: *mut c_uint,
1376 nano: *mut c_uint,
1377 );
1378 pub fn gst_plugins_base_version_string() -> *mut c_char;
1379
1380}