gstreamer_rtsp_server_sys/
lib.rs

Help
1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
4// DO NOT EDIT
5
6#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8    clippy::approx_constant,
9    clippy::type_complexity,
10    clippy::unreadable_literal,
11    clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use gio_sys as gio;
16use glib_sys as glib;
17use gobject_sys as gobject;
18use gstreamer_net_sys as gst_net;
19use gstreamer_rtsp_sys as gst_rtsp;
20use gstreamer_sdp_sys as gst_sdp;
21use gstreamer_sys as gst;
22
23#[cfg(unix)]
24#[allow(unused_imports)]
25use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
26#[allow(unused_imports)]
27use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
28#[allow(unused_imports)]
29use std::ffi::{
30    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
31};
32
33#[allow(unused_imports)]
34use glib::{gboolean, gconstpointer, gpointer, GType};
35
36// Enums
37pub type GstRTSPAddressPoolResult = c_int;
38pub const GST_RTSP_ADDRESS_POOL_OK: GstRTSPAddressPoolResult = 0;
39pub const GST_RTSP_ADDRESS_POOL_EINVAL: GstRTSPAddressPoolResult = -1;
40pub const GST_RTSP_ADDRESS_POOL_ERESERVED: GstRTSPAddressPoolResult = -2;
41pub const GST_RTSP_ADDRESS_POOL_ERANGE: GstRTSPAddressPoolResult = -3;
42pub const GST_RTSP_ADDRESS_POOL_ELAST: GstRTSPAddressPoolResult = -4;
43
44pub type GstRTSPFilterResult = c_int;
45pub const GST_RTSP_FILTER_REMOVE: GstRTSPFilterResult = 0;
46pub const GST_RTSP_FILTER_KEEP: GstRTSPFilterResult = 1;
47pub const GST_RTSP_FILTER_REF: GstRTSPFilterResult = 2;
48
49pub type GstRTSPMediaStatus = c_int;
50pub const GST_RTSP_MEDIA_STATUS_UNPREPARED: GstRTSPMediaStatus = 0;
51pub const GST_RTSP_MEDIA_STATUS_UNPREPARING: GstRTSPMediaStatus = 1;
52pub const GST_RTSP_MEDIA_STATUS_PREPARING: GstRTSPMediaStatus = 2;
53pub const GST_RTSP_MEDIA_STATUS_PREPARED: GstRTSPMediaStatus = 3;
54pub const GST_RTSP_MEDIA_STATUS_SUSPENDED: GstRTSPMediaStatus = 4;
55pub const GST_RTSP_MEDIA_STATUS_ERROR: GstRTSPMediaStatus = 5;
56
57pub type GstRTSPPublishClockMode = c_int;
58pub const GST_RTSP_PUBLISH_CLOCK_MODE_NONE: GstRTSPPublishClockMode = 0;
59pub const GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK: GstRTSPPublishClockMode = 1;
60pub const GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK_AND_OFFSET: GstRTSPPublishClockMode = 2;
61
62pub type GstRTSPSuspendMode = c_int;
63pub const GST_RTSP_SUSPEND_MODE_NONE: GstRTSPSuspendMode = 0;
64pub const GST_RTSP_SUSPEND_MODE_PAUSE: GstRTSPSuspendMode = 1;
65pub const GST_RTSP_SUSPEND_MODE_RESET: GstRTSPSuspendMode = 2;
66
67pub type GstRTSPThreadType = c_int;
68pub const GST_RTSP_THREAD_TYPE_CLIENT: GstRTSPThreadType = 0;
69pub const GST_RTSP_THREAD_TYPE_MEDIA: GstRTSPThreadType = 1;
70
71// Constants
72pub const GST_RTSP_ADDRESS_POOL_ANY_IPV4: &[u8] = b"0.0.0.0\0";
73pub const GST_RTSP_ADDRESS_POOL_ANY_IPV6: &[u8] = b"::\0";
74pub const GST_RTSP_AUTH_CHECK_CONNECT: &[u8] = b"auth.check.connect\0";
75pub const GST_RTSP_AUTH_CHECK_MEDIA_FACTORY_ACCESS: &[u8] = b"auth.check.media.factory.access\0";
76pub const GST_RTSP_AUTH_CHECK_MEDIA_FACTORY_CONSTRUCT: &[u8] =
77    b"auth.check.media.factory.construct\0";
78pub const GST_RTSP_AUTH_CHECK_TRANSPORT_CLIENT_SETTINGS: &[u8] =
79    b"auth.check.transport.client-settings\0";
80pub const GST_RTSP_AUTH_CHECK_URL: &[u8] = b"auth.check.url\0";
81pub const GST_RTSP_ONVIF_BACKCHANNEL_REQUIREMENT: &[u8] = b"www.onvif.org/ver20/backchannel\0";
82pub const GST_RTSP_ONVIF_REPLAY_REQUIREMENT: &[u8] = b"onvif-replay\0";
83pub const GST_RTSP_PERM_MEDIA_FACTORY_ACCESS: &[u8] = b"media.factory.access\0";
84pub const GST_RTSP_PERM_MEDIA_FACTORY_CONSTRUCT: &[u8] = b"media.factory.construct\0";
85pub const GST_RTSP_TOKEN_MEDIA_FACTORY_ROLE: &[u8] = b"media.factory.role\0";
86pub const GST_RTSP_TOKEN_TRANSPORT_CLIENT_SETTINGS: &[u8] = b"transport.client-settings\0";
87
88// Flags
89pub type GstRTSPAddressFlags = c_uint;
90pub const GST_RTSP_ADDRESS_FLAG_NONE: GstRTSPAddressFlags = 0;
91pub const GST_RTSP_ADDRESS_FLAG_IPV4: GstRTSPAddressFlags = 1;
92pub const GST_RTSP_ADDRESS_FLAG_IPV6: GstRTSPAddressFlags = 2;
93pub const GST_RTSP_ADDRESS_FLAG_EVEN_PORT: GstRTSPAddressFlags = 4;
94pub const GST_RTSP_ADDRESS_FLAG_MULTICAST: GstRTSPAddressFlags = 8;
95pub const GST_RTSP_ADDRESS_FLAG_UNICAST: GstRTSPAddressFlags = 16;
96
97pub type GstRTSPTransportMode = c_uint;
98pub const GST_RTSP_TRANSPORT_MODE_PLAY: GstRTSPTransportMode = 1;
99pub const GST_RTSP_TRANSPORT_MODE_RECORD: GstRTSPTransportMode = 2;
100
101// Callbacks
102pub type GstRTSPClientSendFunc = Option<
103    unsafe extern "C" fn(
104        *mut GstRTSPClient,
105        *mut gst_rtsp::GstRTSPMessage,
106        gboolean,
107        gpointer,
108    ) -> gboolean,
109>;
110pub type GstRTSPClientSendMessagesFunc = Option<
111    unsafe extern "C" fn(
112        *mut GstRTSPClient,
113        *mut gst_rtsp::GstRTSPMessage,
114        c_uint,
115        gboolean,
116        gpointer,
117    ) -> gboolean,
118>;
119pub type GstRTSPClientSessionFilterFunc = Option<
120    unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPSession, gpointer) -> GstRTSPFilterResult,
121>;
122pub type GstRTSPKeepAliveFunc = Option<unsafe extern "C" fn(gpointer)>;
123pub type GstRTSPMessageSentFunc = Option<unsafe extern "C" fn(gpointer)>;
124pub type GstRTSPMessageSentFuncFull =
125    Option<unsafe extern "C" fn(*mut GstRTSPStreamTransport, gpointer)>;
126pub type GstRTSPSendFunc =
127    Option<unsafe extern "C" fn(*mut gst::GstBuffer, u8, gpointer) -> gboolean>;
128pub type GstRTSPSendListFunc =
129    Option<unsafe extern "C" fn(*mut gst::GstBufferList, u8, gpointer) -> gboolean>;
130pub type GstRTSPServerClientFilterFunc = Option<
131    unsafe extern "C" fn(*mut GstRTSPServer, *mut GstRTSPClient, gpointer) -> GstRTSPFilterResult,
132>;
133pub type GstRTSPSessionFilterFunc = Option<
134    unsafe extern "C" fn(
135        *mut GstRTSPSession,
136        *mut GstRTSPSessionMedia,
137        gpointer,
138    ) -> GstRTSPFilterResult,
139>;
140pub type GstRTSPSessionPoolFilterFunc = Option<
141    unsafe extern "C" fn(
142        *mut GstRTSPSessionPool,
143        *mut GstRTSPSession,
144        gpointer,
145    ) -> GstRTSPFilterResult,
146>;
147pub type GstRTSPSessionPoolFunc =
148    Option<unsafe extern "C" fn(*mut GstRTSPSessionPool, gpointer) -> gboolean>;
149pub type GstRTSPStreamTransportFilterFunc = Option<
150    unsafe extern "C" fn(
151        *mut GstRTSPStream,
152        *mut GstRTSPStreamTransport,
153        gpointer,
154    ) -> GstRTSPFilterResult,
155>;
156
157// Records
158#[derive(Copy, Clone)]
159#[repr(C)]
160pub struct GstRTSPAddress {
161    pub pool: *mut GstRTSPAddressPool,
162    pub address: *mut c_char,
163    pub port: u16,
164    pub n_ports: c_int,
165    pub ttl: u8,
166    pub priv_: gpointer,
167}
168
169impl ::std::fmt::Debug for GstRTSPAddress {
170    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
171        f.debug_struct(&format!("GstRTSPAddress @ {self:p}"))
172            .field("pool", &self.pool)
173            .field("address", &self.address)
174            .field("port", &self.port)
175            .field("n_ports", &self.n_ports)
176            .field("ttl", &self.ttl)
177            .finish()
178    }
179}
180
181#[derive(Copy, Clone)]
182#[repr(C)]
183pub struct GstRTSPAddressPoolClass {
184    pub parent_class: gobject::GObjectClass,
185    pub _gst_reserved: [gpointer; 4],
186}
187
188impl ::std::fmt::Debug for GstRTSPAddressPoolClass {
189    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
190        f.debug_struct(&format!("GstRTSPAddressPoolClass @ {self:p}"))
191            .field("parent_class", &self.parent_class)
192            .finish()
193    }
194}
195
196#[repr(C)]
197#[allow(dead_code)]
198pub struct _GstRTSPAddressPoolPrivate {
199    _data: [u8; 0],
200    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
201}
202
203pub type GstRTSPAddressPoolPrivate = _GstRTSPAddressPoolPrivate;
204
205#[derive(Copy, Clone)]
206#[repr(C)]
207pub struct GstRTSPAuthClass {
208    pub parent_class: gobject::GObjectClass,
209    pub authenticate:
210        Option<unsafe extern "C" fn(*mut GstRTSPAuth, *mut GstRTSPContext) -> gboolean>,
211    pub check: Option<
212        unsafe extern "C" fn(*mut GstRTSPAuth, *mut GstRTSPContext, *const c_char) -> gboolean,
213    >,
214    pub generate_authenticate_header:
215        Option<unsafe extern "C" fn(*mut GstRTSPAuth, *mut GstRTSPContext)>,
216    pub accept_certificate: Option<
217        unsafe extern "C" fn(
218            *mut GstRTSPAuth,
219            *mut gio::GTlsConnection,
220            *mut gio::GTlsCertificate,
221            gio::GTlsCertificateFlags,
222        ) -> gboolean,
223    >,
224    pub _gst_reserved: [gpointer; 3],
225}
226
227impl ::std::fmt::Debug for GstRTSPAuthClass {
228    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
229        f.debug_struct(&format!("GstRTSPAuthClass @ {self:p}"))
230            .field("parent_class", &self.parent_class)
231            .field("authenticate", &self.authenticate)
232            .field("check", &self.check)
233            .field(
234                "generate_authenticate_header",
235                &self.generate_authenticate_header,
236            )
237            .field("accept_certificate", &self.accept_certificate)
238            .finish()
239    }
240}
241
242#[repr(C)]
243#[allow(dead_code)]
244pub struct _GstRTSPAuthPrivate {
245    _data: [u8; 0],
246    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
247}
248
249pub type GstRTSPAuthPrivate = _GstRTSPAuthPrivate;
250
251#[derive(Copy, Clone)]
252#[repr(C)]
253pub struct GstRTSPClientClass {
254    pub parent_class: gobject::GObjectClass,
255    pub create_sdp: Option<
256        unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPMedia) -> *mut gst_sdp::GstSDPMessage,
257    >,
258    pub configure_client_media: Option<
259        unsafe extern "C" fn(
260            *mut GstRTSPClient,
261            *mut GstRTSPMedia,
262            *mut GstRTSPStream,
263            *mut GstRTSPContext,
264        ) -> gboolean,
265    >,
266    pub configure_client_transport: Option<
267        unsafe extern "C" fn(
268            *mut GstRTSPClient,
269            *mut GstRTSPContext,
270            *mut gst_rtsp::GstRTSPTransport,
271        ) -> gboolean,
272    >,
273    pub params_set: Option<
274        unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext) -> gst_rtsp::GstRTSPResult,
275    >,
276    pub params_get: Option<
277        unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext) -> gst_rtsp::GstRTSPResult,
278    >,
279    pub make_path_from_uri: Option<
280        unsafe extern "C" fn(*mut GstRTSPClient, *const gst_rtsp::GstRTSPUrl) -> *mut c_char,
281    >,
282    pub adjust_play_mode: Option<
283        unsafe extern "C" fn(
284            *mut GstRTSPClient,
285            *mut GstRTSPContext,
286            *mut *mut gst_rtsp::GstRTSPTimeRange,
287            *mut gst::GstSeekFlags,
288            *mut c_double,
289            *mut gst::GstClockTime,
290            *mut gboolean,
291        ) -> gst_rtsp::GstRTSPStatusCode,
292    >,
293    pub adjust_play_response: Option<
294        unsafe extern "C" fn(
295            *mut GstRTSPClient,
296            *mut GstRTSPContext,
297        ) -> gst_rtsp::GstRTSPStatusCode,
298    >,
299    pub closed: Option<unsafe extern "C" fn(*mut GstRTSPClient)>,
300    pub new_session: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPSession)>,
301    pub options_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
302    pub describe_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
303    pub setup_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
304    pub play_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
305    pub pause_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
306    pub teardown_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
307    pub set_parameter_request:
308        Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
309    pub get_parameter_request:
310        Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
311    pub handle_response: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
312    pub tunnel_http_response: Option<
313        unsafe extern "C" fn(
314            *mut GstRTSPClient,
315            *mut gst_rtsp::GstRTSPMessage,
316            *mut gst_rtsp::GstRTSPMessage,
317        ),
318    >,
319    pub send_message: Option<
320        unsafe extern "C" fn(
321            *mut GstRTSPClient,
322            *mut GstRTSPContext,
323            *mut gst_rtsp::GstRTSPMessage,
324        ),
325    >,
326    pub handle_sdp: Option<
327        unsafe extern "C" fn(
328            *mut GstRTSPClient,
329            *mut GstRTSPContext,
330            *mut GstRTSPMedia,
331            *mut gst_sdp::GstSDPMessage,
332        ) -> gboolean,
333    >,
334    pub announce_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
335    pub record_request: Option<unsafe extern "C" fn(*mut GstRTSPClient, *mut GstRTSPContext)>,
336    pub check_requirements: Option<
337        unsafe extern "C" fn(
338            *mut GstRTSPClient,
339            *mut GstRTSPContext,
340            *mut *mut c_char,
341        ) -> *mut c_char,
342    >,
343    pub pre_options_request: Option<
344        unsafe extern "C" fn(
345            *mut GstRTSPClient,
346            *mut GstRTSPContext,
347        ) -> gst_rtsp::GstRTSPStatusCode,
348    >,
349    pub pre_describe_request: Option<
350        unsafe extern "C" fn(
351            *mut GstRTSPClient,
352            *mut GstRTSPContext,
353        ) -> gst_rtsp::GstRTSPStatusCode,
354    >,
355    pub pre_setup_request: Option<
356        unsafe extern "C" fn(
357            *mut GstRTSPClient,
358            *mut GstRTSPContext,
359        ) -> gst_rtsp::GstRTSPStatusCode,
360    >,
361    pub pre_play_request: Option<
362        unsafe extern "C" fn(
363            *mut GstRTSPClient,
364            *mut GstRTSPContext,
365        ) -> gst_rtsp::GstRTSPStatusCode,
366    >,
367    pub pre_pause_request: Option<
368        unsafe extern "C" fn(
369            *mut GstRTSPClient,
370            *mut GstRTSPContext,
371        ) -> gst_rtsp::GstRTSPStatusCode,
372    >,
373    pub pre_teardown_request: Option<
374        unsafe extern "C" fn(
375            *mut GstRTSPClient,
376            *mut GstRTSPContext,
377        ) -> gst_rtsp::GstRTSPStatusCode,
378    >,
379    pub pre_set_parameter_request: Option<
380        unsafe extern "C" fn(
381            *mut GstRTSPClient,
382            *mut GstRTSPContext,
383        ) -> gst_rtsp::GstRTSPStatusCode,
384    >,
385    pub pre_get_parameter_request: Option<
386        unsafe extern "C" fn(
387            *mut GstRTSPClient,
388            *mut GstRTSPContext,
389        ) -> gst_rtsp::GstRTSPStatusCode,
390    >,
391    pub pre_announce_request: Option<
392        unsafe extern "C" fn(
393            *mut GstRTSPClient,
394            *mut GstRTSPContext,
395        ) -> gst_rtsp::GstRTSPStatusCode,
396    >,
397    pub pre_record_request: Option<
398        unsafe extern "C" fn(
399            *mut GstRTSPClient,
400            *mut GstRTSPContext,
401        ) -> gst_rtsp::GstRTSPStatusCode,
402    >,
403    pub adjust_error_code: Option<
404        unsafe extern "C" fn(
405            *mut GstRTSPClient,
406            *mut GstRTSPContext,
407            gst_rtsp::GstRTSPStatusCode,
408        ) -> gst_rtsp::GstRTSPStatusCode,
409    >,
410    pub _gst_reserved: [gpointer; 1],
411}
412
413impl ::std::fmt::Debug for GstRTSPClientClass {
414    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
415        f.debug_struct(&format!("GstRTSPClientClass @ {self:p}"))
416            .field("parent_class", &self.parent_class)
417            .field("create_sdp", &self.create_sdp)
418            .field("configure_client_media", &self.configure_client_media)
419            .field(
420                "configure_client_transport",
421                &self.configure_client_transport,
422            )
423            .field("params_set", &self.params_set)
424            .field("params_get", &self.params_get)
425            .field("make_path_from_uri", &self.make_path_from_uri)
426            .field("adjust_play_mode", &self.adjust_play_mode)
427            .field("adjust_play_response", &self.adjust_play_response)
428            .field("closed", &self.closed)
429            .field("new_session", &self.new_session)
430            .field("options_request", &self.options_request)
431            .field("describe_request", &self.describe_request)
432            .field("setup_request", &self.setup_request)
433            .field("play_request", &self.play_request)
434            .field("pause_request", &self.pause_request)
435            .field("teardown_request", &self.teardown_request)
436            .field("set_parameter_request", &self.set_parameter_request)
437            .field("get_parameter_request", &self.get_parameter_request)
438            .field("handle_response", &self.handle_response)
439            .field("tunnel_http_response", &self.tunnel_http_response)
440            .field("send_message", &self.send_message)
441            .field("handle_sdp", &self.handle_sdp)
442            .field("announce_request", &self.announce_request)
443            .field("record_request", &self.record_request)
444            .field("check_requirements", &self.check_requirements)
445            .field("pre_options_request", &self.pre_options_request)
446            .field("pre_describe_request", &self.pre_describe_request)
447            .field("pre_setup_request", &self.pre_setup_request)
448            .field("pre_play_request", &self.pre_play_request)
449            .field("pre_pause_request", &self.pre_pause_request)
450            .field("pre_teardown_request", &self.pre_teardown_request)
451            .field("pre_set_parameter_request", &self.pre_set_parameter_request)
452            .field("pre_get_parameter_request", &self.pre_get_parameter_request)
453            .field("pre_announce_request", &self.pre_announce_request)
454            .field("pre_record_request", &self.pre_record_request)
455            .field("adjust_error_code", &self.adjust_error_code)
456            .finish()
457    }
458}
459
460#[repr(C)]
461#[allow(dead_code)]
462pub struct _GstRTSPClientPrivate {
463    _data: [u8; 0],
464    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
465}
466
467pub type GstRTSPClientPrivate = _GstRTSPClientPrivate;
468
469#[derive(Copy, Clone)]
470#[repr(C)]
471pub struct GstRTSPContext {
472    pub server: *mut GstRTSPServer,
473    pub conn: *mut gst_rtsp::GstRTSPConnection,
474    pub client: *mut GstRTSPClient,
475    pub request: *mut gst_rtsp::GstRTSPMessage,
476    pub uri: *mut gst_rtsp::GstRTSPUrl,
477    pub method: gst_rtsp::GstRTSPMethod,
478    pub auth: *mut GstRTSPAuth,
479    pub token: *mut GstRTSPToken,
480    pub session: *mut GstRTSPSession,
481    pub sessmedia: *mut GstRTSPSessionMedia,
482    pub factory: *mut GstRTSPMediaFactory,
483    pub media: *mut GstRTSPMedia,
484    pub stream: *mut GstRTSPStream,
485    pub response: *mut gst_rtsp::GstRTSPMessage,
486    pub trans: *mut GstRTSPStreamTransport,
487    pub _gst_reserved: [gpointer; 3],
488}
489
490impl ::std::fmt::Debug for GstRTSPContext {
491    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
492        f.debug_struct(&format!("GstRTSPContext @ {self:p}"))
493            .field("server", &self.server)
494            .field("conn", &self.conn)
495            .field("client", &self.client)
496            .field("request", &self.request)
497            .field("uri", &self.uri)
498            .field("method", &self.method)
499            .field("auth", &self.auth)
500            .field("token", &self.token)
501            .field("session", &self.session)
502            .field("sessmedia", &self.sessmedia)
503            .field("factory", &self.factory)
504            .field("media", &self.media)
505            .field("stream", &self.stream)
506            .field("response", &self.response)
507            .field("trans", &self.trans)
508            .finish()
509    }
510}
511
512#[derive(Copy, Clone)]
513#[repr(C)]
514pub struct GstRTSPMediaClass {
515    pub parent_class: gobject::GObjectClass,
516    pub handle_message:
517        Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut gst::GstMessage) -> gboolean>,
518    pub prepare: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut GstRTSPThread) -> gboolean>,
519    pub unprepare: Option<unsafe extern "C" fn(*mut GstRTSPMedia) -> gboolean>,
520    pub suspend: Option<unsafe extern "C" fn(*mut GstRTSPMedia) -> gboolean>,
521    pub unsuspend: Option<unsafe extern "C" fn(*mut GstRTSPMedia) -> gboolean>,
522    pub convert_range: Option<
523        unsafe extern "C" fn(
524            *mut GstRTSPMedia,
525            *mut gst_rtsp::GstRTSPTimeRange,
526            gst_rtsp::GstRTSPRangeUnit,
527        ) -> gboolean,
528    >,
529    pub query_position: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut i64) -> gboolean>,
530    pub query_stop: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut i64) -> gboolean>,
531    pub create_rtpbin: Option<unsafe extern "C" fn(*mut GstRTSPMedia) -> *mut gst::GstElement>,
532    pub setup_rtpbin:
533        Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut gst::GstElement) -> gboolean>,
534    pub setup_sdp: Option<
535        unsafe extern "C" fn(
536            *mut GstRTSPMedia,
537            *mut gst_sdp::GstSDPMessage,
538            *mut GstSDPInfo,
539        ) -> gboolean,
540    >,
541    pub new_stream: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut GstRTSPStream)>,
542    pub removed_stream: Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut GstRTSPStream)>,
543    pub prepared: Option<unsafe extern "C" fn(*mut GstRTSPMedia)>,
544    pub unprepared: Option<unsafe extern "C" fn(*mut GstRTSPMedia)>,
545    pub target_state: Option<unsafe extern "C" fn(*mut GstRTSPMedia, gst::GstState)>,
546    pub new_state: Option<unsafe extern "C" fn(*mut GstRTSPMedia, gst::GstState)>,
547    pub handle_sdp:
548        Option<unsafe extern "C" fn(*mut GstRTSPMedia, *mut gst_sdp::GstSDPMessage) -> gboolean>,
549    pub _gst_reserved: [gpointer; 19],
550}
551
552impl ::std::fmt::Debug for GstRTSPMediaClass {
553    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
554        f.debug_struct(&format!("GstRTSPMediaClass @ {self:p}"))
555            .field("parent_class", &self.parent_class)
556            .field("handle_message", &self.handle_message)
557            .field("prepare", &self.prepare)
558            .field("unprepare", &self.unprepare)
559            .field("suspend", &self.suspend)
560            .field("unsuspend", &self.unsuspend)
561            .field("convert_range", &self.convert_range)
562            .field("query_position", &self.query_position)
563            .field("query_stop", &self.query_stop)
564            .field("create_rtpbin", &self.create_rtpbin)
565            .field("setup_rtpbin", &self.setup_rtpbin)
566            .field("setup_sdp", &self.setup_sdp)
567            .field("new_stream", &self.new_stream)
568            .field("removed_stream", &self.removed_stream)
569            .field("prepared", &self.prepared)
570            .field("unprepared", &self.unprepared)
571            .field("target_state", &self.target_state)
572            .field("new_state", &self.new_state)
573            .field("handle_sdp", &self.handle_sdp)
574            .finish()
575    }
576}
577
578#[derive(Copy, Clone)]
579#[repr(C)]
580pub struct GstRTSPMediaFactoryClass {
581    pub parent_class: gobject::GObjectClass,
582    pub gen_key: Option<
583        unsafe extern "C" fn(*mut GstRTSPMediaFactory, *const gst_rtsp::GstRTSPUrl) -> *mut c_char,
584    >,
585    pub create_element: Option<
586        unsafe extern "C" fn(
587            *mut GstRTSPMediaFactory,
588            *const gst_rtsp::GstRTSPUrl,
589        ) -> *mut gst::GstElement,
590    >,
591    pub construct: Option<
592        unsafe extern "C" fn(
593            *mut GstRTSPMediaFactory,
594            *const gst_rtsp::GstRTSPUrl,
595        ) -> *mut GstRTSPMedia,
596    >,
597    pub create_pipeline: Option<
598        unsafe extern "C" fn(*mut GstRTSPMediaFactory, *mut GstRTSPMedia) -> *mut gst::GstElement,
599    >,
600    pub configure: Option<unsafe extern "C" fn(*mut GstRTSPMediaFactory, *mut GstRTSPMedia)>,
601    pub media_constructed:
602        Option<unsafe extern "C" fn(*mut GstRTSPMediaFactory, *mut GstRTSPMedia)>,
603    pub media_configure: Option<unsafe extern "C" fn(*mut GstRTSPMediaFactory, *mut GstRTSPMedia)>,
604    pub _gst_reserved: [gpointer; 20],
605}
606
607impl ::std::fmt::Debug for GstRTSPMediaFactoryClass {
608    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
609        f.debug_struct(&format!("GstRTSPMediaFactoryClass @ {self:p}"))
610            .field("parent_class", &self.parent_class)
611            .field("gen_key", &self.gen_key)
612            .field("create_element", &self.create_element)
613            .field("construct", &self.construct)
614            .field("create_pipeline", &self.create_pipeline)
615            .field("configure", &self.configure)
616            .field("media_constructed", &self.media_constructed)
617            .field("media_configure", &self.media_configure)
618            .finish()
619    }
620}
621
622#[repr(C)]
623#[allow(dead_code)]
624pub struct _GstRTSPMediaFactoryPrivate {
625    _data: [u8; 0],
626    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
627}
628
629pub type GstRTSPMediaFactoryPrivate = _GstRTSPMediaFactoryPrivate;
630
631#[derive(Copy, Clone)]
632#[repr(C)]
633pub struct GstRTSPMediaFactoryURIClass {
634    pub parent_class: GstRTSPMediaFactoryClass,
635    pub _gst_reserved: [gpointer; 4],
636}
637
638impl ::std::fmt::Debug for GstRTSPMediaFactoryURIClass {
639    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
640        f.debug_struct(&format!("GstRTSPMediaFactoryURIClass @ {self:p}"))
641            .field("parent_class", &self.parent_class)
642            .finish()
643    }
644}
645
646#[repr(C)]
647#[allow(dead_code)]
648pub struct _GstRTSPMediaFactoryURIPrivate {
649    _data: [u8; 0],
650    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
651}
652
653pub type GstRTSPMediaFactoryURIPrivate = _GstRTSPMediaFactoryURIPrivate;
654
655#[repr(C)]
656#[allow(dead_code)]
657pub struct _GstRTSPMediaPrivate {
658    _data: [u8; 0],
659    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
660}
661
662pub type GstRTSPMediaPrivate = _GstRTSPMediaPrivate;
663
664#[derive(Copy, Clone)]
665#[repr(C)]
666pub struct GstRTSPMountPointsClass {
667    pub parent_class: gobject::GObjectClass,
668    pub make_path: Option<
669        unsafe extern "C" fn(*mut GstRTSPMountPoints, *const gst_rtsp::GstRTSPUrl) -> *mut c_char,
670    >,
671    pub _gst_reserved: [gpointer; 4],
672}
673
674impl ::std::fmt::Debug for GstRTSPMountPointsClass {
675    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
676        f.debug_struct(&format!("GstRTSPMountPointsClass @ {self:p}"))
677            .field("parent_class", &self.parent_class)
678            .field("make_path", &self.make_path)
679            .finish()
680    }
681}
682
683#[repr(C)]
684#[allow(dead_code)]
685pub struct _GstRTSPMountPointsPrivate {
686    _data: [u8; 0],
687    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
688}
689
690pub type GstRTSPMountPointsPrivate = _GstRTSPMountPointsPrivate;
691
692#[derive(Copy, Clone)]
693#[repr(C)]
694pub struct GstRTSPOnvifClientClass {
695    pub parent: GstRTSPClientClass,
696    pub _gst_reserved: [gpointer; 20],
697}
698
699impl ::std::fmt::Debug for GstRTSPOnvifClientClass {
700    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
701        f.debug_struct(&format!("GstRTSPOnvifClientClass @ {self:p}"))
702            .field("parent", &self.parent)
703            .finish()
704    }
705}
706
707#[derive(Copy, Clone)]
708#[repr(C)]
709pub struct GstRTSPOnvifMediaClass {
710    pub parent: GstRTSPMediaClass,
711    pub _gst_reserved: [gpointer; 20],
712}
713
714impl ::std::fmt::Debug for GstRTSPOnvifMediaClass {
715    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
716        f.debug_struct(&format!("GstRTSPOnvifMediaClass @ {self:p}"))
717            .field("parent", &self.parent)
718            .finish()
719    }
720}
721
722#[derive(Copy, Clone)]
723#[repr(C)]
724pub struct GstRTSPOnvifMediaFactoryClass {
725    pub parent: GstRTSPMediaFactoryClass,
726    pub has_backchannel_support:
727        Option<unsafe extern "C" fn(*mut GstRTSPOnvifMediaFactory) -> gboolean>,
728    pub create_backchannel_stream: Option<
729        unsafe extern "C" fn(
730            *mut GstRTSPOnvifMediaFactory,
731            *mut GstRTSPOnvifMedia,
732            *mut GstRTSPContext,
733        ) -> gboolean,
734    >,
735    pub _gst_reserved: [gpointer; 19],
736}
737
738impl ::std::fmt::Debug for GstRTSPOnvifMediaFactoryClass {
739    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
740        f.debug_struct(&format!("GstRTSPOnvifMediaFactoryClass @ {self:p}"))
741            .field("parent", &self.parent)
742            .field("has_backchannel_support", &self.has_backchannel_support)
743            .field("create_backchannel_stream", &self.create_backchannel_stream)
744            .finish()
745    }
746}
747
748#[repr(C)]
749#[allow(dead_code)]
750pub struct _GstRTSPOnvifMediaFactoryPrivate {
751    _data: [u8; 0],
752    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
753}
754
755pub type GstRTSPOnvifMediaFactoryPrivate = _GstRTSPOnvifMediaFactoryPrivate;
756
757#[repr(C)]
758#[allow(dead_code)]
759pub struct _GstRTSPOnvifMediaPrivate {
760    _data: [u8; 0],
761    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
762}
763
764pub type GstRTSPOnvifMediaPrivate = _GstRTSPOnvifMediaPrivate;
765
766#[derive(Copy, Clone)]
767#[repr(C)]
768pub struct GstRTSPOnvifServerClass {
769    pub parent: GstRTSPServerClass,
770    pub _gst_reserved: [gpointer; 20],
771}
772
773impl ::std::fmt::Debug for GstRTSPOnvifServerClass {
774    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
775        f.debug_struct(&format!("GstRTSPOnvifServerClass @ {self:p}"))
776            .field("parent", &self.parent)
777            .finish()
778    }
779}
780
781#[derive(Copy, Clone)]
782#[repr(C)]
783pub struct GstRTSPPermissions {
784    pub mini_object: gst::GstMiniObject,
785}
786
787impl ::std::fmt::Debug for GstRTSPPermissions {
788    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
789        f.debug_struct(&format!("GstRTSPPermissions @ {self:p}"))
790            .field("mini_object", &self.mini_object)
791            .finish()
792    }
793}
794
795#[derive(Copy, Clone)]
796#[repr(C)]
797pub struct GstRTSPServerClass {
798    pub parent_class: gobject::GObjectClass,
799    pub create_client: Option<unsafe extern "C" fn(*mut GstRTSPServer) -> *mut GstRTSPClient>,
800    pub client_connected: Option<unsafe extern "C" fn(*mut GstRTSPServer, *mut GstRTSPClient)>,
801    pub _gst_reserved: [gpointer; 20],
802}
803
804impl ::std::fmt::Debug for GstRTSPServerClass {
805    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
806        f.debug_struct(&format!("GstRTSPServerClass @ {self:p}"))
807            .field("parent_class", &self.parent_class)
808            .field("create_client", &self.create_client)
809            .field("client_connected", &self.client_connected)
810            .finish()
811    }
812}
813
814#[repr(C)]
815#[allow(dead_code)]
816pub struct _GstRTSPServerPrivate {
817    _data: [u8; 0],
818    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
819}
820
821pub type GstRTSPServerPrivate = _GstRTSPServerPrivate;
822
823#[derive(Copy, Clone)]
824#[repr(C)]
825pub struct GstRTSPSessionClass {
826    pub parent_class: gobject::GObjectClass,
827    pub _gst_reserved: [gpointer; 4],
828}
829
830impl ::std::fmt::Debug for GstRTSPSessionClass {
831    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
832        f.debug_struct(&format!("GstRTSPSessionClass @ {self:p}"))
833            .field("parent_class", &self.parent_class)
834            .finish()
835    }
836}
837
838#[derive(Copy, Clone)]
839#[repr(C)]
840pub struct GstRTSPSessionMediaClass {
841    pub parent_class: gobject::GObjectClass,
842    pub _gst_reserved: [gpointer; 4],
843}
844
845impl ::std::fmt::Debug for GstRTSPSessionMediaClass {
846    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
847        f.debug_struct(&format!("GstRTSPSessionMediaClass @ {self:p}"))
848            .field("parent_class", &self.parent_class)
849            .finish()
850    }
851}
852
853#[repr(C)]
854#[allow(dead_code)]
855pub struct _GstRTSPSessionMediaPrivate {
856    _data: [u8; 0],
857    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
858}
859
860pub type GstRTSPSessionMediaPrivate = _GstRTSPSessionMediaPrivate;
861
862#[derive(Copy, Clone)]
863#[repr(C)]
864pub struct GstRTSPSessionPoolClass {
865    pub parent_class: gobject::GObjectClass,
866    pub create_session_id: Option<unsafe extern "C" fn(*mut GstRTSPSessionPool) -> *mut c_char>,
867    pub create_session:
868        Option<unsafe extern "C" fn(*mut GstRTSPSessionPool, *const c_char) -> *mut GstRTSPSession>,
869    pub session_removed: Option<unsafe extern "C" fn(*mut GstRTSPSessionPool, *mut GstRTSPSession)>,
870    pub _gst_reserved: [gpointer; 19],
871}
872
873impl ::std::fmt::Debug for GstRTSPSessionPoolClass {
874    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
875        f.debug_struct(&format!("GstRTSPSessionPoolClass @ {self:p}"))
876            .field("parent_class", &self.parent_class)
877            .field("create_session_id", &self.create_session_id)
878            .field("create_session", &self.create_session)
879            .field("session_removed", &self.session_removed)
880            .finish()
881    }
882}
883
884#[repr(C)]
885#[allow(dead_code)]
886pub struct _GstRTSPSessionPoolPrivate {
887    _data: [u8; 0],
888    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
889}
890
891pub type GstRTSPSessionPoolPrivate = _GstRTSPSessionPoolPrivate;
892
893#[repr(C)]
894#[allow(dead_code)]
895pub struct _GstRTSPSessionPrivate {
896    _data: [u8; 0],
897    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
898}
899
900pub type GstRTSPSessionPrivate = _GstRTSPSessionPrivate;
901
902#[derive(Copy, Clone)]
903#[repr(C)]
904pub struct GstRTSPStreamClass {
905    pub parent_class: gobject::GObjectClass,
906    pub _gst_reserved: [gpointer; 4],
907}
908
909impl ::std::fmt::Debug for GstRTSPStreamClass {
910    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
911        f.debug_struct(&format!("GstRTSPStreamClass @ {self:p}"))
912            .field("parent_class", &self.parent_class)
913            .finish()
914    }
915}
916
917#[repr(C)]
918#[allow(dead_code)]
919pub struct _GstRTSPStreamPrivate {
920    _data: [u8; 0],
921    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
922}
923
924pub type GstRTSPStreamPrivate = _GstRTSPStreamPrivate;
925
926#[derive(Copy, Clone)]
927#[repr(C)]
928pub struct GstRTSPStreamTransportClass {
929    pub parent_class: gobject::GObjectClass,
930    pub _gst_reserved: [gpointer; 4],
931}
932
933impl ::std::fmt::Debug for GstRTSPStreamTransportClass {
934    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
935        f.debug_struct(&format!("GstRTSPStreamTransportClass @ {self:p}"))
936            .field("parent_class", &self.parent_class)
937            .finish()
938    }
939}
940
941#[repr(C)]
942#[allow(dead_code)]
943pub struct _GstRTSPStreamTransportPrivate {
944    _data: [u8; 0],
945    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
946}
947
948pub type GstRTSPStreamTransportPrivate = _GstRTSPStreamTransportPrivate;
949
950#[derive(Copy, Clone)]
951#[repr(C)]
952pub struct GstRTSPThread {
953    pub mini_object: gst::GstMiniObject,
954    pub type_: GstRTSPThreadType,
955    pub context: *mut glib::GMainContext,
956    pub loop_: *mut glib::GMainLoop,
957}
958
959impl ::std::fmt::Debug for GstRTSPThread {
960    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
961        f.debug_struct(&format!("GstRTSPThread @ {self:p}"))
962            .field("mini_object", &self.mini_object)
963            .field("type_", &self.type_)
964            .field("context", &self.context)
965            .field("loop_", &self.loop_)
966            .finish()
967    }
968}
969
970#[derive(Copy, Clone)]
971#[repr(C)]
972pub struct GstRTSPThreadPoolClass {
973    pub parent_class: gobject::GObjectClass,
974    pub pool: *mut glib::GThreadPool,
975    pub get_thread: Option<
976        unsafe extern "C" fn(
977            *mut GstRTSPThreadPool,
978            GstRTSPThreadType,
979            *mut GstRTSPContext,
980        ) -> *mut GstRTSPThread,
981    >,
982    pub configure_thread: Option<
983        unsafe extern "C" fn(*mut GstRTSPThreadPool, *mut GstRTSPThread, *mut GstRTSPContext),
984    >,
985    pub thread_enter: Option<unsafe extern "C" fn(*mut GstRTSPThreadPool, *mut GstRTSPThread)>,
986    pub thread_leave: Option<unsafe extern "C" fn(*mut GstRTSPThreadPool, *mut GstRTSPThread)>,
987    pub _gst_reserved: [gpointer; 4],
988}
989
990impl ::std::fmt::Debug for GstRTSPThreadPoolClass {
991    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
992        f.debug_struct(&format!("GstRTSPThreadPoolClass @ {self:p}"))
993            .field("parent_class", &self.parent_class)
994            .field("pool", &self.pool)
995            .field("get_thread", &self.get_thread)
996            .field("configure_thread", &self.configure_thread)
997            .field("thread_enter", &self.thread_enter)
998            .field("thread_leave", &self.thread_leave)
999            .finish()
1000    }
1001}
1002
1003#[repr(C)]
1004#[allow(dead_code)]
1005pub struct _GstRTSPThreadPoolPrivate {
1006    _data: [u8; 0],
1007    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1008}
1009
1010pub type GstRTSPThreadPoolPrivate = _GstRTSPThreadPoolPrivate;
1011
1012#[derive(Copy, Clone)]
1013#[repr(C)]
1014pub struct GstRTSPToken {
1015    pub mini_object: gst::GstMiniObject,
1016}
1017
1018impl ::std::fmt::Debug for GstRTSPToken {
1019    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1020        f.debug_struct(&format!("GstRTSPToken @ {self:p}"))
1021            .field("mini_object", &self.mini_object)
1022            .finish()
1023    }
1024}
1025
1026#[derive(Copy, Clone)]
1027#[repr(C)]
1028pub struct GstSDPInfo {
1029    pub is_ipv6: gboolean,
1030    pub server_ip: *const c_char,
1031}
1032
1033impl ::std::fmt::Debug for GstSDPInfo {
1034    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1035        f.debug_struct(&format!("GstSDPInfo @ {self:p}"))
1036            .field("is_ipv6", &self.is_ipv6)
1037            .field("server_ip", &self.server_ip)
1038            .finish()
1039    }
1040}
1041
1042// Classes
1043#[derive(Copy, Clone)]
1044#[repr(C)]
1045pub struct GstRTSPAddressPool {
1046    pub parent: gobject::GObject,
1047    pub priv_: *mut GstRTSPAddressPoolPrivate,
1048    pub _gst_reserved: [gpointer; 4],
1049}
1050
1051impl ::std::fmt::Debug for GstRTSPAddressPool {
1052    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1053        f.debug_struct(&format!("GstRTSPAddressPool @ {self:p}"))
1054            .field("parent", &self.parent)
1055            .finish()
1056    }
1057}
1058
1059#[derive(Copy, Clone)]
1060#[repr(C)]
1061pub struct GstRTSPAuth {
1062    pub parent: gobject::GObject,
1063    pub priv_: *mut GstRTSPAuthPrivate,
1064    pub _gst_reserved: [gpointer; 4],
1065}
1066
1067impl ::std::fmt::Debug for GstRTSPAuth {
1068    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1069        f.debug_struct(&format!("GstRTSPAuth @ {self:p}"))
1070            .field("parent", &self.parent)
1071            .finish()
1072    }
1073}
1074
1075#[derive(Copy, Clone)]
1076#[repr(C)]
1077pub struct GstRTSPClient {
1078    pub parent: gobject::GObject,
1079    pub priv_: *mut GstRTSPClientPrivate,
1080    pub _gst_reserved: [gpointer; 4],
1081}
1082
1083impl ::std::fmt::Debug for GstRTSPClient {
1084    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1085        f.debug_struct(&format!("GstRTSPClient @ {self:p}"))
1086            .field("parent", &self.parent)
1087            .finish()
1088    }
1089}
1090
1091#[derive(Copy, Clone)]
1092#[repr(C)]
1093pub struct GstRTSPMedia {
1094    pub parent: gobject::GObject,
1095    pub priv_: *mut GstRTSPMediaPrivate,
1096    pub _gst_reserved: [gpointer; 4],
1097}
1098
1099impl ::std::fmt::Debug for GstRTSPMedia {
1100    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1101        f.debug_struct(&format!("GstRTSPMedia @ {self:p}"))
1102            .field("parent", &self.parent)
1103            .finish()
1104    }
1105}
1106
1107#[derive(Copy, Clone)]
1108#[repr(C)]
1109pub struct GstRTSPMediaFactory {
1110    pub parent: gobject::GObject,
1111    pub priv_: *mut GstRTSPMediaFactoryPrivate,
1112    pub _gst_reserved: [gpointer; 4],
1113}
1114
1115impl ::std::fmt::Debug for GstRTSPMediaFactory {
1116    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1117        f.debug_struct(&format!("GstRTSPMediaFactory @ {self:p}"))
1118            .field("parent", &self.parent)
1119            .finish()
1120    }
1121}
1122
1123#[derive(Copy, Clone)]
1124#[repr(C)]
1125pub struct GstRTSPMediaFactoryURI {
1126    pub parent: GstRTSPMediaFactory,
1127    pub priv_: *mut GstRTSPMediaFactoryURIPrivate,
1128    pub _gst_reserved: [gpointer; 4],
1129}
1130
1131impl ::std::fmt::Debug for GstRTSPMediaFactoryURI {
1132    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1133        f.debug_struct(&format!("GstRTSPMediaFactoryURI @ {self:p}"))
1134            .field("parent", &self.parent)
1135            .finish()
1136    }
1137}
1138
1139#[derive(Copy, Clone)]
1140#[repr(C)]
1141pub struct GstRTSPMountPoints {
1142    pub parent: gobject::GObject,
1143    pub priv_: *mut GstRTSPMountPointsPrivate,
1144    pub _gst_reserved: [gpointer; 4],
1145}
1146
1147impl ::std::fmt::Debug for GstRTSPMountPoints {
1148    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1149        f.debug_struct(&format!("GstRTSPMountPoints @ {self:p}"))
1150            .field("parent", &self.parent)
1151            .finish()
1152    }
1153}
1154
1155#[derive(Copy, Clone)]
1156#[repr(C)]
1157pub struct GstRTSPOnvifClient {
1158    pub parent: GstRTSPClient,
1159    pub _gst_reserved: [gpointer; 4],
1160}
1161
1162impl ::std::fmt::Debug for GstRTSPOnvifClient {
1163    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1164        f.debug_struct(&format!("GstRTSPOnvifClient @ {self:p}"))
1165            .field("parent", &self.parent)
1166            .finish()
1167    }
1168}
1169
1170#[derive(Copy, Clone)]
1171#[repr(C)]
1172pub struct GstRTSPOnvifMedia {
1173    pub parent: GstRTSPMedia,
1174    pub priv_: *mut GstRTSPOnvifMediaPrivate,
1175    pub _gst_reserved: [gpointer; 4],
1176}
1177
1178impl ::std::fmt::Debug for GstRTSPOnvifMedia {
1179    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1180        f.debug_struct(&format!("GstRTSPOnvifMedia @ {self:p}"))
1181            .field("parent", &self.parent)
1182            .field("priv_", &self.priv_)
1183            .finish()
1184    }
1185}
1186
1187#[derive(Copy, Clone)]
1188#[repr(C)]
1189pub struct GstRTSPOnvifMediaFactory {
1190    pub parent: GstRTSPMediaFactory,
1191    pub priv_: *mut GstRTSPOnvifMediaFactoryPrivate,
1192    pub _gst_reserved: [gpointer; 4],
1193}
1194
1195impl ::std::fmt::Debug for GstRTSPOnvifMediaFactory {
1196    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1197        f.debug_struct(&format!("GstRTSPOnvifMediaFactory @ {self:p}"))
1198            .field("parent", &self.parent)
1199            .field("priv_", &self.priv_)
1200            .finish()
1201    }
1202}
1203
1204#[derive(Copy, Clone)]
1205#[repr(C)]
1206pub struct GstRTSPOnvifServer {
1207    pub parent: GstRTSPServer,
1208    pub _gst_reserved: [gpointer; 4],
1209}
1210
1211impl ::std::fmt::Debug for GstRTSPOnvifServer {
1212    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1213        f.debug_struct(&format!("GstRTSPOnvifServer @ {self:p}"))
1214            .field("parent", &self.parent)
1215            .finish()
1216    }
1217}
1218
1219#[derive(Copy, Clone)]
1220#[repr(C)]
1221pub struct GstRTSPServer {
1222    pub parent: gobject::GObject,
1223    pub priv_: *mut GstRTSPServerPrivate,
1224    pub _gst_reserved: [gpointer; 4],
1225}
1226
1227impl ::std::fmt::Debug for GstRTSPServer {
1228    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1229        f.debug_struct(&format!("GstRTSPServer @ {self:p}"))
1230            .field("parent", &self.parent)
1231            .finish()
1232    }
1233}
1234
1235#[derive(Copy, Clone)]
1236#[repr(C)]
1237pub struct GstRTSPSession {
1238    pub parent: gobject::GObject,
1239    pub priv_: *mut GstRTSPSessionPrivate,
1240    pub _gst_reserved: [gpointer; 4],
1241}
1242
1243impl ::std::fmt::Debug for GstRTSPSession {
1244    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1245        f.debug_struct(&format!("GstRTSPSession @ {self:p}"))
1246            .field("parent", &self.parent)
1247            .finish()
1248    }
1249}
1250
1251#[derive(Copy, Clone)]
1252#[repr(C)]
1253pub struct GstRTSPSessionMedia {
1254    pub parent: gobject::GObject,
1255    pub priv_: *mut GstRTSPSessionMediaPrivate,
1256    pub _gst_reserved: [gpointer; 4],
1257}
1258
1259impl ::std::fmt::Debug for GstRTSPSessionMedia {
1260    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1261        f.debug_struct(&format!("GstRTSPSessionMedia @ {self:p}"))
1262            .field("parent", &self.parent)
1263            .finish()
1264    }
1265}
1266
1267#[derive(Copy, Clone)]
1268#[repr(C)]
1269pub struct GstRTSPSessionPool {
1270    pub parent: gobject::GObject,
1271    pub priv_: *mut GstRTSPSessionPoolPrivate,
1272    pub _gst_reserved: [gpointer; 4],
1273}
1274
1275impl ::std::fmt::Debug for GstRTSPSessionPool {
1276    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1277        f.debug_struct(&format!("GstRTSPSessionPool @ {self:p}"))
1278            .field("parent", &self.parent)
1279            .finish()
1280    }
1281}
1282
1283#[derive(Copy, Clone)]
1284#[repr(C)]
1285pub struct GstRTSPStream {
1286    pub parent: gobject::GObject,
1287    pub priv_: *mut GstRTSPStreamPrivate,
1288    pub _gst_reserved: [gpointer; 4],
1289}
1290
1291impl ::std::fmt::Debug for GstRTSPStream {
1292    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1293        f.debug_struct(&format!("GstRTSPStream @ {self:p}"))
1294            .field("parent", &self.parent)
1295            .finish()
1296    }
1297}
1298
1299#[derive(Copy, Clone)]
1300#[repr(C)]
1301pub struct GstRTSPStreamTransport {
1302    pub parent: gobject::GObject,
1303    pub priv_: *mut GstRTSPStreamTransportPrivate,
1304    pub _gst_reserved: [gpointer; 4],
1305}
1306
1307impl ::std::fmt::Debug for GstRTSPStreamTransport {
1308    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1309        f.debug_struct(&format!("GstRTSPStreamTransport @ {self:p}"))
1310            .field("parent", &self.parent)
1311            .finish()
1312    }
1313}
1314
1315#[derive(Copy, Clone)]
1316#[repr(C)]
1317pub struct GstRTSPThreadPool {
1318    pub parent: gobject::GObject,
1319    pub priv_: *mut GstRTSPThreadPoolPrivate,
1320    pub _gst_reserved: [gpointer; 4],
1321}
1322
1323impl ::std::fmt::Debug for GstRTSPThreadPool {
1324    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1325        f.debug_struct(&format!("GstRTSPThreadPool @ {self:p}"))
1326            .field("parent", &self.parent)
1327            .finish()
1328    }
1329}
1330
1331extern "C" {
1332
1333    //=========================================================================
1334    // GstRTSPPublishClockMode
1335    //=========================================================================
1336    pub fn gst_rtsp_publish_clock_mode_get_type() -> GType;
1337
1338    //=========================================================================
1339    // GstRTSPSuspendMode
1340    //=========================================================================
1341    pub fn gst_rtsp_suspend_mode_get_type() -> GType;
1342
1343    //=========================================================================
1344    // GstRTSPTransportMode
1345    //=========================================================================
1346    pub fn gst_rtsp_transport_mode_get_type() -> GType;
1347
1348    //=========================================================================
1349    // GstRTSPAddress
1350    //=========================================================================
1351    pub fn gst_rtsp_address_get_type() -> GType;
1352    pub fn gst_rtsp_address_copy(addr: *mut GstRTSPAddress) -> *mut GstRTSPAddress;
1353    pub fn gst_rtsp_address_free(addr: *mut GstRTSPAddress);
1354
1355    //=========================================================================
1356    // GstRTSPContext
1357    //=========================================================================
1358    pub fn gst_rtsp_context_get_type() -> GType;
1359    pub fn gst_rtsp_context_pop_current(ctx: *mut GstRTSPContext);
1360    pub fn gst_rtsp_context_push_current(ctx: *mut GstRTSPContext);
1361    #[cfg(feature = "v1_22")]
1362    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
1363    pub fn gst_rtsp_context_set_token(ctx: *mut GstRTSPContext, token: *mut GstRTSPToken);
1364    pub fn gst_rtsp_context_get_current() -> *mut GstRTSPContext;
1365
1366    //=========================================================================
1367    // GstRTSPPermissions
1368    //=========================================================================
1369    pub fn gst_rtsp_permissions_get_type() -> GType;
1370    pub fn gst_rtsp_permissions_new() -> *mut GstRTSPPermissions;
1371    pub fn gst_rtsp_permissions_add_permission_for_role(
1372        permissions: *mut GstRTSPPermissions,
1373        role: *const c_char,
1374        permission: *const c_char,
1375        allowed: gboolean,
1376    );
1377    pub fn gst_rtsp_permissions_add_role(
1378        permissions: *mut GstRTSPPermissions,
1379        role: *const c_char,
1380        fieldname: *const c_char,
1381        ...
1382    );
1383    pub fn gst_rtsp_permissions_add_role_empty(
1384        permissions: *mut GstRTSPPermissions,
1385        role: *const c_char,
1386    );
1387    pub fn gst_rtsp_permissions_add_role_from_structure(
1388        permissions: *mut GstRTSPPermissions,
1389        structure: *mut gst::GstStructure,
1390    );
1391    //pub fn gst_rtsp_permissions_add_role_valist(permissions: *mut GstRTSPPermissions, role: *const c_char, fieldname: *const c_char, var_args: /*Unimplemented*/va_list);
1392    pub fn gst_rtsp_permissions_get_role(
1393        permissions: *mut GstRTSPPermissions,
1394        role: *const c_char,
1395    ) -> *const gst::GstStructure;
1396    pub fn gst_rtsp_permissions_is_allowed(
1397        permissions: *mut GstRTSPPermissions,
1398        role: *const c_char,
1399        permission: *const c_char,
1400    ) -> gboolean;
1401    pub fn gst_rtsp_permissions_remove_role(
1402        permissions: *mut GstRTSPPermissions,
1403        role: *const c_char,
1404    );
1405
1406    //=========================================================================
1407    // GstRTSPThread
1408    //=========================================================================
1409    pub fn gst_rtsp_thread_get_type() -> GType;
1410    pub fn gst_rtsp_thread_new(type_: GstRTSPThreadType) -> *mut GstRTSPThread;
1411    pub fn gst_rtsp_thread_reuse(thread: *mut GstRTSPThread) -> gboolean;
1412    pub fn gst_rtsp_thread_stop(thread: *mut GstRTSPThread);
1413
1414    //=========================================================================
1415    // GstRTSPToken
1416    //=========================================================================
1417    pub fn gst_rtsp_token_get_type() -> GType;
1418    pub fn gst_rtsp_token_new(firstfield: *const c_char, ...) -> *mut GstRTSPToken;
1419    pub fn gst_rtsp_token_new_empty() -> *mut GstRTSPToken;
1420    //pub fn gst_rtsp_token_new_valist(firstfield: *const c_char, var_args: /*Unimplemented*/va_list) -> *mut GstRTSPToken;
1421    pub fn gst_rtsp_token_get_string(
1422        token: *mut GstRTSPToken,
1423        field: *const c_char,
1424    ) -> *const c_char;
1425    pub fn gst_rtsp_token_get_structure(token: *mut GstRTSPToken) -> *const gst::GstStructure;
1426    pub fn gst_rtsp_token_is_allowed(token: *mut GstRTSPToken, field: *const c_char) -> gboolean;
1427    pub fn gst_rtsp_token_set_bool(
1428        token: *mut GstRTSPToken,
1429        field: *const c_char,
1430        bool_value: gboolean,
1431    );
1432    pub fn gst_rtsp_token_set_string(
1433        token: *mut GstRTSPToken,
1434        field: *const c_char,
1435        string_value: *const c_char,
1436    );
1437    pub fn gst_rtsp_token_writable_structure(token: *mut GstRTSPToken) -> *mut gst::GstStructure;
1438
1439    //=========================================================================
1440    // GstRTSPAddressPool
1441    //=========================================================================
1442    pub fn gst_rtsp_address_pool_get_type() -> GType;
1443    pub fn gst_rtsp_address_pool_new() -> *mut GstRTSPAddressPool;
1444    pub fn gst_rtsp_address_pool_acquire_address(
1445        pool: *mut GstRTSPAddressPool,
1446        flags: GstRTSPAddressFlags,
1447        n_ports: c_int,
1448    ) -> *mut GstRTSPAddress;
1449    pub fn gst_rtsp_address_pool_add_range(
1450        pool: *mut GstRTSPAddressPool,
1451        min_address: *const c_char,
1452        max_address: *const c_char,
1453        min_port: u16,
1454        max_port: u16,
1455        ttl: u8,
1456    ) -> gboolean;
1457    pub fn gst_rtsp_address_pool_clear(pool: *mut GstRTSPAddressPool);
1458    pub fn gst_rtsp_address_pool_dump(pool: *mut GstRTSPAddressPool);
1459    pub fn gst_rtsp_address_pool_has_unicast_addresses(pool: *mut GstRTSPAddressPool) -> gboolean;
1460    pub fn gst_rtsp_address_pool_reserve_address(
1461        pool: *mut GstRTSPAddressPool,
1462        ip_address: *const c_char,
1463        port: c_uint,
1464        n_ports: c_uint,
1465        ttl: c_uint,
1466        address: *mut *mut GstRTSPAddress,
1467    ) -> GstRTSPAddressPoolResult;
1468
1469    //=========================================================================
1470    // GstRTSPAuth
1471    //=========================================================================
1472    pub fn gst_rtsp_auth_get_type() -> GType;
1473    pub fn gst_rtsp_auth_new() -> *mut GstRTSPAuth;
1474    pub fn gst_rtsp_auth_check(check: *const c_char) -> gboolean;
1475    pub fn gst_rtsp_auth_make_basic(user: *const c_char, pass: *const c_char) -> *mut c_char;
1476    pub fn gst_rtsp_auth_add_basic(
1477        auth: *mut GstRTSPAuth,
1478        basic: *const c_char,
1479        token: *mut GstRTSPToken,
1480    );
1481    pub fn gst_rtsp_auth_add_digest(
1482        auth: *mut GstRTSPAuth,
1483        user: *const c_char,
1484        pass: *const c_char,
1485        token: *mut GstRTSPToken,
1486    );
1487    pub fn gst_rtsp_auth_get_default_token(auth: *mut GstRTSPAuth) -> *mut GstRTSPToken;
1488    #[cfg(feature = "v1_16")]
1489    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1490    pub fn gst_rtsp_auth_get_realm(auth: *mut GstRTSPAuth) -> *mut c_char;
1491    pub fn gst_rtsp_auth_get_supported_methods(
1492        auth: *mut GstRTSPAuth,
1493    ) -> gst_rtsp::GstRTSPAuthMethod;
1494    pub fn gst_rtsp_auth_get_tls_authentication_mode(
1495        auth: *mut GstRTSPAuth,
1496    ) -> gio::GTlsAuthenticationMode;
1497    pub fn gst_rtsp_auth_get_tls_certificate(auth: *mut GstRTSPAuth) -> *mut gio::GTlsCertificate;
1498    pub fn gst_rtsp_auth_get_tls_database(auth: *mut GstRTSPAuth) -> *mut gio::GTlsDatabase;
1499    #[cfg(feature = "v1_16")]
1500    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1501    pub fn gst_rtsp_auth_parse_htdigest(
1502        auth: *mut GstRTSPAuth,
1503        path: *const c_char,
1504        token: *mut GstRTSPToken,
1505    ) -> gboolean;
1506    pub fn gst_rtsp_auth_remove_basic(auth: *mut GstRTSPAuth, basic: *const c_char);
1507    pub fn gst_rtsp_auth_remove_digest(auth: *mut GstRTSPAuth, user: *const c_char);
1508    pub fn gst_rtsp_auth_set_default_token(auth: *mut GstRTSPAuth, token: *mut GstRTSPToken);
1509    #[cfg(feature = "v1_16")]
1510    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1511    pub fn gst_rtsp_auth_set_realm(auth: *mut GstRTSPAuth, realm: *const c_char);
1512    pub fn gst_rtsp_auth_set_supported_methods(
1513        auth: *mut GstRTSPAuth,
1514        methods: gst_rtsp::GstRTSPAuthMethod,
1515    );
1516    pub fn gst_rtsp_auth_set_tls_authentication_mode(
1517        auth: *mut GstRTSPAuth,
1518        mode: gio::GTlsAuthenticationMode,
1519    );
1520    pub fn gst_rtsp_auth_set_tls_certificate(
1521        auth: *mut GstRTSPAuth,
1522        cert: *mut gio::GTlsCertificate,
1523    );
1524    pub fn gst_rtsp_auth_set_tls_database(auth: *mut GstRTSPAuth, database: *mut gio::GTlsDatabase);
1525
1526    //=========================================================================
1527    // GstRTSPClient
1528    //=========================================================================
1529    pub fn gst_rtsp_client_get_type() -> GType;
1530    pub fn gst_rtsp_client_new() -> *mut GstRTSPClient;
1531    pub fn gst_rtsp_client_attach(
1532        client: *mut GstRTSPClient,
1533        context: *mut glib::GMainContext,
1534    ) -> c_uint;
1535    pub fn gst_rtsp_client_close(client: *mut GstRTSPClient);
1536    pub fn gst_rtsp_client_get_auth(client: *mut GstRTSPClient) -> *mut GstRTSPAuth;
1537    pub fn gst_rtsp_client_get_connection(
1538        client: *mut GstRTSPClient,
1539    ) -> *mut gst_rtsp::GstRTSPConnection;
1540    #[cfg(feature = "v1_18")]
1541    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1542    pub fn gst_rtsp_client_get_content_length_limit(client: *mut GstRTSPClient) -> c_uint;
1543    pub fn gst_rtsp_client_get_mount_points(client: *mut GstRTSPClient) -> *mut GstRTSPMountPoints;
1544    pub fn gst_rtsp_client_get_session_pool(client: *mut GstRTSPClient) -> *mut GstRTSPSessionPool;
1545    #[cfg(feature = "v1_18")]
1546    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1547    pub fn gst_rtsp_client_get_stream_transport(
1548        client: *mut GstRTSPClient,
1549        channel: u8,
1550    ) -> *mut GstRTSPStreamTransport;
1551    pub fn gst_rtsp_client_get_thread_pool(client: *mut GstRTSPClient) -> *mut GstRTSPThreadPool;
1552    pub fn gst_rtsp_client_handle_message(
1553        client: *mut GstRTSPClient,
1554        message: *mut gst_rtsp::GstRTSPMessage,
1555    ) -> gst_rtsp::GstRTSPResult;
1556    pub fn gst_rtsp_client_send_message(
1557        client: *mut GstRTSPClient,
1558        session: *mut GstRTSPSession,
1559        message: *mut gst_rtsp::GstRTSPMessage,
1560    ) -> gst_rtsp::GstRTSPResult;
1561    pub fn gst_rtsp_client_session_filter(
1562        client: *mut GstRTSPClient,
1563        func: GstRTSPClientSessionFilterFunc,
1564        user_data: gpointer,
1565    ) -> *mut glib::GList;
1566    pub fn gst_rtsp_client_set_auth(client: *mut GstRTSPClient, auth: *mut GstRTSPAuth);
1567    pub fn gst_rtsp_client_set_connection(
1568        client: *mut GstRTSPClient,
1569        conn: *mut gst_rtsp::GstRTSPConnection,
1570    ) -> gboolean;
1571    #[cfg(feature = "v1_18")]
1572    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1573    pub fn gst_rtsp_client_set_content_length_limit(client: *mut GstRTSPClient, limit: c_uint);
1574    pub fn gst_rtsp_client_set_mount_points(
1575        client: *mut GstRTSPClient,
1576        mounts: *mut GstRTSPMountPoints,
1577    );
1578    pub fn gst_rtsp_client_set_send_func(
1579        client: *mut GstRTSPClient,
1580        func: GstRTSPClientSendFunc,
1581        user_data: gpointer,
1582        notify: glib::GDestroyNotify,
1583    );
1584    #[cfg(feature = "v1_16")]
1585    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1586    pub fn gst_rtsp_client_set_send_messages_func(
1587        client: *mut GstRTSPClient,
1588        func: GstRTSPClientSendMessagesFunc,
1589        user_data: gpointer,
1590        notify: glib::GDestroyNotify,
1591    );
1592    pub fn gst_rtsp_client_set_session_pool(
1593        client: *mut GstRTSPClient,
1594        pool: *mut GstRTSPSessionPool,
1595    );
1596    pub fn gst_rtsp_client_set_thread_pool(
1597        client: *mut GstRTSPClient,
1598        pool: *mut GstRTSPThreadPool,
1599    );
1600
1601    //=========================================================================
1602    // GstRTSPMedia
1603    //=========================================================================
1604    pub fn gst_rtsp_media_get_type() -> GType;
1605    pub fn gst_rtsp_media_new(element: *mut gst::GstElement) -> *mut GstRTSPMedia;
1606    #[cfg(feature = "v1_24")]
1607    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1608    pub fn gst_rtsp_media_can_be_shared(media: *mut GstRTSPMedia) -> gboolean;
1609    pub fn gst_rtsp_media_collect_streams(media: *mut GstRTSPMedia);
1610    pub fn gst_rtsp_media_complete_pipeline(
1611        media: *mut GstRTSPMedia,
1612        transports: *mut glib::GPtrArray,
1613    ) -> gboolean;
1614    pub fn gst_rtsp_media_create_stream(
1615        media: *mut GstRTSPMedia,
1616        payloader: *mut gst::GstElement,
1617        pad: *mut gst::GstPad,
1618    ) -> *mut GstRTSPStream;
1619    pub fn gst_rtsp_media_find_stream(
1620        media: *mut GstRTSPMedia,
1621        control: *const c_char,
1622    ) -> *mut GstRTSPStream;
1623    pub fn gst_rtsp_media_get_address_pool(media: *mut GstRTSPMedia) -> *mut GstRTSPAddressPool;
1624    pub fn gst_rtsp_media_get_base_time(media: *mut GstRTSPMedia) -> gst::GstClockTime;
1625    pub fn gst_rtsp_media_get_buffer_size(media: *mut GstRTSPMedia) -> c_uint;
1626    pub fn gst_rtsp_media_get_clock(media: *mut GstRTSPMedia) -> *mut gst::GstClock;
1627    #[cfg(feature = "v1_16")]
1628    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1629    pub fn gst_rtsp_media_get_do_retransmission(media: *mut GstRTSPMedia) -> gboolean;
1630    #[cfg(feature = "v1_18")]
1631    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1632    pub fn gst_rtsp_media_get_dscp_qos(media: *mut GstRTSPMedia) -> c_int;
1633    pub fn gst_rtsp_media_get_element(media: *mut GstRTSPMedia) -> *mut gst::GstElement;
1634    #[cfg(feature = "v1_24")]
1635    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1636    pub fn gst_rtsp_media_get_ensure_keyunit_on_start(media: *mut GstRTSPMedia) -> gboolean;
1637    #[cfg(feature = "v1_24")]
1638    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1639    pub fn gst_rtsp_media_get_ensure_keyunit_on_start_timeout(media: *mut GstRTSPMedia) -> c_uint;
1640    pub fn gst_rtsp_media_get_latency(media: *mut GstRTSPMedia) -> c_uint;
1641    #[cfg(feature = "v1_16")]
1642    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1643    pub fn gst_rtsp_media_get_max_mcast_ttl(media: *mut GstRTSPMedia) -> c_uint;
1644    pub fn gst_rtsp_media_get_multicast_iface(media: *mut GstRTSPMedia) -> *mut c_char;
1645    pub fn gst_rtsp_media_get_permissions(media: *mut GstRTSPMedia) -> *mut GstRTSPPermissions;
1646    pub fn gst_rtsp_media_get_profiles(media: *mut GstRTSPMedia) -> gst_rtsp::GstRTSPProfile;
1647    pub fn gst_rtsp_media_get_protocols(media: *mut GstRTSPMedia) -> gst_rtsp::GstRTSPLowerTrans;
1648    pub fn gst_rtsp_media_get_publish_clock_mode(
1649        media: *mut GstRTSPMedia,
1650    ) -> GstRTSPPublishClockMode;
1651    pub fn gst_rtsp_media_get_range_string(
1652        media: *mut GstRTSPMedia,
1653        play: gboolean,
1654        unit: gst_rtsp::GstRTSPRangeUnit,
1655    ) -> *mut c_char;
1656    #[cfg(feature = "v1_18")]
1657    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1658    pub fn gst_rtsp_media_get_rate_control(media: *mut GstRTSPMedia) -> gboolean;
1659    #[cfg(feature = "v1_18")]
1660    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1661    pub fn gst_rtsp_media_get_rates(
1662        media: *mut GstRTSPMedia,
1663        rate: *mut c_double,
1664        applied_rate: *mut c_double,
1665    ) -> gboolean;
1666    pub fn gst_rtsp_media_get_retransmission_time(media: *mut GstRTSPMedia) -> gst::GstClockTime;
1667    pub fn gst_rtsp_media_get_status(media: *mut GstRTSPMedia) -> GstRTSPMediaStatus;
1668    pub fn gst_rtsp_media_get_stream(media: *mut GstRTSPMedia, idx: c_uint) -> *mut GstRTSPStream;
1669    pub fn gst_rtsp_media_get_suspend_mode(media: *mut GstRTSPMedia) -> GstRTSPSuspendMode;
1670    pub fn gst_rtsp_media_get_time_provider(
1671        media: *mut GstRTSPMedia,
1672        address: *const c_char,
1673        port: u16,
1674    ) -> *mut gst_net::GstNetTimeProvider;
1675    pub fn gst_rtsp_media_get_transport_mode(media: *mut GstRTSPMedia) -> GstRTSPTransportMode;
1676    pub fn gst_rtsp_media_handle_sdp(
1677        media: *mut GstRTSPMedia,
1678        sdp: *mut gst_sdp::GstSDPMessage,
1679    ) -> gboolean;
1680    #[cfg(feature = "v1_18")]
1681    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1682    pub fn gst_rtsp_media_has_completed_sender(media: *mut GstRTSPMedia) -> gboolean;
1683    #[cfg(feature = "v1_16")]
1684    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1685    pub fn gst_rtsp_media_is_bind_mcast_address(media: *mut GstRTSPMedia) -> gboolean;
1686    pub fn gst_rtsp_media_is_eos_shutdown(media: *mut GstRTSPMedia) -> gboolean;
1687    #[cfg(feature = "v1_18")]
1688    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1689    pub fn gst_rtsp_media_is_receive_only(media: *mut GstRTSPMedia) -> gboolean;
1690    pub fn gst_rtsp_media_is_reusable(media: *mut GstRTSPMedia) -> gboolean;
1691    pub fn gst_rtsp_media_is_shared(media: *mut GstRTSPMedia) -> gboolean;
1692    pub fn gst_rtsp_media_is_stop_on_disconnect(media: *mut GstRTSPMedia) -> gboolean;
1693    pub fn gst_rtsp_media_is_time_provider(media: *mut GstRTSPMedia) -> gboolean;
1694    #[cfg(feature = "v1_18")]
1695    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1696    pub fn gst_rtsp_media_lock(media: *mut GstRTSPMedia);
1697    pub fn gst_rtsp_media_n_streams(media: *mut GstRTSPMedia) -> c_uint;
1698    pub fn gst_rtsp_media_prepare(media: *mut GstRTSPMedia, thread: *mut GstRTSPThread)
1699        -> gboolean;
1700    pub fn gst_rtsp_media_seek(
1701        media: *mut GstRTSPMedia,
1702        range: *mut gst_rtsp::GstRTSPTimeRange,
1703    ) -> gboolean;
1704    #[cfg(feature = "v1_18")]
1705    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1706    pub fn gst_rtsp_media_seek_full(
1707        media: *mut GstRTSPMedia,
1708        range: *mut gst_rtsp::GstRTSPTimeRange,
1709        flags: gst::GstSeekFlags,
1710    ) -> gboolean;
1711    #[cfg(feature = "v1_18")]
1712    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1713    pub fn gst_rtsp_media_seek_trickmode(
1714        media: *mut GstRTSPMedia,
1715        range: *mut gst_rtsp::GstRTSPTimeRange,
1716        flags: gst::GstSeekFlags,
1717        rate: c_double,
1718        trickmode_interval: gst::GstClockTime,
1719    ) -> gboolean;
1720    pub fn gst_rtsp_media_seekable(media: *mut GstRTSPMedia) -> gst::GstClockTimeDiff;
1721    pub fn gst_rtsp_media_set_address_pool(media: *mut GstRTSPMedia, pool: *mut GstRTSPAddressPool);
1722    #[cfg(feature = "v1_16")]
1723    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1724    pub fn gst_rtsp_media_set_bind_mcast_address(
1725        media: *mut GstRTSPMedia,
1726        bind_mcast_addr: gboolean,
1727    );
1728    pub fn gst_rtsp_media_set_buffer_size(media: *mut GstRTSPMedia, size: c_uint);
1729    pub fn gst_rtsp_media_set_clock(media: *mut GstRTSPMedia, clock: *mut gst::GstClock);
1730    #[cfg(feature = "v1_16")]
1731    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1732    pub fn gst_rtsp_media_set_do_retransmission(
1733        media: *mut GstRTSPMedia,
1734        do_retransmission: gboolean,
1735    );
1736    #[cfg(feature = "v1_18")]
1737    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1738    pub fn gst_rtsp_media_set_dscp_qos(media: *mut GstRTSPMedia, dscp_qos: c_int);
1739    #[cfg(feature = "v1_24")]
1740    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1741    pub fn gst_rtsp_media_set_ensure_keyunit_on_start(
1742        media: *mut GstRTSPMedia,
1743        ensure_keyunit_on_start: gboolean,
1744    );
1745    #[cfg(feature = "v1_24")]
1746    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1747    pub fn gst_rtsp_media_set_ensure_keyunit_on_start_timeout(
1748        media: *mut GstRTSPMedia,
1749        timeout: c_uint,
1750    );
1751    pub fn gst_rtsp_media_set_eos_shutdown(media: *mut GstRTSPMedia, eos_shutdown: gboolean);
1752    pub fn gst_rtsp_media_set_latency(media: *mut GstRTSPMedia, latency: c_uint);
1753    #[cfg(feature = "v1_16")]
1754    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1755    pub fn gst_rtsp_media_set_max_mcast_ttl(media: *mut GstRTSPMedia, ttl: c_uint) -> gboolean;
1756    pub fn gst_rtsp_media_set_multicast_iface(
1757        media: *mut GstRTSPMedia,
1758        multicast_iface: *const c_char,
1759    );
1760    pub fn gst_rtsp_media_set_permissions(
1761        media: *mut GstRTSPMedia,
1762        permissions: *mut GstRTSPPermissions,
1763    );
1764    pub fn gst_rtsp_media_set_pipeline_state(media: *mut GstRTSPMedia, state: gst::GstState);
1765    pub fn gst_rtsp_media_set_profiles(
1766        media: *mut GstRTSPMedia,
1767        profiles: gst_rtsp::GstRTSPProfile,
1768    );
1769    pub fn gst_rtsp_media_set_protocols(
1770        media: *mut GstRTSPMedia,
1771        protocols: gst_rtsp::GstRTSPLowerTrans,
1772    );
1773    pub fn gst_rtsp_media_set_publish_clock_mode(
1774        media: *mut GstRTSPMedia,
1775        mode: GstRTSPPublishClockMode,
1776    );
1777    #[cfg(feature = "v1_18")]
1778    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1779    pub fn gst_rtsp_media_set_rate_control(media: *mut GstRTSPMedia, enabled: gboolean);
1780    pub fn gst_rtsp_media_set_retransmission_time(
1781        media: *mut GstRTSPMedia,
1782        time: gst::GstClockTime,
1783    );
1784    pub fn gst_rtsp_media_set_reusable(media: *mut GstRTSPMedia, reusable: gboolean);
1785    pub fn gst_rtsp_media_set_shared(media: *mut GstRTSPMedia, shared: gboolean);
1786    pub fn gst_rtsp_media_set_state(
1787        media: *mut GstRTSPMedia,
1788        state: gst::GstState,
1789        transports: *mut glib::GPtrArray,
1790    ) -> gboolean;
1791    pub fn gst_rtsp_media_set_stop_on_disconnect(
1792        media: *mut GstRTSPMedia,
1793        stop_on_disconnect: gboolean,
1794    );
1795    pub fn gst_rtsp_media_set_suspend_mode(media: *mut GstRTSPMedia, mode: GstRTSPSuspendMode);
1796    pub fn gst_rtsp_media_set_transport_mode(media: *mut GstRTSPMedia, mode: GstRTSPTransportMode);
1797    pub fn gst_rtsp_media_setup_sdp(
1798        media: *mut GstRTSPMedia,
1799        sdp: *mut gst_sdp::GstSDPMessage,
1800        info: *mut GstSDPInfo,
1801    ) -> gboolean;
1802    pub fn gst_rtsp_media_suspend(media: *mut GstRTSPMedia) -> gboolean;
1803    pub fn gst_rtsp_media_take_pipeline(media: *mut GstRTSPMedia, pipeline: *mut gst::GstPipeline);
1804    #[cfg(feature = "v1_18")]
1805    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1806    pub fn gst_rtsp_media_unlock(media: *mut GstRTSPMedia);
1807    pub fn gst_rtsp_media_unprepare(media: *mut GstRTSPMedia) -> gboolean;
1808    pub fn gst_rtsp_media_unsuspend(media: *mut GstRTSPMedia) -> gboolean;
1809    pub fn gst_rtsp_media_use_time_provider(media: *mut GstRTSPMedia, time_provider: gboolean);
1810
1811    //=========================================================================
1812    // GstRTSPMediaFactory
1813    //=========================================================================
1814    pub fn gst_rtsp_media_factory_get_type() -> GType;
1815    pub fn gst_rtsp_media_factory_new() -> *mut GstRTSPMediaFactory;
1816    pub fn gst_rtsp_media_factory_add_role(
1817        factory: *mut GstRTSPMediaFactory,
1818        role: *const c_char,
1819        fieldname: *const c_char,
1820        ...
1821    );
1822    pub fn gst_rtsp_media_factory_add_role_from_structure(
1823        factory: *mut GstRTSPMediaFactory,
1824        structure: *mut gst::GstStructure,
1825    );
1826    pub fn gst_rtsp_media_factory_construct(
1827        factory: *mut GstRTSPMediaFactory,
1828        url: *const gst_rtsp::GstRTSPUrl,
1829    ) -> *mut GstRTSPMedia;
1830    pub fn gst_rtsp_media_factory_create_element(
1831        factory: *mut GstRTSPMediaFactory,
1832        url: *const gst_rtsp::GstRTSPUrl,
1833    ) -> *mut gst::GstElement;
1834    pub fn gst_rtsp_media_factory_get_address_pool(
1835        factory: *mut GstRTSPMediaFactory,
1836    ) -> *mut GstRTSPAddressPool;
1837    pub fn gst_rtsp_media_factory_get_buffer_size(factory: *mut GstRTSPMediaFactory) -> c_uint;
1838    pub fn gst_rtsp_media_factory_get_clock(
1839        factory: *mut GstRTSPMediaFactory,
1840    ) -> *mut gst::GstClock;
1841    #[cfg(feature = "v1_16")]
1842    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1843    pub fn gst_rtsp_media_factory_get_do_retransmission(
1844        factory: *mut GstRTSPMediaFactory,
1845    ) -> gboolean;
1846    #[cfg(feature = "v1_18")]
1847    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1848    pub fn gst_rtsp_media_factory_get_dscp_qos(factory: *mut GstRTSPMediaFactory) -> c_int;
1849    #[cfg(feature = "v1_24")]
1850    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1851    pub fn gst_rtsp_media_factory_get_ensure_keyunit_on_start(
1852        factory: *mut GstRTSPMediaFactory,
1853    ) -> gboolean;
1854    #[cfg(feature = "v1_24")]
1855    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1856    pub fn gst_rtsp_media_factory_get_ensure_keyunit_on_start_timeout(
1857        factory: *mut GstRTSPMediaFactory,
1858    ) -> c_uint;
1859    pub fn gst_rtsp_media_factory_get_latency(factory: *mut GstRTSPMediaFactory) -> c_uint;
1860    pub fn gst_rtsp_media_factory_get_launch(factory: *mut GstRTSPMediaFactory) -> *mut c_char;
1861    #[cfg(feature = "v1_16")]
1862    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1863    pub fn gst_rtsp_media_factory_get_max_mcast_ttl(factory: *mut GstRTSPMediaFactory) -> c_uint;
1864    pub fn gst_rtsp_media_factory_get_media_gtype(factory: *mut GstRTSPMediaFactory) -> GType;
1865    pub fn gst_rtsp_media_factory_get_multicast_iface(
1866        factory: *mut GstRTSPMediaFactory,
1867    ) -> *mut c_char;
1868    pub fn gst_rtsp_media_factory_get_permissions(
1869        factory: *mut GstRTSPMediaFactory,
1870    ) -> *mut GstRTSPPermissions;
1871    pub fn gst_rtsp_media_factory_get_profiles(
1872        factory: *mut GstRTSPMediaFactory,
1873    ) -> gst_rtsp::GstRTSPProfile;
1874    pub fn gst_rtsp_media_factory_get_protocols(
1875        factory: *mut GstRTSPMediaFactory,
1876    ) -> gst_rtsp::GstRTSPLowerTrans;
1877    pub fn gst_rtsp_media_factory_get_publish_clock_mode(
1878        factory: *mut GstRTSPMediaFactory,
1879    ) -> GstRTSPPublishClockMode;
1880    pub fn gst_rtsp_media_factory_get_retransmission_time(
1881        factory: *mut GstRTSPMediaFactory,
1882    ) -> gst::GstClockTime;
1883    pub fn gst_rtsp_media_factory_get_suspend_mode(
1884        factory: *mut GstRTSPMediaFactory,
1885    ) -> GstRTSPSuspendMode;
1886    pub fn gst_rtsp_media_factory_get_transport_mode(
1887        factory: *mut GstRTSPMediaFactory,
1888    ) -> GstRTSPTransportMode;
1889    #[cfg(feature = "v1_16")]
1890    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1891    pub fn gst_rtsp_media_factory_is_bind_mcast_address(
1892        factory: *mut GstRTSPMediaFactory,
1893    ) -> gboolean;
1894    #[cfg(feature = "v1_20")]
1895    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1896    pub fn gst_rtsp_media_factory_is_enable_rtcp(factory: *mut GstRTSPMediaFactory) -> gboolean;
1897    pub fn gst_rtsp_media_factory_is_eos_shutdown(factory: *mut GstRTSPMediaFactory) -> gboolean;
1898    pub fn gst_rtsp_media_factory_is_shared(factory: *mut GstRTSPMediaFactory) -> gboolean;
1899    pub fn gst_rtsp_media_factory_is_stop_on_disonnect(
1900        factory: *mut GstRTSPMediaFactory,
1901    ) -> gboolean;
1902    pub fn gst_rtsp_media_factory_set_address_pool(
1903        factory: *mut GstRTSPMediaFactory,
1904        pool: *mut GstRTSPAddressPool,
1905    );
1906    #[cfg(feature = "v1_16")]
1907    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1908    pub fn gst_rtsp_media_factory_set_bind_mcast_address(
1909        factory: *mut GstRTSPMediaFactory,
1910        bind_mcast_addr: gboolean,
1911    );
1912    pub fn gst_rtsp_media_factory_set_buffer_size(factory: *mut GstRTSPMediaFactory, size: c_uint);
1913    pub fn gst_rtsp_media_factory_set_clock(
1914        factory: *mut GstRTSPMediaFactory,
1915        clock: *mut gst::GstClock,
1916    );
1917    #[cfg(feature = "v1_16")]
1918    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1919    pub fn gst_rtsp_media_factory_set_do_retransmission(
1920        factory: *mut GstRTSPMediaFactory,
1921        do_retransmission: gboolean,
1922    );
1923    #[cfg(feature = "v1_18")]
1924    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1925    pub fn gst_rtsp_media_factory_set_dscp_qos(factory: *mut GstRTSPMediaFactory, dscp_qos: c_int);
1926    #[cfg(feature = "v1_20")]
1927    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1928    pub fn gst_rtsp_media_factory_set_enable_rtcp(
1929        factory: *mut GstRTSPMediaFactory,
1930        enable: gboolean,
1931    );
1932    #[cfg(feature = "v1_24")]
1933    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1934    pub fn gst_rtsp_media_factory_set_ensure_keyunit_on_start(
1935        factory: *mut GstRTSPMediaFactory,
1936        ensure_keyunit_on_start: gboolean,
1937    );
1938    #[cfg(feature = "v1_24")]
1939    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1940    pub fn gst_rtsp_media_factory_set_ensure_keyunit_on_start_timeout(
1941        factory: *mut GstRTSPMediaFactory,
1942        timeout: c_uint,
1943    );
1944    pub fn gst_rtsp_media_factory_set_eos_shutdown(
1945        factory: *mut GstRTSPMediaFactory,
1946        eos_shutdown: gboolean,
1947    );
1948    pub fn gst_rtsp_media_factory_set_latency(factory: *mut GstRTSPMediaFactory, latency: c_uint);
1949    pub fn gst_rtsp_media_factory_set_launch(
1950        factory: *mut GstRTSPMediaFactory,
1951        launch: *const c_char,
1952    );
1953    #[cfg(feature = "v1_16")]
1954    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1955    pub fn gst_rtsp_media_factory_set_max_mcast_ttl(
1956        factory: *mut GstRTSPMediaFactory,
1957        ttl: c_uint,
1958    ) -> gboolean;
1959    pub fn gst_rtsp_media_factory_set_media_gtype(
1960        factory: *mut GstRTSPMediaFactory,
1961        media_gtype: GType,
1962    );
1963    pub fn gst_rtsp_media_factory_set_multicast_iface(
1964        factory: *mut GstRTSPMediaFactory,
1965        multicast_iface: *const c_char,
1966    );
1967    pub fn gst_rtsp_media_factory_set_permissions(
1968        factory: *mut GstRTSPMediaFactory,
1969        permissions: *mut GstRTSPPermissions,
1970    );
1971    pub fn gst_rtsp_media_factory_set_profiles(
1972        factory: *mut GstRTSPMediaFactory,
1973        profiles: gst_rtsp::GstRTSPProfile,
1974    );
1975    pub fn gst_rtsp_media_factory_set_protocols(
1976        factory: *mut GstRTSPMediaFactory,
1977        protocols: gst_rtsp::GstRTSPLowerTrans,
1978    );
1979    pub fn gst_rtsp_media_factory_set_publish_clock_mode(
1980        factory: *mut GstRTSPMediaFactory,
1981        mode: GstRTSPPublishClockMode,
1982    );
1983    pub fn gst_rtsp_media_factory_set_retransmission_time(
1984        factory: *mut GstRTSPMediaFactory,
1985        time: gst::GstClockTime,
1986    );
1987    pub fn gst_rtsp_media_factory_set_shared(factory: *mut GstRTSPMediaFactory, shared: gboolean);
1988    pub fn gst_rtsp_media_factory_set_stop_on_disconnect(
1989        factory: *mut GstRTSPMediaFactory,
1990        stop_on_disconnect: gboolean,
1991    );
1992    pub fn gst_rtsp_media_factory_set_suspend_mode(
1993        factory: *mut GstRTSPMediaFactory,
1994        mode: GstRTSPSuspendMode,
1995    );
1996    pub fn gst_rtsp_media_factory_set_transport_mode(
1997        factory: *mut GstRTSPMediaFactory,
1998        mode: GstRTSPTransportMode,
1999    );
2000
2001    //=========================================================================
2002    // GstRTSPMediaFactoryURI
2003    //=========================================================================
2004    pub fn gst_rtsp_media_factory_uri_get_type() -> GType;
2005    pub fn gst_rtsp_media_factory_uri_new() -> *mut GstRTSPMediaFactoryURI;
2006    pub fn gst_rtsp_media_factory_uri_get_uri(factory: *mut GstRTSPMediaFactoryURI) -> *mut c_char;
2007    pub fn gst_rtsp_media_factory_uri_set_uri(
2008        factory: *mut GstRTSPMediaFactoryURI,
2009        uri: *const c_char,
2010    );
2011
2012    //=========================================================================
2013    // GstRTSPMountPoints
2014    //=========================================================================
2015    pub fn gst_rtsp_mount_points_get_type() -> GType;
2016    pub fn gst_rtsp_mount_points_new() -> *mut GstRTSPMountPoints;
2017    pub fn gst_rtsp_mount_points_add_factory(
2018        mounts: *mut GstRTSPMountPoints,
2019        path: *const c_char,
2020        factory: *mut GstRTSPMediaFactory,
2021    );
2022    pub fn gst_rtsp_mount_points_make_path(
2023        mounts: *mut GstRTSPMountPoints,
2024        url: *const gst_rtsp::GstRTSPUrl,
2025    ) -> *mut c_char;
2026    pub fn gst_rtsp_mount_points_match(
2027        mounts: *mut GstRTSPMountPoints,
2028        path: *const c_char,
2029        matched: *mut c_int,
2030    ) -> *mut GstRTSPMediaFactory;
2031    pub fn gst_rtsp_mount_points_remove_factory(
2032        mounts: *mut GstRTSPMountPoints,
2033        path: *const c_char,
2034    );
2035
2036    //=========================================================================
2037    // GstRTSPOnvifClient
2038    //=========================================================================
2039    pub fn gst_rtsp_onvif_client_get_type() -> GType;
2040    #[cfg(feature = "v1_18")]
2041    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2042    pub fn gst_rtsp_onvif_client_new() -> *mut GstRTSPClient;
2043
2044    //=========================================================================
2045    // GstRTSPOnvifMedia
2046    //=========================================================================
2047    pub fn gst_rtsp_onvif_media_get_type() -> GType;
2048    pub fn gst_rtsp_onvif_media_collect_backchannel(media: *mut GstRTSPOnvifMedia) -> gboolean;
2049    pub fn gst_rtsp_onvif_media_get_backchannel_bandwidth(media: *mut GstRTSPOnvifMedia) -> c_uint;
2050    pub fn gst_rtsp_onvif_media_set_backchannel_bandwidth(
2051        media: *mut GstRTSPOnvifMedia,
2052        bandwidth: c_uint,
2053    );
2054
2055    //=========================================================================
2056    // GstRTSPOnvifMediaFactory
2057    //=========================================================================
2058    pub fn gst_rtsp_onvif_media_factory_get_type() -> GType;
2059    pub fn gst_rtsp_onvif_media_factory_new() -> *mut GstRTSPMediaFactory;
2060    pub fn gst_rtsp_onvif_media_factory_requires_backchannel(
2061        factory: *mut GstRTSPMediaFactory,
2062        ctx: *mut GstRTSPContext,
2063    ) -> gboolean;
2064    pub fn gst_rtsp_onvif_media_factory_get_backchannel_bandwidth(
2065        factory: *mut GstRTSPOnvifMediaFactory,
2066    ) -> c_uint;
2067    pub fn gst_rtsp_onvif_media_factory_get_backchannel_launch(
2068        factory: *mut GstRTSPOnvifMediaFactory,
2069    ) -> *mut c_char;
2070    pub fn gst_rtsp_onvif_media_factory_has_backchannel_support(
2071        factory: *mut GstRTSPOnvifMediaFactory,
2072    ) -> gboolean;
2073    #[cfg(feature = "v1_18")]
2074    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2075    pub fn gst_rtsp_onvif_media_factory_has_replay_support(
2076        factory: *mut GstRTSPOnvifMediaFactory,
2077    ) -> gboolean;
2078    pub fn gst_rtsp_onvif_media_factory_set_backchannel_bandwidth(
2079        factory: *mut GstRTSPOnvifMediaFactory,
2080        bandwidth: c_uint,
2081    );
2082    pub fn gst_rtsp_onvif_media_factory_set_backchannel_launch(
2083        factory: *mut GstRTSPOnvifMediaFactory,
2084        launch: *const c_char,
2085    );
2086    #[cfg(feature = "v1_18")]
2087    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2088    pub fn gst_rtsp_onvif_media_factory_set_replay_support(
2089        factory: *mut GstRTSPOnvifMediaFactory,
2090        has_replay_support: gboolean,
2091    );
2092
2093    //=========================================================================
2094    // GstRTSPOnvifServer
2095    //=========================================================================
2096    pub fn gst_rtsp_onvif_server_get_type() -> GType;
2097    pub fn gst_rtsp_onvif_server_new() -> *mut GstRTSPServer;
2098
2099    //=========================================================================
2100    // GstRTSPServer
2101    //=========================================================================
2102    pub fn gst_rtsp_server_get_type() -> GType;
2103    pub fn gst_rtsp_server_new() -> *mut GstRTSPServer;
2104    pub fn gst_rtsp_server_io_func(
2105        socket: *mut gio::GSocket,
2106        condition: glib::GIOCondition,
2107        server: *mut GstRTSPServer,
2108    ) -> gboolean;
2109    pub fn gst_rtsp_server_attach(
2110        server: *mut GstRTSPServer,
2111        context: *mut glib::GMainContext,
2112    ) -> c_uint;
2113    pub fn gst_rtsp_server_client_filter(
2114        server: *mut GstRTSPServer,
2115        func: GstRTSPServerClientFilterFunc,
2116        user_data: gpointer,
2117    ) -> *mut glib::GList;
2118    pub fn gst_rtsp_server_create_socket(
2119        server: *mut GstRTSPServer,
2120        cancellable: *mut gio::GCancellable,
2121        error: *mut *mut glib::GError,
2122    ) -> *mut gio::GSocket;
2123    pub fn gst_rtsp_server_create_source(
2124        server: *mut GstRTSPServer,
2125        cancellable: *mut gio::GCancellable,
2126        error: *mut *mut glib::GError,
2127    ) -> *mut glib::GSource;
2128    pub fn gst_rtsp_server_get_address(server: *mut GstRTSPServer) -> *mut c_char;
2129    pub fn gst_rtsp_server_get_auth(server: *mut GstRTSPServer) -> *mut GstRTSPAuth;
2130    pub fn gst_rtsp_server_get_backlog(server: *mut GstRTSPServer) -> c_int;
2131    pub fn gst_rtsp_server_get_bound_port(server: *mut GstRTSPServer) -> c_int;
2132    #[cfg(feature = "v1_18")]
2133    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2134    pub fn gst_rtsp_server_get_content_length_limit(server: *mut GstRTSPServer) -> c_uint;
2135    pub fn gst_rtsp_server_get_mount_points(server: *mut GstRTSPServer) -> *mut GstRTSPMountPoints;
2136    pub fn gst_rtsp_server_get_service(server: *mut GstRTSPServer) -> *mut c_char;
2137    pub fn gst_rtsp_server_get_session_pool(server: *mut GstRTSPServer) -> *mut GstRTSPSessionPool;
2138    pub fn gst_rtsp_server_get_thread_pool(server: *mut GstRTSPServer) -> *mut GstRTSPThreadPool;
2139    pub fn gst_rtsp_server_set_address(server: *mut GstRTSPServer, address: *const c_char);
2140    pub fn gst_rtsp_server_set_auth(server: *mut GstRTSPServer, auth: *mut GstRTSPAuth);
2141    pub fn gst_rtsp_server_set_backlog(server: *mut GstRTSPServer, backlog: c_int);
2142    #[cfg(feature = "v1_18")]
2143    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2144    pub fn gst_rtsp_server_set_content_length_limit(server: *mut GstRTSPServer, limit: c_uint);
2145    pub fn gst_rtsp_server_set_mount_points(
2146        server: *mut GstRTSPServer,
2147        mounts: *mut GstRTSPMountPoints,
2148    );
2149    pub fn gst_rtsp_server_set_service(server: *mut GstRTSPServer, service: *const c_char);
2150    pub fn gst_rtsp_server_set_session_pool(
2151        server: *mut GstRTSPServer,
2152        pool: *mut GstRTSPSessionPool,
2153    );
2154    pub fn gst_rtsp_server_set_thread_pool(
2155        server: *mut GstRTSPServer,
2156        pool: *mut GstRTSPThreadPool,
2157    );
2158    pub fn gst_rtsp_server_transfer_connection(
2159        server: *mut GstRTSPServer,
2160        socket: *mut gio::GSocket,
2161        ip: *const c_char,
2162        port: c_int,
2163        initial_buffer: *const c_char,
2164    ) -> gboolean;
2165
2166    //=========================================================================
2167    // GstRTSPSession
2168    //=========================================================================
2169    pub fn gst_rtsp_session_get_type() -> GType;
2170    pub fn gst_rtsp_session_new(sessionid: *const c_char) -> *mut GstRTSPSession;
2171    pub fn gst_rtsp_session_allow_expire(session: *mut GstRTSPSession);
2172    #[cfg(feature = "v1_20")]
2173    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2174    pub fn gst_rtsp_session_dup_media(
2175        sess: *mut GstRTSPSession,
2176        path: *const c_char,
2177        matched: *mut c_int,
2178    ) -> *mut GstRTSPSessionMedia;
2179    pub fn gst_rtsp_session_filter(
2180        sess: *mut GstRTSPSession,
2181        func: GstRTSPSessionFilterFunc,
2182        user_data: gpointer,
2183    ) -> *mut glib::GList;
2184    pub fn gst_rtsp_session_get_header(session: *mut GstRTSPSession) -> *mut c_char;
2185    pub fn gst_rtsp_session_get_media(
2186        sess: *mut GstRTSPSession,
2187        path: *const c_char,
2188        matched: *mut c_int,
2189    ) -> *mut GstRTSPSessionMedia;
2190    pub fn gst_rtsp_session_get_sessionid(session: *mut GstRTSPSession) -> *const c_char;
2191    pub fn gst_rtsp_session_get_timeout(session: *mut GstRTSPSession) -> c_uint;
2192    pub fn gst_rtsp_session_is_expired(
2193        session: *mut GstRTSPSession,
2194        now: *mut glib::GTimeVal,
2195    ) -> gboolean;
2196    pub fn gst_rtsp_session_is_expired_usec(session: *mut GstRTSPSession, now: i64) -> gboolean;
2197    pub fn gst_rtsp_session_manage_media(
2198        sess: *mut GstRTSPSession,
2199        path: *const c_char,
2200        media: *mut GstRTSPMedia,
2201    ) -> *mut GstRTSPSessionMedia;
2202    pub fn gst_rtsp_session_next_timeout(
2203        session: *mut GstRTSPSession,
2204        now: *mut glib::GTimeVal,
2205    ) -> c_int;
2206    pub fn gst_rtsp_session_next_timeout_usec(session: *mut GstRTSPSession, now: i64) -> c_int;
2207    pub fn gst_rtsp_session_prevent_expire(session: *mut GstRTSPSession);
2208    pub fn gst_rtsp_session_release_media(
2209        sess: *mut GstRTSPSession,
2210        media: *mut GstRTSPSessionMedia,
2211    ) -> gboolean;
2212    pub fn gst_rtsp_session_set_timeout(session: *mut GstRTSPSession, timeout: c_uint);
2213    pub fn gst_rtsp_session_touch(session: *mut GstRTSPSession);
2214
2215    //=========================================================================
2216    // GstRTSPSessionMedia
2217    //=========================================================================
2218    pub fn gst_rtsp_session_media_get_type() -> GType;
2219    pub fn gst_rtsp_session_media_new(
2220        path: *const c_char,
2221        media: *mut GstRTSPMedia,
2222    ) -> *mut GstRTSPSessionMedia;
2223    pub fn gst_rtsp_session_media_alloc_channels(
2224        media: *mut GstRTSPSessionMedia,
2225        range: *mut gst_rtsp::GstRTSPRange,
2226    ) -> gboolean;
2227    pub fn gst_rtsp_session_media_get_base_time(
2228        media: *mut GstRTSPSessionMedia,
2229    ) -> gst::GstClockTime;
2230    pub fn gst_rtsp_session_media_get_media(media: *mut GstRTSPSessionMedia) -> *mut GstRTSPMedia;
2231    pub fn gst_rtsp_session_media_get_rtpinfo(media: *mut GstRTSPSessionMedia) -> *mut c_char;
2232    pub fn gst_rtsp_session_media_get_rtsp_state(
2233        media: *mut GstRTSPSessionMedia,
2234    ) -> gst_rtsp::GstRTSPState;
2235    pub fn gst_rtsp_session_media_get_transport(
2236        media: *mut GstRTSPSessionMedia,
2237        idx: c_uint,
2238    ) -> *mut GstRTSPStreamTransport;
2239    pub fn gst_rtsp_session_media_get_transports(
2240        media: *mut GstRTSPSessionMedia,
2241    ) -> *mut glib::GPtrArray;
2242    pub fn gst_rtsp_session_media_matches(
2243        media: *mut GstRTSPSessionMedia,
2244        path: *const c_char,
2245        matched: *mut c_int,
2246    ) -> gboolean;
2247    pub fn gst_rtsp_session_media_set_rtsp_state(
2248        media: *mut GstRTSPSessionMedia,
2249        state: gst_rtsp::GstRTSPState,
2250    );
2251    pub fn gst_rtsp_session_media_set_state(
2252        media: *mut GstRTSPSessionMedia,
2253        state: gst::GstState,
2254    ) -> gboolean;
2255    pub fn gst_rtsp_session_media_set_transport(
2256        media: *mut GstRTSPSessionMedia,
2257        stream: *mut GstRTSPStream,
2258        tr: *mut gst_rtsp::GstRTSPTransport,
2259    ) -> *mut GstRTSPStreamTransport;
2260
2261    //=========================================================================
2262    // GstRTSPSessionPool
2263    //=========================================================================
2264    pub fn gst_rtsp_session_pool_get_type() -> GType;
2265    pub fn gst_rtsp_session_pool_new() -> *mut GstRTSPSessionPool;
2266    pub fn gst_rtsp_session_pool_cleanup(pool: *mut GstRTSPSessionPool) -> c_uint;
2267    pub fn gst_rtsp_session_pool_create(pool: *mut GstRTSPSessionPool) -> *mut GstRTSPSession;
2268    pub fn gst_rtsp_session_pool_create_watch(pool: *mut GstRTSPSessionPool) -> *mut glib::GSource;
2269    pub fn gst_rtsp_session_pool_filter(
2270        pool: *mut GstRTSPSessionPool,
2271        func: GstRTSPSessionPoolFilterFunc,
2272        user_data: gpointer,
2273    ) -> *mut glib::GList;
2274    pub fn gst_rtsp_session_pool_find(
2275        pool: *mut GstRTSPSessionPool,
2276        sessionid: *const c_char,
2277    ) -> *mut GstRTSPSession;
2278    pub fn gst_rtsp_session_pool_get_max_sessions(pool: *mut GstRTSPSessionPool) -> c_uint;
2279    pub fn gst_rtsp_session_pool_get_n_sessions(pool: *mut GstRTSPSessionPool) -> c_uint;
2280    pub fn gst_rtsp_session_pool_remove(
2281        pool: *mut GstRTSPSessionPool,
2282        sess: *mut GstRTSPSession,
2283    ) -> gboolean;
2284    pub fn gst_rtsp_session_pool_set_max_sessions(pool: *mut GstRTSPSessionPool, max: c_uint);
2285
2286    //=========================================================================
2287    // GstRTSPStream
2288    //=========================================================================
2289    pub fn gst_rtsp_stream_get_type() -> GType;
2290    pub fn gst_rtsp_stream_new(
2291        idx: c_uint,
2292        payloader: *mut gst::GstElement,
2293        pad: *mut gst::GstPad,
2294    ) -> *mut GstRTSPStream;
2295    #[cfg(feature = "v1_16")]
2296    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2297    pub fn gst_rtsp_stream_add_multicast_client_address(
2298        stream: *mut GstRTSPStream,
2299        destination: *const c_char,
2300        rtp_port: c_uint,
2301        rtcp_port: c_uint,
2302        family: gio::GSocketFamily,
2303    ) -> gboolean;
2304    pub fn gst_rtsp_stream_add_transport(
2305        stream: *mut GstRTSPStream,
2306        trans: *mut GstRTSPStreamTransport,
2307    ) -> gboolean;
2308    pub fn gst_rtsp_stream_allocate_udp_sockets(
2309        stream: *mut GstRTSPStream,
2310        family: gio::GSocketFamily,
2311        transport: *mut gst_rtsp::GstRTSPTransport,
2312        use_client_settings: gboolean,
2313    ) -> gboolean;
2314    pub fn gst_rtsp_stream_complete_stream(
2315        stream: *mut GstRTSPStream,
2316        transport: *const gst_rtsp::GstRTSPTransport,
2317    ) -> gboolean;
2318    pub fn gst_rtsp_stream_get_address_pool(stream: *mut GstRTSPStream) -> *mut GstRTSPAddressPool;
2319    pub fn gst_rtsp_stream_get_buffer_size(stream: *mut GstRTSPStream) -> c_uint;
2320    pub fn gst_rtsp_stream_get_caps(stream: *mut GstRTSPStream) -> *mut gst::GstCaps;
2321    pub fn gst_rtsp_stream_get_control(stream: *mut GstRTSPStream) -> *mut c_char;
2322    pub fn gst_rtsp_stream_get_current_seqnum(stream: *mut GstRTSPStream) -> u16;
2323    pub fn gst_rtsp_stream_get_dscp_qos(stream: *mut GstRTSPStream) -> c_int;
2324    pub fn gst_rtsp_stream_get_index(stream: *mut GstRTSPStream) -> c_uint;
2325    pub fn gst_rtsp_stream_get_joined_bin(stream: *mut GstRTSPStream) -> *mut gst::GstBin;
2326    #[cfg(feature = "v1_16")]
2327    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2328    pub fn gst_rtsp_stream_get_max_mcast_ttl(stream: *mut GstRTSPStream) -> c_uint;
2329    pub fn gst_rtsp_stream_get_mtu(stream: *mut GstRTSPStream) -> c_uint;
2330    pub fn gst_rtsp_stream_get_multicast_address(
2331        stream: *mut GstRTSPStream,
2332        family: gio::GSocketFamily,
2333    ) -> *mut GstRTSPAddress;
2334    #[cfg(feature = "v1_16")]
2335    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2336    pub fn gst_rtsp_stream_get_multicast_client_addresses(
2337        stream: *mut GstRTSPStream,
2338    ) -> *mut c_char;
2339    pub fn gst_rtsp_stream_get_multicast_iface(stream: *mut GstRTSPStream) -> *mut c_char;
2340    pub fn gst_rtsp_stream_get_profiles(stream: *mut GstRTSPStream) -> gst_rtsp::GstRTSPProfile;
2341    pub fn gst_rtsp_stream_get_protocols(stream: *mut GstRTSPStream)
2342        -> gst_rtsp::GstRTSPLowerTrans;
2343    pub fn gst_rtsp_stream_get_pt(stream: *mut GstRTSPStream) -> c_uint;
2344    pub fn gst_rtsp_stream_get_publish_clock_mode(
2345        stream: *mut GstRTSPStream,
2346    ) -> GstRTSPPublishClockMode;
2347    #[cfg(feature = "v1_18")]
2348    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2349    pub fn gst_rtsp_stream_get_rate_control(stream: *mut GstRTSPStream) -> gboolean;
2350    #[cfg(feature = "v1_18")]
2351    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2352    pub fn gst_rtsp_stream_get_rates(
2353        stream: *mut GstRTSPStream,
2354        rate: *mut c_double,
2355        applied_rate: *mut c_double,
2356    ) -> gboolean;
2357    pub fn gst_rtsp_stream_get_retransmission_pt(stream: *mut GstRTSPStream) -> c_uint;
2358    pub fn gst_rtsp_stream_get_retransmission_time(stream: *mut GstRTSPStream)
2359        -> gst::GstClockTime;
2360    pub fn gst_rtsp_stream_get_rtcp_multicast_socket(
2361        stream: *mut GstRTSPStream,
2362        family: gio::GSocketFamily,
2363    ) -> *mut gio::GSocket;
2364    pub fn gst_rtsp_stream_get_rtcp_socket(
2365        stream: *mut GstRTSPStream,
2366        family: gio::GSocketFamily,
2367    ) -> *mut gio::GSocket;
2368    pub fn gst_rtsp_stream_get_rtp_multicast_socket(
2369        stream: *mut GstRTSPStream,
2370        family: gio::GSocketFamily,
2371    ) -> *mut gio::GSocket;
2372    pub fn gst_rtsp_stream_get_rtp_socket(
2373        stream: *mut GstRTSPStream,
2374        family: gio::GSocketFamily,
2375    ) -> *mut gio::GSocket;
2376    pub fn gst_rtsp_stream_get_rtpinfo(
2377        stream: *mut GstRTSPStream,
2378        rtptime: *mut c_uint,
2379        seq: *mut c_uint,
2380        clock_rate: *mut c_uint,
2381        running_time: *mut gst::GstClockTime,
2382    ) -> gboolean;
2383    pub fn gst_rtsp_stream_get_rtpsession(stream: *mut GstRTSPStream) -> *mut gobject::GObject;
2384    pub fn gst_rtsp_stream_get_server_port(
2385        stream: *mut GstRTSPStream,
2386        server_port: *mut gst_rtsp::GstRTSPRange,
2387        family: gio::GSocketFamily,
2388    );
2389    pub fn gst_rtsp_stream_get_sinkpad(stream: *mut GstRTSPStream) -> *mut gst::GstPad;
2390    pub fn gst_rtsp_stream_get_srcpad(stream: *mut GstRTSPStream) -> *mut gst::GstPad;
2391    pub fn gst_rtsp_stream_get_srtp_encoder(stream: *mut GstRTSPStream) -> *mut gst::GstElement;
2392    pub fn gst_rtsp_stream_get_ssrc(stream: *mut GstRTSPStream, ssrc: *mut c_uint);
2393    pub fn gst_rtsp_stream_get_ulpfec_enabled(stream: *mut GstRTSPStream) -> gboolean;
2394    #[cfg(feature = "v1_16")]
2395    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2396    pub fn gst_rtsp_stream_get_ulpfec_percentage(stream: *mut GstRTSPStream) -> c_uint;
2397    #[cfg(feature = "v1_16")]
2398    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2399    pub fn gst_rtsp_stream_get_ulpfec_pt(stream: *mut GstRTSPStream) -> c_uint;
2400    #[cfg(feature = "v1_16")]
2401    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2402    pub fn gst_rtsp_stream_handle_keymgmt(
2403        stream: *mut GstRTSPStream,
2404        keymgmt: *const c_char,
2405    ) -> gboolean;
2406    pub fn gst_rtsp_stream_has_control(
2407        stream: *mut GstRTSPStream,
2408        control: *const c_char,
2409    ) -> gboolean;
2410    #[cfg(feature = "v1_16")]
2411    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2412    pub fn gst_rtsp_stream_is_bind_mcast_address(stream: *mut GstRTSPStream) -> gboolean;
2413    pub fn gst_rtsp_stream_is_blocking(stream: *mut GstRTSPStream) -> gboolean;
2414    pub fn gst_rtsp_stream_is_client_side(stream: *mut GstRTSPStream) -> gboolean;
2415    pub fn gst_rtsp_stream_is_complete(stream: *mut GstRTSPStream) -> gboolean;
2416    pub fn gst_rtsp_stream_is_receiver(stream: *mut GstRTSPStream) -> gboolean;
2417    pub fn gst_rtsp_stream_is_sender(stream: *mut GstRTSPStream) -> gboolean;
2418    pub fn gst_rtsp_stream_is_transport_supported(
2419        stream: *mut GstRTSPStream,
2420        transport: *mut gst_rtsp::GstRTSPTransport,
2421    ) -> gboolean;
2422    pub fn gst_rtsp_stream_join_bin(
2423        stream: *mut GstRTSPStream,
2424        bin: *mut gst::GstBin,
2425        rtpbin: *mut gst::GstElement,
2426        state: gst::GstState,
2427    ) -> gboolean;
2428    pub fn gst_rtsp_stream_leave_bin(
2429        stream: *mut GstRTSPStream,
2430        bin: *mut gst::GstBin,
2431        rtpbin: *mut gst::GstElement,
2432    ) -> gboolean;
2433    pub fn gst_rtsp_stream_query_position(
2434        stream: *mut GstRTSPStream,
2435        position: *mut i64,
2436    ) -> gboolean;
2437    pub fn gst_rtsp_stream_query_stop(stream: *mut GstRTSPStream, stop: *mut i64) -> gboolean;
2438    pub fn gst_rtsp_stream_recv_rtcp(
2439        stream: *mut GstRTSPStream,
2440        buffer: *mut gst::GstBuffer,
2441    ) -> gst::GstFlowReturn;
2442    pub fn gst_rtsp_stream_recv_rtp(
2443        stream: *mut GstRTSPStream,
2444        buffer: *mut gst::GstBuffer,
2445    ) -> gst::GstFlowReturn;
2446    pub fn gst_rtsp_stream_remove_transport(
2447        stream: *mut GstRTSPStream,
2448        trans: *mut GstRTSPStreamTransport,
2449    ) -> gboolean;
2450    #[cfg(feature = "v1_16")]
2451    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2452    pub fn gst_rtsp_stream_request_aux_receiver(
2453        stream: *mut GstRTSPStream,
2454        sessid: c_uint,
2455    ) -> *mut gst::GstElement;
2456    pub fn gst_rtsp_stream_request_aux_sender(
2457        stream: *mut GstRTSPStream,
2458        sessid: c_uint,
2459    ) -> *mut gst::GstElement;
2460    #[cfg(feature = "v1_16")]
2461    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2462    pub fn gst_rtsp_stream_request_ulpfec_decoder(
2463        stream: *mut GstRTSPStream,
2464        rtpbin: *mut gst::GstElement,
2465        sessid: c_uint,
2466    ) -> *mut gst::GstElement;
2467    #[cfg(feature = "v1_16")]
2468    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2469    pub fn gst_rtsp_stream_request_ulpfec_encoder(
2470        stream: *mut GstRTSPStream,
2471        sessid: c_uint,
2472    ) -> *mut gst::GstElement;
2473    pub fn gst_rtsp_stream_reserve_address(
2474        stream: *mut GstRTSPStream,
2475        address: *const c_char,
2476        port: c_uint,
2477        n_ports: c_uint,
2478        ttl: c_uint,
2479    ) -> *mut GstRTSPAddress;
2480    pub fn gst_rtsp_stream_seekable(stream: *mut GstRTSPStream) -> gboolean;
2481    pub fn gst_rtsp_stream_set_address_pool(
2482        stream: *mut GstRTSPStream,
2483        pool: *mut GstRTSPAddressPool,
2484    );
2485    #[cfg(feature = "v1_16")]
2486    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2487    pub fn gst_rtsp_stream_set_bind_mcast_address(
2488        stream: *mut GstRTSPStream,
2489        bind_mcast_addr: gboolean,
2490    );
2491    pub fn gst_rtsp_stream_set_blocked(stream: *mut GstRTSPStream, blocked: gboolean) -> gboolean;
2492    pub fn gst_rtsp_stream_set_buffer_size(stream: *mut GstRTSPStream, size: c_uint);
2493    pub fn gst_rtsp_stream_set_client_side(stream: *mut GstRTSPStream, client_side: gboolean);
2494    pub fn gst_rtsp_stream_set_control(stream: *mut GstRTSPStream, control: *const c_char);
2495    pub fn gst_rtsp_stream_set_dscp_qos(stream: *mut GstRTSPStream, dscp_qos: c_int);
2496    #[cfg(feature = "v1_16")]
2497    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2498    pub fn gst_rtsp_stream_set_max_mcast_ttl(stream: *mut GstRTSPStream, ttl: c_uint) -> gboolean;
2499    pub fn gst_rtsp_stream_set_mtu(stream: *mut GstRTSPStream, mtu: c_uint);
2500    pub fn gst_rtsp_stream_set_multicast_iface(
2501        stream: *mut GstRTSPStream,
2502        multicast_iface: *const c_char,
2503    );
2504    pub fn gst_rtsp_stream_set_profiles(
2505        stream: *mut GstRTSPStream,
2506        profiles: gst_rtsp::GstRTSPProfile,
2507    );
2508    pub fn gst_rtsp_stream_set_protocols(
2509        stream: *mut GstRTSPStream,
2510        protocols: gst_rtsp::GstRTSPLowerTrans,
2511    );
2512    pub fn gst_rtsp_stream_set_pt_map(
2513        stream: *mut GstRTSPStream,
2514        pt: c_uint,
2515        caps: *mut gst::GstCaps,
2516    );
2517    pub fn gst_rtsp_stream_set_publish_clock_mode(
2518        stream: *mut GstRTSPStream,
2519        mode: GstRTSPPublishClockMode,
2520    );
2521    #[cfg(feature = "v1_18")]
2522    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2523    pub fn gst_rtsp_stream_set_rate_control(stream: *mut GstRTSPStream, enabled: gboolean);
2524    pub fn gst_rtsp_stream_set_retransmission_pt(stream: *mut GstRTSPStream, rtx_pt: c_uint);
2525    pub fn gst_rtsp_stream_set_retransmission_time(
2526        stream: *mut GstRTSPStream,
2527        time: gst::GstClockTime,
2528    );
2529    pub fn gst_rtsp_stream_set_seqnum_offset(stream: *mut GstRTSPStream, seqnum: u16);
2530    #[cfg(feature = "v1_16")]
2531    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2532    pub fn gst_rtsp_stream_set_ulpfec_percentage(stream: *mut GstRTSPStream, percentage: c_uint);
2533    #[cfg(feature = "v1_16")]
2534    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2535    pub fn gst_rtsp_stream_set_ulpfec_pt(stream: *mut GstRTSPStream, pt: c_uint);
2536    pub fn gst_rtsp_stream_transport_filter(
2537        stream: *mut GstRTSPStream,
2538        func: GstRTSPStreamTransportFilterFunc,
2539        user_data: gpointer,
2540    ) -> *mut glib::GList;
2541    pub fn gst_rtsp_stream_unblock_linked(stream: *mut GstRTSPStream) -> gboolean;
2542    #[cfg(feature = "v1_20")]
2543    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2544    pub fn gst_rtsp_stream_unblock_rtcp(stream: *mut GstRTSPStream);
2545    pub fn gst_rtsp_stream_update_crypto(
2546        stream: *mut GstRTSPStream,
2547        ssrc: c_uint,
2548        crypto: *mut gst::GstCaps,
2549    ) -> gboolean;
2550    #[cfg(feature = "v1_16")]
2551    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2552    pub fn gst_rtsp_stream_verify_mcast_ttl(stream: *mut GstRTSPStream, ttl: c_uint) -> gboolean;
2553
2554    //=========================================================================
2555    // GstRTSPStreamTransport
2556    //=========================================================================
2557    pub fn gst_rtsp_stream_transport_get_type() -> GType;
2558    pub fn gst_rtsp_stream_transport_new(
2559        stream: *mut GstRTSPStream,
2560        tr: *mut gst_rtsp::GstRTSPTransport,
2561    ) -> *mut GstRTSPStreamTransport;
2562    pub fn gst_rtsp_stream_transport_get_rtpinfo(
2563        trans: *mut GstRTSPStreamTransport,
2564        start_time: gst::GstClockTime,
2565    ) -> *mut c_char;
2566    pub fn gst_rtsp_stream_transport_get_stream(
2567        trans: *mut GstRTSPStreamTransport,
2568    ) -> *mut GstRTSPStream;
2569    pub fn gst_rtsp_stream_transport_get_transport(
2570        trans: *mut GstRTSPStreamTransport,
2571    ) -> *const gst_rtsp::GstRTSPTransport;
2572    pub fn gst_rtsp_stream_transport_get_url(
2573        trans: *mut GstRTSPStreamTransport,
2574    ) -> *const gst_rtsp::GstRTSPUrl;
2575    pub fn gst_rtsp_stream_transport_is_timed_out(trans: *mut GstRTSPStreamTransport) -> gboolean;
2576    pub fn gst_rtsp_stream_transport_keep_alive(trans: *mut GstRTSPStreamTransport);
2577    #[cfg(feature = "v1_16")]
2578    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2579    pub fn gst_rtsp_stream_transport_message_sent(trans: *mut GstRTSPStreamTransport);
2580    pub fn gst_rtsp_stream_transport_recv_data(
2581        trans: *mut GstRTSPStreamTransport,
2582        channel: c_uint,
2583        buffer: *mut gst::GstBuffer,
2584    ) -> gst::GstFlowReturn;
2585    pub fn gst_rtsp_stream_transport_send_rtcp(
2586        trans: *mut GstRTSPStreamTransport,
2587        buffer: *mut gst::GstBuffer,
2588    ) -> gboolean;
2589    #[cfg(feature = "v1_16")]
2590    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2591    pub fn gst_rtsp_stream_transport_send_rtcp_list(
2592        trans: *mut GstRTSPStreamTransport,
2593        buffer_list: *mut gst::GstBufferList,
2594    ) -> gboolean;
2595    pub fn gst_rtsp_stream_transport_send_rtp(
2596        trans: *mut GstRTSPStreamTransport,
2597        buffer: *mut gst::GstBuffer,
2598    ) -> gboolean;
2599    #[cfg(feature = "v1_16")]
2600    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2601    pub fn gst_rtsp_stream_transport_send_rtp_list(
2602        trans: *mut GstRTSPStreamTransport,
2603        buffer_list: *mut gst::GstBufferList,
2604    ) -> gboolean;
2605    pub fn gst_rtsp_stream_transport_set_active(
2606        trans: *mut GstRTSPStreamTransport,
2607        active: gboolean,
2608    ) -> gboolean;
2609    pub fn gst_rtsp_stream_transport_set_callbacks(
2610        trans: *mut GstRTSPStreamTransport,
2611        send_rtp: GstRTSPSendFunc,
2612        send_rtcp: GstRTSPSendFunc,
2613        user_data: gpointer,
2614        notify: glib::GDestroyNotify,
2615    );
2616    pub fn gst_rtsp_stream_transport_set_keepalive(
2617        trans: *mut GstRTSPStreamTransport,
2618        keep_alive: GstRTSPKeepAliveFunc,
2619        user_data: gpointer,
2620        notify: glib::GDestroyNotify,
2621    );
2622    #[cfg(feature = "v1_16")]
2623    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2624    pub fn gst_rtsp_stream_transport_set_list_callbacks(
2625        trans: *mut GstRTSPStreamTransport,
2626        send_rtp_list: GstRTSPSendListFunc,
2627        send_rtcp_list: GstRTSPSendListFunc,
2628        user_data: gpointer,
2629        notify: glib::GDestroyNotify,
2630    );
2631    pub fn gst_rtsp_stream_transport_set_message_sent(
2632        trans: *mut GstRTSPStreamTransport,
2633        message_sent: GstRTSPMessageSentFunc,
2634        user_data: gpointer,
2635        notify: glib::GDestroyNotify,
2636    );
2637    #[cfg(feature = "v1_18")]
2638    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2639    pub fn gst_rtsp_stream_transport_set_message_sent_full(
2640        trans: *mut GstRTSPStreamTransport,
2641        message_sent: GstRTSPMessageSentFuncFull,
2642        user_data: gpointer,
2643        notify: glib::GDestroyNotify,
2644    );
2645    pub fn gst_rtsp_stream_transport_set_timed_out(
2646        trans: *mut GstRTSPStreamTransport,
2647        timedout: gboolean,
2648    );
2649    pub fn gst_rtsp_stream_transport_set_transport(
2650        trans: *mut GstRTSPStreamTransport,
2651        tr: *mut gst_rtsp::GstRTSPTransport,
2652    );
2653    pub fn gst_rtsp_stream_transport_set_url(
2654        trans: *mut GstRTSPStreamTransport,
2655        url: *const gst_rtsp::GstRTSPUrl,
2656    );
2657
2658    //=========================================================================
2659    // GstRTSPThreadPool
2660    //=========================================================================
2661    pub fn gst_rtsp_thread_pool_get_type() -> GType;
2662    pub fn gst_rtsp_thread_pool_new() -> *mut GstRTSPThreadPool;
2663    pub fn gst_rtsp_thread_pool_cleanup();
2664    pub fn gst_rtsp_thread_pool_get_max_threads(pool: *mut GstRTSPThreadPool) -> c_int;
2665    pub fn gst_rtsp_thread_pool_get_thread(
2666        pool: *mut GstRTSPThreadPool,
2667        type_: GstRTSPThreadType,
2668        ctx: *mut GstRTSPContext,
2669    ) -> *mut GstRTSPThread;
2670    pub fn gst_rtsp_thread_pool_set_max_threads(pool: *mut GstRTSPThreadPool, max_threads: c_int);
2671
2672    //=========================================================================
2673    // Other functions
2674    //=========================================================================
2675    pub fn gst_rtsp_params_get(
2676        client: *mut GstRTSPClient,
2677        ctx: *mut GstRTSPContext,
2678    ) -> gst_rtsp::GstRTSPResult;
2679    pub fn gst_rtsp_params_set(
2680        client: *mut GstRTSPClient,
2681        ctx: *mut GstRTSPContext,
2682    ) -> gst_rtsp::GstRTSPResult;
2683    pub fn gst_rtsp_sdp_from_media(
2684        sdp: *mut gst_sdp::GstSDPMessage,
2685        info: *mut GstSDPInfo,
2686        media: *mut GstRTSPMedia,
2687    ) -> gboolean;
2688    pub fn gst_rtsp_sdp_from_stream(
2689        sdp: *mut gst_sdp::GstSDPMessage,
2690        info: *mut GstSDPInfo,
2691        stream: *mut GstRTSPStream,
2692    ) -> gboolean;
2693    pub fn gst_rtsp_sdp_make_media(
2694        sdp: *mut gst_sdp::GstSDPMessage,
2695        info: *mut GstSDPInfo,
2696        stream: *mut GstRTSPStream,
2697        caps: *mut gst::GstCaps,
2698        profile: gst_rtsp::GstRTSPProfile,
2699    ) -> gboolean;
2700
2701}
gstreamer_rtsp_server_sys/lib.rs

gstreamer_rtsp_server_sys/
lib.rs
