gstreamer/
enums.rs

Help
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::{cmp, ops};
4
5use glib::{
6    prelude::*,
7    translate::*,
8    value::{FromValue, ToValue, Value},
9    Type,
10};
11use thiserror::Error;
12
13use crate::{ffi, ClockReturn, State, StateChange, StateChangeReturn};
14
15macro_rules! impl_return_result_traits {
16    ($ffi_type:ident, $ret_type:ident, $ok_type:ident, $err_type:ident) => {
17        impl From<$ok_type> for $ret_type {
18            #[inline]
19            fn from(value: $ok_type) -> Self {
20                skip_assert_initialized!();
21                $ret_type::from_ok(value)
22            }
23        }
24
25        impl IntoGlib for $ok_type {
26            type GlibType = <$ret_type as IntoGlib>::GlibType;
27
28            #[inline]
29            fn into_glib(self) -> Self::GlibType {
30                $ret_type::from_ok(self).into_glib()
31            }
32        }
33
34        impl From<$err_type> for $ret_type {
35            #[inline]
36            fn from(value: $err_type) -> Self {
37                skip_assert_initialized!();
38                $ret_type::from_error(value)
39            }
40        }
41
42        impl IntoGlib for $err_type {
43            type GlibType = <$ret_type as IntoGlib>::GlibType;
44
45            #[inline]
46            fn into_glib(self) -> Self::GlibType {
47                $ret_type::from_error(self).into_glib()
48            }
49        }
50
51        impl From<Result<$ok_type, $err_type>> for $ret_type {
52            #[inline]
53            fn from(res: Result<$ok_type, $err_type>) -> Self {
54                skip_assert_initialized!();
55                match res {
56                    Ok(success) => $ret_type::from_ok(success),
57                    Err(error) => $ret_type::from_error(error),
58                }
59            }
60        }
61
62        impl TryFromGlib<ffi::$ffi_type> for $ok_type {
63            type Error = $err_type;
64
65            #[inline]
66            unsafe fn try_from_glib(val: ffi::$ffi_type) -> Result<$ok_type, $err_type> {
67                skip_assert_initialized!();
68                $ret_type::from_glib(val).into_result()
69            }
70        }
71    };
72}
73
74impl StateChangeReturn {
75    #[inline]
76    pub fn into_result(self) -> Result<StateChangeSuccess, StateChangeError> {
77        match self {
78            StateChangeReturn::Failure => Err(StateChangeError),
79            _ => Ok(unsafe { std::mem::transmute::<StateChangeReturn, StateChangeSuccess>(self) }),
80        }
81    }
82
83    #[inline]
84    pub fn from_error(_: StateChangeError) -> Self {
85        skip_assert_initialized!();
86        StateChangeReturn::Failure
87    }
88
89    #[inline]
90    pub fn from_ok(v: StateChangeSuccess) -> Self {
91        skip_assert_initialized!();
92        unsafe { std::mem::transmute(v) }
93    }
94}
95
96#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
97#[repr(i32)]
98pub enum StateChangeSuccess {
99    Success = ffi::GST_STATE_CHANGE_SUCCESS,
100    Async = ffi::GST_STATE_CHANGE_ASYNC,
101    NoPreroll = ffi::GST_STATE_CHANGE_NO_PREROLL,
102}
103
104#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)]
105#[must_use]
106#[error("Element failed to change its state")]
107pub struct StateChangeError;
108
109impl_return_result_traits!(
110    GstStateChangeReturn,
111    StateChangeReturn,
112    StateChangeSuccess,
113    StateChangeError
114);
115
116#[must_use]
117#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
118#[repr(i32)]
119#[doc(alias = "GstFlowReturn")]
120pub enum FlowReturn {
121    #[doc(alias = "GST_FLOW_CUSTOM_SUCCESS_2")]
122    CustomSuccess2 = ffi::GST_FLOW_CUSTOM_SUCCESS_2,
123    #[doc(alias = "GST_FLOW_CUSTOM_SUCCESS_1")]
124    CustomSuccess1 = ffi::GST_FLOW_CUSTOM_SUCCESS_1,
125    #[doc(alias = "GST_FLOW_CUSTOM_SUCCESS")]
126    CustomSuccess = ffi::GST_FLOW_CUSTOM_SUCCESS,
127    #[doc(alias = "GST_FLOW_OK")]
128    Ok = ffi::GST_FLOW_OK,
129    #[doc(alias = "GST_FLOW_NOT_LINKED")]
130    NotLinked = ffi::GST_FLOW_NOT_LINKED,
131    #[doc(alias = "GST_FLOW_FLUSHING")]
132    Flushing = ffi::GST_FLOW_FLUSHING,
133    #[doc(alias = "GST_FLOW_EOS")]
134    Eos = ffi::GST_FLOW_EOS,
135    #[doc(alias = "GST_FLOW_NOT_NEGOTIATED")]
136    NotNegotiated = ffi::GST_FLOW_NOT_NEGOTIATED,
137    #[doc(alias = "GST_FLOW_ERROR")]
138    Error = ffi::GST_FLOW_ERROR,
139    #[doc(alias = "GST_FLOW_NOT_SUPPORTED")]
140    NotSupported = ffi::GST_FLOW_NOT_SUPPORTED,
141    #[doc(alias = "GST_FLOW_CUSTOM_ERROR")]
142    CustomError = ffi::GST_FLOW_CUSTOM_ERROR,
143    #[doc(alias = "GST_FLOW_CUSTOM_ERROR_1")]
144    CustomError1 = ffi::GST_FLOW_CUSTOM_ERROR_1,
145    #[doc(alias = "GST_FLOW_CUSTOM_ERROR_2")]
146    CustomError2 = ffi::GST_FLOW_CUSTOM_ERROR_2,
147}
148
149#[doc(hidden)]
150impl IntoGlib for FlowReturn {
151    type GlibType = ffi::GstFlowReturn;
152
153    #[inline]
154    fn into_glib(self) -> ffi::GstFlowReturn {
155        self as ffi::GstFlowReturn
156    }
157}
158
159#[doc(hidden)]
160impl FromGlib<ffi::GstFlowReturn> for FlowReturn {
161    #[inline]
162    unsafe fn from_glib(value: ffi::GstFlowReturn) -> Self {
163        skip_assert_initialized!();
164
165        if value < ffi::GST_FLOW_NOT_SUPPORTED
166            && (value > ffi::GST_FLOW_CUSTOM_ERROR || value < ffi::GST_FLOW_CUSTOM_ERROR_2)
167        {
168            FlowReturn::Error
169        } else if value > 0
170            && (value < ffi::GST_FLOW_CUSTOM_SUCCESS || value > ffi::GST_FLOW_CUSTOM_SUCCESS_2)
171        {
172            FlowReturn::Ok
173        } else {
174            std::mem::transmute::<i32, FlowReturn>(value)
175        }
176    }
177}
178
179impl StaticType for FlowReturn {
180    #[inline]
181    fn static_type() -> Type {
182        unsafe { from_glib(ffi::gst_flow_return_get_type()) }
183    }
184}
185
186impl glib::value::ValueType for FlowReturn {
187    type Type = Self;
188}
189
190unsafe impl<'a> FromValue<'a> for FlowReturn {
191    type Checker = glib::value::GenericValueTypeChecker<Self>;
192
193    #[inline]
194    unsafe fn from_value(value: &'a glib::Value) -> Self {
195        skip_assert_initialized!();
196        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
197    }
198}
199
200impl ToValue for FlowReturn {
201    #[inline]
202    fn to_value(&self) -> glib::Value {
203        let mut value = glib::Value::for_value_type::<Self>();
204        unsafe {
205            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
206        }
207        value
208    }
209
210    #[inline]
211    fn value_type(&self) -> glib::Type {
212        Self::static_type()
213    }
214}
215
216impl From<FlowReturn> for glib::Value {
217    #[inline]
218    fn from(v: FlowReturn) -> Self {
219        skip_assert_initialized!();
220        ToValue::to_value(&v)
221    }
222}
223
224impl FlowReturn {
225    #[inline]
226    pub fn into_result(self) -> Result<FlowSuccess, FlowError> {
227        if self.into_glib() >= 0 {
228            Ok(unsafe { std::mem::transmute::<FlowReturn, FlowSuccess>(self) })
229        } else {
230            Err(unsafe { std::mem::transmute::<FlowReturn, FlowError>(self) })
231        }
232    }
233
234    #[inline]
235    pub fn from_error(v: FlowError) -> Self {
236        skip_assert_initialized!();
237        unsafe { std::mem::transmute(v) }
238    }
239
240    #[inline]
241    pub fn from_ok(v: FlowSuccess) -> Self {
242        skip_assert_initialized!();
243        unsafe { std::mem::transmute(v) }
244    }
245}
246
247#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
248#[repr(i32)]
249pub enum FlowSuccess {
250    CustomSuccess2 = ffi::GST_FLOW_CUSTOM_SUCCESS_2,
251    CustomSuccess1 = ffi::GST_FLOW_CUSTOM_SUCCESS_1,
252    CustomSuccess = ffi::GST_FLOW_CUSTOM_SUCCESS,
253    Ok = ffi::GST_FLOW_OK,
254}
255
256#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)]
257#[must_use]
258#[repr(i32)]
259pub enum FlowError {
260    #[error("Pad is not linked")]
261    NotLinked = ffi::GST_FLOW_NOT_LINKED,
262    #[error("Pad is flushing")]
263    Flushing = ffi::GST_FLOW_FLUSHING,
264    #[error("Pad is EOS")]
265    Eos = ffi::GST_FLOW_EOS,
266    #[error("Pad is not negotiated")]
267    NotNegotiated = ffi::GST_FLOW_NOT_NEGOTIATED,
268    #[error("Some (fatal) error occurred. Element generating this error should post an error message with more details")]
269    Error = ffi::GST_FLOW_ERROR,
270    #[error("This operation is not supported")]
271    NotSupported = ffi::GST_FLOW_NOT_SUPPORTED,
272    #[error("Elements can use values starting from this (and lower) to define custom error codes")]
273    CustomError = ffi::GST_FLOW_CUSTOM_ERROR,
274    #[error("Pre-defined custom error code")]
275    CustomError1 = ffi::GST_FLOW_CUSTOM_ERROR_1,
276    #[error("Pre-defined custom error code")]
277    CustomError2 = ffi::GST_FLOW_CUSTOM_ERROR_2,
278}
279
280impl_return_result_traits!(GstFlowReturn, FlowReturn, FlowSuccess, FlowError);
281
282#[must_use]
283#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
284#[repr(i32)]
285#[doc(alias = "GstPadLinkReturn")]
286pub enum PadLinkReturn {
287    #[doc(alias = "GST_PAD_LINK_OK")]
288    Ok = ffi::GST_PAD_LINK_OK,
289    #[doc(alias = "GST_PAD_LINK_WRONG_HIERARCHY")]
290    WrongHierarchy = ffi::GST_PAD_LINK_WRONG_HIERARCHY,
291    #[doc(alias = "GST_PAD_LINK_WAS_LINKED")]
292    WasLinked = ffi::GST_PAD_LINK_WAS_LINKED,
293    #[doc(alias = "GST_PAD_LINK_WRONG_DIRECTION")]
294    WrongDirection = ffi::GST_PAD_LINK_WRONG_DIRECTION,
295    #[doc(alias = "GST_PAD_LINK_NOFORMAT")]
296    Noformat = ffi::GST_PAD_LINK_NOFORMAT,
297    #[doc(alias = "GST_PAD_LINK_NOSCHED")]
298    Nosched = ffi::GST_PAD_LINK_NOSCHED,
299    #[doc(alias = "GST_PAD_LINK_REFUSED")]
300    Refused = ffi::GST_PAD_LINK_REFUSED,
301}
302
303#[doc(hidden)]
304impl IntoGlib for PadLinkReturn {
305    type GlibType = ffi::GstPadLinkReturn;
306
307    #[inline]
308    fn into_glib(self) -> ffi::GstPadLinkReturn {
309        self as ffi::GstPadLinkReturn
310    }
311}
312
313#[doc(hidden)]
314impl FromGlib<ffi::GstPadLinkReturn> for PadLinkReturn {
315    #[inline]
316    unsafe fn from_glib(value: ffi::GstPadLinkReturn) -> Self {
317        skip_assert_initialized!();
318
319        if value >= 0 {
320            PadLinkReturn::Ok
321        } else if value < ffi::GST_PAD_LINK_REFUSED {
322            PadLinkReturn::Refused
323        } else {
324            std::mem::transmute::<i32, PadLinkReturn>(value)
325        }
326    }
327}
328
329impl StaticType for PadLinkReturn {
330    #[inline]
331    fn static_type() -> Type {
332        unsafe { from_glib(ffi::gst_pad_link_return_get_type()) }
333    }
334}
335
336impl glib::value::ValueType for PadLinkReturn {
337    type Type = Self;
338}
339
340unsafe impl<'a> FromValue<'a> for PadLinkReturn {
341    type Checker = glib::value::GenericValueTypeChecker<Self>;
342
343    #[inline]
344    unsafe fn from_value(value: &'a glib::Value) -> Self {
345        skip_assert_initialized!();
346        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
347    }
348}
349
350impl ToValue for PadLinkReturn {
351    #[inline]
352    fn to_value(&self) -> glib::Value {
353        let mut value = glib::Value::for_value_type::<Self>();
354        unsafe {
355            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
356        }
357        value
358    }
359
360    #[inline]
361    fn value_type(&self) -> glib::Type {
362        Self::static_type()
363    }
364}
365
366impl From<PadLinkReturn> for glib::Value {
367    #[inline]
368    fn from(v: PadLinkReturn) -> Self {
369        skip_assert_initialized!();
370        ToValue::to_value(&v)
371    }
372}
373
374impl PadLinkReturn {
375    #[inline]
376    pub fn into_result(self) -> Result<PadLinkSuccess, PadLinkError> {
377        if self == PadLinkReturn::Ok {
378            Ok(PadLinkSuccess)
379        } else {
380            Err(unsafe { std::mem::transmute::<PadLinkReturn, PadLinkError>(self) })
381        }
382    }
383
384    #[inline]
385    pub fn from_error(v: PadLinkError) -> Self {
386        skip_assert_initialized!();
387        unsafe { std::mem::transmute(v) }
388    }
389
390    #[inline]
391    pub fn from_ok(_: PadLinkSuccess) -> Self {
392        skip_assert_initialized!();
393        PadLinkReturn::Ok
394    }
395}
396
397#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
398pub struct PadLinkSuccess;
399
400#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)]
401#[must_use]
402#[repr(i32)]
403pub enum PadLinkError {
404    #[error("Pads have no common grandparent")]
405    WrongHierarchy = ffi::GST_PAD_LINK_WRONG_HIERARCHY,
406    #[error("Pad was already linked")]
407    WasLinked = ffi::GST_PAD_LINK_WAS_LINKED,
408    #[error("Pads have wrong direction")]
409    WrongDirection = ffi::GST_PAD_LINK_WRONG_DIRECTION,
410    #[error("Pads do not have common format")]
411    Noformat = ffi::GST_PAD_LINK_NOFORMAT,
412    #[error("Pads cannot cooperate in scheduling")]
413    Nosched = ffi::GST_PAD_LINK_NOSCHED,
414    #[error("Refused for some other reason")]
415    Refused = ffi::GST_PAD_LINK_REFUSED,
416}
417
418impl_return_result_traits!(
419    GstPadLinkReturn,
420    PadLinkReturn,
421    PadLinkSuccess,
422    PadLinkError
423);
424
425impl ClockReturn {
426    #[inline]
427    pub fn into_result(self) -> Result<ClockSuccess, ClockError> {
428        match self {
429            ClockReturn::Ok => Ok(ClockSuccess::Ok),
430            ClockReturn::Done => Ok(ClockSuccess::Done),
431            _ => Err(unsafe { std::mem::transmute::<ClockReturn, ClockError>(self) }),
432        }
433    }
434
435    #[inline]
436    pub fn from_error(v: ClockError) -> Self {
437        skip_assert_initialized!();
438        unsafe { std::mem::transmute(v) }
439    }
440
441    #[inline]
442    pub fn from_ok(v: ClockSuccess) -> Self {
443        skip_assert_initialized!();
444        unsafe { std::mem::transmute(v) }
445    }
446}
447
448#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
449#[repr(i32)]
450pub enum ClockSuccess {
451    Ok = ffi::GST_CLOCK_OK,
452    Done = ffi::GST_CLOCK_DONE,
453}
454
455#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)]
456#[must_use]
457#[repr(i32)]
458pub enum ClockError {
459    #[error("The operation was scheduled too late")]
460    Early = ffi::GST_CLOCK_EARLY,
461    #[error("The clockID was unscheduled")]
462    Unscheduled = ffi::GST_CLOCK_UNSCHEDULED,
463    #[error("The ClockID is busy")]
464    Busy = ffi::GST_CLOCK_BUSY,
465    #[error("A bad time was provided to a function")]
466    Badtime = ffi::GST_CLOCK_BADTIME,
467    #[error("An error occurred")]
468    Error = ffi::GST_CLOCK_ERROR,
469    #[error("Operation is not supported")]
470    Unsupported = ffi::GST_CLOCK_UNSUPPORTED,
471}
472
473impl_return_result_traits!(GstClockReturn, ClockReturn, ClockSuccess, ClockError);
474
475impl PartialEq for crate::TypeFindProbability {
476    #[inline]
477    fn eq(&self, other: &crate::TypeFindProbability) -> bool {
478        (self.into_glib() as u32).eq(&(other.into_glib() as u32))
479    }
480}
481
482impl Eq for crate::TypeFindProbability {}
483
484impl PartialOrd for crate::TypeFindProbability {
485    #[inline]
486    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
487        Some(self.cmp(other))
488    }
489}
490
491impl Ord for crate::TypeFindProbability {
492    #[inline]
493    fn cmp(&self, other: &Self) -> cmp::Ordering {
494        (self.into_glib() as u32).cmp(&(other.into_glib() as u32))
495    }
496}
497
498impl ops::Add<u32> for crate::TypeFindProbability {
499    type Output = crate::TypeFindProbability;
500
501    #[inline]
502    fn add(self, rhs: u32) -> crate::TypeFindProbability {
503        let res = (self.into_glib() as u32).saturating_add(rhs);
504        unsafe { from_glib(res as i32) }
505    }
506}
507
508impl ops::AddAssign<u32> for crate::TypeFindProbability {
509    #[inline]
510    fn add_assign(&mut self, rhs: u32) {
511        let res = (self.into_glib() as u32).saturating_add(rhs);
512        *self = unsafe { from_glib(res as i32) };
513    }
514}
515
516impl ops::Sub<u32> for crate::TypeFindProbability {
517    type Output = crate::TypeFindProbability;
518
519    #[inline]
520    fn sub(self, rhs: u32) -> crate::TypeFindProbability {
521        let res = (self.into_glib() as u32).saturating_sub(rhs);
522        unsafe { from_glib(res as i32) }
523    }
524}
525
526impl ops::SubAssign<u32> for crate::TypeFindProbability {
527    #[inline]
528    fn sub_assign(&mut self, rhs: u32) {
529        let res = (self.into_glib() as u32).saturating_sub(rhs);
530        *self = unsafe { from_glib(res as i32) };
531    }
532}
533
534#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Error)]
535#[must_use]
536pub enum TagError {
537    #[error("The value type doesn't match with the specified Tag")]
538    TypeMismatch,
539}
540
541// This cannot be done automatically because in GStreamer it's exposed as a bitflag but works as an
542// enum instead
543#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
544#[doc(alias = "GstMessageType")]
545#[non_exhaustive]
546pub enum MessageType {
547    #[doc(alias = "GST_MESSAGE_UNKNOWN")]
548    Unknown,
549    #[doc(alias = "GST_MESSAGE_EOS")]
550    Eos,
551    #[doc(alias = "GST_MESSAGE_ERROR")]
552    Error,
553    #[doc(alias = "GST_MESSAGE_WARNING")]
554    Warning,
555    #[doc(alias = "GST_MESSAGE_INFO")]
556    Info,
557    #[doc(alias = "GST_MESSAGE_TAG")]
558    Tag,
559    #[doc(alias = "GST_MESSAGE_BUFFERING")]
560    Buffering,
561    #[doc(alias = "GST_MESSAGE_STATE_CHANGED")]
562    StateChanged,
563    #[doc(alias = "GST_MESSAGE_STATE_DIRTY")]
564    StateDirty,
565    #[doc(alias = "GST_MESSAGE_STEP_DONE")]
566    StepDone,
567    #[doc(alias = "GST_MESSAGE_CLOCK_PROVIDE")]
568    ClockProvide,
569    #[doc(alias = "GST_MESSAGE_CLOCK_LOST")]
570    ClockLost,
571    #[doc(alias = "GST_MESSAGE_NEW_CLOCK")]
572    NewClock,
573    #[doc(alias = "GST_MESSAGE_STRUCTURE_CHANGE")]
574    StructureChange,
575    #[doc(alias = "GST_MESSAGE_STREAM_STATUS")]
576    StreamStatus,
577    #[doc(alias = "GST_MESSAGE_APPLICATION")]
578    Application,
579    #[doc(alias = "GST_MESSAGE_ELEMENT")]
580    Element,
581    #[doc(alias = "GST_MESSAGE_SEGMENT_START")]
582    SegmentStart,
583    #[doc(alias = "GST_MESSAGE_SEGMENT_DONE")]
584    SegmentDone,
585    #[doc(alias = "GST_MESSAGE_DURATION_CHANGED")]
586    DurationChanged,
587    #[doc(alias = "GST_MESSAGE_LATENCY")]
588    Latency,
589    #[doc(alias = "GST_MESSAGE_ASYNC_START")]
590    AsyncStart,
591    #[doc(alias = "GST_MESSAGE_ASYNC_DONE")]
592    AsyncDone,
593    #[doc(alias = "GST_MESSAGE_REQUEST_STATE")]
594    RequestState,
595    #[doc(alias = "GST_MESSAGE_STEP_START")]
596    StepStart,
597    #[doc(alias = "GST_MESSAGE_QOS")]
598    Qos,
599    #[doc(alias = "GST_MESSAGE_PROGRESS")]
600    Progress,
601    #[doc(alias = "GST_MESSAGE_TOC")]
602    Toc,
603    #[doc(alias = "GST_MESSAGE_RESET_TIME")]
604    ResetTime,
605    #[doc(alias = "GST_MESSAGE_STREAM_START")]
606    StreamStart,
607    #[doc(alias = "GST_MESSAGE_NEED_CONTEXT")]
608    NeedContext,
609    #[doc(alias = "GST_MESSAGE_HAVE_CONTEXT")]
610    HaveContext,
611    #[doc(alias = "GST_MESSAGE_EXTENDED")]
612    Extended,
613    #[doc(alias = "GST_MESSAGE_DEVICE_ADDED")]
614    DeviceAdded,
615    #[doc(alias = "GST_MESSAGE_DEVICE_REMOVED")]
616    DeviceRemoved,
617    #[doc(alias = "GST_MESSAGE_PROPERTY_NOTIFY")]
618    PropertyNotify,
619    #[doc(alias = "GST_MESSAGE_STREAM_COLLECTION")]
620    StreamCollection,
621    #[doc(alias = "GST_MESSAGE_STREAMS_SELECTED")]
622    StreamsSelected,
623    #[doc(alias = "GST_MESSAGE_REDIRECT")]
624    Redirect,
625    #[doc(hidden)]
626    __Unknown(i32),
627}
628
629#[doc(hidden)]
630impl IntoGlib for MessageType {
631    type GlibType = ffi::GstMessageType;
632
633    fn into_glib(self) -> ffi::GstMessageType {
634        match self {
635            MessageType::Unknown => ffi::GST_MESSAGE_UNKNOWN,
636            MessageType::Eos => ffi::GST_MESSAGE_EOS,
637            MessageType::Error => ffi::GST_MESSAGE_ERROR,
638            MessageType::Warning => ffi::GST_MESSAGE_WARNING,
639            MessageType::Info => ffi::GST_MESSAGE_INFO,
640            MessageType::Tag => ffi::GST_MESSAGE_TAG,
641            MessageType::Buffering => ffi::GST_MESSAGE_BUFFERING,
642            MessageType::StateChanged => ffi::GST_MESSAGE_STATE_CHANGED,
643            MessageType::StateDirty => ffi::GST_MESSAGE_STATE_DIRTY,
644            MessageType::StepDone => ffi::GST_MESSAGE_STEP_DONE,
645            MessageType::ClockProvide => ffi::GST_MESSAGE_CLOCK_PROVIDE,
646            MessageType::ClockLost => ffi::GST_MESSAGE_CLOCK_LOST,
647            MessageType::NewClock => ffi::GST_MESSAGE_NEW_CLOCK,
648            MessageType::StructureChange => ffi::GST_MESSAGE_STRUCTURE_CHANGE,
649            MessageType::StreamStatus => ffi::GST_MESSAGE_STREAM_STATUS,
650            MessageType::Application => ffi::GST_MESSAGE_APPLICATION,
651            MessageType::Element => ffi::GST_MESSAGE_ELEMENT,
652            MessageType::SegmentStart => ffi::GST_MESSAGE_SEGMENT_START,
653            MessageType::SegmentDone => ffi::GST_MESSAGE_SEGMENT_DONE,
654            MessageType::DurationChanged => ffi::GST_MESSAGE_DURATION_CHANGED,
655            MessageType::Latency => ffi::GST_MESSAGE_LATENCY,
656            MessageType::AsyncStart => ffi::GST_MESSAGE_ASYNC_START,
657            MessageType::AsyncDone => ffi::GST_MESSAGE_ASYNC_DONE,
658            MessageType::RequestState => ffi::GST_MESSAGE_REQUEST_STATE,
659            MessageType::StepStart => ffi::GST_MESSAGE_STEP_START,
660            MessageType::Qos => ffi::GST_MESSAGE_QOS,
661            MessageType::Progress => ffi::GST_MESSAGE_PROGRESS,
662            MessageType::Toc => ffi::GST_MESSAGE_TOC,
663            MessageType::ResetTime => ffi::GST_MESSAGE_RESET_TIME,
664            MessageType::StreamStart => ffi::GST_MESSAGE_STREAM_START,
665            MessageType::NeedContext => ffi::GST_MESSAGE_NEED_CONTEXT,
666            MessageType::HaveContext => ffi::GST_MESSAGE_HAVE_CONTEXT,
667            MessageType::Extended => ffi::GST_MESSAGE_EXTENDED,
668            MessageType::DeviceAdded => ffi::GST_MESSAGE_DEVICE_ADDED,
669            MessageType::DeviceRemoved => ffi::GST_MESSAGE_DEVICE_REMOVED,
670            MessageType::PropertyNotify => ffi::GST_MESSAGE_PROPERTY_NOTIFY,
671            MessageType::StreamCollection => ffi::GST_MESSAGE_STREAM_COLLECTION,
672            MessageType::StreamsSelected => ffi::GST_MESSAGE_STREAMS_SELECTED,
673            MessageType::Redirect => ffi::GST_MESSAGE_REDIRECT,
674            MessageType::__Unknown(value) => value as u32,
675        }
676    }
677}
678
679#[doc(hidden)]
680impl FromGlib<ffi::GstMessageType> for MessageType {
681    #[allow(clippy::unreadable_literal)]
682    unsafe fn from_glib(value: ffi::GstMessageType) -> Self {
683        skip_assert_initialized!();
684        match value {
685            ffi::GST_MESSAGE_UNKNOWN => MessageType::Unknown,
686            ffi::GST_MESSAGE_EOS => MessageType::Eos,
687            ffi::GST_MESSAGE_ERROR => MessageType::Error,
688            ffi::GST_MESSAGE_WARNING => MessageType::Warning,
689            ffi::GST_MESSAGE_INFO => MessageType::Info,
690            ffi::GST_MESSAGE_TAG => MessageType::Tag,
691            ffi::GST_MESSAGE_BUFFERING => MessageType::Buffering,
692            ffi::GST_MESSAGE_STATE_CHANGED => MessageType::StateChanged,
693            ffi::GST_MESSAGE_STATE_DIRTY => MessageType::StateDirty,
694            ffi::GST_MESSAGE_STEP_DONE => MessageType::StepDone,
695            ffi::GST_MESSAGE_CLOCK_PROVIDE => MessageType::ClockProvide,
696            ffi::GST_MESSAGE_CLOCK_LOST => MessageType::ClockLost,
697            ffi::GST_MESSAGE_NEW_CLOCK => MessageType::NewClock,
698            ffi::GST_MESSAGE_STRUCTURE_CHANGE => MessageType::StructureChange,
699            ffi::GST_MESSAGE_STREAM_STATUS => MessageType::StreamStatus,
700            ffi::GST_MESSAGE_APPLICATION => MessageType::Application,
701            ffi::GST_MESSAGE_ELEMENT => MessageType::Element,
702            ffi::GST_MESSAGE_SEGMENT_START => MessageType::SegmentStart,
703            ffi::GST_MESSAGE_SEGMENT_DONE => MessageType::SegmentDone,
704            ffi::GST_MESSAGE_DURATION_CHANGED => MessageType::DurationChanged,
705            ffi::GST_MESSAGE_LATENCY => MessageType::Latency,
706            ffi::GST_MESSAGE_ASYNC_START => MessageType::AsyncStart,
707            ffi::GST_MESSAGE_ASYNC_DONE => MessageType::AsyncDone,
708            ffi::GST_MESSAGE_REQUEST_STATE => MessageType::RequestState,
709            ffi::GST_MESSAGE_STEP_START => MessageType::StepStart,
710            ffi::GST_MESSAGE_QOS => MessageType::Qos,
711            ffi::GST_MESSAGE_PROGRESS => MessageType::Progress,
712            ffi::GST_MESSAGE_TOC => MessageType::Toc,
713            ffi::GST_MESSAGE_RESET_TIME => MessageType::ResetTime,
714            ffi::GST_MESSAGE_STREAM_START => MessageType::StreamStart,
715            ffi::GST_MESSAGE_NEED_CONTEXT => MessageType::NeedContext,
716            ffi::GST_MESSAGE_HAVE_CONTEXT => MessageType::HaveContext,
717            ffi::GST_MESSAGE_EXTENDED => MessageType::Extended,
718            ffi::GST_MESSAGE_DEVICE_ADDED => MessageType::DeviceAdded,
719            ffi::GST_MESSAGE_DEVICE_REMOVED => MessageType::DeviceRemoved,
720            ffi::GST_MESSAGE_PROPERTY_NOTIFY => MessageType::PropertyNotify,
721            ffi::GST_MESSAGE_STREAM_COLLECTION => MessageType::StreamCollection,
722            ffi::GST_MESSAGE_STREAMS_SELECTED => MessageType::StreamsSelected,
723            ffi::GST_MESSAGE_REDIRECT => MessageType::Redirect,
724            value => MessageType::__Unknown(value as i32),
725        }
726    }
727}
728
729impl StaticType for MessageType {
730    #[inline]
731    fn static_type() -> Type {
732        unsafe { from_glib(ffi::gst_message_type_get_type()) }
733    }
734}
735
736impl glib::value::ValueType for MessageType {
737    type Type = Self;
738}
739
740unsafe impl FromValue<'_> for MessageType {
741    type Checker = glib::value::GenericValueTypeChecker<Self>;
742
743    #[inline]
744    unsafe fn from_value(value: &glib::Value) -> Self {
745        skip_assert_initialized!();
746        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0) as ffi::GstMessageType)
747    }
748}
749
750impl ToValue for MessageType {
751    #[inline]
752    fn to_value(&self) -> Value {
753        let mut value = glib::Value::for_value_type::<Self>();
754        unsafe {
755            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib() as i32)
756        }
757        value
758    }
759
760    #[inline]
761    fn value_type(&self) -> Type {
762        Self::static_type()
763    }
764}
765
766impl From<MessageType> for glib::Value {
767    #[inline]
768    fn from(v: MessageType) -> glib::Value {
769        skip_assert_initialized!();
770        ToValue::to_value(&v)
771    }
772}
773
774impl State {
775    #[must_use]
776    #[inline]
777    pub fn next(self, pending: Self) -> Self {
778        let current = self.into_glib();
779        let pending = pending.into_glib();
780
781        let sign = (pending - current).signum();
782
783        unsafe { from_glib(current + sign) }
784    }
785}
786
787impl StateChange {
788    #[inline]
789    pub fn new(current: State, next: State) -> Self {
790        skip_assert_initialized!();
791        let current = current.into_glib();
792        let next = next.into_glib();
793        unsafe { from_glib((current << 3) | next) }
794    }
795
796    #[inline]
797    pub fn current(self) -> State {
798        unsafe { from_glib(self.into_glib() >> 3) }
799    }
800
801    #[inline]
802    pub fn next(self) -> State {
803        unsafe { from_glib(self.into_glib() & 0x7) }
804    }
805}
gstreamer/enums.rs

gstreamer/
enums.rs
