1use std::{borrow::Borrow, ffi::CStr, fmt, mem, num::NonZeroU32, ops::Deref, ops::DerefMut, ptr};
4
5use glib::{
6 translate::*,
7 value::{SendValue, ValueType},
8};
9use smallvec::SmallVec;
10
11use crate::{
12 ffi,
13 format::{CompatibleFormattedValue, FormattedValue},
14 prelude::*,
15 structure::*,
16 GenericFormattedValue, GroupId, MessageType, Object, Seqnum, TagList,
17};
18
19mini_object_wrapper!(Message, MessageRef, ffi::GstMessage, || {
20 ffi::gst_message_get_type()
21});
22
23impl MessageRef {
24 #[doc(alias = "get_src")]
25 #[inline]
26 pub fn src(&self) -> Option<&Object> {
27 unsafe {
28 if (*self.as_ptr()).src.is_null() {
29 None
30 } else {
31 Some(Object::from_glib_ptr_borrow(&(*self.as_ptr()).src))
32 }
33 }
34 }
35
36 #[doc(alias = "get_seqnum")]
37 #[doc(alias = "gst_message_get_seqnum")]
38 pub fn seqnum(&self) -> Seqnum {
39 unsafe {
40 let seqnum = ffi::gst_message_get_seqnum(self.as_mut_ptr());
41
42 if seqnum == 0 {
43 let next = Seqnum::next();
47
48 crate::warning!(
49 crate::CAT_RUST,
50 "get_seqnum detected invalid seqnum, returning next {:?}",
51 next
52 );
53
54 return next;
55 }
56
57 Seqnum(NonZeroU32::new_unchecked(seqnum))
58 }
59 }
60
61 #[doc(alias = "gst_message_set_seqnum")]
62 pub fn set_seqnum(&self, seqnum: Seqnum) {
63 unsafe {
64 ffi::gst_message_set_seqnum(self.as_mut_ptr(), seqnum.0.get());
65 }
66 }
67
68 #[doc(alias = "get_structure")]
69 #[doc(alias = "gst_message_get_structure")]
70 #[inline]
71 pub fn structure(&self) -> Option<&StructureRef> {
72 unsafe {
73 let structure = ffi::gst_message_get_structure(self.as_mut_ptr());
74 if structure.is_null() {
75 None
76 } else {
77 Some(StructureRef::from_glib_borrow(structure))
78 }
79 }
80 }
81
82 #[doc(alias = "gst_message_writable_structure")]
83 #[inline]
84 pub fn structure_mut(&mut self) -> &mut StructureRef {
85 unsafe {
86 StructureRef::from_glib_borrow_mut(ffi::gst_message_writable_structure(
87 self.as_mut_ptr(),
88 ))
89 }
90 }
91
92 #[cfg(feature = "v1_26")]
93 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
94 #[doc(alias = "gst_message_writable_details")]
95 #[inline]
96 pub fn details(&self) -> Option<&StructureRef> {
97 unsafe {
98 let structure = ffi::gst_message_writable_details(self.as_mut_ptr());
99 if structure.is_null() {
100 None
101 } else {
102 Some(StructureRef::from_glib_borrow(structure))
103 }
104 }
105 }
106
107 #[cfg(feature = "v1_26")]
108 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
109 #[doc(alias = "gst_message_writable_details")]
110 #[inline]
111 pub fn details_mut(&mut self) -> &mut StructureRef {
112 unsafe {
113 StructureRef::from_glib_borrow_mut(ffi::gst_message_writable_details(self.as_mut_ptr()))
114 }
115 }
116
117 #[cfg(feature = "v1_26")]
118 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
119 #[doc(alias = "gst_message_set_details")]
120 #[inline]
121 pub fn set_details(&mut self, structure: Structure) {
122 unsafe {
123 ffi::gst_message_set_details(self.as_mut_ptr(), structure.into_glib_ptr());
124 }
125 }
126
127 #[doc(alias = "gst_message_has_name")]
128 #[inline]
129 pub fn has_name(&self, name: &str) -> bool {
130 self.structure().is_some_and(|s| s.has_name(name))
131 }
132
133 pub fn view(&self) -> MessageView<'_> {
134 unsafe {
135 let type_ = (*self.as_ptr()).type_;
136
137 match type_ {
138 ffi::GST_MESSAGE_EOS => Eos::view(self),
139 ffi::GST_MESSAGE_ERROR => Error::view(self),
140 ffi::GST_MESSAGE_WARNING => Warning::view(self),
141 ffi::GST_MESSAGE_INFO => Info::view(self),
142 ffi::GST_MESSAGE_TAG => Tag::view(self),
143 ffi::GST_MESSAGE_BUFFERING => Buffering::view(self),
144 ffi::GST_MESSAGE_STATE_CHANGED => StateChanged::view(self),
145 ffi::GST_MESSAGE_STATE_DIRTY => StateDirty::view(self),
146 ffi::GST_MESSAGE_STEP_DONE => StepDone::view(self),
147 ffi::GST_MESSAGE_CLOCK_PROVIDE => ClockProvide::view(self),
148 ffi::GST_MESSAGE_CLOCK_LOST => ClockLost::view(self),
149 ffi::GST_MESSAGE_NEW_CLOCK => NewClock::view(self),
150 ffi::GST_MESSAGE_STRUCTURE_CHANGE => StructureChange::view(self),
151 ffi::GST_MESSAGE_STREAM_STATUS => StreamStatus::view(self),
152 ffi::GST_MESSAGE_APPLICATION => Application::view(self),
153 ffi::GST_MESSAGE_ELEMENT => Element::view(self),
154 ffi::GST_MESSAGE_SEGMENT_START => SegmentStart::view(self),
155 ffi::GST_MESSAGE_SEGMENT_DONE => SegmentDone::view(self),
156 ffi::GST_MESSAGE_DURATION_CHANGED => DurationChanged::view(self),
157 ffi::GST_MESSAGE_LATENCY => Latency::view(self),
158 ffi::GST_MESSAGE_ASYNC_START => AsyncStart::view(self),
159 ffi::GST_MESSAGE_ASYNC_DONE => AsyncDone::view(self),
160 ffi::GST_MESSAGE_REQUEST_STATE => RequestState::view(self),
161 ffi::GST_MESSAGE_STEP_START => StepStart::view(self),
162 ffi::GST_MESSAGE_QOS => Qos::view(self),
163 ffi::GST_MESSAGE_PROGRESS => Progress::view(self),
164 ffi::GST_MESSAGE_TOC => Toc::view(self),
165 ffi::GST_MESSAGE_RESET_TIME => ResetTime::view(self),
166 ffi::GST_MESSAGE_STREAM_START => StreamStart::view(self),
167 ffi::GST_MESSAGE_NEED_CONTEXT => NeedContext::view(self),
168 ffi::GST_MESSAGE_HAVE_CONTEXT => HaveContext::view(self),
169 ffi::GST_MESSAGE_DEVICE_ADDED => DeviceAdded::view(self),
170 ffi::GST_MESSAGE_DEVICE_REMOVED => DeviceRemoved::view(self),
171 ffi::GST_MESSAGE_REDIRECT => Redirect::view(self),
172 ffi::GST_MESSAGE_PROPERTY_NOTIFY => PropertyNotify::view(self),
173 ffi::GST_MESSAGE_STREAM_COLLECTION => StreamCollection::view(self),
174 ffi::GST_MESSAGE_STREAMS_SELECTED => StreamsSelected::view(self),
175 #[cfg(feature = "v1_16")]
176 ffi::GST_MESSAGE_DEVICE_CHANGED => DeviceChanged::view(self),
177 #[cfg(feature = "v1_18")]
178 ffi::GST_MESSAGE_INSTANT_RATE_REQUEST => InstantRateRequest::view(self),
179 _ => MessageView::Other,
180 }
181 }
182 }
183
184 pub fn view_mut(&mut self) -> MessageViewMut<'_> {
185 unsafe {
186 let type_ = (*self.as_ptr()).type_;
187
188 match type_ {
189 ffi::GST_MESSAGE_EOS => Eos::view_mut(self),
190 ffi::GST_MESSAGE_ERROR => Error::view_mut(self),
191 ffi::GST_MESSAGE_WARNING => Warning::view_mut(self),
192 ffi::GST_MESSAGE_INFO => Info::view_mut(self),
193 ffi::GST_MESSAGE_TAG => Tag::view_mut(self),
194 ffi::GST_MESSAGE_BUFFERING => Buffering::view_mut(self),
195 ffi::GST_MESSAGE_STATE_CHANGED => StateChanged::view_mut(self),
196 ffi::GST_MESSAGE_STATE_DIRTY => StateDirty::view_mut(self),
197 ffi::GST_MESSAGE_STEP_DONE => StepDone::view_mut(self),
198 ffi::GST_MESSAGE_CLOCK_PROVIDE => ClockProvide::view_mut(self),
199 ffi::GST_MESSAGE_CLOCK_LOST => ClockLost::view_mut(self),
200 ffi::GST_MESSAGE_NEW_CLOCK => NewClock::view_mut(self),
201 ffi::GST_MESSAGE_STRUCTURE_CHANGE => StructureChange::view_mut(self),
202 ffi::GST_MESSAGE_STREAM_STATUS => StreamStatus::view_mut(self),
203 ffi::GST_MESSAGE_APPLICATION => Application::view_mut(self),
204 ffi::GST_MESSAGE_ELEMENT => Element::view_mut(self),
205 ffi::GST_MESSAGE_SEGMENT_START => SegmentStart::view_mut(self),
206 ffi::GST_MESSAGE_SEGMENT_DONE => SegmentDone::view_mut(self),
207 ffi::GST_MESSAGE_DURATION_CHANGED => DurationChanged::view_mut(self),
208 ffi::GST_MESSAGE_LATENCY => Latency::view_mut(self),
209 ffi::GST_MESSAGE_ASYNC_START => AsyncStart::view_mut(self),
210 ffi::GST_MESSAGE_ASYNC_DONE => AsyncDone::view_mut(self),
211 ffi::GST_MESSAGE_REQUEST_STATE => RequestState::view_mut(self),
212 ffi::GST_MESSAGE_STEP_START => StepStart::view_mut(self),
213 ffi::GST_MESSAGE_QOS => Qos::view_mut(self),
214 ffi::GST_MESSAGE_PROGRESS => Progress::view_mut(self),
215 ffi::GST_MESSAGE_TOC => Toc::view_mut(self),
216 ffi::GST_MESSAGE_RESET_TIME => ResetTime::view_mut(self),
217 ffi::GST_MESSAGE_STREAM_START => StreamStart::view_mut(self),
218 ffi::GST_MESSAGE_NEED_CONTEXT => NeedContext::view_mut(self),
219 ffi::GST_MESSAGE_HAVE_CONTEXT => HaveContext::view_mut(self),
220 ffi::GST_MESSAGE_DEVICE_ADDED => DeviceAdded::view_mut(self),
221 ffi::GST_MESSAGE_DEVICE_REMOVED => DeviceRemoved::view_mut(self),
222 ffi::GST_MESSAGE_REDIRECT => Redirect::view_mut(self),
223 ffi::GST_MESSAGE_PROPERTY_NOTIFY => PropertyNotify::view_mut(self),
224 ffi::GST_MESSAGE_STREAM_COLLECTION => StreamCollection::view_mut(self),
225 ffi::GST_MESSAGE_STREAMS_SELECTED => StreamsSelected::view_mut(self),
226 #[cfg(feature = "v1_16")]
227 ffi::GST_MESSAGE_DEVICE_CHANGED => DeviceChanged::view_mut(self),
228 #[cfg(feature = "v1_18")]
229 ffi::GST_MESSAGE_INSTANT_RATE_REQUEST => InstantRateRequest::view_mut(self),
230 _ => MessageViewMut::Other,
231 }
232 }
233 }
234
235 #[doc(alias = "get_type")]
236 #[inline]
237 pub fn type_(&self) -> MessageType {
238 unsafe { from_glib((*self.as_ptr()).type_) }
239 }
240}
241
242impl fmt::Debug for Message {
243 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
244 MessageRef::fmt(self, f)
245 }
246}
247
248impl fmt::Debug for MessageRef {
249 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
250 let seqnum = unsafe { ffi::gst_message_get_seqnum(self.as_mut_ptr()) };
256 let seqnum = if seqnum != 0 {
257 &seqnum as &dyn fmt::Debug
258 } else {
259 &"INVALID (0)" as &dyn fmt::Debug
260 };
261
262 f.debug_struct("Message")
263 .field("ptr", &self.as_ptr())
264 .field("type", &unsafe {
265 let type_ = ffi::gst_message_type_get_name((*self.as_ptr()).type_);
266 CStr::from_ptr(type_).to_str().unwrap()
267 })
268 .field("seqnum", seqnum)
269 .field(
270 "src",
271 &self
272 .src()
273 .map(|s| s.name())
274 .as_ref()
275 .map(glib::GString::as_str),
276 )
277 .field("structure", &self.structure())
278 .finish()
279 }
280}
281
282#[derive(Debug)]
283#[non_exhaustive]
284pub enum MessageView<'a> {
285 Eos(&'a Eos),
286 Error(&'a Error),
287 Warning(&'a Warning),
288 Info(&'a Info),
289 Tag(&'a Tag),
290 Buffering(&'a Buffering),
291 StateChanged(&'a StateChanged),
292 StateDirty(&'a StateDirty),
293 StepDone(&'a StepDone),
294 ClockProvide(&'a ClockProvide),
295 ClockLost(&'a ClockLost),
296 NewClock(&'a NewClock),
297 StructureChange(&'a StructureChange),
298 StreamStatus(&'a StreamStatus),
299 Application(&'a Application),
300 Element(&'a Element),
301 SegmentStart(&'a SegmentStart),
302 SegmentDone(&'a SegmentDone),
303 DurationChanged(&'a DurationChanged),
304 Latency(&'a Latency),
305 AsyncStart(&'a AsyncStart),
306 AsyncDone(&'a AsyncDone),
307 RequestState(&'a RequestState),
308 StepStart(&'a StepStart),
309 Qos(&'a Qos),
310 Progress(&'a Progress),
311 Toc(&'a Toc),
312 ResetTime(&'a ResetTime),
313 StreamStart(&'a StreamStart),
314 NeedContext(&'a NeedContext),
315 HaveContext(&'a HaveContext),
316 DeviceAdded(&'a DeviceAdded),
317 DeviceRemoved(&'a DeviceRemoved),
318 PropertyNotify(&'a PropertyNotify),
319 StreamCollection(&'a StreamCollection),
320 StreamsSelected(&'a StreamsSelected),
321 Redirect(&'a Redirect),
322 #[cfg(feature = "v1_16")]
323 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
324 DeviceChanged(&'a DeviceChanged),
325 #[cfg(feature = "v1_18")]
326 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
327 InstantRateRequest(&'a InstantRateRequest),
328 Other,
329}
330
331#[derive(Debug)]
332#[non_exhaustive]
333pub enum MessageViewMut<'a> {
334 Eos(&'a mut Eos),
335 Error(&'a mut Error),
336 Warning(&'a mut Warning),
337 Info(&'a mut Info),
338 Tag(&'a mut Tag),
339 Buffering(&'a mut Buffering),
340 StateChanged(&'a mut StateChanged),
341 StateDirty(&'a mut StateDirty),
342 StepDone(&'a mut StepDone),
343 ClockProvide(&'a mut ClockProvide),
344 ClockLost(&'a mut ClockLost),
345 NewClock(&'a mut NewClock),
346 StructureChange(&'a mut StructureChange),
347 StreamStatus(&'a mut StreamStatus),
348 Application(&'a mut Application),
349 Element(&'a mut Element),
350 SegmentStart(&'a mut SegmentStart),
351 SegmentDone(&'a mut SegmentDone),
352 DurationChanged(&'a mut DurationChanged),
353 Latency(&'a mut Latency),
354 AsyncStart(&'a mut AsyncStart),
355 AsyncDone(&'a mut AsyncDone),
356 RequestState(&'a mut RequestState),
357 StepStart(&'a mut StepStart),
358 Qos(&'a mut Qos),
359 Progress(&'a mut Progress),
360 Toc(&'a mut Toc),
361 ResetTime(&'a mut ResetTime),
362 StreamStart(&'a mut StreamStart),
363 NeedContext(&'a mut NeedContext),
364 HaveContext(&'a mut HaveContext),
365 DeviceAdded(&'a mut DeviceAdded),
366 DeviceRemoved(&'a mut DeviceRemoved),
367 PropertyNotify(&'a mut PropertyNotify),
368 StreamCollection(&'a mut StreamCollection),
369 StreamsSelected(&'a mut StreamsSelected),
370 Redirect(&'a mut Redirect),
371 #[cfg(feature = "v1_16")]
372 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
373 DeviceChanged(&'a mut DeviceChanged),
374 #[cfg(feature = "v1_18")]
375 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
376 InstantRateRequest(&'a mut InstantRateRequest),
377 Other,
378}
379
380macro_rules! declare_concrete_message(
381 ($name:ident, $param:ident) => {
382 #[repr(transparent)]
383 pub struct $name<$param = MessageRef>($param);
384
385 impl $name {
386 #[inline]
387 pub fn message(&self) -> &MessageRef {
388 unsafe { &*(self as *const Self as *const MessageRef) }
389 }
390
391 #[inline]
392 pub fn message_mut(&mut self) -> &mut MessageRef {
393 unsafe { &mut *(self as *mut Self as *mut MessageRef) }
394 }
395
396 #[inline]
397 unsafe fn view(message: &MessageRef) -> MessageView<'_> {
398 let message = &*(message as *const MessageRef as *const Self);
399 MessageView::$name(message)
400 }
401
402 #[inline]
403 unsafe fn view_mut(message: &mut MessageRef) -> MessageViewMut<'_> {
404 let message = &mut *(message as *mut MessageRef as *mut Self);
405 MessageViewMut::$name(message)
406 }
407 }
408
409 impl Deref for $name {
410 type Target = MessageRef;
411
412 #[inline]
413 fn deref(&self) -> &Self::Target {
414 unsafe {
415 &*(self as *const Self as *const Self::Target)
416 }
417 }
418 }
419
420 impl DerefMut for $name {
421 #[inline]
422 fn deref_mut(&mut self) -> &mut Self::Target {
423 self.message_mut()
424 }
425 }
426
427 impl ToOwned for $name {
428 type Owned = $name<Message>;
429
430 #[inline]
431 fn to_owned(&self) -> Self::Owned {
432 $name::<Message>(self.copy())
433 }
434 }
435
436 impl $name<Message> {
437 #[inline]
438 pub fn get_mut(&mut self) -> Option<&mut $name> {
439 self.0.get_mut().map(|message| unsafe {
440 &mut *(message as *mut MessageRef as *mut $name)
441 })
442 }
443 }
444
445 impl Deref for $name<Message> {
446 type Target = $name;
447
448 #[inline]
449 fn deref(&self) -> &Self::Target {
450 unsafe { &*(self.0.as_ptr() as *const Self::Target) }
451 }
452 }
453
454 impl DerefMut for $name<Message> {
455 #[inline]
456 fn deref_mut(&mut self) -> &mut Self::Target {
457 debug_assert!(self.0.is_writable());
458 unsafe { &mut *(self.0.as_mut_ptr() as *mut Self::Target) }
459 }
460 }
461
462 impl Borrow<$name> for $name<Message> {
463 #[inline]
464 fn borrow(&self) -> &$name {
465 &*self
466 }
467 }
468
469 impl From<$name<Message>> for Message {
470 #[inline]
471 fn from(concrete: $name<Message>) -> Self {
472 skip_assert_initialized!();
473 concrete.0
474 }
475 }
476 }
477);
478
479declare_concrete_message!(Eos, T);
480impl Eos {
481 #[doc(alias = "gst_message_new_eos")]
482 #[allow(clippy::new_ret_no_self)]
483 pub fn new() -> Message {
484 skip_assert_initialized!();
485 Self::builder().build()
486 }
487
488 pub fn builder<'a>() -> EosBuilder<'a> {
489 assert_initialized_main_thread!();
490 EosBuilder::new()
491 }
492}
493
494impl std::fmt::Debug for Eos {
495 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
496 f.debug_struct("Eos")
497 .field("structure", &self.message().structure())
498 .field("source", &self.src().map(|obj| (obj, obj.name())))
499 .finish()
500 }
501}
502
503impl std::fmt::Debug for Eos<Message> {
504 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
505 Eos::<MessageRef>::fmt(self, f)
506 }
507}
508
509declare_concrete_message!(Error, T);
510impl Error {
511 #[doc(alias = "gst_message_new_error")]
512 #[allow(clippy::new_ret_no_self)]
513 pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
514 skip_assert_initialized!();
515 Self::builder(error, message).build()
516 }
517
518 pub fn builder<T: MessageErrorDomain>(error: T, message: &str) -> ErrorBuilder<'_> {
519 assert_initialized_main_thread!();
520 ErrorBuilder::new(glib::Error::new(error, message))
521 }
522
523 pub fn builder_from_error<'a>(error: glib::Error) -> ErrorBuilder<'a> {
524 assert_initialized_main_thread!();
525
526 assert!([
527 crate::CoreError::domain(),
528 crate::ResourceError::domain(),
529 crate::StreamError::domain(),
530 crate::LibraryError::domain(),
531 ]
532 .contains(&error.domain()));
533 ErrorBuilder::new(error)
534 }
535
536 #[doc(alias = "get_error")]
537 #[doc(alias = "gst_message_parse_error")]
538 pub fn error(&self) -> glib::Error {
539 unsafe {
540 let mut error = ptr::null_mut();
541
542 ffi::gst_message_parse_error(self.as_mut_ptr(), &mut error, ptr::null_mut());
543
544 from_glib_full(error)
545 }
546 }
547
548 #[doc(alias = "get_debug")]
549 #[doc(alias = "gst_message_parse_error")]
550 pub fn debug(&self) -> Option<glib::GString> {
551 unsafe {
552 let mut debug = ptr::null_mut();
553
554 ffi::gst_message_parse_error(self.as_mut_ptr(), ptr::null_mut(), &mut debug);
555
556 from_glib_full(debug)
557 }
558 }
559
560 #[doc(alias = "get_details")]
561 #[doc(alias = "gst_message_parse_error_details")]
562 pub fn details(&self) -> Option<&StructureRef> {
563 unsafe {
564 let mut details = ptr::null();
565
566 ffi::gst_message_parse_error_details(self.as_mut_ptr(), &mut details);
567
568 if details.is_null() {
569 None
570 } else {
571 Some(StructureRef::from_glib_borrow(details))
572 }
573 }
574 }
575
576 #[cfg(feature = "v1_26")]
577 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
578 #[doc(alias = "gst_message_parse_error_writable_details")]
579 pub fn writable_details(&mut self) -> &mut StructureRef {
580 unsafe {
581 let mut details = ptr::null_mut();
582
583 ffi::gst_message_parse_error_writable_details(self.as_mut_ptr(), &mut details);
584
585 StructureRef::from_glib_borrow_mut(details)
586 }
587 }
588}
589
590impl std::fmt::Display for Error {
591 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
592 write!(f, "{}", self.error())
593 }
594}
595
596impl std::fmt::Debug for Error {
597 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
598 f.debug_struct("Error")
599 .field("structure", &self.message().structure())
600 .field("source", &self.src().map(|obj| (obj, obj.name())))
601 .field("error", &self.error())
602 .field("debug", &self.debug())
603 .field("details", &self.details())
604 .finish()
605 }
606}
607
608impl std::fmt::Debug for Error<Message> {
609 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
610 Error::<MessageRef>::fmt(self, f)
611 }
612}
613
614declare_concrete_message!(Warning, T);
615impl Warning {
616 #[doc(alias = "gst_message_new_warning")]
617 #[allow(clippy::new_ret_no_self)]
618 pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
619 skip_assert_initialized!();
620 Self::builder(error, message).build()
621 }
622
623 pub fn builder<T: MessageErrorDomain>(error: T, message: &str) -> WarningBuilder<'_> {
624 assert_initialized_main_thread!();
625 WarningBuilder::new(glib::Error::new(error, message))
626 }
627
628 pub fn builder_from_error<'a>(error: glib::Error) -> WarningBuilder<'a> {
629 assert_initialized_main_thread!();
630
631 assert!([
632 crate::CoreError::domain(),
633 crate::ResourceError::domain(),
634 crate::StreamError::domain(),
635 crate::LibraryError::domain(),
636 ]
637 .contains(&error.domain()));
638 WarningBuilder::new(error)
639 }
640
641 #[doc(alias = "get_error")]
642 #[doc(alias = "gst_message_parse_warning")]
643 pub fn error(&self) -> glib::Error {
644 unsafe {
645 let mut error = ptr::null_mut();
646
647 ffi::gst_message_parse_warning(self.as_mut_ptr(), &mut error, ptr::null_mut());
648
649 from_glib_full(error)
650 }
651 }
652
653 #[doc(alias = "get_debug")]
654 #[doc(alias = "gst_message_parse_warning")]
655 pub fn debug(&self) -> Option<glib::GString> {
656 unsafe {
657 let mut debug = ptr::null_mut();
658
659 ffi::gst_message_parse_warning(self.as_mut_ptr(), ptr::null_mut(), &mut debug);
660
661 from_glib_full(debug)
662 }
663 }
664
665 #[doc(alias = "get_details")]
666 #[doc(alias = "gst_message_parse_warning_details")]
667 pub fn details(&self) -> Option<&StructureRef> {
668 unsafe {
669 let mut details = ptr::null();
670
671 ffi::gst_message_parse_warning_details(self.as_mut_ptr(), &mut details);
672
673 if details.is_null() {
674 None
675 } else {
676 Some(StructureRef::from_glib_borrow(details))
677 }
678 }
679 }
680
681 #[cfg(feature = "v1_26")]
682 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
683 #[doc(alias = "gst_message_parse_warning_writable_details")]
684 pub fn writable_details(&mut self) -> &mut StructureRef {
685 unsafe {
686 let mut details = ptr::null_mut();
687
688 ffi::gst_message_parse_warning_writable_details(self.as_mut_ptr(), &mut details);
689
690 StructureRef::from_glib_borrow_mut(details)
691 }
692 }
693}
694
695impl std::fmt::Display for Warning {
696 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
697 write!(f, "{}", self.error())
698 }
699}
700
701impl std::fmt::Debug for Warning {
702 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
703 f.debug_struct("Warning")
704 .field("structure", &self.message().structure())
705 .field("source", &self.src().map(|obj| (obj, obj.name())))
706 .field("error", &self.error())
707 .field("debug", &self.debug())
708 .field("details", &self.details())
709 .finish()
710 }
711}
712
713impl std::fmt::Debug for Warning<Message> {
714 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
715 Warning::<MessageRef>::fmt(self, f)
716 }
717}
718
719declare_concrete_message!(Info, T);
720impl Info {
721 #[doc(alias = "gst_message_new_info")]
722 #[allow(clippy::new_ret_no_self)]
723 pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
724 skip_assert_initialized!();
725 Self::builder(error, message).build()
726 }
727
728 pub fn builder<T: MessageErrorDomain>(error: T, message: &str) -> InfoBuilder<'_> {
729 assert_initialized_main_thread!();
730 InfoBuilder::new(glib::Error::new(error, message))
731 }
732
733 pub fn builder_from_error<'a>(error: glib::Error) -> InfoBuilder<'a> {
734 assert_initialized_main_thread!();
735
736 assert!([
737 crate::CoreError::domain(),
738 crate::ResourceError::domain(),
739 crate::StreamError::domain(),
740 crate::LibraryError::domain(),
741 ]
742 .contains(&error.domain()));
743 InfoBuilder::new(error)
744 }
745
746 #[doc(alias = "get_error")]
747 #[doc(alias = "gst_message_parse_info")]
748 pub fn error(&self) -> glib::Error {
749 unsafe {
750 let mut error = ptr::null_mut();
751
752 ffi::gst_message_parse_info(self.as_mut_ptr(), &mut error, ptr::null_mut());
753
754 from_glib_full(error)
755 }
756 }
757
758 #[doc(alias = "get_debug")]
759 #[doc(alias = "gst_message_parse_info")]
760 pub fn debug(&self) -> Option<glib::GString> {
761 unsafe {
762 let mut debug = ptr::null_mut();
763
764 ffi::gst_message_parse_info(self.as_mut_ptr(), ptr::null_mut(), &mut debug);
765
766 from_glib_full(debug)
767 }
768 }
769
770 #[doc(alias = "get_details")]
771 #[doc(alias = "gst_message_parse_info_details")]
772 pub fn details(&self) -> Option<&StructureRef> {
773 unsafe {
774 let mut details = ptr::null();
775
776 ffi::gst_message_parse_info_details(self.as_mut_ptr(), &mut details);
777
778 if details.is_null() {
779 None
780 } else {
781 Some(StructureRef::from_glib_borrow(details))
782 }
783 }
784 }
785
786 #[cfg(feature = "v1_26")]
787 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
788 #[doc(alias = "gst_message_parse_info_writable_details")]
789 pub fn writable_details(&mut self) -> &mut StructureRef {
790 unsafe {
791 let mut details = ptr::null_mut();
792
793 ffi::gst_message_parse_info_writable_details(self.as_mut_ptr(), &mut details);
794
795 StructureRef::from_glib_borrow_mut(details)
796 }
797 }
798}
799
800impl std::fmt::Display for Info {
801 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
802 write!(f, "{}", self.error())
803 }
804}
805
806impl std::fmt::Debug for Info {
807 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
808 f.debug_struct("Info")
809 .field("structure", &self.message().structure())
810 .field("source", &self.src().map(|obj| (obj, obj.name())))
811 .field("error", &self.error())
812 .field("debug", &self.debug())
813 .field("details", &self.details())
814 .finish()
815 }
816}
817
818impl std::fmt::Debug for Info<Message> {
819 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
820 Info::<MessageRef>::fmt(self, f)
821 }
822}
823
824declare_concrete_message!(Tag, T);
825impl Tag {
826 #[doc(alias = "gst_message_new_tag")]
827 #[allow(clippy::new_ret_no_self)]
828 pub fn new(tags: TagList) -> Message {
829 skip_assert_initialized!();
830 Self::builder(tags).build()
831 }
832
833 pub fn builder<'a>(tags: TagList) -> TagBuilder<'a> {
834 assert_initialized_main_thread!();
835 TagBuilder::new(tags)
836 }
837
838 #[doc(alias = "get_tags")]
839 #[doc(alias = "gst_message_parse_tag")]
840 pub fn tags(&self) -> TagList {
841 unsafe {
842 let mut tags = ptr::null_mut();
843 ffi::gst_message_parse_tag(self.as_mut_ptr(), &mut tags);
844 from_glib_full(tags)
845 }
846 }
847}
848
849impl std::fmt::Debug for Tag {
850 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
851 f.debug_struct("Tag")
852 .field("structure", &self.message().structure())
853 .field("source", &self.src().map(|obj| (obj, obj.name())))
854 .field("tags", &self.tags())
855 .finish()
856 }
857}
858
859impl std::fmt::Debug for Tag<Message> {
860 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
861 Tag::<MessageRef>::fmt(self, f)
862 }
863}
864
865declare_concrete_message!(Buffering, T);
866impl Buffering {
867 #[doc(alias = "gst_message_new_buffering")]
868 #[allow(clippy::new_ret_no_self)]
869 pub fn new(percent: i32) -> Message {
870 skip_assert_initialized!();
871 Self::builder(percent).build()
872 }
873
874 pub fn builder<'a>(percent: i32) -> BufferingBuilder<'a> {
875 assert_initialized_main_thread!();
876 BufferingBuilder::new(percent)
877 }
878
879 #[doc(alias = "get_percent")]
880 #[doc(alias = "gst_message_parse_buffering")]
881 pub fn percent(&self) -> i32 {
882 unsafe {
883 let mut p = mem::MaybeUninit::uninit();
884 ffi::gst_message_parse_buffering(self.as_mut_ptr(), p.as_mut_ptr());
885 p.assume_init()
886 }
887 }
888
889 #[doc(alias = "get_buffering_stats")]
890 #[doc(alias = "gst_message_parse_buffering_stats")]
891 pub fn buffering_stats(&self) -> (crate::BufferingMode, i32, i32, i64) {
892 unsafe {
893 let mut mode = mem::MaybeUninit::uninit();
894 let mut avg_in = mem::MaybeUninit::uninit();
895 let mut avg_out = mem::MaybeUninit::uninit();
896 let mut buffering_left = mem::MaybeUninit::uninit();
897
898 ffi::gst_message_parse_buffering_stats(
899 self.as_mut_ptr(),
900 mode.as_mut_ptr(),
901 avg_in.as_mut_ptr(),
902 avg_out.as_mut_ptr(),
903 buffering_left.as_mut_ptr(),
904 );
905
906 (
907 from_glib(mode.assume_init()),
908 avg_in.assume_init(),
909 avg_out.assume_init(),
910 buffering_left.assume_init(),
911 )
912 }
913 }
914}
915
916impl std::fmt::Debug for Buffering {
917 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
918 f.debug_struct("Buffering")
919 .field("structure", &self.message().structure())
920 .field("source", &self.src().map(|obj| (obj, obj.name())))
921 .field("percent", &self.percent())
922 .field("buffering-stats", &self.buffering_stats())
923 .finish()
924 }
925}
926
927impl std::fmt::Debug for Buffering<Message> {
928 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
929 Buffering::<MessageRef>::fmt(self, f)
930 }
931}
932
933declare_concrete_message!(StateChanged, T);
934impl StateChanged {
935 #[doc(alias = "gst_message_new_state_changed")]
936 #[allow(clippy::new_ret_no_self)]
937 pub fn new(old: crate::State, new: crate::State, pending: crate::State) -> Message {
938 skip_assert_initialized!();
939 Self::builder(old, new, pending).build()
940 }
941
942 pub fn builder<'a>(
943 old: crate::State,
944 new: crate::State,
945 pending: crate::State,
946 ) -> StateChangedBuilder<'a> {
947 assert_initialized_main_thread!();
948 StateChangedBuilder::new(old, new, pending)
949 }
950
951 #[doc(alias = "get_old")]
952 #[doc(alias = "gst_message_parse_state_changed")]
953 pub fn old(&self) -> crate::State {
954 unsafe {
955 let mut state = mem::MaybeUninit::uninit();
956
957 ffi::gst_message_parse_state_changed(
958 self.as_mut_ptr(),
959 state.as_mut_ptr(),
960 ptr::null_mut(),
961 ptr::null_mut(),
962 );
963
964 from_glib(state.assume_init())
965 }
966 }
967
968 #[doc(alias = "get_current")]
969 #[doc(alias = "gst_message_parse_state_changed")]
970 pub fn current(&self) -> crate::State {
971 unsafe {
972 let mut state = mem::MaybeUninit::uninit();
973
974 ffi::gst_message_parse_state_changed(
975 self.as_mut_ptr(),
976 ptr::null_mut(),
977 state.as_mut_ptr(),
978 ptr::null_mut(),
979 );
980
981 from_glib(state.assume_init())
982 }
983 }
984
985 #[doc(alias = "get_pending")]
986 #[doc(alias = "gst_message_parse_state_changed")]
987 pub fn pending(&self) -> crate::State {
988 unsafe {
989 let mut state = mem::MaybeUninit::uninit();
990
991 ffi::gst_message_parse_state_changed(
992 self.as_mut_ptr(),
993 ptr::null_mut(),
994 ptr::null_mut(),
995 state.as_mut_ptr(),
996 );
997
998 from_glib(state.assume_init())
999 }
1000 }
1001}
1002
1003impl std::fmt::Debug for StateChanged {
1004 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1005 f.debug_struct("StateChanged")
1006 .field("structure", &self.message().structure())
1007 .field("source", &self.src().map(|obj| (obj, obj.name())))
1008 .field("old", &self.old())
1009 .field("current", &self.current())
1010 .field("pending", &self.pending())
1011 .finish()
1012 }
1013}
1014
1015impl std::fmt::Debug for StateChanged<Message> {
1016 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1017 StateChanged::<MessageRef>::fmt(self, f)
1018 }
1019}
1020
1021declare_concrete_message!(StateDirty, T);
1022impl StateDirty {
1023 #[doc(alias = "gst_message_new_state_dirty")]
1024 #[allow(clippy::new_ret_no_self)]
1025 pub fn new() -> Message {
1026 skip_assert_initialized!();
1027 Self::builder().build()
1028 }
1029
1030 pub fn builder<'a>() -> StateDirtyBuilder<'a> {
1031 assert_initialized_main_thread!();
1032 StateDirtyBuilder::new()
1033 }
1034}
1035
1036impl std::fmt::Debug for StateDirty {
1037 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1038 f.debug_struct("StateDirty")
1039 .field("structure", &self.message().structure())
1040 .field("source", &self.src().map(|obj| (obj, obj.name())))
1041 .finish()
1042 }
1043}
1044
1045impl std::fmt::Debug for StateDirty<Message> {
1046 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1047 StateDirty::<MessageRef>::fmt(self, f)
1048 }
1049}
1050
1051declare_concrete_message!(StepDone, T);
1052impl StepDone {
1053 #[doc(alias = "gst_message_new_step_done")]
1054 #[allow(clippy::new_ret_no_self)]
1055 pub fn new(
1056 amount: impl FormattedValue,
1057 rate: f64,
1058 flush: bool,
1059 intermediate: bool,
1060 duration: impl Into<Option<crate::ClockTime>>,
1061 eos: bool,
1062 ) -> Message {
1063 skip_assert_initialized!();
1064 Self::builder(amount, rate, flush, intermediate, duration, eos).build()
1065 }
1066
1067 pub fn builder<'a>(
1068 amount: impl FormattedValue,
1069 rate: f64,
1070 flush: bool,
1071 intermediate: bool,
1072 duration: impl Into<Option<crate::ClockTime>>,
1073 eos: bool,
1074 ) -> StepDoneBuilder<'a> {
1075 assert_initialized_main_thread!();
1076 StepDoneBuilder::new(
1077 amount.into(),
1078 rate,
1079 flush,
1080 intermediate,
1081 duration.into(),
1082 eos,
1083 )
1084 }
1085
1086 #[doc(alias = "gst_message_parse_step_done")]
1087 pub fn get(
1088 &self,
1089 ) -> (
1090 GenericFormattedValue,
1091 f64,
1092 bool,
1093 bool,
1094 Option<crate::ClockTime>,
1095 bool,
1096 ) {
1097 unsafe {
1098 let mut format = mem::MaybeUninit::uninit();
1099 let mut amount = mem::MaybeUninit::uninit();
1100 let mut rate = mem::MaybeUninit::uninit();
1101 let mut flush = mem::MaybeUninit::uninit();
1102 let mut intermediate = mem::MaybeUninit::uninit();
1103 let mut duration = mem::MaybeUninit::uninit();
1104 let mut eos = mem::MaybeUninit::uninit();
1105
1106 ffi::gst_message_parse_step_done(
1107 self.as_mut_ptr(),
1108 format.as_mut_ptr(),
1109 amount.as_mut_ptr(),
1110 rate.as_mut_ptr(),
1111 flush.as_mut_ptr(),
1112 intermediate.as_mut_ptr(),
1113 duration.as_mut_ptr(),
1114 eos.as_mut_ptr(),
1115 );
1116
1117 (
1118 GenericFormattedValue::new(
1119 from_glib(format.assume_init()),
1120 amount.assume_init() as i64,
1121 ),
1122 rate.assume_init(),
1123 from_glib(flush.assume_init()),
1124 from_glib(intermediate.assume_init()),
1125 from_glib(duration.assume_init()),
1126 from_glib(eos.assume_init()),
1127 )
1128 }
1129 }
1130}
1131
1132impl std::fmt::Debug for StepDone {
1133 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1134 let (format, rate, flush, intermediate, duration, eos) = self.get();
1135 f.debug_struct("StepDone")
1136 .field("structure", &self.message().structure())
1137 .field("source", &self.src().map(|obj| (obj, obj.name())))
1138 .field("format", &format)
1139 .field("rate", &rate)
1140 .field("flush", &flush)
1141 .field("intermediate", &intermediate)
1142 .field("duration", &duration)
1143 .field("eos", &eos)
1144 .finish()
1145 }
1146}
1147
1148impl std::fmt::Debug for StepDone<Message> {
1149 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1150 StepDone::<MessageRef>::fmt(self, f)
1151 }
1152}
1153
1154declare_concrete_message!(ClockProvide, T);
1155impl ClockProvide {
1156 #[doc(alias = "gst_message_new_clock_provide")]
1157 #[allow(clippy::new_ret_no_self)]
1158 pub fn new(clock: &crate::Clock, ready: bool) -> Message {
1159 skip_assert_initialized!();
1160 Self::builder(clock, ready).build()
1161 }
1162
1163 pub fn builder(clock: &crate::Clock, ready: bool) -> ClockProvideBuilder<'_> {
1164 assert_initialized_main_thread!();
1165 ClockProvideBuilder::new(clock, ready)
1166 }
1167
1168 #[doc(alias = "get_clock")]
1169 #[doc(alias = "gst_message_parse_clock_provide")]
1170 pub fn clock(&self) -> Option<crate::Clock> {
1171 let mut clock = ptr::null_mut();
1172
1173 unsafe {
1174 ffi::gst_message_parse_clock_provide(self.as_mut_ptr(), &mut clock, ptr::null_mut());
1175
1176 from_glib_none(clock)
1177 }
1178 }
1179
1180 #[doc(alias = "get_ready")]
1181 #[doc(alias = "gst_message_parse_clock_provide")]
1182 pub fn is_ready(&self) -> bool {
1183 unsafe {
1184 let mut ready = mem::MaybeUninit::uninit();
1185
1186 ffi::gst_message_parse_clock_provide(
1187 self.as_mut_ptr(),
1188 ptr::null_mut(),
1189 ready.as_mut_ptr(),
1190 );
1191
1192 from_glib(ready.assume_init())
1193 }
1194 }
1195}
1196
1197impl std::fmt::Debug for ClockProvide {
1198 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1199 f.debug_struct("ClockProvide")
1200 .field("structure", &self.message().structure())
1201 .field("source", &self.src().map(|obj| (obj, obj.name())))
1202 .field("clock", &self.clock())
1203 .field("is-ready", &self.is_ready())
1204 .finish()
1205 }
1206}
1207
1208impl std::fmt::Debug for ClockProvide<Message> {
1209 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1210 ClockProvide::<MessageRef>::fmt(self, f)
1211 }
1212}
1213
1214declare_concrete_message!(ClockLost, T);
1215impl ClockLost {
1216 #[doc(alias = "gst_message_new_clock_lost")]
1217 #[allow(clippy::new_ret_no_self)]
1218 pub fn new(clock: &crate::Clock) -> Message {
1219 skip_assert_initialized!();
1220 Self::builder(clock).build()
1221 }
1222
1223 pub fn builder(clock: &crate::Clock) -> ClockLostBuilder<'_> {
1224 assert_initialized_main_thread!();
1225 ClockLostBuilder::new(clock)
1226 }
1227
1228 #[doc(alias = "get_clock")]
1229 #[doc(alias = "gst_message_parse_clock_lost")]
1230 pub fn clock(&self) -> Option<crate::Clock> {
1231 let mut clock = ptr::null_mut();
1232
1233 unsafe {
1234 ffi::gst_message_parse_clock_lost(self.as_mut_ptr(), &mut clock);
1235
1236 from_glib_none(clock)
1237 }
1238 }
1239}
1240
1241impl std::fmt::Debug for ClockLost {
1242 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1243 f.debug_struct("ClockLost")
1244 .field("structure", &self.message().structure())
1245 .field("source", &self.src().map(|obj| (obj, obj.name())))
1246 .field("clock", &self.clock())
1247 .finish()
1248 }
1249}
1250
1251impl std::fmt::Debug for ClockLost<Message> {
1252 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1253 ClockLost::<MessageRef>::fmt(self, f)
1254 }
1255}
1256
1257declare_concrete_message!(NewClock, T);
1258impl NewClock {
1259 #[doc(alias = "gst_message_new_new_clock")]
1260 #[allow(clippy::new_ret_no_self)]
1261 pub fn new(clock: &crate::Clock) -> Message {
1262 skip_assert_initialized!();
1263 Self::builder(clock).build()
1264 }
1265
1266 pub fn builder(clock: &crate::Clock) -> NewClockBuilder<'_> {
1267 assert_initialized_main_thread!();
1268 NewClockBuilder::new(clock)
1269 }
1270
1271 #[doc(alias = "get_clock")]
1272 #[doc(alias = "gst_message_parse_new_clock")]
1273 pub fn clock(&self) -> Option<crate::Clock> {
1274 let mut clock = ptr::null_mut();
1275
1276 unsafe {
1277 ffi::gst_message_parse_new_clock(self.as_mut_ptr(), &mut clock);
1278
1279 from_glib_none(clock)
1280 }
1281 }
1282}
1283
1284impl std::fmt::Debug for NewClock {
1285 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1286 f.debug_struct("NewClock")
1287 .field("structure", &self.message().structure())
1288 .field("source", &self.src().map(|obj| (obj, obj.name())))
1289 .field("clock", &self.clock())
1290 .finish()
1291 }
1292}
1293
1294impl std::fmt::Debug for NewClock<Message> {
1295 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1296 NewClock::<MessageRef>::fmt(self, f)
1297 }
1298}
1299
1300declare_concrete_message!(StructureChange, T);
1301impl StructureChange {
1302 #[doc(alias = "gst_message_new_structure_change")]
1303 #[allow(clippy::new_ret_no_self)]
1304 pub fn new(type_: crate::StructureChangeType, owner: &crate::Element, busy: bool) -> Message {
1305 skip_assert_initialized!();
1306 Self::builder(type_, owner, busy).build()
1307 }
1308
1309 pub fn builder(
1310 type_: crate::StructureChangeType,
1311 owner: &crate::Element,
1312 busy: bool,
1313 ) -> StructureChangeBuilder<'_> {
1314 assert_initialized_main_thread!();
1315 StructureChangeBuilder::new(type_, owner, busy)
1316 }
1317
1318 #[doc(alias = "gst_message_parse_structure_change")]
1319 pub fn get(&self) -> (crate::StructureChangeType, crate::Element, bool) {
1320 unsafe {
1321 let mut type_ = mem::MaybeUninit::uninit();
1322 let mut owner = ptr::null_mut();
1323 let mut busy = mem::MaybeUninit::uninit();
1324
1325 ffi::gst_message_parse_structure_change(
1326 self.as_mut_ptr(),
1327 type_.as_mut_ptr(),
1328 &mut owner,
1329 busy.as_mut_ptr(),
1330 );
1331
1332 (
1333 from_glib(type_.assume_init()),
1334 from_glib_none(owner),
1335 from_glib(busy.assume_init()),
1336 )
1337 }
1338 }
1339}
1340
1341impl std::fmt::Debug for StructureChange {
1342 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1343 let (type_, owner, busy) = self.get();
1344
1345 f.debug_struct("StructureChange")
1346 .field("structure", &self.message().structure())
1347 .field("source", &self.src().map(|obj| (obj, obj.name())))
1348 .field("type", &type_)
1349 .field("owner", &owner)
1350 .field("busy", &busy)
1351 .finish()
1352 }
1353}
1354
1355impl std::fmt::Debug for StructureChange<Message> {
1356 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1357 StructureChange::<MessageRef>::fmt(self, f)
1358 }
1359}
1360
1361declare_concrete_message!(StreamStatus, T);
1362impl StreamStatus {
1363 #[doc(alias = "gst_message_new_stream_status")]
1364 #[allow(clippy::new_ret_no_self)]
1365 pub fn new(type_: crate::StreamStatusType, owner: &crate::Element) -> Message {
1366 skip_assert_initialized!();
1367 Self::builder(type_, owner).build()
1368 }
1369
1370 pub fn builder(
1371 type_: crate::StreamStatusType,
1372 owner: &crate::Element,
1373 ) -> StreamStatusBuilder<'_> {
1374 assert_initialized_main_thread!();
1375 StreamStatusBuilder::new(type_, owner)
1376 }
1377
1378 #[doc(alias = "gst_message_parse_stream_status")]
1379 pub fn get(&self) -> (crate::StreamStatusType, crate::Element) {
1380 unsafe {
1381 let mut type_ = mem::MaybeUninit::uninit();
1382 let mut owner = ptr::null_mut();
1383
1384 ffi::gst_message_parse_stream_status(self.as_mut_ptr(), type_.as_mut_ptr(), &mut owner);
1385
1386 (from_glib(type_.assume_init()), from_glib_none(owner))
1387 }
1388 }
1389
1390 #[doc(alias = "get_stream_status_object")]
1391 #[doc(alias = "gst_message_get_stream_status_object")]
1392 pub fn stream_status_object(&self) -> Option<glib::Value> {
1393 unsafe {
1394 let value = ffi::gst_message_get_stream_status_object(self.as_mut_ptr());
1395
1396 from_glib_none(value)
1397 }
1398 }
1399}
1400
1401impl std::fmt::Debug for StreamStatus {
1402 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1403 f.debug_struct("StreamStatus")
1404 .field("structure", &self.message().structure())
1405 .field("source", &self.src().map(|obj| (obj, obj.name())))
1406 .field("status", &self.stream_status_object())
1407 .finish()
1408 }
1409}
1410
1411impl std::fmt::Debug for StreamStatus<Message> {
1412 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1413 StreamStatus::<MessageRef>::fmt(self, f)
1414 }
1415}
1416
1417declare_concrete_message!(Application, T);
1418impl Application {
1419 #[doc(alias = "gst_message_new_application")]
1420 #[allow(clippy::new_ret_no_self)]
1421 pub fn new(structure: crate::Structure) -> Message {
1422 skip_assert_initialized!();
1423 Self::builder(structure).build()
1424 }
1425
1426 pub fn builder<'a>(structure: crate::Structure) -> ApplicationBuilder<'a> {
1427 assert_initialized_main_thread!();
1428 ApplicationBuilder::new(structure)
1429 }
1430}
1431
1432impl std::fmt::Debug for Application {
1433 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1434 f.debug_struct("Application")
1435 .field("structure", &self.message().structure())
1436 .field("source", &self.src().map(|obj| (obj, obj.name())))
1437 .finish()
1438 }
1439}
1440
1441impl std::fmt::Debug for Application<Message> {
1442 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1443 Application::<MessageRef>::fmt(self, f)
1444 }
1445}
1446
1447declare_concrete_message!(Element, T);
1448impl Element {
1449 #[doc(alias = "gst_message_new_element")]
1450 #[allow(clippy::new_ret_no_self)]
1451 pub fn new(structure: crate::Structure) -> Message {
1452 skip_assert_initialized!();
1453 Self::builder(structure).build()
1454 }
1455
1456 pub fn builder<'a>(structure: crate::Structure) -> ElementBuilder<'a> {
1457 assert_initialized_main_thread!();
1458 ElementBuilder::new(structure)
1459 }
1460}
1461
1462impl std::fmt::Debug for Element {
1463 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1464 f.debug_struct("Element")
1465 .field("structure", &self.message().structure())
1466 .field("source", &self.src().map(|obj| (obj, obj.name())))
1467 .finish()
1468 }
1469}
1470
1471impl std::fmt::Debug for Element<Message> {
1472 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1473 Element::<MessageRef>::fmt(self, f)
1474 }
1475}
1476
1477declare_concrete_message!(SegmentStart, T);
1478impl SegmentStart {
1479 #[doc(alias = "gst_message_new_segment_start")]
1480 #[allow(clippy::new_ret_no_self)]
1481 pub fn new(position: impl FormattedValue) -> Message {
1482 skip_assert_initialized!();
1483 Self::builder(position).build()
1484 }
1485
1486 pub fn builder<'a>(position: impl FormattedValue) -> SegmentStartBuilder<'a> {
1487 assert_initialized_main_thread!();
1488 SegmentStartBuilder::new(position.into())
1489 }
1490
1491 #[doc(alias = "gst_message_parse_segment_start")]
1492 pub fn get(&self) -> GenericFormattedValue {
1493 unsafe {
1494 let mut format = mem::MaybeUninit::uninit();
1495 let mut position = mem::MaybeUninit::uninit();
1496
1497 ffi::gst_message_parse_segment_start(
1498 self.as_mut_ptr(),
1499 format.as_mut_ptr(),
1500 position.as_mut_ptr(),
1501 );
1502
1503 GenericFormattedValue::new(from_glib(format.assume_init()), position.assume_init())
1504 }
1505 }
1506}
1507
1508impl std::fmt::Debug for SegmentStart {
1509 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1510 f.debug_struct("SegmentStart")
1511 .field("structure", &self.message().structure())
1512 .field("source", &self.src().map(|obj| (obj, obj.name())))
1513 .field("segment", &self.get())
1514 .finish()
1515 }
1516}
1517
1518impl std::fmt::Debug for SegmentStart<Message> {
1519 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1520 SegmentStart::<MessageRef>::fmt(self, f)
1521 }
1522}
1523
1524declare_concrete_message!(SegmentDone, T);
1525impl SegmentDone {
1526 #[doc(alias = "gst_message_new_segment_done")]
1527 #[allow(clippy::new_ret_no_self)]
1528 pub fn new(position: impl FormattedValue) -> Message {
1529 skip_assert_initialized!();
1530 Self::builder(position).build()
1531 }
1532
1533 pub fn builder<'a>(position: impl FormattedValue) -> SegmentDoneBuilder<'a> {
1534 assert_initialized_main_thread!();
1535 SegmentDoneBuilder::new(position.into())
1536 }
1537
1538 #[doc(alias = "gst_message_parse_segment_done")]
1539 pub fn get(&self) -> GenericFormattedValue {
1540 unsafe {
1541 let mut format = mem::MaybeUninit::uninit();
1542 let mut position = mem::MaybeUninit::uninit();
1543
1544 ffi::gst_message_parse_segment_done(
1545 self.as_mut_ptr(),
1546 format.as_mut_ptr(),
1547 position.as_mut_ptr(),
1548 );
1549
1550 GenericFormattedValue::new(from_glib(format.assume_init()), position.assume_init())
1551 }
1552 }
1553}
1554
1555impl std::fmt::Debug for SegmentDone {
1556 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1557 f.debug_struct("SegmentDone")
1558 .field("structure", &self.message().structure())
1559 .field("source", &self.src().map(|obj| (obj, obj.name())))
1560 .field("segment", &self.get())
1561 .finish()
1562 }
1563}
1564
1565impl std::fmt::Debug for SegmentDone<Message> {
1566 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1567 SegmentDone::<MessageRef>::fmt(self, f)
1568 }
1569}
1570
1571declare_concrete_message!(DurationChanged, T);
1572impl DurationChanged {
1573 #[doc(alias = "gst_message_new_duration_changed")]
1574 #[allow(clippy::new_ret_no_self)]
1575 pub fn new() -> Message {
1576 skip_assert_initialized!();
1577 Self::builder().build()
1578 }
1579
1580 pub fn builder<'a>() -> DurationChangedBuilder<'a> {
1581 assert_initialized_main_thread!();
1582 DurationChangedBuilder::new()
1583 }
1584}
1585
1586impl std::fmt::Debug for DurationChanged {
1587 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1588 f.debug_struct("DurationChanged")
1589 .field("structure", &self.message().structure())
1590 .field("source", &self.src().map(|obj| (obj, obj.name())))
1591 .finish()
1592 }
1593}
1594
1595impl std::fmt::Debug for DurationChanged<Message> {
1596 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1597 DurationChanged::<MessageRef>::fmt(self, f)
1598 }
1599}
1600
1601declare_concrete_message!(Latency, T);
1602impl Latency {
1603 #[doc(alias = "gst_message_new_latency")]
1604 #[allow(clippy::new_ret_no_self)]
1605 pub fn new() -> Message {
1606 skip_assert_initialized!();
1607 Self::builder().build()
1608 }
1609
1610 pub fn builder<'a>() -> LatencyBuilder<'a> {
1611 assert_initialized_main_thread!();
1612 LatencyBuilder::new()
1613 }
1614}
1615
1616impl std::fmt::Debug for Latency {
1617 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1618 f.debug_struct("Latency")
1619 .field("structure", &self.message().structure())
1620 .field("source", &self.src().map(|obj| (obj, obj.name())))
1621 .finish()
1622 }
1623}
1624
1625impl std::fmt::Debug for Latency<Message> {
1626 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1627 Latency::<MessageRef>::fmt(self, f)
1628 }
1629}
1630
1631declare_concrete_message!(AsyncStart, T);
1632impl AsyncStart {
1633 #[doc(alias = "gst_message_new_async_start")]
1634 #[allow(clippy::new_ret_no_self)]
1635 pub fn new() -> Message {
1636 skip_assert_initialized!();
1637 Self::builder().build()
1638 }
1639
1640 pub fn builder<'a>() -> AsyncStartBuilder<'a> {
1641 assert_initialized_main_thread!();
1642 AsyncStartBuilder::new()
1643 }
1644}
1645
1646impl std::fmt::Debug for AsyncStart {
1647 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1648 f.debug_struct("AsyncStart")
1649 .field("structure", &self.message().structure())
1650 .field("source", &self.src().map(|obj| (obj, obj.name())))
1651 .finish()
1652 }
1653}
1654
1655impl std::fmt::Debug for AsyncStart<Message> {
1656 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1657 AsyncStart::<MessageRef>::fmt(self, f)
1658 }
1659}
1660
1661declare_concrete_message!(AsyncDone, T);
1662impl AsyncDone {
1663 #[doc(alias = "gst_message_new_async_done")]
1664 #[allow(clippy::new_ret_no_self)]
1665 pub fn new(running_time: impl Into<Option<crate::ClockTime>>) -> Message {
1666 skip_assert_initialized!();
1667 Self::builder().running_time(running_time).build()
1668 }
1669
1670 pub fn builder<'a>() -> AsyncDoneBuilder<'a> {
1671 assert_initialized_main_thread!();
1672 AsyncDoneBuilder::new()
1673 }
1674
1675 #[doc(alias = "get_running_time")]
1676 #[doc(alias = "gst_message_parse_async_done")]
1677 pub fn running_time(&self) -> Option<crate::ClockTime> {
1678 unsafe {
1679 let mut running_time = mem::MaybeUninit::uninit();
1680
1681 ffi::gst_message_parse_async_done(self.as_mut_ptr(), running_time.as_mut_ptr());
1682
1683 from_glib(running_time.assume_init())
1684 }
1685 }
1686}
1687
1688impl std::fmt::Debug for AsyncDone {
1689 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1690 f.debug_struct("AsyncDone")
1691 .field("structure", &self.message().structure())
1692 .field("source", &self.src().map(|obj| (obj, obj.name())))
1693 .field("running-time", &self.running_time())
1694 .finish()
1695 }
1696}
1697
1698impl std::fmt::Debug for AsyncDone<Message> {
1699 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1700 AsyncDone::<MessageRef>::fmt(self, f)
1701 }
1702}
1703
1704declare_concrete_message!(RequestState, T);
1705impl RequestState {
1706 #[doc(alias = "gst_message_new_request_state")]
1707 #[allow(clippy::new_ret_no_self)]
1708 pub fn new(state: crate::State) -> Message {
1709 skip_assert_initialized!();
1710 Self::builder(state).build()
1711 }
1712
1713 pub fn builder<'a>(state: crate::State) -> RequestStateBuilder<'a> {
1714 assert_initialized_main_thread!();
1715 RequestStateBuilder::new(state)
1716 }
1717
1718 #[doc(alias = "get_requested_state")]
1719 #[doc(alias = "gst_message_parse_request_state")]
1720 pub fn requested_state(&self) -> crate::State {
1721 unsafe {
1722 let mut state = mem::MaybeUninit::uninit();
1723
1724 ffi::gst_message_parse_request_state(self.as_mut_ptr(), state.as_mut_ptr());
1725
1726 from_glib(state.assume_init())
1727 }
1728 }
1729}
1730
1731impl std::fmt::Debug for RequestState {
1732 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1733 f.debug_struct("RequestState")
1734 .field("structure", &self.message().structure())
1735 .field("source", &self.src().map(|obj| (obj, obj.name())))
1736 .field("requested-state", &self.requested_state())
1737 .finish()
1738 }
1739}
1740
1741impl std::fmt::Debug for RequestState<Message> {
1742 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1743 RequestState::<MessageRef>::fmt(self, f)
1744 }
1745}
1746
1747declare_concrete_message!(StepStart, T);
1748impl StepStart {
1749 #[doc(alias = "gst_message_new_step_start")]
1750 #[allow(clippy::new_ret_no_self)]
1751 pub fn new(
1752 active: bool,
1753 amount: impl FormattedValue,
1754 rate: f64,
1755 flush: bool,
1756 intermediate: bool,
1757 ) -> Message {
1758 skip_assert_initialized!();
1759 Self::builder(active, amount, rate, flush, intermediate).build()
1760 }
1761
1762 pub fn builder<'a>(
1763 active: bool,
1764 amount: impl FormattedValue,
1765 rate: f64,
1766 flush: bool,
1767 intermediate: bool,
1768 ) -> StepStartBuilder<'a> {
1769 assert_initialized_main_thread!();
1770 StepStartBuilder::new(active, amount.into(), rate, flush, intermediate)
1771 }
1772
1773 #[doc(alias = "gst_message_parse_step_start")]
1774 pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) {
1775 unsafe {
1776 let mut active = mem::MaybeUninit::uninit();
1777 let mut format = mem::MaybeUninit::uninit();
1778 let mut amount = mem::MaybeUninit::uninit();
1779 let mut rate = mem::MaybeUninit::uninit();
1780 let mut flush = mem::MaybeUninit::uninit();
1781 let mut intermediate = mem::MaybeUninit::uninit();
1782
1783 ffi::gst_message_parse_step_start(
1784 self.as_mut_ptr(),
1785 active.as_mut_ptr(),
1786 format.as_mut_ptr(),
1787 amount.as_mut_ptr(),
1788 rate.as_mut_ptr(),
1789 flush.as_mut_ptr(),
1790 intermediate.as_mut_ptr(),
1791 );
1792
1793 (
1794 from_glib(active.assume_init()),
1795 GenericFormattedValue::new(
1796 from_glib(format.assume_init()),
1797 amount.assume_init() as i64,
1798 ),
1799 rate.assume_init(),
1800 from_glib(flush.assume_init()),
1801 from_glib(intermediate.assume_init()),
1802 )
1803 }
1804 }
1805}
1806
1807impl std::fmt::Debug for StepStart {
1808 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1809 let (active, amount, rate, flush, intermediate) = self.get();
1810 f.debug_struct("StepStart")
1811 .field("structure", &self.message().structure())
1812 .field("source", &self.src().map(|obj| (obj, obj.name())))
1813 .field("active", &active)
1814 .field("amount", &amount)
1815 .field("rate", &rate)
1816 .field("flush", &flush)
1817 .field("intermediate", &intermediate)
1818 .finish()
1819 }
1820}
1821
1822impl std::fmt::Debug for StepStart<Message> {
1823 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1824 StepStart::<MessageRef>::fmt(self, f)
1825 }
1826}
1827
1828declare_concrete_message!(Qos, T);
1829impl Qos {
1830 #[doc(alias = "gst_message_new_qos")]
1831 #[allow(clippy::new_ret_no_self)]
1832 pub fn new(
1833 live: bool,
1834 running_time: impl Into<Option<crate::ClockTime>>,
1835 stream_time: impl Into<Option<crate::ClockTime>>,
1836 timestamp: impl Into<Option<crate::ClockTime>>,
1837 duration: impl Into<Option<crate::ClockTime>>,
1838 ) -> Message {
1839 skip_assert_initialized!();
1840 Self::builder(live)
1841 .running_time(running_time)
1842 .stream_time(stream_time)
1843 .timestamp(timestamp)
1844 .duration(duration)
1845 .build()
1846 }
1847
1848 pub fn builder<'a>(live: bool) -> QosBuilder<'a> {
1849 assert_initialized_main_thread!();
1850 QosBuilder::new(live)
1851 }
1852
1853 #[doc(alias = "gst_message_parse_qos")]
1854 pub fn get(
1855 &self,
1856 ) -> (
1857 bool,
1858 Option<crate::ClockTime>,
1859 Option<crate::ClockTime>,
1860 Option<crate::ClockTime>,
1861 Option<crate::ClockTime>,
1862 ) {
1863 unsafe {
1864 let mut live = mem::MaybeUninit::uninit();
1865 let mut running_time = mem::MaybeUninit::uninit();
1866 let mut stream_time = mem::MaybeUninit::uninit();
1867 let mut timestamp = mem::MaybeUninit::uninit();
1868 let mut duration = mem::MaybeUninit::uninit();
1869
1870 ffi::gst_message_parse_qos(
1871 self.as_mut_ptr(),
1872 live.as_mut_ptr(),
1873 running_time.as_mut_ptr(),
1874 stream_time.as_mut_ptr(),
1875 timestamp.as_mut_ptr(),
1876 duration.as_mut_ptr(),
1877 );
1878
1879 (
1880 from_glib(live.assume_init()),
1881 from_glib(running_time.assume_init()),
1882 from_glib(stream_time.assume_init()),
1883 from_glib(timestamp.assume_init()),
1884 from_glib(duration.assume_init()),
1885 )
1886 }
1887 }
1888
1889 #[doc(alias = "get_values")]
1890 #[doc(alias = "gst_message_parse_qos_values")]
1891 pub fn values(&self) -> (i64, f64, i32) {
1892 unsafe {
1893 let mut jitter = mem::MaybeUninit::uninit();
1894 let mut proportion = mem::MaybeUninit::uninit();
1895 let mut quality = mem::MaybeUninit::uninit();
1896
1897 ffi::gst_message_parse_qos_values(
1898 self.as_mut_ptr(),
1899 jitter.as_mut_ptr(),
1900 proportion.as_mut_ptr(),
1901 quality.as_mut_ptr(),
1902 );
1903
1904 (
1905 jitter.assume_init(),
1906 proportion.assume_init(),
1907 quality.assume_init(),
1908 )
1909 }
1910 }
1911
1912 #[doc(alias = "get_stats")]
1913 #[doc(alias = "gst_message_parse_qos_stats")]
1914 pub fn stats(&self) -> (GenericFormattedValue, GenericFormattedValue) {
1915 unsafe {
1916 let mut format = mem::MaybeUninit::uninit();
1917 let mut processed = mem::MaybeUninit::uninit();
1918 let mut dropped = mem::MaybeUninit::uninit();
1919
1920 ffi::gst_message_parse_qos_stats(
1921 self.as_mut_ptr(),
1922 format.as_mut_ptr(),
1923 processed.as_mut_ptr(),
1924 dropped.as_mut_ptr(),
1925 );
1926
1927 (
1928 GenericFormattedValue::new(
1929 from_glib(format.assume_init()),
1930 processed.assume_init() as i64,
1931 ),
1932 GenericFormattedValue::new(
1933 from_glib(format.assume_init()),
1934 dropped.assume_init() as i64,
1935 ),
1936 )
1937 }
1938 }
1939}
1940
1941impl std::fmt::Debug for Qos {
1942 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1943 let (live, running_time, stream_time, timestamp, duration) = self.get();
1944 let (jitter, proportion, quality) = self.values();
1945 let (processed, dropped) = self.stats();
1946
1947 f.debug_struct("Qos")
1948 .field("structure", &self.message().structure())
1949 .field("source", &self.src().map(|obj| (obj, obj.name())))
1950 .field("live", &live)
1951 .field("running-time", &running_time)
1952 .field("stream-time", &stream_time)
1953 .field("timestamp", ×tamp)
1954 .field("duration", &duration)
1955 .field("jitter", &jitter)
1956 .field("proportion", &proportion)
1957 .field("quality", &quality)
1958 .field("processed", &processed)
1959 .field("dropped", &dropped)
1960 .finish()
1961 }
1962}
1963
1964impl std::fmt::Debug for Qos<Message> {
1965 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1966 Qos::<MessageRef>::fmt(self, f)
1967 }
1968}
1969
1970declare_concrete_message!(Progress, T);
1971impl Progress {
1972 #[doc(alias = "gst_message_new_progress")]
1973 #[allow(clippy::new_ret_no_self)]
1974 pub fn new(type_: crate::ProgressType, code: &str, text: &str) -> Message {
1975 skip_assert_initialized!();
1976 Self::builder(type_, code, text).build()
1977 }
1978
1979 pub fn builder<'a>(
1980 type_: crate::ProgressType,
1981 code: &'a str,
1982 text: &'a str,
1983 ) -> ProgressBuilder<'a> {
1984 assert_initialized_main_thread!();
1985 ProgressBuilder::new(type_, code, text)
1986 }
1987
1988 #[doc(alias = "gst_message_parse_progress")]
1989 pub fn get(&self) -> (crate::ProgressType, &str, &str) {
1990 unsafe {
1991 let mut type_ = mem::MaybeUninit::uninit();
1992 let mut code = ptr::null_mut();
1993 let mut text = ptr::null_mut();
1994
1995 ffi::gst_message_parse_progress(
1996 self.as_mut_ptr(),
1997 type_.as_mut_ptr(),
1998 &mut code,
1999 &mut text,
2000 );
2001
2002 let code = CStr::from_ptr(code).to_str().unwrap();
2003 let text = CStr::from_ptr(text).to_str().unwrap();
2004
2005 (from_glib(type_.assume_init()), code, text)
2006 }
2007 }
2008}
2009
2010impl std::fmt::Debug for Progress {
2011 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2012 let (type_, code, text) = self.get();
2013 f.debug_struct("Progress")
2014 .field("structure", &self.message().structure())
2015 .field("source", &self.src().map(|obj| (obj, obj.name())))
2016 .field("type", &type_)
2017 .field("code", &code)
2018 .field("text", &text)
2019 .finish()
2020 }
2021}
2022
2023impl std::fmt::Debug for Progress<Message> {
2024 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2025 Progress::<MessageRef>::fmt(self, f)
2026 }
2027}
2028
2029declare_concrete_message!(Toc, T);
2030impl Toc {
2031 #[doc(alias = "gst_message_new_toc")]
2034 #[allow(clippy::new_ret_no_self)]
2035 pub fn new(toc: &crate::Toc, updated: bool) -> Message {
2036 skip_assert_initialized!();
2037 Self::builder(toc, updated).build()
2038 }
2039
2040 pub fn builder(toc: &crate::Toc, updated: bool) -> TocBuilder<'_> {
2041 assert_initialized_main_thread!();
2042 TocBuilder::new(toc, updated)
2043 }
2044
2045 #[doc(alias = "get_toc")]
2046 #[doc(alias = "gst_message_parse_toc")]
2047 pub fn toc(&self) -> (crate::Toc, bool) {
2048 unsafe {
2049 let mut toc = ptr::null_mut();
2050 let mut updated = mem::MaybeUninit::uninit();
2051 ffi::gst_message_parse_toc(self.as_mut_ptr(), &mut toc, updated.as_mut_ptr());
2052 (from_glib_full(toc), from_glib(updated.assume_init()))
2053 }
2054 }
2055}
2056
2057impl std::fmt::Debug for Toc {
2058 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2059 f.debug_struct("Toc")
2060 .field("structure", &self.message().structure())
2061 .field("source", &self.src().map(|obj| (obj, obj.name())))
2062 .field("toc", &self.toc())
2063 .finish()
2064 }
2065}
2066
2067impl std::fmt::Debug for Toc<Message> {
2068 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2069 Toc::<MessageRef>::fmt(self, f)
2070 }
2071}
2072
2073declare_concrete_message!(ResetTime, T);
2074impl ResetTime {
2075 #[doc(alias = "gst_message_new_reset_time")]
2076 #[allow(clippy::new_ret_no_self)]
2077 pub fn new(running_time: crate::ClockTime) -> Message {
2078 skip_assert_initialized!();
2079 Self::builder(running_time).build()
2080 }
2081
2082 pub fn builder<'a>(running_time: crate::ClockTime) -> ResetTimeBuilder<'a> {
2083 assert_initialized_main_thread!();
2084 ResetTimeBuilder::new(running_time)
2085 }
2086
2087 #[doc(alias = "get_running_time")]
2088 #[doc(alias = "gst_message_parse_reset_time")]
2089 pub fn running_time(&self) -> crate::ClockTime {
2090 unsafe {
2091 let mut running_time = mem::MaybeUninit::uninit();
2092
2093 ffi::gst_message_parse_reset_time(self.as_mut_ptr(), running_time.as_mut_ptr());
2094
2095 try_from_glib(running_time.assume_init()).expect("undefined running_time")
2096 }
2097 }
2098}
2099
2100impl std::fmt::Debug for ResetTime {
2101 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2102 f.debug_struct("ResetTime")
2103 .field("structure", &self.message().structure())
2104 .field("source", &self.src().map(|obj| (obj, obj.name())))
2105 .field("running-time", &self.running_time())
2106 .finish()
2107 }
2108}
2109
2110impl std::fmt::Debug for ResetTime<Message> {
2111 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2112 ResetTime::<MessageRef>::fmt(self, f)
2113 }
2114}
2115
2116declare_concrete_message!(StreamStart, T);
2117impl StreamStart {
2118 #[doc(alias = "gst_message_new_stream_start")]
2119 #[allow(clippy::new_ret_no_self)]
2120 pub fn new() -> Message {
2121 skip_assert_initialized!();
2122 Self::builder().build()
2123 }
2124
2125 pub fn builder<'a>() -> StreamStartBuilder<'a> {
2126 assert_initialized_main_thread!();
2127 StreamStartBuilder::new()
2128 }
2129
2130 #[doc(alias = "get_group_id")]
2131 #[doc(alias = "gst_message_parse_group_id")]
2132 pub fn group_id(&self) -> Option<GroupId> {
2133 unsafe {
2134 let mut group_id = mem::MaybeUninit::uninit();
2135
2136 if from_glib(ffi::gst_message_parse_group_id(
2137 self.as_mut_ptr(),
2138 group_id.as_mut_ptr(),
2139 )) {
2140 let group_id = group_id.assume_init();
2141 if group_id == 0 {
2142 None
2143 } else {
2144 Some(GroupId(NonZeroU32::new_unchecked(group_id)))
2145 }
2146 } else {
2147 None
2148 }
2149 }
2150 }
2151
2152 #[doc(alias = "gst_message_set_group_id")]
2153 pub fn set_group_id(&mut self, group_id: GroupId) {
2154 unsafe {
2155 ffi::gst_message_set_group_id(self.as_mut_ptr(), group_id.0.get());
2156 }
2157 }
2158}
2159
2160impl std::fmt::Debug for StreamStart {
2161 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2162 f.debug_struct("StreamStart")
2163 .field("structure", &self.message().structure())
2164 .field("source", &self.src().map(|obj| (obj, obj.name())))
2165 .field("group-id", &self.group_id())
2166 .finish()
2167 }
2168}
2169
2170impl std::fmt::Debug for StreamStart<Message> {
2171 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2172 StreamStart::<MessageRef>::fmt(self, f)
2173 }
2174}
2175
2176declare_concrete_message!(NeedContext, T);
2177impl NeedContext {
2178 #[doc(alias = "gst_message_new_need_context")]
2179 #[allow(clippy::new_ret_no_self)]
2180 pub fn new(context_type: &str) -> Message {
2181 skip_assert_initialized!();
2182 Self::builder(context_type).build()
2183 }
2184
2185 pub fn builder(context_type: &str) -> NeedContextBuilder<'_> {
2186 assert_initialized_main_thread!();
2187 NeedContextBuilder::new(context_type)
2188 }
2189
2190 #[doc(alias = "get_context_type")]
2191 #[doc(alias = "gst_message_parse_context_type")]
2192 pub fn context_type(&self) -> &str {
2193 unsafe {
2194 let mut context_type = ptr::null();
2195
2196 ffi::gst_message_parse_context_type(self.as_mut_ptr(), &mut context_type);
2197
2198 CStr::from_ptr(context_type).to_str().unwrap()
2199 }
2200 }
2201}
2202
2203impl std::fmt::Debug for NeedContext {
2204 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2205 f.debug_struct("NeedContext")
2206 .field("structure", &self.message().structure())
2207 .field("source", &self.src().map(|obj| (obj, obj.name())))
2208 .field("context-type", &self.context_type())
2209 .finish()
2210 }
2211}
2212
2213impl std::fmt::Debug for NeedContext<Message> {
2214 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2215 NeedContext::<MessageRef>::fmt(self, f)
2216 }
2217}
2218
2219declare_concrete_message!(HaveContext, T);
2220impl HaveContext {
2221 #[doc(alias = "gst_message_new_have_context")]
2222 #[allow(clippy::new_ret_no_self)]
2223 pub fn new(context: crate::Context) -> Message {
2224 skip_assert_initialized!();
2225 Self::builder(context).build()
2226 }
2227
2228 pub fn builder<'a>(context: crate::Context) -> HaveContextBuilder<'a> {
2229 assert_initialized_main_thread!();
2230 HaveContextBuilder::new(context)
2231 }
2232
2233 #[doc(alias = "get_context")]
2234 #[doc(alias = "gst_message_parse_have_context")]
2235 pub fn context(&self) -> crate::Context {
2236 unsafe {
2237 let mut context = ptr::null_mut();
2238 ffi::gst_message_parse_have_context(self.as_mut_ptr(), &mut context);
2239 from_glib_full(context)
2240 }
2241 }
2242}
2243
2244impl std::fmt::Debug for HaveContext {
2245 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2246 f.debug_struct("HaveContext")
2247 .field("structure", &self.message().structure())
2248 .field("source", &self.src().map(|obj| (obj, obj.name())))
2249 .field("context", &self.context())
2250 .finish()
2251 }
2252}
2253
2254impl std::fmt::Debug for HaveContext<Message> {
2255 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2256 HaveContext::<MessageRef>::fmt(self, f)
2257 }
2258}
2259
2260declare_concrete_message!(DeviceAdded, T);
2261impl DeviceAdded {
2262 #[doc(alias = "gst_message_new_device_added")]
2263 #[allow(clippy::new_ret_no_self)]
2264 pub fn new(device: &crate::Device) -> Message {
2265 skip_assert_initialized!();
2266 Self::builder(device).build()
2267 }
2268
2269 pub fn builder(device: &crate::Device) -> DeviceAddedBuilder<'_> {
2270 assert_initialized_main_thread!();
2271 DeviceAddedBuilder::new(device)
2272 }
2273
2274 #[doc(alias = "get_device")]
2275 #[doc(alias = "gst_message_parse_device_added")]
2276 pub fn device(&self) -> crate::Device {
2277 unsafe {
2278 let mut device = ptr::null_mut();
2279
2280 ffi::gst_message_parse_device_added(self.as_mut_ptr(), &mut device);
2281
2282 from_glib_full(device)
2283 }
2284 }
2285}
2286
2287impl std::fmt::Debug for DeviceAdded {
2288 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2289 f.debug_struct("DeviceAdded")
2290 .field("structure", &self.message().structure())
2291 .field("source", &self.src().map(|obj| (obj, obj.name())))
2292 .field("device", &self.device())
2293 .finish()
2294 }
2295}
2296
2297impl std::fmt::Debug for DeviceAdded<Message> {
2298 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2299 DeviceAdded::<MessageRef>::fmt(self, f)
2300 }
2301}
2302
2303declare_concrete_message!(DeviceRemoved, T);
2304impl DeviceRemoved {
2305 #[doc(alias = "gst_message_new_device_removed")]
2306 #[allow(clippy::new_ret_no_self)]
2307 pub fn new(device: &crate::Device) -> Message {
2308 skip_assert_initialized!();
2309 Self::builder(device).build()
2310 }
2311
2312 pub fn builder(device: &crate::Device) -> DeviceRemovedBuilder<'_> {
2313 assert_initialized_main_thread!();
2314 DeviceRemovedBuilder::new(device)
2315 }
2316
2317 #[doc(alias = "get_device")]
2318 #[doc(alias = "gst_message_parse_device_removed")]
2319 pub fn device(&self) -> crate::Device {
2320 unsafe {
2321 let mut device = ptr::null_mut();
2322
2323 ffi::gst_message_parse_device_removed(self.as_mut_ptr(), &mut device);
2324
2325 from_glib_full(device)
2326 }
2327 }
2328}
2329
2330impl std::fmt::Debug for DeviceRemoved {
2331 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2332 f.debug_struct("DeviceRemoved")
2333 .field("structure", &self.message().structure())
2334 .field("source", &self.src().map(|obj| (obj, obj.name())))
2335 .field("device", &self.device())
2336 .finish()
2337 }
2338}
2339
2340impl std::fmt::Debug for DeviceRemoved<Message> {
2341 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2342 DeviceRemoved::<MessageRef>::fmt(self, f)
2343 }
2344}
2345
2346declare_concrete_message!(PropertyNotify, T);
2347impl PropertyNotify {
2348 #[doc(alias = "gst_message_new_property_notify")]
2349 #[allow(clippy::new_ret_no_self)]
2350 pub fn new(object: &impl IsA<crate::Object>, property_name: &str) -> Message {
2351 skip_assert_initialized!();
2352 Self::builder(object, property_name).build()
2353 }
2354
2355 pub fn builder<'a>(
2356 object: &'a impl IsA<crate::Object>,
2357 property_name: &'a str,
2358 ) -> PropertyNotifyBuilder<'a> {
2359 assert_initialized_main_thread!();
2360 PropertyNotifyBuilder::new(property_name).src(object)
2361 }
2362
2363 #[doc(alias = "gst_message_parse_property_notify")]
2364 pub fn get(&self) -> (Object, &str, Option<&glib::Value>) {
2365 unsafe {
2366 let mut object = ptr::null_mut();
2367 let mut property_name = ptr::null();
2368 let mut value = ptr::null();
2369
2370 ffi::gst_message_parse_property_notify(
2371 self.as_mut_ptr(),
2372 &mut object,
2373 &mut property_name,
2374 &mut value,
2375 );
2376
2377 (
2378 from_glib_none(object),
2379 CStr::from_ptr(property_name).to_str().unwrap(),
2380 if value.is_null() {
2381 None
2382 } else {
2383 Some(&*(value as *const glib::Value))
2384 },
2385 )
2386 }
2387 }
2388}
2389
2390impl std::fmt::Debug for PropertyNotify {
2391 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2392 let (object, property_name, value) = self.get();
2393 f.debug_struct("PropertyNotify")
2394 .field("structure", &self.message().structure())
2395 .field("source", &self.src().map(|obj| (obj, obj.name())))
2396 .field("object", &object)
2397 .field("property-name", &property_name)
2398 .field("value", &value)
2399 .finish()
2400 }
2401}
2402
2403impl std::fmt::Debug for PropertyNotify<Message> {
2404 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2405 PropertyNotify::<MessageRef>::fmt(self, f)
2406 }
2407}
2408
2409declare_concrete_message!(StreamCollection, T);
2410impl StreamCollection {
2411 #[doc(alias = "gst_message_new_stream_collection")]
2412 #[allow(clippy::new_ret_no_self)]
2413 pub fn new(collection: &crate::StreamCollection) -> Message {
2414 skip_assert_initialized!();
2415 Self::builder(collection).build()
2416 }
2417
2418 pub fn builder(collection: &crate::StreamCollection) -> StreamCollectionBuilder<'_> {
2419 assert_initialized_main_thread!();
2420 StreamCollectionBuilder::new(collection)
2421 }
2422
2423 #[doc(alias = "get_stream_collection")]
2424 #[doc(alias = "gst_message_parse_stream_collection")]
2425 pub fn stream_collection(&self) -> crate::StreamCollection {
2426 unsafe {
2427 let mut collection = ptr::null_mut();
2428
2429 ffi::gst_message_parse_stream_collection(self.as_mut_ptr(), &mut collection);
2430
2431 from_glib_full(collection)
2432 }
2433 }
2434}
2435
2436impl std::fmt::Debug for StreamCollection {
2437 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2438 f.debug_struct("StreamCollection")
2439 .field("structure", &self.message().structure())
2440 .field("source", &self.src().map(|obj| (obj, obj.name())))
2441 .field("stream-collection", &self.stream_collection())
2442 .finish()
2443 }
2444}
2445
2446impl std::fmt::Debug for StreamCollection<Message> {
2447 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2448 StreamCollection::<MessageRef>::fmt(self, f)
2449 }
2450}
2451
2452declare_concrete_message!(StreamsSelected, T);
2453impl StreamsSelected {
2454 #[doc(alias = "gst_message_new_streams_selected")]
2455 #[allow(clippy::new_ret_no_self)]
2456 pub fn new(collection: &crate::StreamCollection) -> Message {
2457 skip_assert_initialized!();
2458 Self::builder(collection).build()
2459 }
2460
2461 pub fn builder(collection: &crate::StreamCollection) -> StreamsSelectedBuilder<'_> {
2462 assert_initialized_main_thread!();
2463 StreamsSelectedBuilder::new(collection)
2464 }
2465
2466 #[doc(alias = "get_stream_collection")]
2467 #[doc(alias = "gst_message_parse_streams_selected")]
2468 pub fn stream_collection(&self) -> crate::StreamCollection {
2469 unsafe {
2470 let mut collection = ptr::null_mut();
2471
2472 ffi::gst_message_parse_streams_selected(self.as_mut_ptr(), &mut collection);
2473
2474 from_glib_full(collection)
2475 }
2476 }
2477
2478 #[doc(alias = "get_streams")]
2479 #[doc(alias = "gst_message_streams_selected_get_size")]
2480 #[doc(alias = "gst_message_streams_selected_get_stream")]
2481 pub fn streams(&self) -> StreamsSelectedIter<'_> {
2482 StreamsSelectedIter::new(self)
2483 }
2484}
2485
2486impl std::fmt::Debug for StreamsSelected {
2487 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2488 struct StreamsDebug<'a>(&'a StreamsSelected);
2489
2490 impl std::fmt::Debug for StreamsDebug<'_> {
2491 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2492 f.debug_list().entries(self.0.streams()).finish()
2493 }
2494 }
2495
2496 f.debug_struct("StreamsSelected")
2497 .field("structure", &self.message().structure())
2498 .field("source", &self.src().map(|obj| (obj, obj.name())))
2499 .field("stream-collection", &self.stream_collection())
2500 .field("streams", &StreamsDebug(self))
2501 .finish()
2502 }
2503}
2504
2505impl std::fmt::Debug for StreamsSelected<Message> {
2506 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2507 StreamsSelected::<MessageRef>::fmt(self, f)
2508 }
2509}
2510
2511crate::utils::define_fixed_size_iter!(
2512 StreamsSelectedIter,
2513 &'a StreamsSelected,
2514 crate::Stream,
2515 |collection: &StreamsSelected| unsafe {
2516 ffi::gst_message_streams_selected_get_size(collection.as_mut_ptr()) as usize
2517 },
2518 |collection: &StreamsSelected, idx: usize| unsafe {
2519 from_glib_full(ffi::gst_message_streams_selected_get_stream(
2520 collection.as_mut_ptr(),
2521 idx as u32,
2522 ))
2523 }
2524);
2525
2526declare_concrete_message!(Redirect, T);
2527impl Redirect {
2528 #[doc(alias = "gst_message_new_redirect")]
2529 #[allow(clippy::new_ret_no_self)]
2530 pub fn new(location: &str) -> Message {
2531 skip_assert_initialized!();
2532 Self::builder(location).build()
2533 }
2534
2535 pub fn builder(location: &str) -> RedirectBuilder<'_> {
2536 assert_initialized_main_thread!();
2537 RedirectBuilder::new(location)
2538 }
2539
2540 #[doc(alias = "get_entries")]
2541 #[doc(alias = "gst_message_get_num_redirect_entries")]
2542 #[doc(alias = "gst_message_parse_redirect_entry")]
2543 pub fn entries(&self) -> RedirectEntriesIter<'_> {
2544 RedirectEntriesIter::new(self)
2545 }
2546}
2547
2548impl std::fmt::Debug for Redirect {
2549 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2550 struct EntriesDebug<'a>(&'a Redirect);
2551
2552 impl std::fmt::Debug for EntriesDebug<'_> {
2553 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2554 f.debug_list().entries(self.0.entries()).finish()
2555 }
2556 }
2557
2558 f.debug_struct("Redirect")
2559 .field("structure", &self.message().structure())
2560 .field("source", &self.src().map(|obj| (obj, obj.name())))
2561 .field("entries", &EntriesDebug(self))
2562 .finish()
2563 }
2564}
2565
2566impl std::fmt::Debug for Redirect<Message> {
2567 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2568 Redirect::<MessageRef>::fmt(self, f)
2569 }
2570}
2571
2572crate::utils::define_fixed_size_iter!(
2573 RedirectEntriesIter,
2574 &'a Redirect,
2575 (&'a str, Option<TagList>, Option<&'a StructureRef>),
2576 |collection: &Redirect| unsafe {
2577 ffi::gst_message_get_num_redirect_entries(collection.as_mut_ptr()) as usize
2578 },
2579 |collection: &Redirect, idx: usize| unsafe {
2580 let mut location = ptr::null();
2581 let mut tags = ptr::null_mut();
2582 let mut structure = ptr::null();
2583
2584 ffi::gst_message_parse_redirect_entry(
2585 collection.as_mut_ptr(),
2586 idx,
2587 &mut location,
2588 &mut tags,
2589 &mut structure,
2590 );
2591
2592 let structure = if structure.is_null() {
2593 None
2594 } else {
2595 Some(StructureRef::from_glib_borrow(structure))
2596 };
2597
2598 (
2599 CStr::from_ptr(location).to_str().unwrap(),
2600 from_glib_none(tags),
2601 structure,
2602 )
2603 }
2604);
2605
2606#[cfg(feature = "v1_16")]
2607#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2608declare_concrete_message!(DeviceChanged, T);
2609#[cfg(feature = "v1_16")]
2610#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2611impl DeviceChanged {
2612 #[doc(alias = "gst_message_new_device_changed")]
2613 #[allow(clippy::new_ret_no_self)]
2614 pub fn new(device: &crate::Device, changed_device: &crate::Device) -> Message {
2615 skip_assert_initialized!();
2616 Self::builder(device, changed_device).build()
2617 }
2618
2619 pub fn builder<'a>(
2620 device: &'a crate::Device,
2621 changed_device: &'a crate::Device,
2622 ) -> DeviceChangedBuilder<'a> {
2623 assert_initialized_main_thread!();
2624 DeviceChangedBuilder::new(device, changed_device)
2625 }
2626
2627 #[doc(alias = "get_device_changed")]
2628 #[doc(alias = "gst_message_parse_device_changed")]
2629 pub fn device_changed(&self) -> (crate::Device, crate::Device) {
2630 unsafe {
2631 let mut device = ptr::null_mut();
2632 let mut changed_device = ptr::null_mut();
2633
2634 ffi::gst_message_parse_device_changed(
2635 self.as_mut_ptr(),
2636 &mut device,
2637 &mut changed_device,
2638 );
2639
2640 (from_glib_full(device), from_glib_full(changed_device))
2641 }
2642 }
2643}
2644
2645#[cfg(feature = "v1_16")]
2646impl std::fmt::Debug for DeviceChanged {
2647 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2648 f.debug_struct("DeviceChanged")
2649 .field("structure", &self.message().structure())
2650 .field("source", &self.src().map(|obj| (obj, obj.name())))
2651 .field("device-changed", &self.device_changed())
2652 .finish()
2653 }
2654}
2655
2656#[cfg(feature = "v1_16")]
2657impl std::fmt::Debug for DeviceChanged<Message> {
2658 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2659 DeviceChanged::<MessageRef>::fmt(self, f)
2660 }
2661}
2662
2663#[cfg(feature = "v1_18")]
2664#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2665declare_concrete_message!(InstantRateRequest, T);
2666#[cfg(feature = "v1_18")]
2667#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2668impl InstantRateRequest {
2669 #[doc(alias = "gst_message_new_instant_rate_request")]
2670 #[allow(clippy::new_ret_no_self)]
2671 pub fn new(rate_multiplier: f64) -> Message {
2672 skip_assert_initialized!();
2673 Self::builder(rate_multiplier).build()
2674 }
2675
2676 pub fn builder<'a>(rate_multiplier: f64) -> InstantRateRequestBuilder<'a> {
2677 assert_initialized_main_thread!();
2678 InstantRateRequestBuilder::new(rate_multiplier)
2679 }
2680
2681 #[doc(alias = "parse_instant_rate_request")]
2682 #[doc(alias = "gst_message_parse_instant_rate_request")]
2683 pub fn rate_multiplier(&self) -> f64 {
2684 unsafe {
2685 let mut rate_multiplier = mem::MaybeUninit::uninit();
2686
2687 ffi::gst_message_parse_instant_rate_request(
2688 self.as_mut_ptr(),
2689 rate_multiplier.as_mut_ptr(),
2690 );
2691
2692 rate_multiplier.assume_init()
2693 }
2694 }
2695}
2696
2697#[cfg(feature = "v1_18")]
2698impl std::fmt::Debug for InstantRateRequest {
2699 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2700 f.debug_struct("InstantRateRequest")
2701 .field("structure", &self.message().structure())
2702 .field("source", &self.src().map(|obj| (obj, obj.name())))
2703 .field("rate-multiplier", &self.rate_multiplier())
2704 .finish()
2705 }
2706}
2707
2708#[cfg(feature = "v1_18")]
2709impl std::fmt::Debug for InstantRateRequest<Message> {
2710 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2711 InstantRateRequest::<MessageRef>::fmt(self, f)
2712 }
2713}
2714
2715struct MessageBuilder<'a> {
2716 src: Option<Object>,
2717 seqnum: Option<Seqnum>,
2718 #[cfg(feature = "v1_26")]
2719 details: Option<Structure>,
2720 other_fields: Vec<(&'a str, glib::SendValue)>,
2721}
2722
2723impl<'a> MessageBuilder<'a> {
2724 fn new() -> Self {
2725 Self {
2726 src: None,
2727 seqnum: None,
2728 #[cfg(feature = "v1_26")]
2729 details: None,
2730 other_fields: Vec::new(),
2731 }
2732 }
2733
2734 pub fn src<O: IsA<Object> + Cast + Clone>(self, src: &O) -> Self {
2735 Self {
2736 src: Some(src.clone().upcast::<Object>()),
2737 ..self
2738 }
2739 }
2740
2741 fn seqnum(self, seqnum: Seqnum) -> Self {
2742 Self {
2743 seqnum: Some(seqnum),
2744 ..self
2745 }
2746 }
2747
2748 #[cfg(feature = "v1_26")]
2749 fn details(self, details: Structure) -> Self {
2750 Self {
2751 details: Some(details),
2752 ..self
2753 }
2754 }
2755
2756 fn other_field(self, name: &'a str, value: impl ToSendValue) -> Self {
2757 let mut other_fields = self.other_fields;
2758 other_fields.push((name, value.to_send_value()));
2759
2760 Self {
2761 other_fields,
2762 ..self
2763 }
2764 }
2765}
2766
2767macro_rules! message_builder_generic_impl {
2768 ($new_fn:expr) => {
2769 #[allow(clippy::needless_update)]
2770 pub fn src<O: IsA<Object> + Cast + Clone>(self, src: &O) -> Self {
2771 Self {
2772 builder: self.builder.src(src),
2773 ..self
2774 }
2775 }
2776
2777 #[allow(clippy::needless_update)]
2778 pub fn src_if<O: IsA<Object> + Cast + Clone>(self, src: &O, predicate: bool) -> Self {
2779 if predicate {
2780 self.src(src)
2781 } else {
2782 self
2783 }
2784 }
2785
2786 #[allow(clippy::needless_update)]
2787 pub fn src_if_some<O: IsA<Object> + Cast + Clone>(self, src: Option<&O>) -> Self {
2788 if let Some(src) = src {
2789 self.src(src)
2790 } else {
2791 self
2792 }
2793 }
2794
2795 #[doc(alias = "gst_message_set_seqnum")]
2796 #[allow(clippy::needless_update)]
2797 pub fn seqnum(self, seqnum: Seqnum) -> Self {
2798 Self {
2799 builder: self.builder.seqnum(seqnum),
2800 ..self
2801 }
2802 }
2803
2804 #[doc(alias = "gst_message_set_seqnum")]
2805 #[allow(clippy::needless_update)]
2806 pub fn seqnum_if(self, seqnum: Seqnum, predicate: bool) -> Self {
2807 if predicate {
2808 self.seqnum(seqnum)
2809 } else {
2810 self
2811 }
2812 }
2813
2814 #[doc(alias = "gst_message_set_seqnum")]
2815 #[allow(clippy::needless_update)]
2816 pub fn seqnum_if_some(self, seqnum: Option<Seqnum>) -> Self {
2817 if let Some(seqnum) = seqnum {
2818 self.seqnum(seqnum)
2819 } else {
2820 self
2821 }
2822 }
2823
2824 #[cfg(feature = "v1_26")]
2825 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2826 #[doc(alias = "gst_message_set_details")]
2827 #[allow(clippy::needless_update)]
2828 pub fn details(self, details: Structure) -> Self {
2829 Self {
2830 builder: self.builder.details(details),
2831 ..self
2832 }
2833 }
2834
2835 #[cfg(feature = "v1_26")]
2836 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2837 #[doc(alias = "gst_message_set_details")]
2838 #[allow(clippy::needless_update)]
2839 pub fn details_if(self, details: Structure, predicate: bool) -> Self {
2840 if predicate {
2841 self.details(details)
2842 } else {
2843 self
2844 }
2845 }
2846
2847 #[cfg(feature = "v1_26")]
2848 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2849 #[doc(alias = "gst_message_set_details")]
2850 #[allow(clippy::needless_update)]
2851 pub fn details_if_some(self, details: Option<Structure>) -> Self {
2852 if let Some(details) = details {
2853 self.details(details)
2854 } else {
2855 self
2856 }
2857 }
2858
2859 #[allow(clippy::needless_update)]
2864 pub fn other_field(self, name: &'a str, value: impl ToSendValue) -> Self {
2865 Self {
2866 builder: self.builder.other_field(name, value),
2867 ..self
2868 }
2869 }
2870
2871 impl_builder_gvalue_extra_setters!(other_field);
2872
2873 #[must_use = "Building the message without using it has no effect"]
2874 #[allow(clippy::redundant_closure_call)]
2875 pub fn build(mut self) -> Message {
2876 unsafe {
2877 let src = self.builder.src.to_glib_none().0;
2878 let msg = $new_fn(&mut self, src);
2879 if let Some(seqnum) = self.builder.seqnum {
2880 ffi::gst_message_set_seqnum(msg, seqnum.0.get());
2881 }
2882
2883 #[cfg(feature = "v1_26")]
2884 if let Some(details) = self.builder.details {
2885 ffi::gst_message_set_details(msg, details.into_glib_ptr());
2886 }
2887
2888 if !self.builder.other_fields.is_empty() {
2889 let structure = ffi::gst_message_writable_structure(msg);
2890
2891 if !structure.is_null() {
2892 let structure = StructureRef::from_glib_borrow_mut(structure as *mut _);
2893
2894 for (k, v) in self.builder.other_fields {
2895 structure.set_value(k, v);
2896 }
2897 }
2898 }
2899
2900 from_glib_full(msg)
2901 }
2902 }
2903 };
2904}
2905
2906#[must_use = "The builder must be built to be used"]
2907pub struct EosBuilder<'a> {
2908 builder: MessageBuilder<'a>,
2909}
2910
2911impl<'a> EosBuilder<'a> {
2912 fn new() -> Self {
2913 skip_assert_initialized!();
2914 Self {
2915 builder: MessageBuilder::new(),
2916 }
2917 }
2918
2919 message_builder_generic_impl!(|_, src| ffi::gst_message_new_eos(src));
2920}
2921
2922pub trait MessageErrorDomain: glib::error::ErrorDomain {}
2923
2924impl MessageErrorDomain for crate::CoreError {}
2925impl MessageErrorDomain for crate::ResourceError {}
2926impl MessageErrorDomain for crate::StreamError {}
2927impl MessageErrorDomain for crate::LibraryError {}
2928
2929#[must_use = "The builder must be built to be used"]
2930pub struct ErrorBuilder<'a> {
2931 builder: MessageBuilder<'a>,
2932 error: glib::Error,
2933 debug: Option<&'a str>,
2934 #[allow(unused)]
2935 details: Option<Structure>,
2936}
2937
2938impl<'a> ErrorBuilder<'a> {
2939 fn new(error: glib::Error) -> Self {
2940 skip_assert_initialized!();
2941 Self {
2942 builder: MessageBuilder::new(),
2943 error,
2944 debug: None,
2945 details: None,
2946 }
2947 }
2948
2949 pub fn debug(self, debug: &'a str) -> Self {
2950 Self {
2951 debug: Some(debug),
2952 ..self
2953 }
2954 }
2955
2956 pub fn debug_if(self, debug: &'a str, predicate: bool) -> Self {
2957 if predicate {
2958 self.debug(debug)
2959 } else {
2960 self
2961 }
2962 }
2963
2964 pub fn debug_if_some(self, debug: Option<&'a str>) -> Self {
2965 if let Some(debug) = debug {
2966 self.debug(debug)
2967 } else {
2968 self
2969 }
2970 }
2971
2972 #[cfg(not(feature = "v1_26"))]
2973 pub fn details(self, details: Structure) -> Self {
2974 Self {
2975 details: Some(details),
2976 ..self
2977 }
2978 }
2979
2980 #[cfg(not(feature = "v1_26"))]
2981 pub fn details_if(self, details: Structure, predicate: bool) -> Self {
2982 if predicate {
2983 self.details(details)
2984 } else {
2985 self
2986 }
2987 }
2988
2989 #[cfg(not(feature = "v1_26"))]
2990 pub fn details_if_some(self, details: Option<Structure>) -> Self {
2991 if let Some(details) = details {
2992 self.details(details)
2993 } else {
2994 self
2995 }
2996 }
2997
2998 message_builder_generic_impl!(|s: &mut Self, src| {
2999 let details = match s.details.take() {
3000 None => ptr::null_mut(),
3001 Some(details) => details.into_glib_ptr(),
3002 };
3003
3004 ffi::gst_message_new_error_with_details(
3005 src,
3006 mut_override(s.error.to_glib_none().0),
3007 s.debug.to_glib_none().0,
3008 details,
3009 )
3010 });
3011}
3012
3013#[must_use = "The builder must be built to be used"]
3014pub struct WarningBuilder<'a> {
3015 builder: MessageBuilder<'a>,
3016 error: glib::Error,
3017 debug: Option<&'a str>,
3018 #[allow(unused)]
3019 details: Option<Structure>,
3020}
3021
3022impl<'a> WarningBuilder<'a> {
3023 fn new(error: glib::Error) -> Self {
3024 skip_assert_initialized!();
3025 Self {
3026 builder: MessageBuilder::new(),
3027 error,
3028 debug: None,
3029 details: None,
3030 }
3031 }
3032
3033 pub fn debug(self, debug: &'a str) -> Self {
3034 Self {
3035 debug: Some(debug),
3036 ..self
3037 }
3038 }
3039
3040 pub fn debug_if(self, debug: &'a str, predicate: bool) -> Self {
3041 if predicate {
3042 self.debug(debug)
3043 } else {
3044 self
3045 }
3046 }
3047
3048 pub fn debug_if_some(self, debug: Option<&'a str>) -> Self {
3049 if let Some(debug) = debug {
3050 self.debug(debug)
3051 } else {
3052 self
3053 }
3054 }
3055
3056 #[cfg(not(feature = "v1_26"))]
3057 pub fn details(self, details: Structure) -> Self {
3058 Self {
3059 details: Some(details),
3060 ..self
3061 }
3062 }
3063
3064 #[cfg(not(feature = "v1_26"))]
3065 pub fn details_if(self, details: Structure, predicate: bool) -> Self {
3066 if predicate {
3067 self.details(details)
3068 } else {
3069 self
3070 }
3071 }
3072
3073 #[cfg(not(feature = "v1_26"))]
3074 pub fn details_if_some(self, details: Option<Structure>) -> Self {
3075 if let Some(details) = details {
3076 self.details(details)
3077 } else {
3078 self
3079 }
3080 }
3081
3082 message_builder_generic_impl!(|s: &mut Self, src| {
3083 let details = match s.details.take() {
3084 None => ptr::null_mut(),
3085 Some(details) => details.into_glib_ptr(),
3086 };
3087
3088 ffi::gst_message_new_warning_with_details(
3089 src,
3090 mut_override(s.error.to_glib_none().0),
3091 s.debug.to_glib_none().0,
3092 details,
3093 )
3094 });
3095}
3096
3097#[must_use = "The builder must be built to be used"]
3098pub struct InfoBuilder<'a> {
3099 builder: MessageBuilder<'a>,
3100 error: glib::Error,
3101 debug: Option<&'a str>,
3102 #[allow(unused)]
3103 details: Option<Structure>,
3104}
3105
3106impl<'a> InfoBuilder<'a> {
3107 fn new(error: glib::Error) -> Self {
3108 skip_assert_initialized!();
3109 Self {
3110 builder: MessageBuilder::new(),
3111 error,
3112 debug: None,
3113 details: None,
3114 }
3115 }
3116
3117 pub fn debug(self, debug: &'a str) -> Self {
3118 Self {
3119 debug: Some(debug),
3120 ..self
3121 }
3122 }
3123
3124 pub fn debug_if(self, debug: &'a str, predicate: bool) -> Self {
3125 if predicate {
3126 self.debug(debug)
3127 } else {
3128 self
3129 }
3130 }
3131
3132 pub fn debug_if_some(self, debug: Option<&'a str>) -> Self {
3133 if let Some(debug) = debug {
3134 self.debug(debug)
3135 } else {
3136 self
3137 }
3138 }
3139
3140 #[cfg(not(feature = "v1_26"))]
3141 pub fn details(self, details: Structure) -> Self {
3142 Self {
3143 details: Some(details),
3144 ..self
3145 }
3146 }
3147
3148 #[cfg(not(feature = "v1_26"))]
3149 pub fn details_if(self, details: Structure, predicate: bool) -> Self {
3150 if predicate {
3151 self.details(details)
3152 } else {
3153 self
3154 }
3155 }
3156
3157 #[cfg(not(feature = "v1_26"))]
3158 pub fn details_if_some(self, details: Option<Structure>) -> Self {
3159 if let Some(details) = details {
3160 self.details(details)
3161 } else {
3162 self
3163 }
3164 }
3165
3166 message_builder_generic_impl!(|s: &mut Self, src| {
3167 let details = match s.details.take() {
3168 None => ptr::null_mut(),
3169 Some(details) => details.into_glib_ptr(),
3170 };
3171
3172 ffi::gst_message_new_info_with_details(
3173 src,
3174 mut_override(s.error.to_glib_none().0),
3175 s.debug.to_glib_none().0,
3176 details,
3177 )
3178 });
3179}
3180
3181#[must_use = "The builder must be built to be used"]
3182pub struct TagBuilder<'a> {
3183 builder: MessageBuilder<'a>,
3184 tags: Option<TagList>,
3185}
3186
3187impl<'a> TagBuilder<'a> {
3188 fn new(tags: TagList) -> Self {
3189 skip_assert_initialized!();
3190 Self {
3191 builder: MessageBuilder::new(),
3192 tags: Some(tags),
3193 }
3194 }
3195
3196 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_tag(
3197 src,
3198 s.tags.take().into_glib_ptr()
3199 ));
3200}
3201
3202#[must_use = "The builder must be built to be used"]
3203pub struct BufferingBuilder<'a> {
3204 builder: MessageBuilder<'a>,
3205 percent: i32,
3206 stats: Option<(crate::BufferingMode, i32, i32, i64)>,
3207}
3208
3209impl<'a> BufferingBuilder<'a> {
3210 fn new(percent: i32) -> Self {
3211 skip_assert_initialized!();
3212 Self {
3213 builder: MessageBuilder::new(),
3214 percent,
3215 stats: None,
3216 }
3217 }
3218
3219 pub fn stats(
3220 self,
3221 mode: crate::BufferingMode,
3222 avg_in: i32,
3223 avg_out: i32,
3224 buffering_left: i64,
3225 ) -> Self {
3226 skip_assert_initialized!();
3227 Self {
3228 stats: Some((mode, avg_in, avg_out, buffering_left)),
3229 ..self
3230 }
3231 }
3232
3233 message_builder_generic_impl!(|s: &mut Self, src| {
3234 let msg = ffi::gst_message_new_buffering(src, s.percent);
3235
3236 if let Some((mode, avg_in, avg_out, buffering_left)) = s.stats {
3237 ffi::gst_message_set_buffering_stats(
3238 msg,
3239 mode.into_glib(),
3240 avg_in,
3241 avg_out,
3242 buffering_left,
3243 );
3244 }
3245
3246 msg
3247 });
3248}
3249
3250#[must_use = "The builder must be built to be used"]
3251pub struct StateChangedBuilder<'a> {
3252 builder: MessageBuilder<'a>,
3253 old: crate::State,
3254 new: crate::State,
3255 pending: crate::State,
3256}
3257
3258impl<'a> StateChangedBuilder<'a> {
3259 fn new(old: crate::State, new: crate::State, pending: crate::State) -> Self {
3260 skip_assert_initialized!();
3261 Self {
3262 builder: MessageBuilder::new(),
3263 old,
3264 new,
3265 pending,
3266 }
3267 }
3268
3269 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_state_changed(
3270 src,
3271 s.old.into_glib(),
3272 s.new.into_glib(),
3273 s.pending.into_glib(),
3274 ));
3275}
3276
3277#[must_use = "The builder must be built to be used"]
3278pub struct StateDirtyBuilder<'a> {
3279 builder: MessageBuilder<'a>,
3280}
3281
3282impl<'a> StateDirtyBuilder<'a> {
3283 fn new() -> Self {
3284 skip_assert_initialized!();
3285 Self {
3286 builder: MessageBuilder::new(),
3287 }
3288 }
3289
3290 message_builder_generic_impl!(|_, src| ffi::gst_message_new_state_dirty(src));
3291}
3292
3293#[must_use = "The builder must be built to be used"]
3294pub struct StepDoneBuilder<'a> {
3295 builder: MessageBuilder<'a>,
3296 amount: GenericFormattedValue,
3297 rate: f64,
3298 flush: bool,
3299 intermediate: bool,
3300 duration: Option<crate::ClockTime>,
3301 eos: bool,
3302}
3303
3304impl<'a> StepDoneBuilder<'a> {
3305 fn new(
3306 amount: GenericFormattedValue,
3307 rate: f64,
3308 flush: bool,
3309 intermediate: bool,
3310 duration: Option<crate::ClockTime>,
3311 eos: bool,
3312 ) -> Self {
3313 skip_assert_initialized!();
3314 assert_eq!(amount.format(), duration.format());
3315 Self {
3316 builder: MessageBuilder::new(),
3317 amount,
3318 rate,
3319 flush,
3320 intermediate,
3321 duration,
3322 eos,
3323 }
3324 }
3325
3326 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_step_done(
3327 src,
3328 s.amount.format().into_glib(),
3329 s.amount.value() as u64,
3330 s.rate,
3331 s.flush.into_glib(),
3332 s.intermediate.into_glib(),
3333 s.duration.into_raw_value() as u64,
3334 s.eos.into_glib(),
3335 ));
3336}
3337
3338#[must_use = "The builder must be built to be used"]
3339pub struct ClockProvideBuilder<'a> {
3340 builder: MessageBuilder<'a>,
3341 clock: &'a crate::Clock,
3342 ready: bool,
3343}
3344
3345impl<'a> ClockProvideBuilder<'a> {
3346 fn new(clock: &'a crate::Clock, ready: bool) -> Self {
3347 skip_assert_initialized!();
3348 Self {
3349 builder: MessageBuilder::new(),
3350 clock,
3351 ready,
3352 }
3353 }
3354
3355 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_clock_provide(
3356 src,
3357 s.clock.to_glib_none().0,
3358 s.ready.into_glib()
3359 ));
3360}
3361
3362#[must_use = "The builder must be built to be used"]
3363pub struct ClockLostBuilder<'a> {
3364 builder: MessageBuilder<'a>,
3365 clock: &'a crate::Clock,
3366}
3367
3368impl<'a> ClockLostBuilder<'a> {
3369 fn new(clock: &'a crate::Clock) -> Self {
3370 skip_assert_initialized!();
3371 Self {
3372 builder: MessageBuilder::new(),
3373 clock,
3374 }
3375 }
3376
3377 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_clock_lost(
3378 src,
3379 s.clock.to_glib_none().0
3380 ));
3381}
3382
3383#[must_use = "The builder must be built to be used"]
3384pub struct NewClockBuilder<'a> {
3385 builder: MessageBuilder<'a>,
3386 clock: &'a crate::Clock,
3387}
3388
3389impl<'a> NewClockBuilder<'a> {
3390 fn new(clock: &'a crate::Clock) -> Self {
3391 skip_assert_initialized!();
3392 Self {
3393 builder: MessageBuilder::new(),
3394 clock,
3395 }
3396 }
3397
3398 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_new_clock(
3399 src,
3400 s.clock.to_glib_none().0
3401 ));
3402}
3403
3404#[must_use = "The builder must be built to be used"]
3405pub struct StructureChangeBuilder<'a> {
3406 builder: MessageBuilder<'a>,
3407 type_: crate::StructureChangeType,
3408 owner: &'a crate::Element,
3409 busy: bool,
3410}
3411
3412impl<'a> StructureChangeBuilder<'a> {
3413 fn new(type_: crate::StructureChangeType, owner: &'a crate::Element, busy: bool) -> Self {
3414 skip_assert_initialized!();
3415 Self {
3416 builder: MessageBuilder::new(),
3417 type_,
3418 owner,
3419 busy,
3420 }
3421 }
3422
3423 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_structure_change(
3424 src,
3425 s.type_.into_glib(),
3426 s.owner.to_glib_none().0,
3427 s.busy.into_glib(),
3428 ));
3429}
3430
3431#[must_use = "The builder must be built to be used"]
3432pub struct StreamStatusBuilder<'a> {
3433 builder: MessageBuilder<'a>,
3434 type_: crate::StreamStatusType,
3435 owner: &'a crate::Element,
3436 status_object: Option<glib::SendValue>,
3437}
3438
3439impl<'a> StreamStatusBuilder<'a> {
3440 fn new(type_: crate::StreamStatusType, owner: &'a crate::Element) -> Self {
3441 skip_assert_initialized!();
3442 Self {
3443 builder: MessageBuilder::new(),
3444 type_,
3445 owner,
3446 status_object: None,
3447 }
3448 }
3449
3450 pub fn status_object(self, status_object: impl ToSendValue) -> Self {
3451 Self {
3452 status_object: Some(status_object.to_send_value()),
3453 ..self
3454 }
3455 }
3456
3457 pub fn status_object_if(self, status_object: impl ToSendValue, predicate: bool) -> Self {
3458 if predicate {
3459 self.status_object(status_object)
3460 } else {
3461 self
3462 }
3463 }
3464
3465 pub fn status_object_if_some(self, status_object: Option<impl ToSendValue>) -> Self {
3466 if let Some(status_object) = status_object {
3467 self.status_object(status_object)
3468 } else {
3469 self
3470 }
3471 }
3472
3473 message_builder_generic_impl!(|s: &mut Self, src| {
3474 let msg =
3475 ffi::gst_message_new_stream_status(src, s.type_.into_glib(), s.owner.to_glib_none().0);
3476 if let Some(ref status_object) = s.status_object {
3477 ffi::gst_message_set_stream_status_object(msg, status_object.to_glib_none().0);
3478 }
3479 msg
3480 });
3481}
3482
3483#[must_use = "The builder must be built to be used"]
3484pub struct ApplicationBuilder<'a> {
3485 builder: MessageBuilder<'a>,
3486 structure: Option<crate::Structure>,
3487}
3488
3489impl<'a> ApplicationBuilder<'a> {
3490 fn new(structure: crate::Structure) -> Self {
3491 skip_assert_initialized!();
3492 Self {
3493 builder: MessageBuilder::new(),
3494 structure: Some(structure),
3495 }
3496 }
3497
3498 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_application(
3499 src,
3500 s.structure.take().unwrap().into_glib_ptr()
3501 ));
3502}
3503
3504#[must_use = "The builder must be built to be used"]
3505pub struct ElementBuilder<'a> {
3506 builder: MessageBuilder<'a>,
3507 structure: Option<crate::Structure>,
3508}
3509
3510impl<'a> ElementBuilder<'a> {
3511 fn new(structure: crate::Structure) -> Self {
3512 skip_assert_initialized!();
3513 Self {
3514 builder: MessageBuilder::new(),
3515 structure: Some(structure),
3516 }
3517 }
3518
3519 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_element(
3520 src,
3521 s.structure.take().unwrap().into_glib_ptr()
3522 ));
3523}
3524
3525#[must_use = "The builder must be built to be used"]
3526pub struct SegmentStartBuilder<'a> {
3527 builder: MessageBuilder<'a>,
3528 position: GenericFormattedValue,
3529}
3530
3531impl<'a> SegmentStartBuilder<'a> {
3532 fn new(position: GenericFormattedValue) -> Self {
3533 skip_assert_initialized!();
3534 Self {
3535 builder: MessageBuilder::new(),
3536 position,
3537 }
3538 }
3539
3540 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_segment_start(
3541 src,
3542 s.position.format().into_glib(),
3543 s.position.value(),
3544 ));
3545}
3546
3547#[must_use = "The builder must be built to be used"]
3548pub struct SegmentDoneBuilder<'a> {
3549 builder: MessageBuilder<'a>,
3550 position: GenericFormattedValue,
3551}
3552
3553impl<'a> SegmentDoneBuilder<'a> {
3554 fn new(position: GenericFormattedValue) -> Self {
3555 skip_assert_initialized!();
3556 Self {
3557 builder: MessageBuilder::new(),
3558 position,
3559 }
3560 }
3561
3562 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_segment_done(
3563 src,
3564 s.position.format().into_glib(),
3565 s.position.value(),
3566 ));
3567}
3568
3569#[must_use = "The builder must be built to be used"]
3570pub struct DurationChangedBuilder<'a> {
3571 builder: MessageBuilder<'a>,
3572}
3573
3574impl<'a> DurationChangedBuilder<'a> {
3575 fn new() -> Self {
3576 skip_assert_initialized!();
3577 Self {
3578 builder: MessageBuilder::new(),
3579 }
3580 }
3581
3582 message_builder_generic_impl!(|_, src| ffi::gst_message_new_duration_changed(src));
3583}
3584
3585#[must_use = "The builder must be built to be used"]
3586pub struct LatencyBuilder<'a> {
3587 builder: MessageBuilder<'a>,
3588}
3589
3590impl<'a> LatencyBuilder<'a> {
3591 fn new() -> Self {
3592 skip_assert_initialized!();
3593 Self {
3594 builder: MessageBuilder::new(),
3595 }
3596 }
3597
3598 message_builder_generic_impl!(|_, src| ffi::gst_message_new_latency(src));
3599}
3600
3601#[must_use = "The builder must be built to be used"]
3602pub struct AsyncStartBuilder<'a> {
3603 builder: MessageBuilder<'a>,
3604}
3605
3606impl<'a> AsyncStartBuilder<'a> {
3607 fn new() -> Self {
3608 skip_assert_initialized!();
3609 Self {
3610 builder: MessageBuilder::new(),
3611 }
3612 }
3613
3614 message_builder_generic_impl!(|_, src| ffi::gst_message_new_async_start(src));
3615}
3616
3617#[must_use = "The builder must be built to be used"]
3618pub struct AsyncDoneBuilder<'a> {
3619 builder: MessageBuilder<'a>,
3620 running_time: Option<crate::ClockTime>,
3621}
3622
3623impl<'a> AsyncDoneBuilder<'a> {
3624 fn new() -> Self {
3625 skip_assert_initialized!();
3626 Self {
3627 builder: MessageBuilder::new(),
3628 running_time: None,
3629 }
3630 }
3631
3632 pub fn running_time(mut self, running_time: impl Into<Option<crate::ClockTime>>) -> Self {
3633 self.running_time = running_time.into();
3634 self
3635 }
3636
3637 pub fn running_time_if(self, running_time: crate::ClockTime, predicate: bool) -> Self {
3638 if predicate {
3639 self.running_time(running_time)
3640 } else {
3641 self
3642 }
3643 }
3644
3645 pub fn running_time_if_some(self, running_time: Option<crate::ClockTime>) -> Self {
3646 if let Some(running_time) = running_time {
3647 self.running_time(running_time)
3648 } else {
3649 self
3650 }
3651 }
3652
3653 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_async_done(
3654 src,
3655 s.running_time.into_glib()
3656 ));
3657}
3658
3659#[must_use = "The builder must be built to be used"]
3660pub struct RequestStateBuilder<'a> {
3661 builder: MessageBuilder<'a>,
3662 state: crate::State,
3663}
3664
3665impl<'a> RequestStateBuilder<'a> {
3666 fn new(state: crate::State) -> Self {
3667 skip_assert_initialized!();
3668 Self {
3669 builder: MessageBuilder::new(),
3670 state,
3671 }
3672 }
3673
3674 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_request_state(
3675 src,
3676 s.state.into_glib()
3677 ));
3678}
3679
3680#[must_use = "The builder must be built to be used"]
3681pub struct StepStartBuilder<'a> {
3682 builder: MessageBuilder<'a>,
3683 active: bool,
3684 amount: GenericFormattedValue,
3685 rate: f64,
3686 flush: bool,
3687 intermediate: bool,
3688}
3689
3690impl<'a> StepStartBuilder<'a> {
3691 fn new(
3692 active: bool,
3693 amount: GenericFormattedValue,
3694 rate: f64,
3695 flush: bool,
3696 intermediate: bool,
3697 ) -> Self {
3698 skip_assert_initialized!();
3699 Self {
3700 builder: MessageBuilder::new(),
3701 active,
3702 amount,
3703 rate,
3704 flush,
3705 intermediate,
3706 }
3707 }
3708
3709 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_step_start(
3710 src,
3711 s.active.into_glib(),
3712 s.amount.format().into_glib(),
3713 s.amount.value() as u64,
3714 s.rate,
3715 s.flush.into_glib(),
3716 s.intermediate.into_glib(),
3717 ));
3718}
3719
3720#[must_use = "The builder must be built to be used"]
3721pub struct QosBuilder<'a> {
3722 builder: MessageBuilder<'a>,
3723 live: bool,
3724 running_time: Option<crate::ClockTime>,
3725 stream_time: Option<crate::ClockTime>,
3726 timestamp: Option<crate::ClockTime>,
3727 duration: Option<crate::ClockTime>,
3728 values: Option<(i64, f64, i32)>,
3729 stats: Option<(GenericFormattedValue, GenericFormattedValue)>,
3730}
3731
3732impl<'a> QosBuilder<'a> {
3733 fn new(live: bool) -> Self {
3734 skip_assert_initialized!();
3735 Self {
3736 builder: MessageBuilder::new(),
3737 live,
3738 running_time: None,
3739 stream_time: None,
3740 timestamp: None,
3741 duration: None,
3742 values: None,
3743 stats: None,
3744 }
3745 }
3746
3747 pub fn running_time(mut self, running_time: impl Into<Option<crate::ClockTime>>) -> Self {
3748 self.running_time = running_time.into();
3749 self
3750 }
3751
3752 pub fn running_time_if(self, running_time: crate::ClockTime, predicate: bool) -> Self {
3753 if predicate {
3754 self.running_time(running_time)
3755 } else {
3756 self
3757 }
3758 }
3759
3760 pub fn running_time_if_some(self, running_time: Option<crate::ClockTime>) -> Self {
3761 if let Some(running_time) = running_time {
3762 self.running_time(running_time)
3763 } else {
3764 self
3765 }
3766 }
3767
3768 pub fn stream_time(mut self, stream_time: impl Into<Option<crate::ClockTime>>) -> Self {
3769 self.stream_time = stream_time.into();
3770 self
3771 }
3772
3773 pub fn stream_time_if(self, stream_time: crate::ClockTime, predicate: bool) -> Self {
3774 if predicate {
3775 self.stream_time(stream_time)
3776 } else {
3777 self
3778 }
3779 }
3780
3781 pub fn stream_time_if_some(self, stream_time: Option<crate::ClockTime>) -> Self {
3782 if let Some(stream_time) = stream_time {
3783 self.stream_time(stream_time)
3784 } else {
3785 self
3786 }
3787 }
3788
3789 pub fn timestamp(mut self, timestamp: impl Into<Option<crate::ClockTime>>) -> Self {
3790 self.timestamp = timestamp.into();
3791 self
3792 }
3793
3794 pub fn timestamp_if(self, timestamp: crate::ClockTime, predicate: bool) -> Self {
3795 if predicate {
3796 self.timestamp(timestamp)
3797 } else {
3798 self
3799 }
3800 }
3801
3802 pub fn timestamp_if_some(self, timestamp: Option<crate::ClockTime>) -> Self {
3803 if let Some(timestamp) = timestamp {
3804 self.timestamp(timestamp)
3805 } else {
3806 self
3807 }
3808 }
3809
3810 pub fn duration(mut self, duration: impl Into<Option<crate::ClockTime>>) -> Self {
3811 self.duration = duration.into();
3812 self
3813 }
3814
3815 pub fn duration_if(self, duration: crate::ClockTime, predicate: bool) -> Self {
3816 if predicate {
3817 self.duration(duration)
3818 } else {
3819 self
3820 }
3821 }
3822
3823 pub fn duration_if_some(self, duration: Option<crate::ClockTime>) -> Self {
3824 if let Some(duration) = duration {
3825 self.duration(duration)
3826 } else {
3827 self
3828 }
3829 }
3830
3831 pub fn values(self, jitter: i64, proportion: f64, quality: i32) -> Self {
3832 Self {
3833 values: Some((jitter, proportion, quality)),
3834 ..self
3835 }
3836 }
3837
3838 pub fn stats<V: FormattedValue>(
3839 self,
3840 processed: V,
3841 dropped: impl CompatibleFormattedValue<V>,
3842 ) -> Self {
3843 let dropped = dropped.try_into_checked(processed).unwrap();
3844 Self {
3845 stats: Some((processed.into(), dropped.into())),
3846 ..self
3847 }
3848 }
3849
3850 message_builder_generic_impl!(|s: &mut Self, src| {
3851 let msg = ffi::gst_message_new_qos(
3852 src,
3853 s.live.into_glib(),
3854 s.running_time.into_glib(),
3855 s.stream_time.into_glib(),
3856 s.timestamp.into_glib(),
3857 s.duration.into_glib(),
3858 );
3859 if let Some((jitter, proportion, quality)) = s.values {
3860 ffi::gst_message_set_qos_values(msg, jitter, proportion, quality);
3861 }
3862 if let Some((processed, dropped)) = s.stats {
3863 ffi::gst_message_set_qos_stats(
3864 msg,
3865 processed.format().into_glib(),
3866 processed.value() as u64,
3867 dropped.value() as u64,
3868 );
3869 }
3870 msg
3871 });
3872}
3873
3874#[must_use = "The builder must be built to be used"]
3875pub struct ProgressBuilder<'a> {
3876 builder: MessageBuilder<'a>,
3877 type_: crate::ProgressType,
3878 code: &'a str,
3879 text: &'a str,
3880}
3881
3882impl<'a> ProgressBuilder<'a> {
3883 fn new(type_: crate::ProgressType, code: &'a str, text: &'a str) -> Self {
3884 skip_assert_initialized!();
3885 Self {
3886 builder: MessageBuilder::new(),
3887 type_,
3888 code,
3889 text,
3890 }
3891 }
3892
3893 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_progress(
3894 src,
3895 s.type_.into_glib(),
3896 s.code.to_glib_none().0,
3897 s.text.to_glib_none().0,
3898 ));
3899}
3900
3901#[must_use = "The builder must be built to be used"]
3902pub struct TocBuilder<'a> {
3903 builder: MessageBuilder<'a>,
3904 toc: &'a crate::Toc,
3905 updated: bool,
3906}
3907
3908impl<'a> TocBuilder<'a> {
3909 fn new(toc: &'a crate::Toc, updated: bool) -> Self {
3910 skip_assert_initialized!();
3911 Self {
3912 builder: MessageBuilder::new(),
3913 toc,
3914 updated,
3915 }
3916 }
3917
3918 message_builder_generic_impl!(|s: &Self, src| ffi::gst_message_new_toc(
3919 src,
3920 s.toc.to_glib_none().0,
3921 s.updated.into_glib()
3922 ));
3923}
3924
3925#[must_use = "The builder must be built to be used"]
3926pub struct ResetTimeBuilder<'a> {
3927 builder: MessageBuilder<'a>,
3928 running_time: crate::ClockTime,
3929}
3930
3931impl<'a> ResetTimeBuilder<'a> {
3932 fn new(running_time: crate::ClockTime) -> Self {
3933 skip_assert_initialized!();
3934 Self {
3935 builder: MessageBuilder::new(),
3936 running_time,
3937 }
3938 }
3939
3940 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_reset_time(
3941 src,
3942 s.running_time.into_glib()
3943 ));
3944}
3945
3946#[must_use = "The builder must be built to be used"]
3947pub struct StreamStartBuilder<'a> {
3948 builder: MessageBuilder<'a>,
3949 group_id: Option<GroupId>,
3950}
3951
3952impl<'a> StreamStartBuilder<'a> {
3953 fn new() -> Self {
3954 skip_assert_initialized!();
3955 Self {
3956 builder: MessageBuilder::new(),
3957 group_id: None,
3958 }
3959 }
3960
3961 pub fn group_id(self, group_id: GroupId) -> Self {
3962 Self {
3963 group_id: Some(group_id),
3964 ..self
3965 }
3966 }
3967
3968 pub fn group_id_if(self, group_id: GroupId, predicate: bool) -> Self {
3969 if predicate {
3970 self.group_id(group_id)
3971 } else {
3972 self
3973 }
3974 }
3975
3976 pub fn group_id_if_some(self, group_id: Option<GroupId>) -> Self {
3977 if let Some(group_id) = group_id {
3978 self.group_id(group_id)
3979 } else {
3980 self
3981 }
3982 }
3983
3984 message_builder_generic_impl!(|s: &mut Self, src| {
3985 let msg = ffi::gst_message_new_stream_start(src);
3986 if let Some(group_id) = s.group_id {
3987 ffi::gst_message_set_group_id(msg, group_id.0.get());
3988 }
3989 msg
3990 });
3991}
3992
3993#[must_use = "The builder must be built to be used"]
3994pub struct NeedContextBuilder<'a> {
3995 builder: MessageBuilder<'a>,
3996 context_type: &'a str,
3997}
3998
3999impl<'a> NeedContextBuilder<'a> {
4000 fn new(context_type: &'a str) -> Self {
4001 skip_assert_initialized!();
4002 Self {
4003 builder: MessageBuilder::new(),
4004 context_type,
4005 }
4006 }
4007
4008 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_need_context(
4009 src,
4010 s.context_type.to_glib_none().0
4011 ));
4012}
4013
4014#[must_use = "The builder must be built to be used"]
4015pub struct HaveContextBuilder<'a> {
4016 builder: MessageBuilder<'a>,
4017 context: Option<crate::Context>,
4018}
4019
4020impl<'a> HaveContextBuilder<'a> {
4021 fn new(context: crate::Context) -> Self {
4022 skip_assert_initialized!();
4023 Self {
4024 builder: MessageBuilder::new(),
4025 context: Some(context),
4026 }
4027 }
4028
4029 message_builder_generic_impl!(|s: &mut Self, src| {
4030 let context = s.context.take().unwrap();
4031 ffi::gst_message_new_have_context(src, context.into_glib_ptr())
4032 });
4033}
4034
4035#[must_use = "The builder must be built to be used"]
4036pub struct DeviceAddedBuilder<'a> {
4037 builder: MessageBuilder<'a>,
4038 device: &'a crate::Device,
4039}
4040
4041impl<'a> DeviceAddedBuilder<'a> {
4042 fn new(device: &'a crate::Device) -> Self {
4043 skip_assert_initialized!();
4044 Self {
4045 builder: MessageBuilder::new(),
4046 device,
4047 }
4048 }
4049
4050 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_device_added(
4051 src,
4052 s.device.to_glib_none().0
4053 ));
4054}
4055
4056#[must_use = "The builder must be built to be used"]
4057pub struct DeviceRemovedBuilder<'a> {
4058 builder: MessageBuilder<'a>,
4059 device: &'a crate::Device,
4060}
4061
4062impl<'a> DeviceRemovedBuilder<'a> {
4063 fn new(device: &'a crate::Device) -> Self {
4064 skip_assert_initialized!();
4065 Self {
4066 builder: MessageBuilder::new(),
4067 device,
4068 }
4069 }
4070
4071 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_device_removed(
4072 src,
4073 s.device.to_glib_none().0
4074 ));
4075}
4076
4077#[must_use = "The builder must be built to be used"]
4078pub struct PropertyNotifyBuilder<'a> {
4079 builder: MessageBuilder<'a>,
4080 property_name: &'a str,
4081 value: Option<glib::SendValue>,
4082}
4083
4084impl<'a> PropertyNotifyBuilder<'a> {
4085 fn new(property_name: &'a str) -> Self {
4086 skip_assert_initialized!();
4087 Self {
4088 builder: MessageBuilder::new(),
4089 property_name,
4090 value: None,
4091 }
4092 }
4093
4094 pub fn value(self, value: impl ToSendValue) -> Self {
4095 Self {
4096 value: Some(value.to_send_value()),
4097 ..self
4098 }
4099 }
4100
4101 pub fn value_if(self, value: impl ToSendValue, predicate: bool) -> Self {
4102 if predicate {
4103 self.value(value)
4104 } else {
4105 self
4106 }
4107 }
4108
4109 pub fn value_if_some(self, value: Option<impl ToSendValue>) -> Self {
4110 if let Some(value) = value {
4111 self.value(value)
4112 } else {
4113 self
4114 }
4115 }
4116
4117 pub fn value_from_iter<V: ValueType + ToSendValue + FromIterator<SendValue>, I: ToSendValue>(
4118 self,
4119 name: &'a str,
4120 iter: impl IntoIterator<Item = I>,
4121 ) -> Self {
4122 let iter = iter.into_iter().map(|item| item.to_send_value());
4123 self.other_field(name, V::from_iter(iter))
4124 }
4125
4126 pub fn value_field_if_not_empty<
4127 V: ValueType + ToSendValue + FromIterator<SendValue>,
4128 I: ToSendValue,
4129 >(
4130 self,
4131 name: &'a str,
4132 iter: impl IntoIterator<Item = I>,
4133 ) -> Self {
4134 let mut iter = iter.into_iter().peekable();
4135 if iter.peek().is_some() {
4136 let iter = iter.map(|item| item.to_send_value());
4137 self.other_field(name, V::from_iter(iter))
4138 } else {
4139 self
4140 }
4141 }
4142
4143 message_builder_generic_impl!(|s: &mut Self, src| {
4144 let v = s.value.take();
4145 ffi::gst_message_new_property_notify(
4146 src,
4147 s.property_name.to_glib_none().0,
4148 v.as_ref().map(|v| v.as_ptr()).unwrap_or(ptr::null_mut()),
4149 )
4150 });
4151}
4152
4153#[must_use = "The builder must be built to be used"]
4154pub struct StreamCollectionBuilder<'a> {
4155 builder: MessageBuilder<'a>,
4156 collection: &'a crate::StreamCollection,
4157}
4158
4159impl<'a> StreamCollectionBuilder<'a> {
4160 fn new(collection: &'a crate::StreamCollection) -> Self {
4161 skip_assert_initialized!();
4162 Self {
4163 builder: MessageBuilder::new(),
4164 collection,
4165 }
4166 }
4167
4168 message_builder_generic_impl!(|s: &mut Self, src| {
4169 ffi::gst_message_new_stream_collection(src, s.collection.to_glib_none().0)
4170 });
4171}
4172
4173#[must_use = "The builder must be built to be used"]
4174pub struct StreamsSelectedBuilder<'a> {
4175 builder: MessageBuilder<'a>,
4176 collection: &'a crate::StreamCollection,
4177 streams: SmallVec<[crate::Stream; 8]>,
4178}
4179
4180impl<'a> StreamsSelectedBuilder<'a> {
4181 fn new(collection: &'a crate::StreamCollection) -> Self {
4182 skip_assert_initialized!();
4183 Self {
4184 builder: MessageBuilder::new(),
4185 collection,
4186 streams: SmallVec::default(),
4187 }
4188 }
4189
4190 pub fn streams<S: std::borrow::Borrow<crate::Stream>>(
4191 self,
4192 streams: impl IntoIterator<Item = S>,
4193 ) -> Self {
4194 Self {
4195 streams: streams
4196 .into_iter()
4197 .map(|s| s.borrow().clone())
4198 .collect::<SmallVec<_>>(),
4199 ..self
4200 }
4201 }
4202
4203 pub fn streams_if<S: std::borrow::Borrow<crate::Stream>>(
4204 self,
4205 streams: impl IntoIterator<Item = S>,
4206 predicate: bool,
4207 ) -> Self {
4208 if predicate {
4209 self.streams(streams)
4210 } else {
4211 self
4212 }
4213 }
4214
4215 pub fn streams_if_some<S: std::borrow::Borrow<crate::Stream>>(
4216 self,
4217 streams: Option<impl IntoIterator<Item = S>>,
4218 ) -> Self {
4219 if let Some(streams) = streams {
4220 self.streams(streams)
4221 } else {
4222 self
4223 }
4224 }
4225
4226 pub fn streams_if_not_empty<S: std::borrow::Borrow<crate::Stream>>(
4227 self,
4228 streams: impl IntoIterator<Item = S>,
4229 ) -> Self {
4230 let mut streams = streams.into_iter().peekable();
4231 if streams.peek().is_some() {
4232 self.streams(streams)
4233 } else {
4234 self
4235 }
4236 }
4237
4238 message_builder_generic_impl!(|s: &mut Self, src| {
4239 let msg = ffi::gst_message_new_streams_selected(src, s.collection.to_glib_none().0);
4240 for stream in &s.streams {
4241 ffi::gst_message_streams_selected_add(msg, stream.to_glib_none().0);
4242 }
4243 msg
4244 });
4245}
4246
4247#[must_use = "The builder must be built to be used"]
4248pub struct RedirectBuilder<'a> {
4249 builder: MessageBuilder<'a>,
4250 location: &'a str,
4251 tag_list: Option<TagList>,
4252 entry_struct: Option<Structure>,
4253 #[allow(clippy::type_complexity)]
4254 entries: SmallVec<[(&'a str, Option<TagList>, Option<Structure>); 4]>,
4255}
4256
4257impl<'a> RedirectBuilder<'a> {
4258 fn new(location: &'a str) -> Self {
4259 skip_assert_initialized!();
4260 Self {
4261 builder: MessageBuilder::new(),
4262 location,
4263 tag_list: None,
4264 entry_struct: None,
4265 entries: SmallVec::default(),
4266 }
4267 }
4268
4269 pub fn tag_list(self, tag_list: TagList) -> Self {
4270 Self {
4271 tag_list: Some(tag_list),
4272 ..self
4273 }
4274 }
4275
4276 pub fn tag_list_if(self, tag_list: TagList, predicate: bool) -> Self {
4277 if predicate {
4278 self.tag_list(tag_list)
4279 } else {
4280 self
4281 }
4282 }
4283
4284 pub fn tag_list_if_some(self, tag_list: Option<TagList>) -> Self {
4285 if let Some(tag_list) = tag_list {
4286 self.tag_list(tag_list)
4287 } else {
4288 self
4289 }
4290 }
4291
4292 pub fn entry_struct(self, entry_struct: Structure) -> Self {
4293 Self {
4294 entry_struct: Some(entry_struct),
4295 ..self
4296 }
4297 }
4298
4299 pub fn entry_struct_if(self, entry_struct: Structure, predicate: bool) -> Self {
4300 if predicate {
4301 self.entry_struct(entry_struct)
4302 } else {
4303 self
4304 }
4305 }
4306
4307 pub fn entry_struct_if_some(self, entry_struct: Option<Structure>) -> Self {
4308 if let Some(entry_struct) = entry_struct {
4309 self.entry_struct(entry_struct)
4310 } else {
4311 self
4312 }
4313 }
4314
4315 pub fn entries(
4316 self,
4317 entries: impl IntoIterator<Item = (&'a str, Option<TagList>, Option<Structure>)>,
4318 ) -> Self {
4319 skip_assert_initialized!();
4320 Self {
4321 entries: entries.into_iter().collect(),
4322 ..self
4323 }
4324 }
4325
4326 #[allow(clippy::type_complexity)]
4327 pub fn entries_if(
4328 self,
4329 entries: impl IntoIterator<Item = (&'a str, Option<TagList>, Option<Structure>)>,
4330 predicate: bool,
4331 ) -> Self {
4332 if predicate {
4333 self.entries(entries)
4334 } else {
4335 self
4336 }
4337 }
4338
4339 #[allow(clippy::type_complexity)]
4340 pub fn entries_if_some(
4341 self,
4342 entries: Option<impl IntoIterator<Item = (&'a str, Option<TagList>, Option<Structure>)>>,
4343 ) -> Self {
4344 if let Some(entries) = entries {
4345 self.entries(entries)
4346 } else {
4347 self
4348 }
4349 }
4350
4351 message_builder_generic_impl!(|s: &mut Self, src| {
4352 let entry_struct = s.entry_struct.take();
4353 let tag_list = s.tag_list.take();
4354
4355 let msg = ffi::gst_message_new_redirect(
4356 src,
4357 s.location.to_glib_none().0,
4358 tag_list.into_glib_ptr(),
4359 entry_struct.into_glib_ptr(),
4360 );
4361 for (location, tag_list, entry_struct) in mem::take(&mut s.entries) {
4362 ffi::gst_message_add_redirect_entry(
4363 msg,
4364 location.to_glib_none().0,
4365 tag_list.into_glib_ptr(),
4366 entry_struct.into_glib_ptr(),
4367 );
4368 }
4369 msg
4370 });
4371}
4372
4373#[cfg(feature = "v1_16")]
4374#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
4375#[must_use = "The builder must be built to be used"]
4376pub struct DeviceChangedBuilder<'a> {
4377 builder: MessageBuilder<'a>,
4378 device: &'a crate::Device,
4379 changed_device: &'a crate::Device,
4380}
4381
4382#[cfg(feature = "v1_16")]
4383#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
4384impl<'a> DeviceChangedBuilder<'a> {
4385 fn new(device: &'a crate::Device, changed_device: &'a crate::Device) -> Self {
4386 skip_assert_initialized!();
4387 Self {
4388 builder: MessageBuilder::new(),
4389 device,
4390 changed_device,
4391 }
4392 }
4393
4394 message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_device_changed(
4395 src,
4396 s.device.to_glib_none().0,
4397 s.changed_device.to_glib_none().0,
4398 ));
4399}
4400
4401#[cfg(feature = "v1_18")]
4402#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
4403#[must_use = "The builder must be built to be used"]
4404pub struct InstantRateRequestBuilder<'a> {
4405 builder: MessageBuilder<'a>,
4406 rate_multiplier: f64,
4407}
4408
4409#[cfg(feature = "v1_18")]
4410#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
4411impl<'a> InstantRateRequestBuilder<'a> {
4412 fn new(rate_multiplier: f64) -> Self {
4413 skip_assert_initialized!();
4414 Self {
4415 builder: MessageBuilder::new(),
4416 rate_multiplier,
4417 }
4418 }
4419
4420 message_builder_generic_impl!(
4421 |s: &mut Self, src| ffi::gst_message_new_instant_rate_request(src, s.rate_multiplier,)
4422 );
4423}
4424
4425#[cfg(test)]
4426mod tests {
4427 use super::*;
4428
4429 #[test]
4430 fn test_simple() {
4431 crate::init().unwrap();
4432
4433 let seqnum = Seqnum::next();
4435 let eos_msg = Eos::builder().seqnum(seqnum).build();
4436 match eos_msg.view() {
4437 MessageView::Eos(eos_msg) => {
4438 assert_eq!(eos_msg.seqnum(), seqnum);
4439 assert!(eos_msg.structure().is_none());
4440 }
4441 _ => panic!("eos_msg.view() is not a MessageView::Eos(_)"),
4442 }
4443
4444 let buffering_msg = Buffering::new(42);
4446 match buffering_msg.view() {
4447 MessageView::Buffering(buffering_msg) => {
4448 assert_eq!(buffering_msg.percent(), 42);
4449 }
4450 _ => panic!("buffering_msg.view() is not a MessageView::Buffering(_)"),
4451 }
4452 }
4453
4454 #[test]
4455 #[allow(deprecated)]
4456 fn test_other_fields() {
4457 crate::init().unwrap();
4458
4459 let seqnum = Seqnum::next();
4460 let eos_msg = Eos::builder()
4461 .other_field("extra-field", true)
4462 .seqnum(seqnum)
4463 .build();
4464 match eos_msg.view() {
4465 MessageView::Eos(eos_msg) => {
4466 assert_eq!(eos_msg.seqnum(), seqnum);
4467 if let Some(other_fields) = eos_msg.structure() {
4468 assert!(other_fields.has_field("extra-field"));
4469 }
4470 }
4471 _ => panic!("eos_msg.view() is not a MessageView::Eos(_)"),
4472 }
4473
4474 let buffering_msg = Buffering::builder(42)
4475 .other_field("extra-field", true)
4476 .build();
4477 match buffering_msg.view() {
4478 MessageView::Buffering(buffering_msg) => {
4479 assert_eq!(buffering_msg.percent(), 42);
4480 if let Some(other_fields) = buffering_msg.structure() {
4481 assert!(other_fields.has_field("extra-field"));
4482 }
4483 }
4484 _ => panic!("buffering_msg.view() is not a MessageView::Buffering(_)"),
4485 }
4486 }
4487
4488 #[test]
4489 fn test_get_seqnum_valid() {
4490 crate::init().unwrap();
4491
4492 let msg = StreamStart::new();
4493 let seqnum = Seqnum(
4494 NonZeroU32::new(unsafe { ffi::gst_message_get_seqnum(msg.as_mut_ptr()) }).unwrap(),
4495 );
4496
4497 match msg.view() {
4498 MessageView::StreamStart(stream_start) => assert_eq!(seqnum, stream_start.seqnum()),
4499 _ => panic!(),
4500 }
4501 }
4502
4503 #[test]
4504 fn test_get_seqnum_invalid() {
4505 crate::init().unwrap();
4506
4507 let msg = StreamStart::new();
4508 let seqnum_init = msg.seqnum();
4509
4510 unsafe {
4512 (*msg.as_mut_ptr()).seqnum = ffi::GST_SEQNUM_INVALID as u32;
4513 assert_eq!(0, (*msg.as_ptr()).seqnum);
4514 };
4515
4516 match msg.view() {
4517 MessageView::StreamStart(stream_start) => {
4518 assert!(seqnum_init < stream_start.seqnum());
4521 }
4522 _ => panic!(),
4523 }
4524 }
4525}