gstreamer_rtsp_server/auto/
enums.rs1use crate::ffi;
7use glib::{prelude::*, translate::*};
8
9#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10#[non_exhaustive]
11#[doc(alias = "GstRTSPAddressPoolResult")]
12pub enum RTSPAddressPoolResult {
13 #[doc(alias = "GST_RTSP_ADDRESS_POOL_OK")]
14 Ok,
15 #[doc(alias = "GST_RTSP_ADDRESS_POOL_EINVAL")]
16 Einval,
17 #[doc(alias = "GST_RTSP_ADDRESS_POOL_ERESERVED")]
18 Ereserved,
19 #[doc(alias = "GST_RTSP_ADDRESS_POOL_ERANGE")]
20 Erange,
21 #[doc(alias = "GST_RTSP_ADDRESS_POOL_ELAST")]
22 Elast,
23 #[doc(hidden)]
24 __Unknown(i32),
25}
26
27#[doc(hidden)]
28impl IntoGlib for RTSPAddressPoolResult {
29 type GlibType = ffi::GstRTSPAddressPoolResult;
30
31 #[inline]
32 fn into_glib(self) -> ffi::GstRTSPAddressPoolResult {
33 match self {
34 Self::Ok => ffi::GST_RTSP_ADDRESS_POOL_OK,
35 Self::Einval => ffi::GST_RTSP_ADDRESS_POOL_EINVAL,
36 Self::Ereserved => ffi::GST_RTSP_ADDRESS_POOL_ERESERVED,
37 Self::Erange => ffi::GST_RTSP_ADDRESS_POOL_ERANGE,
38 Self::Elast => ffi::GST_RTSP_ADDRESS_POOL_ELAST,
39 Self::__Unknown(value) => value,
40 }
41 }
42}
43
44#[doc(hidden)]
45impl FromGlib<ffi::GstRTSPAddressPoolResult> for RTSPAddressPoolResult {
46 #[inline]
47 unsafe fn from_glib(value: ffi::GstRTSPAddressPoolResult) -> Self {
48 skip_assert_initialized!();
49
50 match value {
51 ffi::GST_RTSP_ADDRESS_POOL_OK => Self::Ok,
52 ffi::GST_RTSP_ADDRESS_POOL_EINVAL => Self::Einval,
53 ffi::GST_RTSP_ADDRESS_POOL_ERESERVED => Self::Ereserved,
54 ffi::GST_RTSP_ADDRESS_POOL_ERANGE => Self::Erange,
55 ffi::GST_RTSP_ADDRESS_POOL_ELAST => Self::Elast,
56 value => Self::__Unknown(value),
57 }
58 }
59}
60
61#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
62#[non_exhaustive]
63#[doc(alias = "GstRTSPFilterResult")]
64pub enum RTSPFilterResult {
65 #[doc(alias = "GST_RTSP_FILTER_REMOVE")]
66 Remove,
67 #[doc(alias = "GST_RTSP_FILTER_KEEP")]
68 Keep,
69 #[doc(alias = "GST_RTSP_FILTER_REF")]
70 Ref,
71 #[doc(hidden)]
72 __Unknown(i32),
73}
74
75#[doc(hidden)]
76impl IntoGlib for RTSPFilterResult {
77 type GlibType = ffi::GstRTSPFilterResult;
78
79 #[inline]
80 fn into_glib(self) -> ffi::GstRTSPFilterResult {
81 match self {
82 Self::Remove => ffi::GST_RTSP_FILTER_REMOVE,
83 Self::Keep => ffi::GST_RTSP_FILTER_KEEP,
84 Self::Ref => ffi::GST_RTSP_FILTER_REF,
85 Self::__Unknown(value) => value,
86 }
87 }
88}
89
90#[doc(hidden)]
91impl FromGlib<ffi::GstRTSPFilterResult> for RTSPFilterResult {
92 #[inline]
93 unsafe fn from_glib(value: ffi::GstRTSPFilterResult) -> Self {
94 skip_assert_initialized!();
95
96 match value {
97 ffi::GST_RTSP_FILTER_REMOVE => Self::Remove,
98 ffi::GST_RTSP_FILTER_KEEP => Self::Keep,
99 ffi::GST_RTSP_FILTER_REF => Self::Ref,
100 value => Self::__Unknown(value),
101 }
102 }
103}
104
105#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
106#[non_exhaustive]
107#[doc(alias = "GstRTSPMediaStatus")]
108pub enum RTSPMediaStatus {
109 #[doc(alias = "GST_RTSP_MEDIA_STATUS_UNPREPARED")]
110 Unprepared,
111 #[doc(alias = "GST_RTSP_MEDIA_STATUS_UNPREPARING")]
112 Unpreparing,
113 #[doc(alias = "GST_RTSP_MEDIA_STATUS_PREPARING")]
114 Preparing,
115 #[doc(alias = "GST_RTSP_MEDIA_STATUS_PREPARED")]
116 Prepared,
117 #[doc(alias = "GST_RTSP_MEDIA_STATUS_SUSPENDED")]
118 Suspended,
119 #[doc(alias = "GST_RTSP_MEDIA_STATUS_ERROR")]
120 Error,
121 #[doc(hidden)]
122 __Unknown(i32),
123}
124
125#[doc(hidden)]
126impl IntoGlib for RTSPMediaStatus {
127 type GlibType = ffi::GstRTSPMediaStatus;
128
129 #[inline]
130 fn into_glib(self) -> ffi::GstRTSPMediaStatus {
131 match self {
132 Self::Unprepared => ffi::GST_RTSP_MEDIA_STATUS_UNPREPARED,
133 Self::Unpreparing => ffi::GST_RTSP_MEDIA_STATUS_UNPREPARING,
134 Self::Preparing => ffi::GST_RTSP_MEDIA_STATUS_PREPARING,
135 Self::Prepared => ffi::GST_RTSP_MEDIA_STATUS_PREPARED,
136 Self::Suspended => ffi::GST_RTSP_MEDIA_STATUS_SUSPENDED,
137 Self::Error => ffi::GST_RTSP_MEDIA_STATUS_ERROR,
138 Self::__Unknown(value) => value,
139 }
140 }
141}
142
143#[doc(hidden)]
144impl FromGlib<ffi::GstRTSPMediaStatus> for RTSPMediaStatus {
145 #[inline]
146 unsafe fn from_glib(value: ffi::GstRTSPMediaStatus) -> Self {
147 skip_assert_initialized!();
148
149 match value {
150 ffi::GST_RTSP_MEDIA_STATUS_UNPREPARED => Self::Unprepared,
151 ffi::GST_RTSP_MEDIA_STATUS_UNPREPARING => Self::Unpreparing,
152 ffi::GST_RTSP_MEDIA_STATUS_PREPARING => Self::Preparing,
153 ffi::GST_RTSP_MEDIA_STATUS_PREPARED => Self::Prepared,
154 ffi::GST_RTSP_MEDIA_STATUS_SUSPENDED => Self::Suspended,
155 ffi::GST_RTSP_MEDIA_STATUS_ERROR => Self::Error,
156 value => Self::__Unknown(value),
157 }
158 }
159}
160
161#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
162#[non_exhaustive]
163#[doc(alias = "GstRTSPPublishClockMode")]
164pub enum RTSPPublishClockMode {
165 #[doc(alias = "GST_RTSP_PUBLISH_CLOCK_MODE_NONE")]
166 None,
167 #[doc(alias = "GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK")]
168 Clock,
169 #[doc(alias = "GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK_AND_OFFSET")]
170 ClockAndOffset,
171 #[doc(hidden)]
172 __Unknown(i32),
173}
174
175#[doc(hidden)]
176impl IntoGlib for RTSPPublishClockMode {
177 type GlibType = ffi::GstRTSPPublishClockMode;
178
179 #[inline]
180 fn into_glib(self) -> ffi::GstRTSPPublishClockMode {
181 match self {
182 Self::None => ffi::GST_RTSP_PUBLISH_CLOCK_MODE_NONE,
183 Self::Clock => ffi::GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK,
184 Self::ClockAndOffset => ffi::GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK_AND_OFFSET,
185 Self::__Unknown(value) => value,
186 }
187 }
188}
189
190#[doc(hidden)]
191impl FromGlib<ffi::GstRTSPPublishClockMode> for RTSPPublishClockMode {
192 #[inline]
193 unsafe fn from_glib(value: ffi::GstRTSPPublishClockMode) -> Self {
194 skip_assert_initialized!();
195
196 match value {
197 ffi::GST_RTSP_PUBLISH_CLOCK_MODE_NONE => Self::None,
198 ffi::GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK => Self::Clock,
199 ffi::GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK_AND_OFFSET => Self::ClockAndOffset,
200 value => Self::__Unknown(value),
201 }
202 }
203}
204
205impl StaticType for RTSPPublishClockMode {
206 #[inline]
207 #[doc(alias = "gst_rtsp_publish_clock_mode_get_type")]
208 fn static_type() -> glib::Type {
209 unsafe { from_glib(ffi::gst_rtsp_publish_clock_mode_get_type()) }
210 }
211}
212
213impl glib::HasParamSpec for RTSPPublishClockMode {
214 type ParamSpec = glib::ParamSpecEnum;
215 type SetValue = Self;
216 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
217
218 fn param_spec_builder() -> Self::BuilderFn {
219 Self::ParamSpec::builder_with_default
220 }
221}
222
223impl glib::value::ValueType for RTSPPublishClockMode {
224 type Type = Self;
225}
226
227unsafe impl<'a> glib::value::FromValue<'a> for RTSPPublishClockMode {
228 type Checker = glib::value::GenericValueTypeChecker<Self>;
229
230 #[inline]
231 unsafe fn from_value(value: &'a glib::Value) -> Self {
232 skip_assert_initialized!();
233 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
234 }
235}
236
237impl ToValue for RTSPPublishClockMode {
238 #[inline]
239 fn to_value(&self) -> glib::Value {
240 let mut value = glib::Value::for_value_type::<Self>();
241 unsafe {
242 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
243 }
244 value
245 }
246
247 #[inline]
248 fn value_type(&self) -> glib::Type {
249 Self::static_type()
250 }
251}
252
253impl From<RTSPPublishClockMode> for glib::Value {
254 #[inline]
255 fn from(v: RTSPPublishClockMode) -> Self {
256 skip_assert_initialized!();
257 ToValue::to_value(&v)
258 }
259}
260
261#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
262#[non_exhaustive]
263#[doc(alias = "GstRTSPSuspendMode")]
264pub enum RTSPSuspendMode {
265 #[doc(alias = "GST_RTSP_SUSPEND_MODE_NONE")]
266 None,
267 #[doc(alias = "GST_RTSP_SUSPEND_MODE_PAUSE")]
268 Pause,
269 #[doc(alias = "GST_RTSP_SUSPEND_MODE_RESET")]
270 Reset,
271 #[doc(hidden)]
272 __Unknown(i32),
273}
274
275#[doc(hidden)]
276impl IntoGlib for RTSPSuspendMode {
277 type GlibType = ffi::GstRTSPSuspendMode;
278
279 #[inline]
280 fn into_glib(self) -> ffi::GstRTSPSuspendMode {
281 match self {
282 Self::None => ffi::GST_RTSP_SUSPEND_MODE_NONE,
283 Self::Pause => ffi::GST_RTSP_SUSPEND_MODE_PAUSE,
284 Self::Reset => ffi::GST_RTSP_SUSPEND_MODE_RESET,
285 Self::__Unknown(value) => value,
286 }
287 }
288}
289
290#[doc(hidden)]
291impl FromGlib<ffi::GstRTSPSuspendMode> for RTSPSuspendMode {
292 #[inline]
293 unsafe fn from_glib(value: ffi::GstRTSPSuspendMode) -> Self {
294 skip_assert_initialized!();
295
296 match value {
297 ffi::GST_RTSP_SUSPEND_MODE_NONE => Self::None,
298 ffi::GST_RTSP_SUSPEND_MODE_PAUSE => Self::Pause,
299 ffi::GST_RTSP_SUSPEND_MODE_RESET => Self::Reset,
300 value => Self::__Unknown(value),
301 }
302 }
303}
304
305impl StaticType for RTSPSuspendMode {
306 #[inline]
307 #[doc(alias = "gst_rtsp_suspend_mode_get_type")]
308 fn static_type() -> glib::Type {
309 unsafe { from_glib(ffi::gst_rtsp_suspend_mode_get_type()) }
310 }
311}
312
313impl glib::HasParamSpec for RTSPSuspendMode {
314 type ParamSpec = glib::ParamSpecEnum;
315 type SetValue = Self;
316 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
317
318 fn param_spec_builder() -> Self::BuilderFn {
319 Self::ParamSpec::builder_with_default
320 }
321}
322
323impl glib::value::ValueType for RTSPSuspendMode {
324 type Type = Self;
325}
326
327unsafe impl<'a> glib::value::FromValue<'a> for RTSPSuspendMode {
328 type Checker = glib::value::GenericValueTypeChecker<Self>;
329
330 #[inline]
331 unsafe fn from_value(value: &'a glib::Value) -> Self {
332 skip_assert_initialized!();
333 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
334 }
335}
336
337impl ToValue for RTSPSuspendMode {
338 #[inline]
339 fn to_value(&self) -> glib::Value {
340 let mut value = glib::Value::for_value_type::<Self>();
341 unsafe {
342 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
343 }
344 value
345 }
346
347 #[inline]
348 fn value_type(&self) -> glib::Type {
349 Self::static_type()
350 }
351}
352
353impl From<RTSPSuspendMode> for glib::Value {
354 #[inline]
355 fn from(v: RTSPSuspendMode) -> Self {
356 skip_assert_initialized!();
357 ToValue::to_value(&v)
358 }
359}
360
361#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
362#[non_exhaustive]
363#[doc(alias = "GstRTSPThreadType")]
364pub enum RTSPThreadType {
365 #[doc(alias = "GST_RTSP_THREAD_TYPE_CLIENT")]
366 Client,
367 #[doc(alias = "GST_RTSP_THREAD_TYPE_MEDIA")]
368 Media,
369 #[doc(hidden)]
370 __Unknown(i32),
371}
372
373#[doc(hidden)]
374impl IntoGlib for RTSPThreadType {
375 type GlibType = ffi::GstRTSPThreadType;
376
377 #[inline]
378 fn into_glib(self) -> ffi::GstRTSPThreadType {
379 match self {
380 Self::Client => ffi::GST_RTSP_THREAD_TYPE_CLIENT,
381 Self::Media => ffi::GST_RTSP_THREAD_TYPE_MEDIA,
382 Self::__Unknown(value) => value,
383 }
384 }
385}
386
387#[doc(hidden)]
388impl FromGlib<ffi::GstRTSPThreadType> for RTSPThreadType {
389 #[inline]
390 unsafe fn from_glib(value: ffi::GstRTSPThreadType) -> Self {
391 skip_assert_initialized!();
392
393 match value {
394 ffi::GST_RTSP_THREAD_TYPE_CLIENT => Self::Client,
395 ffi::GST_RTSP_THREAD_TYPE_MEDIA => Self::Media,
396 value => Self::__Unknown(value),
397 }
398 }
399}