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