1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use gio_sys as gio;
16use glib_sys as glib;
17use gobject_sys as gobject;
18use gstreamer_sdp_sys as gst_sdp;
19use gstreamer_sys as gst;
20
21#[allow(unused_imports)]
22use libc::{FILE, intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t};
23#[cfg(unix)]
24#[allow(unused_imports)]
25use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
26#[allow(unused_imports)]
27use std::ffi::{
28 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
29};
30
31#[allow(unused_imports)]
32use glib::{GType, gboolean, gconstpointer, gpointer};
33
34pub type GstRTSPAuthMethod = c_int;
36pub const GST_RTSP_AUTH_NONE: GstRTSPAuthMethod = 0;
37pub const GST_RTSP_AUTH_BASIC: GstRTSPAuthMethod = 1;
38pub const GST_RTSP_AUTH_DIGEST: GstRTSPAuthMethod = 2;
39
40pub type GstRTSPBackchannelHttpMethod = c_int;
41#[cfg(feature = "v1_30")]
42#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
43pub const GST_RTSP_BACKCHANNEL_HTTP_METHOD_POST: GstRTSPBackchannelHttpMethod = 0;
44#[cfg(feature = "v1_30")]
45#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
46pub const GST_RTSP_BACKCHANNEL_HTTP_METHOD_GET: GstRTSPBackchannelHttpMethod = 1;
47
48pub type GstRTSPFamily = c_int;
49pub const GST_RTSP_FAM_NONE: GstRTSPFamily = 0;
50pub const GST_RTSP_FAM_INET: GstRTSPFamily = 1;
51pub const GST_RTSP_FAM_INET6: GstRTSPFamily = 2;
52
53pub type GstRTSPHeaderField = c_int;
54pub const GST_RTSP_HDR_INVALID: GstRTSPHeaderField = 0;
55pub const GST_RTSP_HDR_ACCEPT: GstRTSPHeaderField = 1;
56pub const GST_RTSP_HDR_ACCEPT_ENCODING: GstRTSPHeaderField = 2;
57pub const GST_RTSP_HDR_ACCEPT_LANGUAGE: GstRTSPHeaderField = 3;
58pub const GST_RTSP_HDR_ALLOW: GstRTSPHeaderField = 4;
59pub const GST_RTSP_HDR_AUTHORIZATION: GstRTSPHeaderField = 5;
60pub const GST_RTSP_HDR_BANDWIDTH: GstRTSPHeaderField = 6;
61pub const GST_RTSP_HDR_BLOCKSIZE: GstRTSPHeaderField = 7;
62pub const GST_RTSP_HDR_CACHE_CONTROL: GstRTSPHeaderField = 8;
63pub const GST_RTSP_HDR_CONFERENCE: GstRTSPHeaderField = 9;
64pub const GST_RTSP_HDR_CONNECTION: GstRTSPHeaderField = 10;
65pub const GST_RTSP_HDR_CONTENT_BASE: GstRTSPHeaderField = 11;
66pub const GST_RTSP_HDR_CONTENT_ENCODING: GstRTSPHeaderField = 12;
67pub const GST_RTSP_HDR_CONTENT_LANGUAGE: GstRTSPHeaderField = 13;
68pub const GST_RTSP_HDR_CONTENT_LENGTH: GstRTSPHeaderField = 14;
69pub const GST_RTSP_HDR_CONTENT_LOCATION: GstRTSPHeaderField = 15;
70pub const GST_RTSP_HDR_CONTENT_TYPE: GstRTSPHeaderField = 16;
71pub const GST_RTSP_HDR_CSEQ: GstRTSPHeaderField = 17;
72pub const GST_RTSP_HDR_DATE: GstRTSPHeaderField = 18;
73pub const GST_RTSP_HDR_EXPIRES: GstRTSPHeaderField = 19;
74pub const GST_RTSP_HDR_FROM: GstRTSPHeaderField = 20;
75pub const GST_RTSP_HDR_IF_MODIFIED_SINCE: GstRTSPHeaderField = 21;
76pub const GST_RTSP_HDR_LAST_MODIFIED: GstRTSPHeaderField = 22;
77pub const GST_RTSP_HDR_PROXY_AUTHENTICATE: GstRTSPHeaderField = 23;
78pub const GST_RTSP_HDR_PROXY_REQUIRE: GstRTSPHeaderField = 24;
79pub const GST_RTSP_HDR_PUBLIC: GstRTSPHeaderField = 25;
80pub const GST_RTSP_HDR_RANGE: GstRTSPHeaderField = 26;
81pub const GST_RTSP_HDR_REFERER: GstRTSPHeaderField = 27;
82pub const GST_RTSP_HDR_REQUIRE: GstRTSPHeaderField = 28;
83pub const GST_RTSP_HDR_RETRY_AFTER: GstRTSPHeaderField = 29;
84pub const GST_RTSP_HDR_RTP_INFO: GstRTSPHeaderField = 30;
85pub const GST_RTSP_HDR_SCALE: GstRTSPHeaderField = 31;
86pub const GST_RTSP_HDR_SESSION: GstRTSPHeaderField = 32;
87pub const GST_RTSP_HDR_SERVER: GstRTSPHeaderField = 33;
88pub const GST_RTSP_HDR_SPEED: GstRTSPHeaderField = 34;
89pub const GST_RTSP_HDR_TRANSPORT: GstRTSPHeaderField = 35;
90pub const GST_RTSP_HDR_UNSUPPORTED: GstRTSPHeaderField = 36;
91pub const GST_RTSP_HDR_USER_AGENT: GstRTSPHeaderField = 37;
92pub const GST_RTSP_HDR_VIA: GstRTSPHeaderField = 38;
93pub const GST_RTSP_HDR_WWW_AUTHENTICATE: GstRTSPHeaderField = 39;
94pub const GST_RTSP_HDR_CLIENT_CHALLENGE: GstRTSPHeaderField = 40;
95pub const GST_RTSP_HDR_REAL_CHALLENGE1: GstRTSPHeaderField = 41;
96pub const GST_RTSP_HDR_REAL_CHALLENGE2: GstRTSPHeaderField = 42;
97pub const GST_RTSP_HDR_REAL_CHALLENGE3: GstRTSPHeaderField = 43;
98pub const GST_RTSP_HDR_SUBSCRIBE: GstRTSPHeaderField = 44;
99pub const GST_RTSP_HDR_ALERT: GstRTSPHeaderField = 45;
100pub const GST_RTSP_HDR_CLIENT_ID: GstRTSPHeaderField = 46;
101pub const GST_RTSP_HDR_COMPANY_ID: GstRTSPHeaderField = 47;
102pub const GST_RTSP_HDR_GUID: GstRTSPHeaderField = 48;
103pub const GST_RTSP_HDR_REGION_DATA: GstRTSPHeaderField = 49;
104pub const GST_RTSP_HDR_MAX_ASM_WIDTH: GstRTSPHeaderField = 50;
105pub const GST_RTSP_HDR_LANGUAGE: GstRTSPHeaderField = 51;
106pub const GST_RTSP_HDR_PLAYER_START_TIME: GstRTSPHeaderField = 52;
107pub const GST_RTSP_HDR_LOCATION: GstRTSPHeaderField = 53;
108pub const GST_RTSP_HDR_ETAG: GstRTSPHeaderField = 54;
109pub const GST_RTSP_HDR_IF_MATCH: GstRTSPHeaderField = 55;
110pub const GST_RTSP_HDR_ACCEPT_CHARSET: GstRTSPHeaderField = 56;
111pub const GST_RTSP_HDR_SUPPORTED: GstRTSPHeaderField = 57;
112pub const GST_RTSP_HDR_VARY: GstRTSPHeaderField = 58;
113pub const GST_RTSP_HDR_X_ACCELERATE_STREAMING: GstRTSPHeaderField = 59;
114pub const GST_RTSP_HDR_X_ACCEPT_AUTHENT: GstRTSPHeaderField = 60;
115pub const GST_RTSP_HDR_X_ACCEPT_PROXY_AUTHENT: GstRTSPHeaderField = 61;
116pub const GST_RTSP_HDR_X_BROADCAST_ID: GstRTSPHeaderField = 62;
117pub const GST_RTSP_HDR_X_BURST_STREAMING: GstRTSPHeaderField = 63;
118pub const GST_RTSP_HDR_X_NOTICE: GstRTSPHeaderField = 64;
119pub const GST_RTSP_HDR_X_PLAYER_LAG_TIME: GstRTSPHeaderField = 65;
120pub const GST_RTSP_HDR_X_PLAYLIST: GstRTSPHeaderField = 66;
121pub const GST_RTSP_HDR_X_PLAYLIST_CHANGE_NOTICE: GstRTSPHeaderField = 67;
122pub const GST_RTSP_HDR_X_PLAYLIST_GEN_ID: GstRTSPHeaderField = 68;
123pub const GST_RTSP_HDR_X_PLAYLIST_SEEK_ID: GstRTSPHeaderField = 69;
124pub const GST_RTSP_HDR_X_PROXY_CLIENT_AGENT: GstRTSPHeaderField = 70;
125pub const GST_RTSP_HDR_X_PROXY_CLIENT_VERB: GstRTSPHeaderField = 71;
126pub const GST_RTSP_HDR_X_RECEDING_PLAYLISTCHANGE: GstRTSPHeaderField = 72;
127pub const GST_RTSP_HDR_X_RTP_INFO: GstRTSPHeaderField = 73;
128pub const GST_RTSP_HDR_X_STARTUPPROFILE: GstRTSPHeaderField = 74;
129pub const GST_RTSP_HDR_TIMESTAMP: GstRTSPHeaderField = 75;
130pub const GST_RTSP_HDR_AUTHENTICATION_INFO: GstRTSPHeaderField = 76;
131pub const GST_RTSP_HDR_HOST: GstRTSPHeaderField = 77;
132pub const GST_RTSP_HDR_PRAGMA: GstRTSPHeaderField = 78;
133pub const GST_RTSP_HDR_X_SERVER_IP_ADDRESS: GstRTSPHeaderField = 79;
134pub const GST_RTSP_HDR_X_SESSIONCOOKIE: GstRTSPHeaderField = 80;
135pub const GST_RTSP_HDR_RTCP_INTERVAL: GstRTSPHeaderField = 81;
136pub const GST_RTSP_HDR_KEYMGMT: GstRTSPHeaderField = 82;
137pub const GST_RTSP_HDR_PIPELINED_REQUESTS: GstRTSPHeaderField = 83;
138pub const GST_RTSP_HDR_MEDIA_PROPERTIES: GstRTSPHeaderField = 84;
139pub const GST_RTSP_HDR_SEEK_STYLE: GstRTSPHeaderField = 85;
140pub const GST_RTSP_HDR_ACCEPT_RANGES: GstRTSPHeaderField = 86;
141pub const GST_RTSP_HDR_FRAMES: GstRTSPHeaderField = 87;
142pub const GST_RTSP_HDR_RATE_CONTROL: GstRTSPHeaderField = 88;
143pub const GST_RTSP_HDR_LAST: GstRTSPHeaderField = 89;
144
145pub type GstRTSPMsgType = c_int;
146pub const GST_RTSP_MESSAGE_INVALID: GstRTSPMsgType = 0;
147pub const GST_RTSP_MESSAGE_REQUEST: GstRTSPMsgType = 1;
148pub const GST_RTSP_MESSAGE_RESPONSE: GstRTSPMsgType = 2;
149pub const GST_RTSP_MESSAGE_HTTP_REQUEST: GstRTSPMsgType = 3;
150pub const GST_RTSP_MESSAGE_HTTP_RESPONSE: GstRTSPMsgType = 4;
151pub const GST_RTSP_MESSAGE_DATA: GstRTSPMsgType = 5;
152
153pub type GstRTSPRangeUnit = c_int;
154pub const GST_RTSP_RANGE_SMPTE: GstRTSPRangeUnit = 0;
155pub const GST_RTSP_RANGE_SMPTE_30_DROP: GstRTSPRangeUnit = 1;
156pub const GST_RTSP_RANGE_SMPTE_25: GstRTSPRangeUnit = 2;
157pub const GST_RTSP_RANGE_NPT: GstRTSPRangeUnit = 3;
158pub const GST_RTSP_RANGE_CLOCK: GstRTSPRangeUnit = 4;
159
160pub type GstRTSPResult = c_int;
161pub const GST_RTSP_OK: GstRTSPResult = 0;
162#[cfg(feature = "v1_24")]
163#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
164pub const GST_RTSP_OK_REDIRECT: GstRTSPResult = 1;
165pub const GST_RTSP_ERROR: GstRTSPResult = -1;
166pub const GST_RTSP_EINVAL: GstRTSPResult = -2;
167pub const GST_RTSP_EINTR: GstRTSPResult = -3;
168pub const GST_RTSP_ENOMEM: GstRTSPResult = -4;
169pub const GST_RTSP_ERESOLV: GstRTSPResult = -5;
170pub const GST_RTSP_ENOTIMPL: GstRTSPResult = -6;
171pub const GST_RTSP_ESYS: GstRTSPResult = -7;
172pub const GST_RTSP_EPARSE: GstRTSPResult = -8;
173pub const GST_RTSP_EWSASTART: GstRTSPResult = -9;
174pub const GST_RTSP_EWSAVERSION: GstRTSPResult = -10;
175pub const GST_RTSP_EEOF: GstRTSPResult = -11;
176pub const GST_RTSP_ENET: GstRTSPResult = -12;
177pub const GST_RTSP_ENOTIP: GstRTSPResult = -13;
178pub const GST_RTSP_ETIMEOUT: GstRTSPResult = -14;
179pub const GST_RTSP_ETGET: GstRTSPResult = -15;
180pub const GST_RTSP_ETPOST: GstRTSPResult = -16;
181pub const GST_RTSP_ELAST: GstRTSPResult = -17;
182
183pub type GstRTSPState = c_int;
184pub const GST_RTSP_STATE_INVALID: GstRTSPState = 0;
185pub const GST_RTSP_STATE_INIT: GstRTSPState = 1;
186pub const GST_RTSP_STATE_READY: GstRTSPState = 2;
187pub const GST_RTSP_STATE_SEEKING: GstRTSPState = 3;
188pub const GST_RTSP_STATE_PLAYING: GstRTSPState = 4;
189pub const GST_RTSP_STATE_RECORDING: GstRTSPState = 5;
190
191pub type GstRTSPStatusCode = c_int;
192pub const GST_RTSP_STS_INVALID: GstRTSPStatusCode = 0;
193pub const GST_RTSP_STS_CONTINUE: GstRTSPStatusCode = 100;
194pub const GST_RTSP_STS_OK: GstRTSPStatusCode = 200;
195pub const GST_RTSP_STS_CREATED: GstRTSPStatusCode = 201;
196pub const GST_RTSP_STS_LOW_ON_STORAGE: GstRTSPStatusCode = 250;
197pub const GST_RTSP_STS_MULTIPLE_CHOICES: GstRTSPStatusCode = 300;
198pub const GST_RTSP_STS_MOVED_PERMANENTLY: GstRTSPStatusCode = 301;
199pub const GST_RTSP_STS_MOVE_TEMPORARILY: GstRTSPStatusCode = 302;
200pub const GST_RTSP_STS_SEE_OTHER: GstRTSPStatusCode = 303;
201pub const GST_RTSP_STS_NOT_MODIFIED: GstRTSPStatusCode = 304;
202pub const GST_RTSP_STS_USE_PROXY: GstRTSPStatusCode = 305;
203#[cfg(feature = "v1_24")]
204#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
205pub const GST_RTSP_STS_REDIRECT_TEMPORARILY: GstRTSPStatusCode = 307;
206#[cfg(feature = "v1_24")]
207#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
208pub const GST_RTSP_STS_REDIRECT_PERMANENTLY: GstRTSPStatusCode = 308;
209pub const GST_RTSP_STS_BAD_REQUEST: GstRTSPStatusCode = 400;
210pub const GST_RTSP_STS_UNAUTHORIZED: GstRTSPStatusCode = 401;
211pub const GST_RTSP_STS_PAYMENT_REQUIRED: GstRTSPStatusCode = 402;
212pub const GST_RTSP_STS_FORBIDDEN: GstRTSPStatusCode = 403;
213pub const GST_RTSP_STS_NOT_FOUND: GstRTSPStatusCode = 404;
214pub const GST_RTSP_STS_METHOD_NOT_ALLOWED: GstRTSPStatusCode = 405;
215pub const GST_RTSP_STS_NOT_ACCEPTABLE: GstRTSPStatusCode = 406;
216pub const GST_RTSP_STS_PROXY_AUTH_REQUIRED: GstRTSPStatusCode = 407;
217pub const GST_RTSP_STS_REQUEST_TIMEOUT: GstRTSPStatusCode = 408;
218pub const GST_RTSP_STS_GONE: GstRTSPStatusCode = 410;
219pub const GST_RTSP_STS_LENGTH_REQUIRED: GstRTSPStatusCode = 411;
220pub const GST_RTSP_STS_PRECONDITION_FAILED: GstRTSPStatusCode = 412;
221pub const GST_RTSP_STS_REQUEST_ENTITY_TOO_LARGE: GstRTSPStatusCode = 413;
222pub const GST_RTSP_STS_REQUEST_URI_TOO_LARGE: GstRTSPStatusCode = 414;
223pub const GST_RTSP_STS_UNSUPPORTED_MEDIA_TYPE: GstRTSPStatusCode = 415;
224pub const GST_RTSP_STS_PARAMETER_NOT_UNDERSTOOD: GstRTSPStatusCode = 451;
225pub const GST_RTSP_STS_CONFERENCE_NOT_FOUND: GstRTSPStatusCode = 452;
226pub const GST_RTSP_STS_NOT_ENOUGH_BANDWIDTH: GstRTSPStatusCode = 453;
227pub const GST_RTSP_STS_SESSION_NOT_FOUND: GstRTSPStatusCode = 454;
228pub const GST_RTSP_STS_METHOD_NOT_VALID_IN_THIS_STATE: GstRTSPStatusCode = 455;
229pub const GST_RTSP_STS_HEADER_FIELD_NOT_VALID_FOR_RESOURCE: GstRTSPStatusCode = 456;
230pub const GST_RTSP_STS_INVALID_RANGE: GstRTSPStatusCode = 457;
231pub const GST_RTSP_STS_PARAMETER_IS_READONLY: GstRTSPStatusCode = 458;
232pub const GST_RTSP_STS_AGGREGATE_OPERATION_NOT_ALLOWED: GstRTSPStatusCode = 459;
233pub const GST_RTSP_STS_ONLY_AGGREGATE_OPERATION_ALLOWED: GstRTSPStatusCode = 460;
234pub const GST_RTSP_STS_UNSUPPORTED_TRANSPORT: GstRTSPStatusCode = 461;
235pub const GST_RTSP_STS_DESTINATION_UNREACHABLE: GstRTSPStatusCode = 462;
236pub const GST_RTSP_STS_KEY_MANAGEMENT_FAILURE: GstRTSPStatusCode = 463;
237pub const GST_RTSP_STS_INTERNAL_SERVER_ERROR: GstRTSPStatusCode = 500;
238pub const GST_RTSP_STS_NOT_IMPLEMENTED: GstRTSPStatusCode = 501;
239pub const GST_RTSP_STS_BAD_GATEWAY: GstRTSPStatusCode = 502;
240pub const GST_RTSP_STS_SERVICE_UNAVAILABLE: GstRTSPStatusCode = 503;
241pub const GST_RTSP_STS_GATEWAY_TIMEOUT: GstRTSPStatusCode = 504;
242pub const GST_RTSP_STS_RTSP_VERSION_NOT_SUPPORTED: GstRTSPStatusCode = 505;
243pub const GST_RTSP_STS_OPTION_NOT_SUPPORTED: GstRTSPStatusCode = 551;
244
245pub type GstRTSPTimeType = c_int;
246pub const GST_RTSP_TIME_SECONDS: GstRTSPTimeType = 0;
247pub const GST_RTSP_TIME_NOW: GstRTSPTimeType = 1;
248pub const GST_RTSP_TIME_END: GstRTSPTimeType = 2;
249pub const GST_RTSP_TIME_FRAMES: GstRTSPTimeType = 3;
250pub const GST_RTSP_TIME_UTC: GstRTSPTimeType = 4;
251
252pub type GstRTSPVersion = c_int;
253pub const GST_RTSP_VERSION_INVALID: GstRTSPVersion = 0;
254pub const GST_RTSP_VERSION_1_0: GstRTSPVersion = 16;
255pub const GST_RTSP_VERSION_1_1: GstRTSPVersion = 17;
256pub const GST_RTSP_VERSION_2_0: GstRTSPVersion = 32;
257
258pub const GST_RTSP_DEFAULT_PORT: c_int = 554;
260
261pub type GstRTSPEvent = c_uint;
263pub const GST_RTSP_EV_READ: GstRTSPEvent = 1;
264pub const GST_RTSP_EV_WRITE: GstRTSPEvent = 2;
265
266pub type GstRTSPLowerTrans = c_uint;
267pub const GST_RTSP_LOWER_TRANS_UNKNOWN: GstRTSPLowerTrans = 0;
268pub const GST_RTSP_LOWER_TRANS_UDP: GstRTSPLowerTrans = 1;
269pub const GST_RTSP_LOWER_TRANS_UDP_MCAST: GstRTSPLowerTrans = 2;
270pub const GST_RTSP_LOWER_TRANS_TCP: GstRTSPLowerTrans = 4;
271pub const GST_RTSP_LOWER_TRANS_HTTP: GstRTSPLowerTrans = 16;
272pub const GST_RTSP_LOWER_TRANS_TLS: GstRTSPLowerTrans = 32;
273
274pub type GstRTSPMethod = c_uint;
275pub const GST_RTSP_INVALID: GstRTSPMethod = 0;
276pub const GST_RTSP_DESCRIBE: GstRTSPMethod = 1;
277pub const GST_RTSP_ANNOUNCE: GstRTSPMethod = 2;
278pub const GST_RTSP_GET_PARAMETER: GstRTSPMethod = 4;
279pub const GST_RTSP_OPTIONS: GstRTSPMethod = 8;
280pub const GST_RTSP_PAUSE: GstRTSPMethod = 16;
281pub const GST_RTSP_PLAY: GstRTSPMethod = 32;
282pub const GST_RTSP_RECORD: GstRTSPMethod = 64;
283pub const GST_RTSP_REDIRECT: GstRTSPMethod = 128;
284pub const GST_RTSP_SETUP: GstRTSPMethod = 256;
285pub const GST_RTSP_SET_PARAMETER: GstRTSPMethod = 512;
286pub const GST_RTSP_TEARDOWN: GstRTSPMethod = 1024;
287pub const GST_RTSP_GET: GstRTSPMethod = 2048;
288pub const GST_RTSP_POST: GstRTSPMethod = 4096;
289
290pub type GstRTSPProfile = c_uint;
291pub const GST_RTSP_PROFILE_UNKNOWN: GstRTSPProfile = 0;
292pub const GST_RTSP_PROFILE_AVP: GstRTSPProfile = 1;
293pub const GST_RTSP_PROFILE_SAVP: GstRTSPProfile = 2;
294pub const GST_RTSP_PROFILE_AVPF: GstRTSPProfile = 4;
295pub const GST_RTSP_PROFILE_SAVPF: GstRTSPProfile = 8;
296
297pub type GstRTSPTransMode = c_uint;
298pub const GST_RTSP_TRANS_UNKNOWN: GstRTSPTransMode = 0;
299pub const GST_RTSP_TRANS_RTP: GstRTSPTransMode = 1;
300pub const GST_RTSP_TRANS_RDT: GstRTSPTransMode = 2;
301
302#[derive(Copy, Clone)]
304#[repr(C)]
305pub union GstRTSPMessage_type_data {
306 pub request: GstRTSPMessage_type_data_request,
307 pub response: GstRTSPMessage_type_data_response,
308 pub data: GstRTSPMessage_type_data_data,
309}
310
311impl ::std::fmt::Debug for GstRTSPMessage_type_data {
312 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
313 f.debug_struct(&format!("GstRTSPMessage_type_data @ {self:p}"))
314 .field("request", unsafe { &self.request })
315 .field("response", unsafe { &self.response })
316 .field("data", unsafe { &self.data })
317 .finish()
318 }
319}
320
321pub type GstRTSPConnectionAcceptCertificateFunc = Option<
323 unsafe extern "C" fn(
324 *mut gio::GTlsConnection,
325 *mut gio::GTlsCertificate,
326 gio::GTlsCertificateFlags,
327 gpointer,
328 ) -> gboolean,
329>;
330
331#[derive(Copy, Clone)]
333#[repr(C)]
334pub struct GstRTSPAuthCredential {
335 pub scheme: GstRTSPAuthMethod,
336 pub params: *mut *mut GstRTSPAuthParam,
337 pub authorization: *mut c_char,
338}
339
340impl ::std::fmt::Debug for GstRTSPAuthCredential {
341 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
342 f.debug_struct(&format!("GstRTSPAuthCredential @ {self:p}"))
343 .field("scheme", &self.scheme)
344 .field("params", &self.params)
345 .field("authorization", &self.authorization)
346 .finish()
347 }
348}
349
350#[derive(Copy, Clone)]
351#[repr(C)]
352pub struct GstRTSPAuthParam {
353 pub name: *mut c_char,
354 pub value: *mut c_char,
355}
356
357impl ::std::fmt::Debug for GstRTSPAuthParam {
358 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
359 f.debug_struct(&format!("GstRTSPAuthParam @ {self:p}"))
360 .field("name", &self.name)
361 .field("value", &self.value)
362 .finish()
363 }
364}
365
366#[repr(C)]
367#[allow(dead_code)]
368pub struct _GstRTSPConnection {
369 _data: [u8; 0],
370 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
371}
372
373pub type GstRTSPConnection = _GstRTSPConnection;
374
375#[derive(Copy, Clone)]
376#[repr(C)]
377pub struct GstRTSPExtensionInterface {
378 pub parent: gobject::GTypeInterface,
379 pub detect_server:
380 Option<unsafe extern "C" fn(*mut GstRTSPExtension, *mut GstRTSPMessage) -> gboolean>,
381 pub before_send:
382 Option<unsafe extern "C" fn(*mut GstRTSPExtension, *mut GstRTSPMessage) -> GstRTSPResult>,
383 pub after_send: Option<
384 unsafe extern "C" fn(
385 *mut GstRTSPExtension,
386 *mut GstRTSPMessage,
387 *mut GstRTSPMessage,
388 ) -> GstRTSPResult,
389 >,
390 pub parse_sdp: Option<
391 unsafe extern "C" fn(
392 *mut GstRTSPExtension,
393 *mut gst_sdp::GstSDPMessage,
394 *mut gst::GstStructure,
395 ) -> GstRTSPResult,
396 >,
397 pub setup_media: Option<
398 unsafe extern "C" fn(*mut GstRTSPExtension, *mut gst_sdp::GstSDPMedia) -> GstRTSPResult,
399 >,
400 pub configure_stream:
401 Option<unsafe extern "C" fn(*mut GstRTSPExtension, *mut gst::GstCaps) -> gboolean>,
402 pub get_transports: Option<
403 unsafe extern "C" fn(
404 *mut GstRTSPExtension,
405 GstRTSPLowerTrans,
406 *mut *mut c_char,
407 ) -> GstRTSPResult,
408 >,
409 pub stream_select:
410 Option<unsafe extern "C" fn(*mut GstRTSPExtension, *mut GstRTSPUrl) -> GstRTSPResult>,
411 pub send: Option<
412 unsafe extern "C" fn(
413 *mut GstRTSPExtension,
414 *mut GstRTSPMessage,
415 *mut GstRTSPMessage,
416 ) -> GstRTSPResult,
417 >,
418 pub receive_request:
419 Option<unsafe extern "C" fn(*mut GstRTSPExtension, *mut GstRTSPMessage) -> GstRTSPResult>,
420 pub _gst_reserved: [gpointer; 4],
421}
422
423impl ::std::fmt::Debug for GstRTSPExtensionInterface {
424 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
425 f.debug_struct(&format!("GstRTSPExtensionInterface @ {self:p}"))
426 .field("parent", &self.parent)
427 .field("detect_server", &self.detect_server)
428 .field("before_send", &self.before_send)
429 .field("after_send", &self.after_send)
430 .field("parse_sdp", &self.parse_sdp)
431 .field("setup_media", &self.setup_media)
432 .field("configure_stream", &self.configure_stream)
433 .field("get_transports", &self.get_transports)
434 .field("stream_select", &self.stream_select)
435 .field("send", &self.send)
436 .field("receive_request", &self.receive_request)
437 .finish()
438 }
439}
440
441#[derive(Copy, Clone)]
442#[repr(C)]
443pub struct GstRTSPMessage {
444 pub type_: GstRTSPMsgType,
445 pub type_data: GstRTSPMessage_type_data,
446 pub hdr_fields: *mut glib::GArray,
447 pub body: *mut u8,
448 pub body_size: c_uint,
449 pub body_buffer: *mut gst::GstBuffer,
450 pub _gst_reserved: [gpointer; 3],
451}
452
453impl ::std::fmt::Debug for GstRTSPMessage {
454 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
455 f.debug_struct(&format!("GstRTSPMessage @ {self:p}"))
456 .field("type_", &self.type_)
457 .field("type_data", &self.type_data)
458 .finish()
459 }
460}
461
462#[derive(Copy, Clone)]
463#[repr(C)]
464pub struct GstRTSPMessage_type_data_data {
465 pub channel: u8,
466}
467
468impl ::std::fmt::Debug for GstRTSPMessage_type_data_data {
469 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
470 f.debug_struct(&format!("GstRTSPMessage_type_data_data @ {self:p}"))
471 .field("channel", &self.channel)
472 .finish()
473 }
474}
475
476#[derive(Copy, Clone)]
477#[repr(C)]
478pub struct GstRTSPMessage_type_data_request {
479 pub method: GstRTSPMethod,
480 pub uri: *mut c_char,
481 pub version: GstRTSPVersion,
482}
483
484impl ::std::fmt::Debug for GstRTSPMessage_type_data_request {
485 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
486 f.debug_struct(&format!("GstRTSPMessage_type_data_request @ {self:p}"))
487 .field("method", &self.method)
488 .field("uri", &self.uri)
489 .field("version", &self.version)
490 .finish()
491 }
492}
493
494#[derive(Copy, Clone)]
495#[repr(C)]
496pub struct GstRTSPMessage_type_data_response {
497 pub code: GstRTSPStatusCode,
498 pub reason: *mut c_char,
499 pub version: GstRTSPVersion,
500}
501
502impl ::std::fmt::Debug for GstRTSPMessage_type_data_response {
503 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
504 f.debug_struct(&format!("GstRTSPMessage_type_data_response @ {self:p}"))
505 .field("code", &self.code)
506 .field("reason", &self.reason)
507 .field("version", &self.version)
508 .finish()
509 }
510}
511
512#[derive(Copy, Clone)]
513#[repr(C)]
514pub struct GstRTSPRange {
515 pub min: c_int,
516 pub max: c_int,
517}
518
519impl ::std::fmt::Debug for GstRTSPRange {
520 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
521 f.debug_struct(&format!("GstRTSPRange @ {self:p}"))
522 .field("min", &self.min)
523 .field("max", &self.max)
524 .finish()
525 }
526}
527
528#[derive(Copy, Clone)]
529#[repr(C)]
530pub struct GstRTSPTime {
531 pub type_: GstRTSPTimeType,
532 pub seconds: c_double,
533}
534
535impl ::std::fmt::Debug for GstRTSPTime {
536 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
537 f.debug_struct(&format!("GstRTSPTime @ {self:p}"))
538 .field("type_", &self.type_)
539 .field("seconds", &self.seconds)
540 .finish()
541 }
542}
543
544#[derive(Copy, Clone)]
545#[repr(C)]
546pub struct GstRTSPTime2 {
547 pub frames: c_double,
548 pub year: c_uint,
549 pub month: c_uint,
550 pub day: c_uint,
551}
552
553impl ::std::fmt::Debug for GstRTSPTime2 {
554 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
555 f.debug_struct(&format!("GstRTSPTime2 @ {self:p}"))
556 .field("frames", &self.frames)
557 .field("year", &self.year)
558 .field("month", &self.month)
559 .field("day", &self.day)
560 .finish()
561 }
562}
563
564#[derive(Copy, Clone)]
565#[repr(C)]
566pub struct GstRTSPTimeRange {
567 pub unit: GstRTSPRangeUnit,
568 pub min: GstRTSPTime,
569 pub max: GstRTSPTime,
570 pub min2: GstRTSPTime2,
571 pub max2: GstRTSPTime2,
572}
573
574impl ::std::fmt::Debug for GstRTSPTimeRange {
575 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
576 f.debug_struct(&format!("GstRTSPTimeRange @ {self:p}"))
577 .field("unit", &self.unit)
578 .field("min", &self.min)
579 .field("max", &self.max)
580 .field("min2", &self.min2)
581 .field("max2", &self.max2)
582 .finish()
583 }
584}
585
586#[derive(Copy, Clone)]
587#[repr(C)]
588pub struct GstRTSPTransport {
589 pub trans: GstRTSPTransMode,
590 pub profile: GstRTSPProfile,
591 pub lower_transport: GstRTSPLowerTrans,
592 pub destination: *mut c_char,
593 pub source: *mut c_char,
594 pub layers: c_uint,
595 pub mode_play: gboolean,
596 pub mode_record: gboolean,
597 pub append: gboolean,
598 pub interleaved: GstRTSPRange,
599 pub ttl: c_uint,
600 pub port: GstRTSPRange,
601 pub client_port: GstRTSPRange,
602 pub server_port: GstRTSPRange,
603 pub ssrc: c_uint,
604 pub _gst_reserved: [gpointer; 4],
605}
606
607impl ::std::fmt::Debug for GstRTSPTransport {
608 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
609 f.debug_struct(&format!("GstRTSPTransport @ {self:p}"))
610 .field("trans", &self.trans)
611 .field("profile", &self.profile)
612 .field("lower_transport", &self.lower_transport)
613 .field("destination", &self.destination)
614 .field("source", &self.source)
615 .field("layers", &self.layers)
616 .field("mode_play", &self.mode_play)
617 .field("mode_record", &self.mode_record)
618 .field("append", &self.append)
619 .field("interleaved", &self.interleaved)
620 .field("ttl", &self.ttl)
621 .field("port", &self.port)
622 .field("client_port", &self.client_port)
623 .field("server_port", &self.server_port)
624 .field("ssrc", &self.ssrc)
625 .finish()
626 }
627}
628
629#[derive(Copy, Clone)]
630#[repr(C)]
631pub struct GstRTSPUrl {
632 pub transports: GstRTSPLowerTrans,
633 pub family: GstRTSPFamily,
634 pub user: *mut c_char,
635 pub passwd: *mut c_char,
636 pub host: *mut c_char,
637 pub port: u16,
638 pub abspath: *mut c_char,
639 pub query: *mut c_char,
640}
641
642impl ::std::fmt::Debug for GstRTSPUrl {
643 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
644 f.debug_struct(&format!("GstRTSPUrl @ {self:p}"))
645 .field("transports", &self.transports)
646 .field("family", &self.family)
647 .field("user", &self.user)
648 .field("passwd", &self.passwd)
649 .field("host", &self.host)
650 .field("port", &self.port)
651 .field("abspath", &self.abspath)
652 .field("query", &self.query)
653 .finish()
654 }
655}
656
657#[repr(C)]
658#[allow(dead_code)]
659pub struct _GstRTSPWatch {
660 _data: [u8; 0],
661 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
662}
663
664pub type GstRTSPWatch = _GstRTSPWatch;
665
666#[derive(Copy, Clone)]
667#[repr(C)]
668pub struct GstRTSPWatchFuncs {
669 pub message_received: Option<
670 unsafe extern "C" fn(*mut GstRTSPWatch, *mut GstRTSPMessage, gpointer) -> GstRTSPResult,
671 >,
672 pub message_sent:
673 Option<unsafe extern "C" fn(*mut GstRTSPWatch, c_uint, gpointer) -> GstRTSPResult>,
674 pub closed: Option<unsafe extern "C" fn(*mut GstRTSPWatch, gpointer) -> GstRTSPResult>,
675 pub error:
676 Option<unsafe extern "C" fn(*mut GstRTSPWatch, GstRTSPResult, gpointer) -> GstRTSPResult>,
677 pub tunnel_start:
678 Option<unsafe extern "C" fn(*mut GstRTSPWatch, gpointer) -> GstRTSPStatusCode>,
679 pub tunnel_complete: Option<unsafe extern "C" fn(*mut GstRTSPWatch, gpointer) -> GstRTSPResult>,
680 pub error_full: Option<
681 unsafe extern "C" fn(
682 *mut GstRTSPWatch,
683 GstRTSPResult,
684 *mut GstRTSPMessage,
685 c_uint,
686 gpointer,
687 ) -> GstRTSPResult,
688 >,
689 pub tunnel_lost: Option<unsafe extern "C" fn(*mut GstRTSPWatch, gpointer) -> GstRTSPResult>,
690 pub tunnel_http_response: Option<
691 unsafe extern "C" fn(
692 *mut GstRTSPWatch,
693 *mut GstRTSPMessage,
694 *mut GstRTSPMessage,
695 gpointer,
696 ) -> GstRTSPResult,
697 >,
698 pub _gst_reserved: [gpointer; 3],
699}
700
701impl ::std::fmt::Debug for GstRTSPWatchFuncs {
702 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
703 f.debug_struct(&format!("GstRTSPWatchFuncs @ {self:p}"))
704 .field("message_received", &self.message_received)
705 .field("message_sent", &self.message_sent)
706 .field("closed", &self.closed)
707 .field("error", &self.error)
708 .field("tunnel_start", &self.tunnel_start)
709 .field("tunnel_complete", &self.tunnel_complete)
710 .field("error_full", &self.error_full)
711 .field("tunnel_lost", &self.tunnel_lost)
712 .field("tunnel_http_response", &self.tunnel_http_response)
713 .finish()
714 }
715}
716
717#[repr(C)]
719#[allow(dead_code)]
720pub struct GstRTSPExtension {
721 _data: [u8; 0],
722 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
723}
724
725impl ::std::fmt::Debug for GstRTSPExtension {
726 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
727 write!(f, "GstRTSPExtension @ {self:p}")
728 }
729}
730
731unsafe extern "C" {
732
733 pub fn gst_rtsp_auth_method_get_type() -> GType;
737
738 #[cfg(feature = "v1_30")]
742 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
743 pub fn gst_rtsp_backchannel_http_method_get_type() -> GType;
744
745 pub fn gst_rtsp_family_get_type() -> GType;
749
750 pub fn gst_rtsp_header_field_get_type() -> GType;
754
755 pub fn gst_rtsp_msg_type_get_type() -> GType;
759
760 pub fn gst_rtsp_range_unit_get_type() -> GType;
764
765 pub fn gst_rtsp_result_get_type() -> GType;
769
770 pub fn gst_rtsp_state_get_type() -> GType;
774
775 pub fn gst_rtsp_status_code_get_type() -> GType;
779
780 pub fn gst_rtsp_time_type_get_type() -> GType;
784
785 pub fn gst_rtsp_version_get_type() -> GType;
789 pub fn gst_rtsp_version_as_text(version: GstRTSPVersion) -> *const c_char;
790
791 pub fn gst_rtsp_event_get_type() -> GType;
795
796 pub fn gst_rtsp_lower_trans_get_type() -> GType;
800
801 pub fn gst_rtsp_method_get_type() -> GType;
805 pub fn gst_rtsp_method_as_text(method: GstRTSPMethod) -> *const c_char;
806
807 pub fn gst_rtsp_profile_get_type() -> GType;
811
812 pub fn gst_rtsp_trans_mode_get_type() -> GType;
816
817 pub fn gst_rtsp_auth_credential_get_type() -> GType;
821
822 pub fn gst_rtsp_auth_param_get_type() -> GType;
826 pub fn gst_rtsp_auth_param_copy(param: *mut GstRTSPAuthParam) -> *mut GstRTSPAuthParam;
827 pub fn gst_rtsp_auth_param_free(param: *mut GstRTSPAuthParam);
828
829 #[cfg(feature = "v1_24")]
833 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
834 pub fn gst_rtsp_connection_add_extra_http_request_header(
835 conn: *mut GstRTSPConnection,
836 key: *const c_char,
837 value: *const c_char,
838 );
839 pub fn gst_rtsp_connection_clear_auth_params(conn: *mut GstRTSPConnection);
840 pub fn gst_rtsp_connection_close(conn: *mut GstRTSPConnection) -> GstRTSPResult;
841 pub fn gst_rtsp_connection_connect(
842 conn: *mut GstRTSPConnection,
843 timeout: *mut glib::GTimeVal,
844 ) -> GstRTSPResult;
845 #[cfg(feature = "v1_18")]
846 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
847 pub fn gst_rtsp_connection_connect_usec(
848 conn: *mut GstRTSPConnection,
849 timeout: i64,
850 ) -> GstRTSPResult;
851 pub fn gst_rtsp_connection_connect_with_response(
852 conn: *mut GstRTSPConnection,
853 timeout: *mut glib::GTimeVal,
854 response: *mut GstRTSPMessage,
855 ) -> GstRTSPResult;
856 #[cfg(feature = "v1_18")]
857 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
858 pub fn gst_rtsp_connection_connect_with_response_usec(
859 conn: *mut GstRTSPConnection,
860 timeout: i64,
861 response: *mut GstRTSPMessage,
862 ) -> GstRTSPResult;
863 pub fn gst_rtsp_connection_do_tunnel(
864 conn: *mut GstRTSPConnection,
865 conn2: *mut GstRTSPConnection,
866 ) -> GstRTSPResult;
867 pub fn gst_rtsp_connection_flush(
868 conn: *mut GstRTSPConnection,
869 flush: gboolean,
870 ) -> GstRTSPResult;
871 pub fn gst_rtsp_connection_free(conn: *mut GstRTSPConnection) -> GstRTSPResult;
872 #[cfg(feature = "v1_30")]
873 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
874 pub fn gst_rtsp_connection_get_backchannel_method(
875 conn: *const GstRTSPConnection,
876 ) -> GstRTSPBackchannelHttpMethod;
877 #[cfg(feature = "v1_20")]
878 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
879 pub fn gst_rtsp_connection_get_ignore_x_server_reply(
880 conn: *const GstRTSPConnection,
881 ) -> gboolean;
882 pub fn gst_rtsp_connection_get_ip(conn: *const GstRTSPConnection) -> *const c_char;
883 pub fn gst_rtsp_connection_get_read_socket(conn: *const GstRTSPConnection)
884 -> *mut gio::GSocket;
885 pub fn gst_rtsp_connection_get_remember_session_id(conn: *mut GstRTSPConnection) -> gboolean;
886 pub fn gst_rtsp_connection_get_tls(
887 conn: *mut GstRTSPConnection,
888 error: *mut *mut glib::GError,
889 ) -> *mut gio::GTlsConnection;
890 pub fn gst_rtsp_connection_get_tls_database(
891 conn: *mut GstRTSPConnection,
892 ) -> *mut gio::GTlsDatabase;
893 pub fn gst_rtsp_connection_get_tls_interaction(
894 conn: *mut GstRTSPConnection,
895 ) -> *mut gio::GTlsInteraction;
896 pub fn gst_rtsp_connection_get_tls_validation_flags(
897 conn: *mut GstRTSPConnection,
898 ) -> gio::GTlsCertificateFlags;
899 pub fn gst_rtsp_connection_get_tunnelid(conn: *const GstRTSPConnection) -> *const c_char;
900 pub fn gst_rtsp_connection_get_url(conn: *const GstRTSPConnection) -> *mut GstRTSPUrl;
901 pub fn gst_rtsp_connection_get_write_socket(
902 conn: *const GstRTSPConnection,
903 ) -> *mut gio::GSocket;
904 pub fn gst_rtsp_connection_is_tunneled(conn: *const GstRTSPConnection) -> gboolean;
905 pub fn gst_rtsp_connection_next_timeout(
906 conn: *mut GstRTSPConnection,
907 timeout: *mut glib::GTimeVal,
908 ) -> GstRTSPResult;
909 #[cfg(feature = "v1_18")]
910 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
911 pub fn gst_rtsp_connection_next_timeout_usec(conn: *mut GstRTSPConnection) -> i64;
912 pub fn gst_rtsp_connection_poll(
913 conn: *mut GstRTSPConnection,
914 events: GstRTSPEvent,
915 revents: *mut GstRTSPEvent,
916 timeout: *mut glib::GTimeVal,
917 ) -> GstRTSPResult;
918 #[cfg(feature = "v1_18")]
919 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
920 pub fn gst_rtsp_connection_poll_usec(
921 conn: *mut GstRTSPConnection,
922 events: GstRTSPEvent,
923 revents: *mut GstRTSPEvent,
924 timeout: i64,
925 ) -> GstRTSPResult;
926 pub fn gst_rtsp_connection_read(
927 conn: *mut GstRTSPConnection,
928 data: *mut u8,
929 size: c_uint,
930 timeout: *mut glib::GTimeVal,
931 ) -> GstRTSPResult;
932 #[cfg(feature = "v1_18")]
933 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
934 pub fn gst_rtsp_connection_read_usec(
935 conn: *mut GstRTSPConnection,
936 data: *mut u8,
937 size: c_uint,
938 timeout: i64,
939 ) -> GstRTSPResult;
940 pub fn gst_rtsp_connection_receive(
941 conn: *mut GstRTSPConnection,
942 message: *mut GstRTSPMessage,
943 timeout: *mut glib::GTimeVal,
944 ) -> GstRTSPResult;
945 #[cfg(feature = "v1_18")]
946 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
947 pub fn gst_rtsp_connection_receive_usec(
948 conn: *mut GstRTSPConnection,
949 message: *mut GstRTSPMessage,
950 timeout: i64,
951 ) -> GstRTSPResult;
952 pub fn gst_rtsp_connection_reset_timeout(conn: *mut GstRTSPConnection) -> GstRTSPResult;
953 pub fn gst_rtsp_connection_send(
954 conn: *mut GstRTSPConnection,
955 message: *mut GstRTSPMessage,
956 timeout: *mut glib::GTimeVal,
957 ) -> GstRTSPResult;
958 #[cfg(feature = "v1_16")]
959 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
960 pub fn gst_rtsp_connection_send_messages(
961 conn: *mut GstRTSPConnection,
962 messages: *mut GstRTSPMessage,
963 n_messages: c_uint,
964 timeout: *mut glib::GTimeVal,
965 ) -> GstRTSPResult;
966 #[cfg(feature = "v1_18")]
967 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
968 pub fn gst_rtsp_connection_send_messages_usec(
969 conn: *mut GstRTSPConnection,
970 messages: *mut GstRTSPMessage,
971 n_messages: c_uint,
972 timeout: i64,
973 ) -> GstRTSPResult;
974 #[cfg(feature = "v1_18")]
975 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
976 pub fn gst_rtsp_connection_send_usec(
977 conn: *mut GstRTSPConnection,
978 message: *mut GstRTSPMessage,
979 timeout: i64,
980 ) -> GstRTSPResult;
981 pub fn gst_rtsp_connection_set_accept_certificate_func(
982 conn: *mut GstRTSPConnection,
983 func: GstRTSPConnectionAcceptCertificateFunc,
984 user_data: gpointer,
985 destroy_notify: glib::GDestroyNotify,
986 );
987 pub fn gst_rtsp_connection_set_auth(
988 conn: *mut GstRTSPConnection,
989 method: GstRTSPAuthMethod,
990 user: *const c_char,
991 pass: *const c_char,
992 ) -> GstRTSPResult;
993 pub fn gst_rtsp_connection_set_auth_param(
994 conn: *mut GstRTSPConnection,
995 param: *const c_char,
996 value: *const c_char,
997 );
998 #[cfg(feature = "v1_30")]
999 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
1000 pub fn gst_rtsp_connection_set_backchannel_method(
1001 conn: *mut GstRTSPConnection,
1002 method: GstRTSPBackchannelHttpMethod,
1003 );
1004 #[cfg(feature = "v1_18")]
1005 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1006 pub fn gst_rtsp_connection_set_content_length_limit(
1007 conn: *mut GstRTSPConnection,
1008 limit: c_uint,
1009 );
1010 pub fn gst_rtsp_connection_set_http_mode(conn: *mut GstRTSPConnection, enable: gboolean);
1011 #[cfg(feature = "v1_20")]
1012 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1013 pub fn gst_rtsp_connection_set_ignore_x_server_reply(
1014 conn: *mut GstRTSPConnection,
1015 ignore: gboolean,
1016 );
1017 pub fn gst_rtsp_connection_set_ip(conn: *mut GstRTSPConnection, ip: *const c_char);
1018 pub fn gst_rtsp_connection_set_proxy(
1019 conn: *mut GstRTSPConnection,
1020 host: *const c_char,
1021 port: c_uint,
1022 ) -> GstRTSPResult;
1023 pub fn gst_rtsp_connection_set_qos_dscp(
1024 conn: *mut GstRTSPConnection,
1025 qos_dscp: c_uint,
1026 ) -> GstRTSPResult;
1027 pub fn gst_rtsp_connection_set_remember_session_id(
1028 conn: *mut GstRTSPConnection,
1029 remember: gboolean,
1030 );
1031 pub fn gst_rtsp_connection_set_tls_database(
1032 conn: *mut GstRTSPConnection,
1033 database: *mut gio::GTlsDatabase,
1034 );
1035 pub fn gst_rtsp_connection_set_tls_interaction(
1036 conn: *mut GstRTSPConnection,
1037 interaction: *mut gio::GTlsInteraction,
1038 );
1039 pub fn gst_rtsp_connection_set_tls_validation_flags(
1040 conn: *mut GstRTSPConnection,
1041 flags: gio::GTlsCertificateFlags,
1042 ) -> gboolean;
1043 pub fn gst_rtsp_connection_set_tunneled(conn: *mut GstRTSPConnection, tunneled: gboolean);
1044 pub fn gst_rtsp_connection_write(
1045 conn: *mut GstRTSPConnection,
1046 data: *const u8,
1047 size: c_uint,
1048 timeout: *mut glib::GTimeVal,
1049 ) -> GstRTSPResult;
1050 #[cfg(feature = "v1_18")]
1051 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1052 pub fn gst_rtsp_connection_write_usec(
1053 conn: *mut GstRTSPConnection,
1054 data: *const u8,
1055 size: c_uint,
1056 timeout: i64,
1057 ) -> GstRTSPResult;
1058 pub fn gst_rtsp_connection_accept(
1059 socket: *mut gio::GSocket,
1060 conn: *mut *mut GstRTSPConnection,
1061 cancellable: *mut gio::GCancellable,
1062 ) -> GstRTSPResult;
1063 pub fn gst_rtsp_connection_create(
1064 url: *const GstRTSPUrl,
1065 conn: *mut *mut GstRTSPConnection,
1066 ) -> GstRTSPResult;
1067 pub fn gst_rtsp_connection_create_from_socket(
1068 socket: *mut gio::GSocket,
1069 ip: *const c_char,
1070 port: u16,
1071 initial_buffer: *const c_char,
1072 conn: *mut *mut GstRTSPConnection,
1073 ) -> GstRTSPResult;
1074
1075 pub fn gst_rtsp_msg_get_type() -> GType;
1079 pub fn gst_rtsp_message_add_header(
1080 msg: *mut GstRTSPMessage,
1081 field: GstRTSPHeaderField,
1082 value: *const c_char,
1083 ) -> GstRTSPResult;
1084 pub fn gst_rtsp_message_add_header_by_name(
1085 msg: *mut GstRTSPMessage,
1086 header: *const c_char,
1087 value: *const c_char,
1088 ) -> GstRTSPResult;
1089 pub fn gst_rtsp_message_append_headers(
1090 msg: *const GstRTSPMessage,
1091 str: *mut glib::GString,
1092 ) -> GstRTSPResult;
1093 pub fn gst_rtsp_message_copy(
1094 msg: *const GstRTSPMessage,
1095 copy: *mut *mut GstRTSPMessage,
1096 ) -> GstRTSPResult;
1097 pub fn gst_rtsp_message_dump(msg: *mut GstRTSPMessage) -> GstRTSPResult;
1098 pub fn gst_rtsp_message_free(msg: *mut GstRTSPMessage) -> GstRTSPResult;
1099 pub fn gst_rtsp_message_get_body(
1100 msg: *const GstRTSPMessage,
1101 data: *mut *mut u8,
1102 size: *mut c_uint,
1103 ) -> GstRTSPResult;
1104 #[cfg(feature = "v1_16")]
1105 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1106 pub fn gst_rtsp_message_get_body_buffer(
1107 msg: *const GstRTSPMessage,
1108 buffer: *mut *mut gst::GstBuffer,
1109 ) -> GstRTSPResult;
1110 pub fn gst_rtsp_message_get_header(
1111 msg: *const GstRTSPMessage,
1112 field: GstRTSPHeaderField,
1113 value: *mut *mut c_char,
1114 indx: c_int,
1115 ) -> GstRTSPResult;
1116 pub fn gst_rtsp_message_get_header_by_name(
1117 msg: *mut GstRTSPMessage,
1118 header: *const c_char,
1119 value: *mut *mut c_char,
1120 index: c_int,
1121 ) -> GstRTSPResult;
1122 pub fn gst_rtsp_message_get_type(msg: *mut GstRTSPMessage) -> GstRTSPMsgType;
1123 #[cfg(feature = "v1_16")]
1124 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1125 pub fn gst_rtsp_message_has_body_buffer(msg: *const GstRTSPMessage) -> gboolean;
1126 pub fn gst_rtsp_message_init(msg: *mut GstRTSPMessage) -> GstRTSPResult;
1127 pub fn gst_rtsp_message_init_data(msg: *mut GstRTSPMessage, channel: u8) -> GstRTSPResult;
1128 pub fn gst_rtsp_message_init_request(
1129 msg: *mut GstRTSPMessage,
1130 method: GstRTSPMethod,
1131 uri: *const c_char,
1132 ) -> GstRTSPResult;
1133 pub fn gst_rtsp_message_init_response(
1134 msg: *mut GstRTSPMessage,
1135 code: GstRTSPStatusCode,
1136 reason: *const c_char,
1137 request: *const GstRTSPMessage,
1138 ) -> GstRTSPResult;
1139 pub fn gst_rtsp_message_parse_auth_credentials(
1140 msg: *mut GstRTSPMessage,
1141 field: GstRTSPHeaderField,
1142 ) -> *mut *mut GstRTSPAuthCredential;
1143 pub fn gst_rtsp_message_parse_data(msg: *mut GstRTSPMessage, channel: *mut u8)
1144 -> GstRTSPResult;
1145 pub fn gst_rtsp_message_parse_request(
1146 msg: *mut GstRTSPMessage,
1147 method: *mut GstRTSPMethod,
1148 uri: *mut *const c_char,
1149 version: *mut GstRTSPVersion,
1150 ) -> GstRTSPResult;
1151 pub fn gst_rtsp_message_parse_response(
1152 msg: *mut GstRTSPMessage,
1153 code: *mut GstRTSPStatusCode,
1154 reason: *mut *const c_char,
1155 version: *mut GstRTSPVersion,
1156 ) -> GstRTSPResult;
1157 pub fn gst_rtsp_message_remove_header(
1158 msg: *mut GstRTSPMessage,
1159 field: GstRTSPHeaderField,
1160 indx: c_int,
1161 ) -> GstRTSPResult;
1162 pub fn gst_rtsp_message_remove_header_by_name(
1163 msg: *mut GstRTSPMessage,
1164 header: *const c_char,
1165 index: c_int,
1166 ) -> GstRTSPResult;
1167 pub fn gst_rtsp_message_set_body(
1168 msg: *mut GstRTSPMessage,
1169 data: *const u8,
1170 size: c_uint,
1171 ) -> GstRTSPResult;
1172 #[cfg(feature = "v1_16")]
1173 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1174 pub fn gst_rtsp_message_set_body_buffer(
1175 msg: *mut GstRTSPMessage,
1176 buffer: *mut gst::GstBuffer,
1177 ) -> GstRTSPResult;
1178 pub fn gst_rtsp_message_steal_body(
1179 msg: *mut GstRTSPMessage,
1180 data: *mut *mut u8,
1181 size: *mut c_uint,
1182 ) -> GstRTSPResult;
1183 #[cfg(feature = "v1_16")]
1184 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1185 pub fn gst_rtsp_message_steal_body_buffer(
1186 msg: *mut GstRTSPMessage,
1187 buffer: *mut *mut gst::GstBuffer,
1188 ) -> GstRTSPResult;
1189 pub fn gst_rtsp_message_take_body(
1190 msg: *mut GstRTSPMessage,
1191 data: *mut u8,
1192 size: c_uint,
1193 ) -> GstRTSPResult;
1194 #[cfg(feature = "v1_16")]
1195 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1196 pub fn gst_rtsp_message_take_body_buffer(
1197 msg: *mut GstRTSPMessage,
1198 buffer: *mut gst::GstBuffer,
1199 ) -> GstRTSPResult;
1200 pub fn gst_rtsp_message_take_header(
1201 msg: *mut GstRTSPMessage,
1202 field: GstRTSPHeaderField,
1203 value: *mut c_char,
1204 ) -> GstRTSPResult;
1205 pub fn gst_rtsp_message_take_header_by_name(
1206 msg: *mut GstRTSPMessage,
1207 header: *const c_char,
1208 value: *mut c_char,
1209 ) -> GstRTSPResult;
1210 pub fn gst_rtsp_message_unset(msg: *mut GstRTSPMessage) -> GstRTSPResult;
1211
1212 pub fn gst_rtsp_range_convert_units(
1216 range: *mut GstRTSPTimeRange,
1217 unit: GstRTSPRangeUnit,
1218 ) -> gboolean;
1219 pub fn gst_rtsp_range_free(range: *mut GstRTSPTimeRange);
1220 pub fn gst_rtsp_range_get_times(
1221 range: *const GstRTSPTimeRange,
1222 min: *mut gst::GstClockTime,
1223 max: *mut gst::GstClockTime,
1224 ) -> gboolean;
1225 pub fn gst_rtsp_range_parse(
1226 rangestr: *const c_char,
1227 range: *mut *mut GstRTSPTimeRange,
1228 ) -> GstRTSPResult;
1229 pub fn gst_rtsp_range_to_string(range: *const GstRTSPTimeRange) -> *mut c_char;
1230
1231 pub fn gst_rtsp_transport_as_text(transport: *mut GstRTSPTransport) -> *mut c_char;
1235 pub fn gst_rtsp_transport_free(transport: *mut GstRTSPTransport) -> GstRTSPResult;
1236 pub fn gst_rtsp_transport_get_media_type(
1237 transport: *mut GstRTSPTransport,
1238 media_type: *mut *const c_char,
1239 ) -> GstRTSPResult;
1240 pub fn gst_rtsp_transport_get_manager(
1241 trans: GstRTSPTransMode,
1242 manager: *mut *const c_char,
1243 option: c_uint,
1244 ) -> GstRTSPResult;
1245 pub fn gst_rtsp_transport_get_mime(
1246 trans: GstRTSPTransMode,
1247 mime: *mut *const c_char,
1248 ) -> GstRTSPResult;
1249 pub fn gst_rtsp_transport_init(transport: *mut GstRTSPTransport) -> GstRTSPResult;
1250 pub fn gst_rtsp_transport_new(transport: *mut *mut GstRTSPTransport) -> GstRTSPResult;
1251 pub fn gst_rtsp_transport_parse(
1252 str: *const c_char,
1253 transport: *mut GstRTSPTransport,
1254 ) -> GstRTSPResult;
1255
1256 pub fn gst_rtsp_url_get_type() -> GType;
1260 pub fn gst_rtsp_url_copy(url: *const GstRTSPUrl) -> *mut GstRTSPUrl;
1261 pub fn gst_rtsp_url_decode_path_components(url: *const GstRTSPUrl) -> *mut *mut c_char;
1262 pub fn gst_rtsp_url_free(url: *mut GstRTSPUrl);
1263 pub fn gst_rtsp_url_get_port(url: *const GstRTSPUrl, port: *mut u16) -> GstRTSPResult;
1264 pub fn gst_rtsp_url_get_request_uri(url: *const GstRTSPUrl) -> *mut c_char;
1265 #[cfg(feature = "v1_18")]
1266 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1267 pub fn gst_rtsp_url_get_request_uri_with_control(
1268 url: *const GstRTSPUrl,
1269 control_path: *const c_char,
1270 ) -> *mut c_char;
1271 pub fn gst_rtsp_url_set_port(url: *mut GstRTSPUrl, port: u16) -> GstRTSPResult;
1272 pub fn gst_rtsp_url_parse(urlstr: *const c_char, url: *mut *mut GstRTSPUrl) -> GstRTSPResult;
1273
1274 pub fn gst_rtsp_watch_attach(
1278 watch: *mut GstRTSPWatch,
1279 context: *mut glib::GMainContext,
1280 ) -> c_uint;
1281 pub fn gst_rtsp_watch_get_send_backlog(
1282 watch: *mut GstRTSPWatch,
1283 bytes: *mut size_t,
1284 messages: *mut c_uint,
1285 );
1286 pub fn gst_rtsp_watch_reset(watch: *mut GstRTSPWatch);
1287 pub fn gst_rtsp_watch_send_message(
1288 watch: *mut GstRTSPWatch,
1289 message: *mut GstRTSPMessage,
1290 id: *mut c_uint,
1291 ) -> GstRTSPResult;
1292 #[cfg(feature = "v1_16")]
1293 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1294 pub fn gst_rtsp_watch_send_messages(
1295 watch: *mut GstRTSPWatch,
1296 messages: *mut GstRTSPMessage,
1297 n_messages: c_uint,
1298 id: *mut c_uint,
1299 ) -> GstRTSPResult;
1300 pub fn gst_rtsp_watch_set_flushing(watch: *mut GstRTSPWatch, flushing: gboolean);
1301 pub fn gst_rtsp_watch_set_send_backlog(
1302 watch: *mut GstRTSPWatch,
1303 bytes: size_t,
1304 messages: c_uint,
1305 );
1306 pub fn gst_rtsp_watch_unref(watch: *mut GstRTSPWatch);
1307 pub fn gst_rtsp_watch_wait_backlog(
1308 watch: *mut GstRTSPWatch,
1309 timeout: *mut glib::GTimeVal,
1310 ) -> GstRTSPResult;
1311 #[cfg(feature = "v1_18")]
1312 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1313 pub fn gst_rtsp_watch_wait_backlog_usec(
1314 watch: *mut GstRTSPWatch,
1315 timeout: i64,
1316 ) -> GstRTSPResult;
1317 pub fn gst_rtsp_watch_write_data(
1318 watch: *mut GstRTSPWatch,
1319 data: *const u8,
1320 size: c_uint,
1321 id: *mut c_uint,
1322 ) -> GstRTSPResult;
1323 pub fn gst_rtsp_watch_new(
1324 conn: *mut GstRTSPConnection,
1325 funcs: *mut GstRTSPWatchFuncs,
1326 user_data: gpointer,
1327 notify: glib::GDestroyNotify,
1328 ) -> *mut GstRTSPWatch;
1329
1330 pub fn gst_rtsp_extension_get_type() -> GType;
1334 pub fn gst_rtsp_extension_after_send(
1335 ext: *mut GstRTSPExtension,
1336 req: *mut GstRTSPMessage,
1337 resp: *mut GstRTSPMessage,
1338 ) -> GstRTSPResult;
1339 pub fn gst_rtsp_extension_before_send(
1340 ext: *mut GstRTSPExtension,
1341 req: *mut GstRTSPMessage,
1342 ) -> GstRTSPResult;
1343 pub fn gst_rtsp_extension_configure_stream(
1344 ext: *mut GstRTSPExtension,
1345 caps: *mut gst::GstCaps,
1346 ) -> gboolean;
1347 pub fn gst_rtsp_extension_detect_server(
1348 ext: *mut GstRTSPExtension,
1349 resp: *mut GstRTSPMessage,
1350 ) -> gboolean;
1351 pub fn gst_rtsp_extension_get_transports(
1352 ext: *mut GstRTSPExtension,
1353 protocols: GstRTSPLowerTrans,
1354 transport: *mut *mut c_char,
1355 ) -> GstRTSPResult;
1356 pub fn gst_rtsp_extension_parse_sdp(
1357 ext: *mut GstRTSPExtension,
1358 sdp: *mut gst_sdp::GstSDPMessage,
1359 s: *mut gst::GstStructure,
1360 ) -> GstRTSPResult;
1361 pub fn gst_rtsp_extension_receive_request(
1362 ext: *mut GstRTSPExtension,
1363 req: *mut GstRTSPMessage,
1364 ) -> GstRTSPResult;
1365 pub fn gst_rtsp_extension_send(
1366 ext: *mut GstRTSPExtension,
1367 req: *mut GstRTSPMessage,
1368 resp: *mut GstRTSPMessage,
1369 ) -> GstRTSPResult;
1370 pub fn gst_rtsp_extension_setup_media(
1371 ext: *mut GstRTSPExtension,
1372 media: *mut gst_sdp::GstSDPMedia,
1373 ) -> GstRTSPResult;
1374 pub fn gst_rtsp_extension_stream_select(
1375 ext: *mut GstRTSPExtension,
1376 url: *mut GstRTSPUrl,
1377 ) -> GstRTSPResult;
1378
1379 pub fn gst_rtsp_auth_credentials_free(credentials: *mut *mut GstRTSPAuthCredential);
1383 pub fn gst_rtsp_find_header_field(header: *const c_char) -> GstRTSPHeaderField;
1384 pub fn gst_rtsp_find_method(method: *const c_char) -> GstRTSPMethod;
1385 pub fn gst_rtsp_generate_digest_auth_response(
1386 algorithm: *const c_char,
1387 method: *const c_char,
1388 realm: *const c_char,
1389 username: *const c_char,
1390 password: *const c_char,
1391 uri: *const c_char,
1392 nonce: *const c_char,
1393 ) -> *mut c_char;
1394 #[cfg(feature = "v1_16")]
1395 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1396 pub fn gst_rtsp_generate_digest_auth_response_from_md5(
1397 algorithm: *const c_char,
1398 method: *const c_char,
1399 md5: *const c_char,
1400 uri: *const c_char,
1401 nonce: *const c_char,
1402 ) -> *mut c_char;
1403 pub fn gst_rtsp_header_allow_multiple(field: GstRTSPHeaderField) -> gboolean;
1404 pub fn gst_rtsp_header_as_text(field: GstRTSPHeaderField) -> *const c_char;
1405 pub fn gst_rtsp_message_new(msg: *mut *mut GstRTSPMessage) -> GstRTSPResult;
1406 pub fn gst_rtsp_message_new_data(msg: *mut *mut GstRTSPMessage, channel: u8) -> GstRTSPResult;
1407 pub fn gst_rtsp_message_new_request(
1408 msg: *mut *mut GstRTSPMessage,
1409 method: GstRTSPMethod,
1410 uri: *const c_char,
1411 ) -> GstRTSPResult;
1412 pub fn gst_rtsp_message_new_response(
1413 msg: *mut *mut GstRTSPMessage,
1414 code: GstRTSPStatusCode,
1415 reason: *const c_char,
1416 request: *const GstRTSPMessage,
1417 ) -> GstRTSPResult;
1418 pub fn gst_rtsp_options_as_text(options: GstRTSPMethod) -> *mut c_char;
1419 pub fn gst_rtsp_options_from_text(options: *const c_char) -> GstRTSPMethod;
1420 pub fn gst_rtsp_status_as_text(code: GstRTSPStatusCode) -> *const c_char;
1421 pub fn gst_rtsp_strresult(result: GstRTSPResult) -> *mut c_char;
1422
1423}