1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::{ffi::CStr, future::Future, mem, num::NonZeroU64, pin::Pin};
4
5use glib::translate::*;
6use itertools::Itertools;
7
8use crate::{
9 ffi,
10 format::{
11 CompatibleFormattedValue, FormattedValue, SpecificFormattedValueFullRange,
12 SpecificFormattedValueIntrinsic,
13 },
14 prelude::*,
15 ClockTime, Element, ElementFlags, Event, Format, GenericFormattedValue, Pad, PadTemplate,
16 Plugin, QueryRef, Rank, State,
17};
18
19impl Element {
20 #[doc(alias = "gst_element_link_many")]
21 pub fn link_many(
22 elements: impl IntoIterator<Item = impl AsRef<Element> + Clone>,
23 ) -> Result<(), glib::BoolError> {
24 skip_assert_initialized!();
25 for (src, dest) in elements.into_iter().tuple_windows() {
26 unsafe {
27 glib::result_from_gboolean!(
28 ffi::gst_element_link(
29 src.as_ref().to_glib_none().0,
30 dest.as_ref().to_glib_none().0,
31 ),
32 "Failed to link elements '{}' and '{}'",
33 src.as_ref().name(),
34 dest.as_ref().name(),
35 )?;
36 }
37 }
38
39 Ok(())
40 }
41
42 #[doc(alias = "gst_element_unlink_many")]
43 pub fn unlink_many(elements: impl IntoIterator<Item = impl AsRef<Element> + Clone>) {
44 skip_assert_initialized!();
45 for (src, dest) in elements.into_iter().tuple_windows() {
46 unsafe {
47 ffi::gst_element_unlink(
48 src.as_ref().to_glib_none().0,
49 dest.as_ref().to_glib_none().0,
50 );
51 }
52 }
53 }
54
55 #[doc(alias = "gst_element_register")]
56 pub fn register(
57 plugin: Option<&Plugin>,
58 name: &str,
59 rank: Rank,
60 type_: glib::types::Type,
61 ) -> Result<(), glib::error::BoolError> {
62 skip_assert_initialized!();
63 unsafe {
64 glib::result_from_gboolean!(
65 ffi::gst_element_register(
66 plugin.to_glib_none().0,
67 name.to_glib_none().0,
68 rank.into_glib() as u32,
69 type_.into_glib()
70 ),
71 "Failed to register element factory"
72 )
73 }
74 }
75}
76
77#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
78pub enum ElementMessageType {
79 Error,
80 Warning,
81 Info,
82}
83
84#[derive(Debug, PartialEq, Eq)]
85pub struct NotifyWatchId(NonZeroU64);
86
87impl IntoGlib for NotifyWatchId {
88 type GlibType = libc::c_ulong;
89
90 #[inline]
91 fn into_glib(self) -> libc::c_ulong {
92 self.0.get() as libc::c_ulong
93 }
94}
95
96impl FromGlib<libc::c_ulong> for NotifyWatchId {
97 #[inline]
98 unsafe fn from_glib(val: libc::c_ulong) -> NotifyWatchId {
99 skip_assert_initialized!();
100 debug_assert_ne!(val, 0);
101 NotifyWatchId(NonZeroU64::new_unchecked(val as _))
102 }
103}
104
105mod sealed {
106 pub trait Sealed {}
107 impl<T: super::IsA<super::Element>> Sealed for T {}
108}
109
110pub trait ElementExtManual: sealed::Sealed + IsA<Element> + 'static {
111 #[doc(alias = "get_element_class")]
112 #[inline]
113 fn element_class(&self) -> &glib::Class<Element> {
114 unsafe { self.unsafe_cast_ref::<Element>().class() }
115 }
116
117 #[doc(alias = "get_current_state")]
118 fn current_state(&self) -> State {
119 self.state(Some(ClockTime::ZERO)).1
120 }
121
122 #[doc(alias = "get_pending_state")]
123 fn pending_state(&self) -> State {
124 self.state(Some(ClockTime::ZERO)).2
125 }
126
127 #[doc(alias = "gst_element_query")]
128 fn query(&self, query: &mut QueryRef) -> bool {
129 unsafe {
130 from_glib(ffi::gst_element_query(
131 self.as_ref().to_glib_none().0,
132 query.as_mut_ptr(),
133 ))
134 }
135 }
136
137 #[doc(alias = "gst_element_send_event")]
138 fn send_event(&self, event: impl Into<Event>) -> bool {
139 unsafe {
140 from_glib(ffi::gst_element_send_event(
141 self.as_ref().to_glib_none().0,
142 event.into().into_glib_ptr(),
143 ))
144 }
145 }
146
147 #[doc(alias = "get_metadata")]
148 #[doc(alias = "gst_element_class_get_metadata")]
149 fn metadata<'a>(&self, key: &str) -> Option<&'a str> {
150 self.element_class().metadata(key)
151 }
152
153 #[doc(alias = "get_pad_template")]
154 #[doc(alias = "gst_element_class_get_pad_template")]
155 fn pad_template(&self, name: &str) -> Option<PadTemplate> {
156 self.element_class().pad_template(name)
157 }
158
159 #[doc(alias = "get_pad_template_list")]
160 #[doc(alias = "gst_element_class_get_pad_template_list")]
161 fn pad_template_list(&self) -> glib::List<PadTemplate> {
162 self.element_class().pad_template_list()
163 }
164
165 #[allow(clippy::too_many_arguments)]
166 #[doc(alias = "gst_element_message_full")]
167 fn message_full<T: crate::MessageErrorDomain>(
168 &self,
169 type_: ElementMessageType,
170 code: T,
171 message: Option<&str>,
172 debug: Option<&str>,
173 file: &str,
174 function: &str,
175 line: u32,
176 ) {
177 unsafe {
178 let type_ = match type_ {
179 ElementMessageType::Error => ffi::GST_MESSAGE_ERROR,
180 ElementMessageType::Warning => ffi::GST_MESSAGE_WARNING,
181 ElementMessageType::Info => ffi::GST_MESSAGE_INFO,
182 };
183
184 ffi::gst_element_message_full(
185 self.as_ref().to_glib_none().0,
186 type_,
187 T::domain().into_glib(),
188 code.code(),
189 message.to_glib_full(),
190 debug.to_glib_full(),
191 file.to_glib_none().0,
192 function.to_glib_none().0,
193 line as i32,
194 );
195 }
196 }
197
198 fn set_element_flags(&self, flags: ElementFlags) {
199 unsafe {
200 let ptr: *mut ffi::GstObject = self.as_ptr() as *mut _;
201 let _guard = self.as_ref().object_lock();
202 (*ptr).flags |= flags.into_glib();
203 }
204 }
205
206 fn unset_element_flags(&self, flags: ElementFlags) {
207 unsafe {
208 let ptr: *mut ffi::GstObject = self.as_ptr() as *mut _;
209 let _guard = self.as_ref().object_lock();
210 (*ptr).flags &= !flags.into_glib();
211 }
212 }
213
214 #[doc(alias = "get_element_flags")]
215 fn element_flags(&self) -> ElementFlags {
216 unsafe {
217 let ptr: *mut ffi::GstObject = self.as_ptr() as *mut _;
218 let _guard = self.as_ref().object_lock();
219 from_glib((*ptr).flags)
220 }
221 }
222
223 #[allow(clippy::too_many_arguments)]
224 #[doc(alias = "gst_element_message_full_with_details")]
225 fn message_full_with_details<T: crate::MessageErrorDomain>(
226 &self,
227 type_: ElementMessageType,
228 code: T,
229 message: Option<&str>,
230 debug: Option<&str>,
231 file: &str,
232 function: &str,
233 line: u32,
234 structure: crate::Structure,
235 ) {
236 unsafe {
237 let type_ = match type_ {
238 ElementMessageType::Error => ffi::GST_MESSAGE_ERROR,
239 ElementMessageType::Warning => ffi::GST_MESSAGE_WARNING,
240 ElementMessageType::Info => ffi::GST_MESSAGE_INFO,
241 };
242
243 ffi::gst_element_message_full_with_details(
244 self.as_ref().to_glib_none().0,
245 type_,
246 T::domain().into_glib(),
247 code.code(),
248 message.to_glib_full(),
249 debug.to_glib_full(),
250 file.to_glib_none().0,
251 function.to_glib_none().0,
252 line as i32,
253 structure.into_glib_ptr(),
254 );
255 }
256 }
257
258 fn post_error_message(&self, msg: crate::ErrorMessage) {
259 let crate::ErrorMessage {
260 error_domain,
261 error_code,
262 ref message,
263 ref debug,
264 filename,
265 function,
266 line,
267 } = msg;
268
269 unsafe {
270 ffi::gst_element_message_full(
271 self.as_ref().to_glib_none().0,
272 ffi::GST_MESSAGE_ERROR,
273 error_domain.into_glib(),
274 error_code,
275 message.to_glib_full(),
276 debug.to_glib_full(),
277 filename.to_glib_none().0,
278 function.to_glib_none().0,
279 line as i32,
280 );
281 }
282 }
283
284 #[doc(alias = "gst_element_iterate_pads")]
285 fn iterate_pads(&self) -> crate::Iterator<Pad> {
286 unsafe {
287 from_glib_full(ffi::gst_element_iterate_pads(
288 self.as_ref().to_glib_none().0,
289 ))
290 }
291 }
292
293 #[doc(alias = "gst_element_iterate_sink_pads")]
294 fn iterate_sink_pads(&self) -> crate::Iterator<Pad> {
295 unsafe {
296 from_glib_full(ffi::gst_element_iterate_sink_pads(
297 self.as_ref().to_glib_none().0,
298 ))
299 }
300 }
301
302 #[doc(alias = "gst_element_iterate_src_pads")]
303 fn iterate_src_pads(&self) -> crate::Iterator<Pad> {
304 unsafe {
305 from_glib_full(ffi::gst_element_iterate_src_pads(
306 self.as_ref().to_glib_none().0,
307 ))
308 }
309 }
310
311 #[doc(alias = "get_pads")]
312 #[doc(alias = "gst_element_foreach_pad")]
313 fn pads(&self) -> Vec<Pad> {
314 unsafe {
315 let elt: &ffi::GstElement = &*(self.as_ptr() as *const _);
316 let _guard = self.as_ref().object_lock();
317 FromGlibPtrContainer::from_glib_none(elt.pads)
318 }
319 }
320
321 #[doc(alias = "get_sink_pads")]
322 #[doc(alias = "gst_element_foreach_sink_pad")]
323 fn sink_pads(&self) -> Vec<Pad> {
324 unsafe {
325 let elt: &ffi::GstElement = &*(self.as_ptr() as *const _);
326 let _guard = self.as_ref().object_lock();
327 FromGlibPtrContainer::from_glib_none(elt.sinkpads)
328 }
329 }
330
331 #[doc(alias = "get_src_pads")]
332 #[doc(alias = "gst_element_foreach_src_pad")]
333 fn src_pads(&self) -> Vec<Pad> {
334 unsafe {
335 let elt: &ffi::GstElement = &*(self.as_ptr() as *const _);
336 let _guard = self.as_ref().object_lock();
337 FromGlibPtrContainer::from_glib_none(elt.srcpads)
338 }
339 }
340
341 fn num_pads(&self) -> u16 {
342 unsafe {
343 let elt: &ffi::GstElement = &*(self.as_ptr() as *const _);
344 let _guard = self.as_ref().object_lock();
345 elt.numpads
346 }
347 }
348
349 fn num_sink_pads(&self) -> u16 {
350 unsafe {
351 let elt: &ffi::GstElement = &*(self.as_ptr() as *const _);
352 let _guard = self.as_ref().object_lock();
353 elt.numsinkpads
354 }
355 }
356
357 fn num_src_pads(&self) -> u16 {
358 unsafe {
359 let elt: &ffi::GstElement = &*(self.as_ptr() as *const _);
360 let _guard = self.as_ref().object_lock();
361 elt.numsrcpads
362 }
363 }
364
365 #[doc(alias = "gst_element_add_property_deep_notify_watch")]
366 fn add_property_deep_notify_watch(
367 &self,
368 property_name: Option<&str>,
369 include_value: bool,
370 ) -> NotifyWatchId {
371 let property_name = property_name.to_glib_none();
372 unsafe {
373 from_glib(ffi::gst_element_add_property_deep_notify_watch(
374 self.as_ref().to_glib_none().0,
375 property_name.0,
376 include_value.into_glib(),
377 ))
378 }
379 }
380
381 #[doc(alias = "gst_element_add_property_notify_watch")]
382 fn add_property_notify_watch(
383 &self,
384 property_name: Option<&str>,
385 include_value: bool,
386 ) -> NotifyWatchId {
387 let property_name = property_name.to_glib_none();
388 unsafe {
389 from_glib(ffi::gst_element_add_property_notify_watch(
390 self.as_ref().to_glib_none().0,
391 property_name.0,
392 include_value.into_glib(),
393 ))
394 }
395 }
396
397 #[doc(alias = "gst_element_remove_property_notify_watch")]
398 fn remove_property_notify_watch(&self, watch_id: NotifyWatchId) {
399 unsafe {
400 ffi::gst_element_remove_property_notify_watch(
401 self.as_ref().to_glib_none().0,
402 watch_id.into_glib(),
403 );
404 }
405 }
406
407 #[doc(alias = "gst_element_query_convert")]
408 fn query_convert<U: SpecificFormattedValueFullRange>(
409 &self,
410 src_val: impl FormattedValue,
411 ) -> Option<U> {
412 unsafe {
413 let mut dest_val = mem::MaybeUninit::uninit();
414 let ret = from_glib(ffi::gst_element_query_convert(
415 self.as_ref().to_glib_none().0,
416 src_val.format().into_glib(),
417 src_val.into_raw_value(),
418 U::default_format().into_glib(),
419 dest_val.as_mut_ptr(),
420 ));
421 if ret {
422 Some(U::from_raw(U::default_format(), dest_val.assume_init()))
423 } else {
424 None
425 }
426 }
427 }
428
429 #[doc(alias = "gst_element_query_convert")]
430 fn query_convert_generic(
431 &self,
432 src_val: impl FormattedValue,
433 dest_format: Format,
434 ) -> Option<GenericFormattedValue> {
435 unsafe {
436 let mut dest_val = mem::MaybeUninit::uninit();
437 let ret = from_glib(ffi::gst_element_query_convert(
438 self.as_ref().to_glib_none().0,
439 src_val.format().into_glib(),
440 src_val.into_raw_value(),
441 dest_format.into_glib(),
442 dest_val.as_mut_ptr(),
443 ));
444 if ret {
445 Some(GenericFormattedValue::new(
446 dest_format,
447 dest_val.assume_init(),
448 ))
449 } else {
450 None
451 }
452 }
453 }
454
455 #[doc(alias = "gst_element_query_duration")]
456 fn query_duration<T: SpecificFormattedValueIntrinsic>(&self) -> Option<T> {
457 unsafe {
458 let mut duration = mem::MaybeUninit::uninit();
459 let ret = from_glib(ffi::gst_element_query_duration(
460 self.as_ref().to_glib_none().0,
461 T::default_format().into_glib(),
462 duration.as_mut_ptr(),
463 ));
464 if ret {
465 try_from_glib(duration.assume_init()).ok()
466 } else {
467 None
468 }
469 }
470 }
471
472 #[doc(alias = "gst_element_query_duration")]
473 fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> {
474 unsafe {
475 let mut duration = mem::MaybeUninit::uninit();
476 let ret = from_glib(ffi::gst_element_query_duration(
477 self.as_ref().to_glib_none().0,
478 format.into_glib(),
479 duration.as_mut_ptr(),
480 ));
481 if ret {
482 Some(GenericFormattedValue::new(format, duration.assume_init()))
483 } else {
484 None
485 }
486 }
487 }
488
489 #[doc(alias = "gst_element_query_position")]
490 fn query_position<T: SpecificFormattedValueIntrinsic>(&self) -> Option<T> {
491 unsafe {
492 let mut cur = mem::MaybeUninit::uninit();
493 let ret = from_glib(ffi::gst_element_query_position(
494 self.as_ref().to_glib_none().0,
495 T::default_format().into_glib(),
496 cur.as_mut_ptr(),
497 ));
498 if ret {
499 try_from_glib(cur.assume_init()).ok()
500 } else {
501 None
502 }
503 }
504 }
505
506 #[doc(alias = "gst_element_query_position")]
507 fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> {
508 unsafe {
509 let mut cur = mem::MaybeUninit::uninit();
510 let ret = from_glib(ffi::gst_element_query_position(
511 self.as_ref().to_glib_none().0,
512 format.into_glib(),
513 cur.as_mut_ptr(),
514 ));
515 if ret {
516 Some(GenericFormattedValue::new(format, cur.assume_init()))
517 } else {
518 None
519 }
520 }
521 }
522
523 #[doc(alias = "gst_element_seek")]
524 fn seek<V: FormattedValue>(
525 &self,
526 rate: f64,
527 flags: crate::SeekFlags,
528 start_type: crate::SeekType,
529 start: V,
530 stop_type: crate::SeekType,
531 stop: impl CompatibleFormattedValue<V>,
532 ) -> Result<(), glib::error::BoolError> {
533 let stop = stop.try_into_checked(start).unwrap();
534
535 unsafe {
536 glib::result_from_gboolean!(
537 ffi::gst_element_seek(
538 self.as_ref().to_glib_none().0,
539 rate,
540 start.format().into_glib(),
541 flags.into_glib(),
542 start_type.into_glib(),
543 start.into_raw_value(),
544 stop_type.into_glib(),
545 stop.into_raw_value(),
546 ),
547 "Failed to seek",
548 )
549 }
550 }
551
552 #[doc(alias = "gst_element_seek_simple")]
553 fn seek_simple(
554 &self,
555 seek_flags: crate::SeekFlags,
556 seek_pos: impl FormattedValue,
557 ) -> Result<(), glib::error::BoolError> {
558 unsafe {
559 glib::result_from_gboolean!(
560 ffi::gst_element_seek_simple(
561 self.as_ref().to_glib_none().0,
562 seek_pos.format().into_glib(),
563 seek_flags.into_glib(),
564 seek_pos.into_raw_value(),
565 ),
566 "Failed to seek",
567 )
568 }
569 }
570
571 #[doc(alias = "gst_element_call_async")]
572 fn call_async<F>(&self, func: F)
573 where
574 F: FnOnce(&Self) + Send + 'static,
575 {
576 let user_data: Box<Option<F>> = Box::new(Some(func));
577
578 unsafe extern "C" fn trampoline<O: IsA<Element>, F: FnOnce(&O) + Send + 'static>(
579 element: *mut ffi::GstElement,
580 user_data: glib::ffi::gpointer,
581 ) {
582 let user_data: &mut Option<F> = &mut *(user_data as *mut _);
583 let callback = user_data.take().unwrap();
584
585 callback(Element::from_glib_borrow(element).unsafe_cast_ref());
586 }
587
588 unsafe extern "C" fn free_user_data<O: IsA<Element>, F: FnOnce(&O) + Send + 'static>(
589 user_data: glib::ffi::gpointer,
590 ) {
591 let _: Box<Option<F>> = Box::from_raw(user_data as *mut _);
592 }
593
594 unsafe {
595 ffi::gst_element_call_async(
596 self.as_ref().to_glib_none().0,
597 Some(trampoline::<Self, F>),
598 Box::into_raw(user_data) as *mut _,
599 Some(free_user_data::<Self, F>),
600 );
601 }
602 }
603
604 fn call_async_future<F, T>(&self, func: F) -> Pin<Box<dyn Future<Output = T> + Send + 'static>>
605 where
606 F: FnOnce(&Self) -> T + Send + 'static,
607 T: Send + 'static,
608 {
609 use futures_channel::oneshot;
610
611 let (sender, receiver) = oneshot::channel();
612
613 self.call_async(move |element| {
614 let _ = sender.send(func(element));
615 });
616
617 Box::pin(async move { receiver.await.expect("sender dropped") })
618 }
619
620 #[doc(alias = "get_current_running_time")]
621 #[doc(alias = "gst_element_get_current_running_time")]
622 fn current_running_time(&self) -> Option<crate::ClockTime> {
623 let base_time = self.base_time();
624 let clock_time = self.current_clock_time();
625
626 clock_time
627 .zip(base_time)
628 .and_then(|(ct, bt)| ct.checked_sub(bt))
629 }
630
631 #[doc(alias = "get_current_clock_time")]
632 #[doc(alias = "gst_element_get_current_clock_time")]
633 fn current_clock_time(&self) -> Option<crate::ClockTime> {
634 if let Some(clock) = self.clock() {
635 clock.time()
636 } else {
637 crate::ClockTime::NONE
638 }
639 }
640
641 #[doc(alias = "gst_element_get_request_pad")]
642 #[doc(alias = "get_request_pad")]
643 #[doc(alias = "gst_element_request_pad_simple")]
644 fn request_pad_simple(&self, name: &str) -> Option<Pad> {
645 unsafe {
646 #[cfg(feature = "v1_20")]
647 {
648 from_glib_full(ffi::gst_element_request_pad_simple(
649 self.as_ref().to_glib_none().0,
650 name.to_glib_none().0,
651 ))
652 }
653 #[cfg(not(feature = "v1_20"))]
654 {
655 from_glib_full(ffi::gst_element_get_request_pad(
656 self.as_ref().to_glib_none().0,
657 name.to_glib_none().0,
658 ))
659 }
660 }
661 }
662
663 #[doc(alias = "gst_element_link")]
664 fn link(&self, dest: &impl IsA<Element>) -> Result<(), glib::error::BoolError> {
665 unsafe {
666 glib::result_from_gboolean!(
667 ffi::gst_element_link(
668 self.as_ref().to_glib_none().0,
669 dest.as_ref().to_glib_none().0
670 ),
671 "Failed to link elements '{}' and '{}'",
672 self.as_ref().name(),
673 dest.as_ref().name(),
674 )
675 }
676 }
677
678 #[doc(alias = "gst_element_link_filtered")]
679 fn link_filtered(
680 &self,
681 dest: &impl IsA<Element>,
682 filter: &crate::Caps,
683 ) -> Result<(), glib::error::BoolError> {
684 unsafe {
685 glib::result_from_gboolean!(
686 ffi::gst_element_link_filtered(
687 self.as_ref().to_glib_none().0,
688 dest.as_ref().to_glib_none().0,
689 filter.to_glib_none().0
690 ),
691 "Failed to link elements '{}' and '{}' with filter '{:?}'",
692 self.as_ref().name(),
693 dest.as_ref().name(),
694 filter,
695 )
696 }
697 }
698
699 #[doc(alias = "gst_element_link_pads")]
700 fn link_pads(
701 &self,
702 srcpadname: Option<&str>,
703 dest: &impl IsA<Element>,
704 destpadname: Option<&str>,
705 ) -> Result<(), glib::error::BoolError> {
706 unsafe {
707 glib::result_from_gboolean!(
708 ffi::gst_element_link_pads(
709 self.as_ref().to_glib_none().0,
710 srcpadname.to_glib_none().0,
711 dest.as_ref().to_glib_none().0,
712 destpadname.to_glib_none().0
713 ),
714 "Failed to link pads '{}' and '{}'",
715 if let Some(srcpadname) = srcpadname {
716 format!("{}:{}", self.as_ref().name(), srcpadname)
717 } else {
718 format!("{}:*", self.as_ref().name())
719 },
720 if let Some(destpadname) = destpadname {
721 format!("{}:{}", dest.as_ref().name(), destpadname)
722 } else {
723 format!("{}:*", dest.as_ref().name())
724 },
725 )
726 }
727 }
728
729 #[doc(alias = "gst_element_link_pads_filtered")]
730 fn link_pads_filtered(
731 &self,
732 srcpadname: Option<&str>,
733 dest: &impl IsA<Element>,
734 destpadname: Option<&str>,
735 filter: &crate::Caps,
736 ) -> Result<(), glib::error::BoolError> {
737 unsafe {
738 glib::result_from_gboolean!(
739 ffi::gst_element_link_pads_filtered(
740 self.as_ref().to_glib_none().0,
741 srcpadname.to_glib_none().0,
742 dest.as_ref().to_glib_none().0,
743 destpadname.to_glib_none().0,
744 filter.to_glib_none().0
745 ),
746 "Failed to link pads '{}' and '{}' with filter '{:?}'",
747 if let Some(srcpadname) = srcpadname {
748 format!("{}:{}", self.as_ref().name(), srcpadname)
749 } else {
750 format!("{}:*", self.as_ref().name())
751 },
752 if let Some(destpadname) = destpadname {
753 format!("{}:{}", dest.as_ref().name(), destpadname)
754 } else {
755 format!("{}:*", dest.as_ref().name())
756 },
757 filter,
758 )
759 }
760 }
761
762 #[doc(alias = "gst_element_link_pads_full")]
763 fn link_pads_full(
764 &self,
765 srcpadname: Option<&str>,
766 dest: &impl IsA<Element>,
767 destpadname: Option<&str>,
768 flags: crate::PadLinkCheck,
769 ) -> Result<(), glib::error::BoolError> {
770 unsafe {
771 glib::result_from_gboolean!(
772 ffi::gst_element_link_pads_full(
773 self.as_ref().to_glib_none().0,
774 srcpadname.to_glib_none().0,
775 dest.as_ref().to_glib_none().0,
776 destpadname.to_glib_none().0,
777 flags.into_glib()
778 ),
779 "Failed to link pads '{}' and '{}' with flags '{:?}'",
780 if let Some(srcpadname) = srcpadname {
781 format!("{}:{}", self.as_ref().name(), srcpadname)
782 } else {
783 format!("{}:*", self.as_ref().name())
784 },
785 if let Some(destpadname) = destpadname {
786 format!("{}:{}", dest.as_ref().name(), destpadname)
787 } else {
788 format!("{}:*", dest.as_ref().name())
789 },
790 flags,
791 )
792 }
793 }
794}
795
796impl<O: IsA<Element>> ElementExtManual for O {}
797
798pub unsafe trait ElementClassExt {
799 #[doc(alias = "get_metadata")]
800 #[doc(alias = "gst_element_class_get_metadata")]
801 fn metadata<'a>(&self, key: &str) -> Option<&'a str> {
802 unsafe {
803 let klass = self as *const _ as *const ffi::GstElementClass;
804
805 let ptr = ffi::gst_element_class_get_metadata(klass as *mut _, key.to_glib_none().0);
806
807 if ptr.is_null() {
808 None
809 } else {
810 Some(CStr::from_ptr(ptr).to_str().unwrap())
811 }
812 }
813 }
814
815 #[doc(alias = "get_pad_template")]
816 #[doc(alias = "gst_element_class_get_pad_template")]
817 fn pad_template(&self, name: &str) -> Option<PadTemplate> {
818 unsafe {
819 let klass = self as *const _ as *const ffi::GstElementClass;
820
821 from_glib_none(ffi::gst_element_class_get_pad_template(
822 klass as *mut _,
823 name.to_glib_none().0,
824 ))
825 }
826 }
827
828 #[doc(alias = "get_pad_template_list")]
829 #[doc(alias = "gst_element_class_get_pad_template_list")]
830 fn pad_template_list(&self) -> glib::List<PadTemplate> {
831 unsafe {
832 let klass = self as *const _ as *const ffi::GstElementClass;
833
834 glib::List::from_glib_none(ffi::gst_element_class_get_pad_template_list(
835 klass as *mut _,
836 ))
837 }
838 }
839}
840
841unsafe impl<T: IsA<Element> + glib::object::IsClass> ElementClassExt for glib::object::Class<T> {}
842
843#[doc(alias = "GST_ELEMENT_METADATA_AUTHOR")]
844pub static ELEMENT_METADATA_AUTHOR: &glib::GStr =
845 unsafe { glib::GStr::from_utf8_with_nul_unchecked(bytes:ffi::GST_ELEMENT_METADATA_AUTHOR) };
846#[doc(alias = "GST_ELEMENT_METADATA_DESCRIPTION")]
847pub static ELEMENT_METADATA_DESCRIPTION: &glib::GStr =
848 unsafe { glib::GStr::from_utf8_with_nul_unchecked(bytes:ffi::GST_ELEMENT_METADATA_DESCRIPTION) };
849#[doc(alias = "GST_ELEMENT_METADATA_DOC_URI")]
850pub static ELEMENT_METADATA_DOC_URI: &glib::GStr =
851 unsafe { glib::GStr::from_utf8_with_nul_unchecked(bytes:ffi::GST_ELEMENT_METADATA_DOC_URI) };
852#[doc(alias = "GST_ELEMENT_METADATA_ICON_NAME")]
853pub static ELEMENT_METADATA_ICON_NAME: &glib::GStr =
854 unsafe { glib::GStr::from_utf8_with_nul_unchecked(bytes:ffi::GST_ELEMENT_METADATA_ICON_NAME) };
855#[doc(alias = "GST_ELEMENT_METADATA_KLASS")]
856pub static ELEMENT_METADATA_KLASS: &glib::GStr =
857 unsafe { glib::GStr::from_utf8_with_nul_unchecked(bytes:ffi::GST_ELEMENT_METADATA_KLASS) };
858#[doc(alias = "GST_ELEMENT_METADATA_LONGNAME")]
859pub static ELEMENT_METADATA_LONGNAME: &glib::GStr =
860 unsafe { glib::GStr::from_utf8_with_nul_unchecked(bytes:ffi::GST_ELEMENT_METADATA_LONGNAME) };
861
862#[doc(alias = "GST_ELEMENT_ERROR")]
863#[doc(alias = "GST_ELEMENT_ERROR_WITH_DETAILS")]
864#[macro_export]
865macro_rules! element_error(
866 ($obj:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*]) => { {
867 use $crate::prelude::ElementExtManual;
868 $obj.message_full(
869 $crate::ElementMessageType::Error,
870 $err,
871 Some(&format!($($msg)*)),
872 Some(&format!($($debug)*)),
873 file!(),
874 $crate::glib::function_name!(),
875 line!(),
876 );
877 }};
878 ($obj:expr, $err:expr, ($($msg:tt)*)) => { {
879 use $crate::prelude::ElementExtManual;
880 $obj.message_full(
881 $crate::ElementMessageType::Error,
882 $err,
883 Some(&format!($($msg)*)),
884 None,
885 file!(),
886 $crate::glib::function_name!(),
887 line!(),
888 );
889 }};
890 ($obj:expr, $err:expr, [$($debug:tt)*]) => { {
891 use $crate::prelude::ElementExtManual;
892 $obj.message_full(
893 $crate::ElementMessageType::Error,
894 $err,
895 None,
896 Some(&format!($($debug)*)),
897 file!(),
898 $crate::glib::function_name!(),
899 line!(),
900 );
901 }};
902
903 ($obj:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*], details: $details:expr) => { {
904 use $crate::prelude::ElementExtManual;
905 $obj.message_full_with_details(
906 $crate::ElementMessageType::Error,
907 $err,
908 Some(&format!($($msg)*)),
909 Some(&format!($($debug)*)),
910 file!(),
911 $crate::glib::function_name!(),
912 line!(),
913 $details,
914 );
915 }};
916 ($obj:expr, $err:expr, ($($msg:tt)*), details: $details:expr) => { {
917 use $crate::prelude::ElementExtManual;
918 $obj.message_full_with_details(
919 $crate::ElementMessageType::Error,
920 $err,
921 Some(&format!($($msg)*)),
922 None,
923 file!(),
924 $crate::glib::function_name!(),
925 line!(),
926 $details,
927 );
928 }};
929 ($obj:expr, $err:expr, [$($debug:tt)*], details: $details:expr) => { {
930 use $crate::prelude::ElementExtManual;
931 $obj.message_full_with_details(
932 $crate::ElementMessageType::Error,
933 $err,
934 None,
935 Some(&format!($($debug)*)),
936 file!(),
937 $crate::glib::function_name!(),
938 line!(),
939 $details,
940 );
941 }};
942);
943
944#[doc(alias = "GST_ELEMENT_WARNING")]
945#[doc(alias = "GST_ELEMENT_WARNING_WITH_DETAILS")]
946#[macro_export]
947macro_rules! element_warning(
948 ($obj:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*]) => { {
949 use $crate::prelude::ElementExtManual;
950 $obj.message_full(
951 $crate::ElementMessageType::Warning,
952 $err,
953 Some(&format!($($msg)*)),
954 Some(&format!($($debug)*)),
955 file!(),
956 $crate::glib::function_name!(),
957 line!(),
958 );
959 }};
960 ($obj:expr, $err:expr, ($($msg:tt)*)) => { {
961 use $crate::prelude::ElementExtManual;
962 $obj.message_full(
963 $crate::ElementMessageType::Warning,
964 $err,
965 Some(&format!($($msg)*)),
966 None,
967 file!(),
968 $crate::glib::function_name!(),
969 line!(),
970 );
971 }};
972 ($obj:expr, $err:expr, [$($debug:tt)*]) => { {
973 use $crate::prelude::ElementExtManual;
974 $obj.message_full(
975 $crate::ElementMessageType::Warning,
976 $err,
977 None,
978 Some(&format!($($debug)*)),
979 file!(),
980 $crate::glib::function_name!(),
981 line!(),
982 );
983 }};
984
985 ($obj:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*], details: $details:expr) => { {
986 use $crate::prelude::ElementExtManual;
987 $obj.message_full_with_details(
988 $crate::ElementMessageType::Warning,
989 $err,
990 Some(&format!($($msg)*)),
991 Some(&format!($($debug)*)),
992 file!(),
993 $crate::glib::function_name!(),
994 line!(),
995 $details,
996 );
997 }};
998 ($obj:expr, $err:expr, ($($msg:tt)*), details: $details:expr) => { {
999 use $crate::prelude::ElementExtManual;
1000 $obj.message_full_with_details(
1001 $crate::ElementMessageType::Warning,
1002 $err,
1003 Some(&format!($($msg)*)),
1004 None,
1005 file!(),
1006 $crate::glib::function_name!(),
1007 line!(),
1008 $details,
1009 );
1010 }};
1011 ($obj:expr, $err:expr, [$($debug:tt)*], details: $details:expr) => { {
1012 use $crate::prelude::ElementExtManual;
1013 $obj.message_full_with_details(
1014 $crate::ElementMessageType::Warning,
1015 $err,
1016 None,
1017 Some(&format!($($debug)*)),
1018 file!(),
1019 $crate::glib::function_name!(),
1020 line!(),
1021 $details,
1022 );
1023 }};
1024);
1025
1026#[doc(alias = "GST_ELEMENT_INFO")]
1027#[doc(alias = "GST_ELEMENT_INFO_WITH_DETAILS")]
1028#[macro_export]
1029macro_rules! element_info(
1030 ($obj:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*]) => { {
1031 use $crate::prelude::ElementExtManual;
1032 $obj.message_full(
1033 $crate::ElementMessageType::Info,
1034 $err,
1035 Some(&format!($($msg)*)),
1036 Some(&format!($($debug)*)),
1037 file!(),
1038 $crate::glib::function_name!(),
1039 line!(),
1040 );
1041 }};
1042 ($obj:expr, $err:expr, ($($msg:tt)*)) => { {
1043 use $crate::prelude::ElementExtManual;
1044 $obj.message_full(
1045 $crate::ElementMessageType::Info,
1046 $err,
1047 Some(&format!($($msg)*)),
1048 None,
1049 file!(),
1050 $crate::glib::function_name!(),
1051 line!(),
1052 );
1053 }};
1054 ($obj:expr, $err:expr, [$($debug:tt)*]) => { {
1055 use $crate::prelude::ElementExtManual;
1056 $obj.message_full(
1057 $crate::ElementMessageType::Info,
1058 $err,
1059 None,
1060 Some(&format!($($debug)*)),
1061 file!(),
1062 $crate::glib::function_name!(),
1063 line!(),
1064 );
1065 }};
1066
1067 ($obj:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*], details: $details:expr) => { {
1068 use $crate::prelude::ElementExtManual;
1069 $obj.message_full_with_details(
1070 $crate::ElementMessageType::Info,
1071 $err,
1072 Some(&format!($($msg)*)),
1073 Some(&format!($($debug)*)),
1074 file!(),
1075 $crate::glib::function_name!(),
1076 line!(),
1077 $details,
1078 );
1079 }};
1080 ($obj:expr, $err:expr, ($($msg:tt)*), details: $details:expr) => { {
1081 use $crate::prelude::ElementExtManual;
1082 $obj.message_full_with_details(
1083 $crate::ElementMessageType::Info,
1084 $err,
1085 Some(&format!($($msg)*)),
1086 None,
1087 file!(),
1088 $crate::glib::function_name!(),
1089 line!(),
1090 $details,
1091 );
1092 }};
1093 ($obj:expr, $err:expr, [$($debug:tt)*], details: $details:expr) => { {
1094 use $crate::prelude::ElementExtManual;
1095 $obj.message_full_with_details(
1096 $crate::ElementMessageType::Info,
1097 $err,
1098 None,
1099 Some(&format!($($debug)*)),
1100 file!(),
1101 $crate::glib::function_name!(),
1102 line!(),
1103 $details,
1104 );
1105 }};
1106);
1107
1108#[doc(alias = "GST_ELEMENT_ERROR")]
1109#[doc(alias = "GST_ELEMENT_ERROR_WITH_DETAILS")]
1110#[macro_export]
1111macro_rules! element_imp_error(
1112 ($imp:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*]) => { {
1113 let obj = $imp.obj();
1114 $crate::element_error!(obj, $err, ($($msg)*), [$($debug)*]);
1115 }};
1116 ($imp:expr, $err:expr, ($($msg:tt)*)) => { {
1117 let obj = $imp.obj();
1118 $crate::element_error!(obj, $err, ($($msg)*));
1119 }};
1120 ($imp:expr, $err:expr, [$($debug:tt)*]) => { {
1121 let obj = $imp.obj();
1122 $crate::element_error!(obj, $err, [$($debug)*]);
1123 }};
1124
1125 ($imp:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*], details: $details:expr) => { {
1126 let obj = $imp.obj();
1127 $crate::element_error!(obj, $err, ($($msg)*), [$($debug)*], details: $details);
1128 }};
1129 ($imp:expr, $err:expr, ($($msg:tt)*), details: $details:expr) => { {
1130 let obj = $imp.obj();
1131 $crate::element_error!(obj, $err, ($($msg)*), details: $details);
1132 }};
1133 ($imp:expr, $err:expr, [$($debug:tt)*], details: $details:expr) => { {
1134 let obj = $imp.obj();
1135 $crate::element_error!(obj, $err, [$($debug)*], details: $details);
1136 }};
1137);
1138
1139#[doc(alias = "GST_ELEMENT_WARNING")]
1140#[doc(alias = "GST_ELEMENT_WARNING_WITH_DETAILS")]
1141#[macro_export]
1142macro_rules! element_imp_warning(
1143 ($imp:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*]) => { {
1144 let obj = $imp.obj();
1145 $crate::element_warning!(obj, $err, ($($msg)*), [$($debug)*]);
1146 }};
1147 ($imp:expr, $err:expr, ($($msg:tt)*)) => { {
1148 let obj = $imp.obj();
1149 $crate::element_warning!(obj, $err, ($($msg)*));
1150 }};
1151 ($imp:expr, $err:expr, [$($debug:tt)*]) => { {
1152 let obj = $imp.obj();
1153 $crate::element_warning!(obj, $err, [$($debug)*]);
1154 }};
1155
1156 ($imp:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*], details: $details:expr) => { {
1157 let obj = $imp.obj();
1158 $crate::element_warning!(obj, $err, ($($msg)*), [$($debug)*], details: $details);
1159 }};
1160 ($imp:expr, $err:expr, ($($msg:tt)*), details: $details:expr) => { {
1161 let obj = $imp.obj();
1162 $crate::element_warning!(obj, $err, ($($msg)*), details: $details);
1163 }};
1164 ($imp:expr, $err:expr, [$($debug:tt)*], details: $details:expr) => { {
1165 let obj = $imp.obj();
1166 $crate::element_warning!(obj, $err, [$($debug)*], details: $details);
1167 }};
1168);
1169
1170#[doc(alias = "GST_ELEMENT_INFO")]
1171#[doc(alias = "GST_ELEMENT_INFO_WITH_DETAILS")]
1172#[macro_export]
1173macro_rules! element_imp_info(
1174 ($imp:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*]) => { {
1175 let obj = $imp.obj();
1176 $crate::element_info!(obj, $err, ($($msg)*), [$($debug)*]);
1177 }};
1178 ($imp:expr, $err:expr, ($($msg:tt)*)) => { {
1179 let obj = $imp.obj();
1180 $crate::element_info!(obj, $err, ($($msg)*));
1181 }};
1182 ($imp:expr, $err:expr, [$($debug:tt)*]) => { {
1183 let obj = $imp.obj();
1184 $crate::element_info!(obj, $err, [$($debug)*]);
1185 }};
1186
1187 ($imp:expr, $err:expr, ($($msg:tt)*), [$($debug:tt)*], details: $details:expr) => { {
1188 let obj = $imp.obj();
1189 $crate::element_info!(obj, $err, ($($msg)*), [$($debug)*], details: $details);
1190 }};
1191 ($imp:expr, $err:expr, ($($msg:tt)*), details: $details:expr) => { {
1192 let obj = $imp.obj();
1193 $crate::element_info!(obj, $err, ($($msg)*), details: $details);
1194 }};
1195 ($imp:expr, $err:expr, [$($debug:tt)*], details: $details:expr) => { {
1196 let obj = $imp.obj();
1197 $crate::element_info!(obj, $err, [$($debug)*], details: $details);
1198 }};
1199);
1200
1201#[cfg(test)]
1202mod tests {
1203 use std::sync::mpsc::channel;
1204
1205 use glib::GString;
1206
1207 use super::*;
1208
1209 #[test]
1210 fn test_get_pads() {
1211 crate::init().unwrap();
1212
1213 let identity = crate::ElementFactory::make("identity").build().unwrap();
1214
1215 let mut pad_names = identity
1216 .pads()
1217 .iter()
1218 .map(|p| p.name())
1219 .collect::<Vec<GString>>();
1220 pad_names.sort();
1221 assert_eq!(pad_names, vec![String::from("sink"), String::from("src")]);
1222
1223 let mut pad_names = identity
1224 .sink_pads()
1225 .iter()
1226 .map(|p| p.name())
1227 .collect::<Vec<GString>>();
1228 pad_names.sort();
1229 assert_eq!(pad_names, vec![String::from("sink")]);
1230
1231 let mut pad_names = identity
1232 .src_pads()
1233 .iter()
1234 .map(|p| p.name())
1235 .collect::<Vec<GString>>();
1236 pad_names.sort();
1237 assert_eq!(pad_names, vec![String::from("src")]);
1238 }
1239
1240 #[test]
1241 fn test_foreach_pad() {
1242 crate::init().unwrap();
1243
1244 let identity = crate::ElementFactory::make("identity").build().unwrap();
1245
1246 let mut pad_names = Vec::new();
1247 identity.foreach_pad(|_element, pad| {
1248 pad_names.push(pad.name());
1249
1250 true
1251 });
1252 pad_names.sort();
1253 assert_eq!(pad_names, vec![String::from("sink"), String::from("src")]);
1254 }
1255
1256 #[test]
1257 fn test_call_async() {
1258 crate::init().unwrap();
1259
1260 let identity = crate::ElementFactory::make("identity").build().unwrap();
1261 let (sender, receiver) = channel();
1262
1263 identity.call_async(move |_| {
1264 sender.send(()).unwrap();
1265 });
1266
1267 assert_eq!(receiver.recv(), Ok(()));
1268 }
1269
1270 #[test]
1271 fn test_element_error() {
1272 crate::init().unwrap();
1273
1274 let identity = crate::ElementFactory::make("identity").build().unwrap();
1275
1276 crate::element_error!(identity, crate::CoreError::Failed, ("msg"), ["debug"]);
1277 crate::element_error!(identity, crate::CoreError::Failed, ["debug"]);
1278 crate::element_error!(identity, crate::CoreError::Failed, ("msg"));
1279
1280 // We define a new variable for each call so there would be a compiler warning if the
1281 // string formatting did not actually use it.
1282 let x = 123i32;
1283 crate::element_error!(identity, crate::CoreError::Failed, ("msg {x}"), ["debug"]);
1284 let x = 123i32;
1285 crate::element_error!(identity, crate::CoreError::Failed, ["debug {x}"]);
1286 let x = 123i32;
1287 crate::element_error!(identity, crate::CoreError::Failed, ("msg {}", x));
1288 }
1289}
1290