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 gstreamer_sys as gst;
17
18#[cfg(unix)]
19#[allow(unused_imports)]
20use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
21#[allow(unused_imports)]
22use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
23#[allow(unused_imports)]
24use std::ffi::{
25 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
26};
27
28#[allow(unused_imports)]
29use glib::{gboolean, gconstpointer, gpointer, GType};
30
31pub type GstMediaSourceEOSError = c_int;
33pub const GST_MEDIA_SOURCE_EOS_ERROR_NONE: GstMediaSourceEOSError = 0;
34pub const GST_MEDIA_SOURCE_EOS_ERROR_NETWORK: GstMediaSourceEOSError = 1;
35pub const GST_MEDIA_SOURCE_EOS_ERROR_DECODE: GstMediaSourceEOSError = 2;
36
37pub type GstMediaSourceError = c_int;
38pub const GST_MEDIA_SOURCE_ERROR_INVALID_STATE: GstMediaSourceError = 0;
39pub const GST_MEDIA_SOURCE_ERROR_TYPE: GstMediaSourceError = 1;
40pub const GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED: GstMediaSourceError = 2;
41pub const GST_MEDIA_SOURCE_ERROR_NOT_FOUND: GstMediaSourceError = 3;
42pub const GST_MEDIA_SOURCE_ERROR_QUOTA_EXCEEDED: GstMediaSourceError = 4;
43
44pub type GstMediaSourceReadyState = c_int;
45pub const GST_MEDIA_SOURCE_READY_STATE_CLOSED: GstMediaSourceReadyState = 0;
46pub const GST_MEDIA_SOURCE_READY_STATE_OPEN: GstMediaSourceReadyState = 1;
47pub const GST_MEDIA_SOURCE_READY_STATE_ENDED: GstMediaSourceReadyState = 2;
48
49pub type GstMseSrcReadyState = c_int;
50pub const GST_MSE_SRC_READY_STATE_HAVE_NOTHING: GstMseSrcReadyState = 0;
51pub const GST_MSE_SRC_READY_STATE_HAVE_METADATA: GstMseSrcReadyState = 1;
52pub const GST_MSE_SRC_READY_STATE_HAVE_CURRENT_DATA: GstMseSrcReadyState = 2;
53pub const GST_MSE_SRC_READY_STATE_HAVE_FUTURE_DATA: GstMseSrcReadyState = 3;
54pub const GST_MSE_SRC_READY_STATE_HAVE_ENOUGH_DATA: GstMseSrcReadyState = 4;
55
56pub type GstSourceBufferAppendMode = c_int;
57pub const GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS: GstSourceBufferAppendMode = 0;
58pub const GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE: GstSourceBufferAppendMode = 1;
59
60#[derive(Copy, Clone)]
62#[repr(C)]
63pub struct GstMediaSourceClass {
64 pub parent_class: gst::GstObjectClass,
65}
66
67impl ::std::fmt::Debug for GstMediaSourceClass {
68 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
69 f.debug_struct(&format!("GstMediaSourceClass @ {self:p}"))
70 .field("parent_class", &self.parent_class)
71 .finish()
72 }
73}
74
75#[derive(Copy, Clone)]
76#[repr(C)]
77pub struct GstMediaSourceRange {
78 pub start: gst::GstClockTime,
79 pub end: gst::GstClockTime,
80}
81
82impl ::std::fmt::Debug for GstMediaSourceRange {
83 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
84 f.debug_struct(&format!("GstMediaSourceRange @ {self:p}"))
85 .field("start", &self.start)
86 .field("end", &self.end)
87 .finish()
88 }
89}
90
91#[derive(Copy, Clone)]
92#[repr(C)]
93pub struct GstMseSrcClass {
94 pub parent_class: gst::GstElementClass,
95}
96
97impl ::std::fmt::Debug for GstMseSrcClass {
98 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
99 f.debug_struct(&format!("GstMseSrcClass @ {self:p}"))
100 .field("parent_class", &self.parent_class)
101 .finish()
102 }
103}
104
105#[derive(Copy, Clone)]
106#[repr(C)]
107pub struct GstMseSrcPadClass {
108 pub parent_class: gst::GstPadClass,
109}
110
111impl ::std::fmt::Debug for GstMseSrcPadClass {
112 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
113 f.debug_struct(&format!("GstMseSrcPadClass @ {self:p}"))
114 .field("parent_class", &self.parent_class)
115 .finish()
116 }
117}
118
119#[derive(Copy, Clone)]
120#[repr(C)]
121pub struct GstSourceBufferClass {
122 pub parent_class: gst::GstObjectClass,
123}
124
125impl ::std::fmt::Debug for GstSourceBufferClass {
126 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
127 f.debug_struct(&format!("GstSourceBufferClass @ {self:p}"))
128 .field("parent_class", &self.parent_class)
129 .finish()
130 }
131}
132
133#[derive(Copy, Clone)]
134#[repr(C)]
135pub struct GstSourceBufferInterval {
136 pub start: gst::GstClockTime,
137 pub end: gst::GstClockTime,
138}
139
140impl ::std::fmt::Debug for GstSourceBufferInterval {
141 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
142 f.debug_struct(&format!("GstSourceBufferInterval @ {self:p}"))
143 .field("start", &self.start)
144 .field("end", &self.end)
145 .finish()
146 }
147}
148
149#[derive(Copy, Clone)]
150#[repr(C)]
151pub struct GstSourceBufferListClass {
152 pub parent_class: gst::GstObjectClass,
153}
154
155impl ::std::fmt::Debug for GstSourceBufferListClass {
156 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
157 f.debug_struct(&format!("GstSourceBufferListClass @ {self:p}"))
158 .field("parent_class", &self.parent_class)
159 .finish()
160 }
161}
162
163#[repr(C)]
165#[allow(dead_code)]
166pub struct GstMediaSource {
167 _data: [u8; 0],
168 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
169}
170
171impl ::std::fmt::Debug for GstMediaSource {
172 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
173 f.debug_struct(&format!("GstMediaSource @ {self:p}"))
174 .finish()
175 }
176}
177
178#[repr(C)]
179#[allow(dead_code)]
180pub struct GstMseSrc {
181 _data: [u8; 0],
182 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
183}
184
185impl ::std::fmt::Debug for GstMseSrc {
186 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
187 f.debug_struct(&format!("GstMseSrc @ {self:p}")).finish()
188 }
189}
190
191#[repr(C)]
192#[allow(dead_code)]
193pub struct GstMseSrcPad {
194 _data: [u8; 0],
195 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
196}
197
198impl ::std::fmt::Debug for GstMseSrcPad {
199 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
200 f.debug_struct(&format!("GstMseSrcPad @ {self:p}")).finish()
201 }
202}
203
204#[repr(C)]
205#[allow(dead_code)]
206pub struct GstSourceBuffer {
207 _data: [u8; 0],
208 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
209}
210
211impl ::std::fmt::Debug for GstSourceBuffer {
212 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
213 f.debug_struct(&format!("GstSourceBuffer @ {self:p}"))
214 .finish()
215 }
216}
217
218#[repr(C)]
219#[allow(dead_code)]
220pub struct GstSourceBufferList {
221 _data: [u8; 0],
222 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
223}
224
225impl ::std::fmt::Debug for GstSourceBufferList {
226 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
227 f.debug_struct(&format!("GstSourceBufferList @ {self:p}"))
228 .finish()
229 }
230}
231
232extern "C" {
233
234 pub fn gst_media_source_eos_error_get_type() -> GType;
238
239 pub fn gst_media_source_error_get_type() -> GType;
243 pub fn gst_media_source_error_quark() -> glib::GQuark;
244
245 pub fn gst_media_source_ready_state_get_type() -> GType;
249
250 pub fn gst_mse_src_ready_state_get_type() -> GType;
254
255 pub fn gst_source_buffer_append_mode_get_type() -> GType;
259
260 pub fn gst_media_source_get_type() -> GType;
264 pub fn gst_media_source_new() -> *mut GstMediaSource;
265 pub fn gst_media_source_is_type_supported(type_: *const c_char) -> gboolean;
266 pub fn gst_media_source_add_source_buffer(
267 self_: *mut GstMediaSource,
268 type_: *const c_char,
269 error: *mut *mut glib::GError,
270 ) -> *mut GstSourceBuffer;
271 pub fn gst_media_source_attach(self_: *mut GstMediaSource, element: *mut GstMseSrc);
272 pub fn gst_media_source_clear_live_seekable_range(
273 self_: *mut GstMediaSource,
274 error: *mut *mut glib::GError,
275 ) -> gboolean;
276 pub fn gst_media_source_detach(self_: *mut GstMediaSource);
277 pub fn gst_media_source_end_of_stream(
278 self_: *mut GstMediaSource,
279 eos_error: GstMediaSourceEOSError,
280 error: *mut *mut glib::GError,
281 ) -> gboolean;
282 pub fn gst_media_source_get_active_source_buffers(
283 self_: *mut GstMediaSource,
284 ) -> *mut GstSourceBufferList;
285 pub fn gst_media_source_get_duration(self_: *mut GstMediaSource) -> gst::GstClockTime;
286 pub fn gst_media_source_get_live_seekable_range(
287 self_: *mut GstMediaSource,
288 range: *mut GstMediaSourceRange,
289 );
290 pub fn gst_media_source_get_position(self_: *mut GstMediaSource) -> gst::GstClockTime;
291 pub fn gst_media_source_get_ready_state(self_: *mut GstMediaSource)
292 -> GstMediaSourceReadyState;
293 pub fn gst_media_source_get_source_buffers(
294 self_: *mut GstMediaSource,
295 ) -> *mut GstSourceBufferList;
296 pub fn gst_media_source_remove_source_buffer(
297 self_: *mut GstMediaSource,
298 buffer: *mut GstSourceBuffer,
299 error: *mut *mut glib::GError,
300 ) -> gboolean;
301 pub fn gst_media_source_set_duration(
302 self_: *mut GstMediaSource,
303 duration: gst::GstClockTime,
304 error: *mut *mut glib::GError,
305 ) -> gboolean;
306 pub fn gst_media_source_set_live_seekable_range(
307 self_: *mut GstMediaSource,
308 start: gst::GstClockTime,
309 end: gst::GstClockTime,
310 error: *mut *mut glib::GError,
311 ) -> gboolean;
312
313 pub fn gst_mse_src_get_type() -> GType;
317 pub fn gst_mse_src_get_duration(self_: *mut GstMseSrc) -> gst::GstClockTime;
318 pub fn gst_mse_src_get_n_audio(self_: *mut GstMseSrc) -> c_uint;
319 pub fn gst_mse_src_get_n_text(self_: *mut GstMseSrc) -> c_uint;
320 pub fn gst_mse_src_get_n_video(self_: *mut GstMseSrc) -> c_uint;
321 pub fn gst_mse_src_get_position(self_: *mut GstMseSrc) -> gst::GstClockTime;
322 pub fn gst_mse_src_get_ready_state(self_: *mut GstMseSrc) -> GstMseSrcReadyState;
323
324 pub fn gst_mse_src_pad_get_type() -> GType;
328
329 pub fn gst_source_buffer_get_type() -> GType;
333 pub fn gst_source_buffer_abort(
334 self_: *mut GstSourceBuffer,
335 error: *mut *mut glib::GError,
336 ) -> gboolean;
337 pub fn gst_source_buffer_append_buffer(
338 self_: *mut GstSourceBuffer,
339 buf: *mut gst::GstBuffer,
340 error: *mut *mut glib::GError,
341 ) -> gboolean;
342 pub fn gst_source_buffer_change_content_type(
343 self_: *mut GstSourceBuffer,
344 type_: *const c_char,
345 error: *mut *mut glib::GError,
346 ) -> gboolean;
347 pub fn gst_source_buffer_get_append_mode(
348 self_: *mut GstSourceBuffer,
349 ) -> GstSourceBufferAppendMode;
350 pub fn gst_source_buffer_get_append_window_end(
351 self_: *mut GstSourceBuffer,
352 ) -> gst::GstClockTime;
353 pub fn gst_source_buffer_get_append_window_start(
354 self_: *mut GstSourceBuffer,
355 ) -> gst::GstClockTime;
356 pub fn gst_source_buffer_get_buffered(
357 self_: *mut GstSourceBuffer,
358 error: *mut *mut glib::GError,
359 ) -> *mut glib::GArray;
360 pub fn gst_source_buffer_get_content_type(self_: *mut GstSourceBuffer) -> *mut c_char;
361 pub fn gst_source_buffer_get_timestamp_offset(self_: *mut GstSourceBuffer)
362 -> gst::GstClockTime;
363 pub fn gst_source_buffer_get_updating(self_: *mut GstSourceBuffer) -> gboolean;
364 pub fn gst_source_buffer_remove(
365 self_: *mut GstSourceBuffer,
366 start: gst::GstClockTime,
367 end: gst::GstClockTime,
368 error: *mut *mut glib::GError,
369 ) -> gboolean;
370 pub fn gst_source_buffer_set_append_mode(
371 self_: *mut GstSourceBuffer,
372 mode: GstSourceBufferAppendMode,
373 error: *mut *mut glib::GError,
374 ) -> gboolean;
375 pub fn gst_source_buffer_set_append_window_end(
376 self_: *mut GstSourceBuffer,
377 end: gst::GstClockTime,
378 error: *mut *mut glib::GError,
379 ) -> gboolean;
380 pub fn gst_source_buffer_set_append_window_start(
381 self_: *mut GstSourceBuffer,
382 start: gst::GstClockTime,
383 error: *mut *mut glib::GError,
384 ) -> gboolean;
385 pub fn gst_source_buffer_set_timestamp_offset(
386 self_: *mut GstSourceBuffer,
387 offset: gst::GstClockTime,
388 error: *mut *mut glib::GError,
389 ) -> gboolean;
390
391 pub fn gst_source_buffer_list_get_type() -> GType;
395 pub fn gst_source_buffer_list_get_length(self_: *mut GstSourceBufferList) -> c_uint;
396 pub fn gst_source_buffer_list_index(
397 self_: *mut GstSourceBufferList,
398 index: c_uint,
399 ) -> *mut GstSourceBuffer;
400
401}