gstreamer_base/auto/
base_sink.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
4// DO NOT EDIT
5
6use crate::ffi;
7use glib::{
8    prelude::*,
9    signal::{connect_raw, SignalHandlerId},
10    translate::*,
11};
12use std::boxed::Box as Box_;
13
14glib::wrapper! {
15    #[doc(alias = "GstBaseSink")]
16    pub struct BaseSink(Object<ffi::GstBaseSink, ffi::GstBaseSinkClass>) @extends gst::Element, gst::Object;
17
18    match fn {
19        type_ => || ffi::gst_base_sink_get_type(),
20    }
21}
22
23impl BaseSink {
24    pub const NONE: Option<&'static BaseSink> = None;
25}
26
27unsafe impl Send for BaseSink {}
28unsafe impl Sync for BaseSink {}
29
30mod sealed {
31    pub trait Sealed {}
32    impl<T: super::IsA<super::BaseSink>> Sealed for T {}
33}
34
35pub trait BaseSinkExt: IsA<BaseSink> + sealed::Sealed + 'static {
36    //#[doc(alias = "gst_base_sink_do_preroll")]
37    //fn do_preroll(&self, obj: /*Ignored*/&gst::MiniObject) -> Result<gst::FlowSuccess, gst::FlowError> {
38    //    unsafe { TODO: call ffi:gst_base_sink_do_preroll() }
39    //}
40
41    #[doc(alias = "gst_base_sink_get_blocksize")]
42    #[doc(alias = "get_blocksize")]
43    fn blocksize(&self) -> u32 {
44        unsafe { ffi::gst_base_sink_get_blocksize(self.as_ref().to_glib_none().0) }
45    }
46
47    #[doc(alias = "gst_base_sink_get_drop_out_of_segment")]
48    #[doc(alias = "get_drop_out_of_segment")]
49    fn drops_out_of_segment(&self) -> bool {
50        unsafe {
51            from_glib(ffi::gst_base_sink_get_drop_out_of_segment(
52                self.as_ref().to_glib_none().0,
53            ))
54        }
55    }
56
57    #[doc(alias = "gst_base_sink_get_last_sample")]
58    #[doc(alias = "get_last_sample")]
59    #[doc(alias = "last-sample")]
60    fn last_sample(&self) -> Option<gst::Sample> {
61        unsafe {
62            from_glib_full(ffi::gst_base_sink_get_last_sample(
63                self.as_ref().to_glib_none().0,
64            ))
65        }
66    }
67
68    #[doc(alias = "gst_base_sink_get_latency")]
69    #[doc(alias = "get_latency")]
70    fn latency(&self) -> gst::ClockTime {
71        unsafe {
72            try_from_glib(ffi::gst_base_sink_get_latency(
73                self.as_ref().to_glib_none().0,
74            ))
75            .expect("mandatory glib value is None")
76        }
77    }
78
79    #[doc(alias = "gst_base_sink_get_max_bitrate")]
80    #[doc(alias = "get_max_bitrate")]
81    #[doc(alias = "max-bitrate")]
82    fn max_bitrate(&self) -> u64 {
83        unsafe { ffi::gst_base_sink_get_max_bitrate(self.as_ref().to_glib_none().0) }
84    }
85
86    #[doc(alias = "gst_base_sink_get_max_lateness")]
87    #[doc(alias = "get_max_lateness")]
88    #[doc(alias = "max-lateness")]
89    fn max_lateness(&self) -> i64 {
90        unsafe { ffi::gst_base_sink_get_max_lateness(self.as_ref().to_glib_none().0) }
91    }
92
93    #[cfg(feature = "v1_16")]
94    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
95    #[doc(alias = "gst_base_sink_get_processing_deadline")]
96    #[doc(alias = "get_processing_deadline")]
97    #[doc(alias = "processing-deadline")]
98    fn processing_deadline(&self) -> gst::ClockTime {
99        unsafe {
100            try_from_glib(ffi::gst_base_sink_get_processing_deadline(
101                self.as_ref().to_glib_none().0,
102            ))
103            .expect("mandatory glib value is None")
104        }
105    }
106
107    #[doc(alias = "gst_base_sink_get_render_delay")]
108    #[doc(alias = "get_render_delay")]
109    #[doc(alias = "render-delay")]
110    fn render_delay(&self) -> gst::ClockTime {
111        unsafe {
112            try_from_glib(ffi::gst_base_sink_get_render_delay(
113                self.as_ref().to_glib_none().0,
114            ))
115            .expect("mandatory glib value is None")
116        }
117    }
118
119    #[cfg(feature = "v1_18")]
120    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
121    #[doc(alias = "gst_base_sink_get_stats")]
122    #[doc(alias = "get_stats")]
123    fn stats(&self) -> gst::Structure {
124        unsafe { from_glib_full(ffi::gst_base_sink_get_stats(self.as_ref().to_glib_none().0)) }
125    }
126
127    #[doc(alias = "gst_base_sink_get_sync")]
128    #[doc(alias = "get_sync")]
129    #[doc(alias = "sync")]
130    fn is_sync(&self) -> bool {
131        unsafe { from_glib(ffi::gst_base_sink_get_sync(self.as_ref().to_glib_none().0)) }
132    }
133
134    #[doc(alias = "gst_base_sink_get_throttle_time")]
135    #[doc(alias = "get_throttle_time")]
136    #[doc(alias = "throttle-time")]
137    fn throttle_time(&self) -> u64 {
138        unsafe { ffi::gst_base_sink_get_throttle_time(self.as_ref().to_glib_none().0) }
139    }
140
141    #[doc(alias = "gst_base_sink_get_ts_offset")]
142    #[doc(alias = "get_ts_offset")]
143    #[doc(alias = "ts-offset")]
144    fn ts_offset(&self) -> gst::ClockTimeDiff {
145        unsafe { ffi::gst_base_sink_get_ts_offset(self.as_ref().to_glib_none().0) }
146    }
147
148    #[doc(alias = "gst_base_sink_set_blocksize")]
149    #[doc(alias = "blocksize")]
150    fn set_blocksize(&self, blocksize: u32) {
151        unsafe {
152            ffi::gst_base_sink_set_blocksize(self.as_ref().to_glib_none().0, blocksize);
153        }
154    }
155
156    #[doc(alias = "gst_base_sink_set_drop_out_of_segment")]
157    fn set_drop_out_of_segment(&self, drop_out_of_segment: bool) {
158        unsafe {
159            ffi::gst_base_sink_set_drop_out_of_segment(
160                self.as_ref().to_glib_none().0,
161                drop_out_of_segment.into_glib(),
162            );
163        }
164    }
165
166    #[doc(alias = "gst_base_sink_set_max_bitrate")]
167    #[doc(alias = "max-bitrate")]
168    fn set_max_bitrate(&self, max_bitrate: u64) {
169        unsafe {
170            ffi::gst_base_sink_set_max_bitrate(self.as_ref().to_glib_none().0, max_bitrate);
171        }
172    }
173
174    #[doc(alias = "gst_base_sink_set_max_lateness")]
175    #[doc(alias = "max-lateness")]
176    fn set_max_lateness(&self, max_lateness: i64) {
177        unsafe {
178            ffi::gst_base_sink_set_max_lateness(self.as_ref().to_glib_none().0, max_lateness);
179        }
180    }
181
182    #[cfg(feature = "v1_16")]
183    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
184    #[doc(alias = "gst_base_sink_set_processing_deadline")]
185    #[doc(alias = "processing-deadline")]
186    fn set_processing_deadline(&self, processing_deadline: gst::ClockTime) {
187        unsafe {
188            ffi::gst_base_sink_set_processing_deadline(
189                self.as_ref().to_glib_none().0,
190                processing_deadline.into_glib(),
191            );
192        }
193    }
194
195    #[doc(alias = "gst_base_sink_set_render_delay")]
196    #[doc(alias = "render-delay")]
197    fn set_render_delay(&self, delay: gst::ClockTime) {
198        unsafe {
199            ffi::gst_base_sink_set_render_delay(self.as_ref().to_glib_none().0, delay.into_glib());
200        }
201    }
202
203    #[doc(alias = "gst_base_sink_set_sync")]
204    #[doc(alias = "sync")]
205    fn set_sync(&self, sync: bool) {
206        unsafe {
207            ffi::gst_base_sink_set_sync(self.as_ref().to_glib_none().0, sync.into_glib());
208        }
209    }
210
211    #[doc(alias = "gst_base_sink_set_throttle_time")]
212    #[doc(alias = "throttle-time")]
213    fn set_throttle_time(&self, throttle: u64) {
214        unsafe {
215            ffi::gst_base_sink_set_throttle_time(self.as_ref().to_glib_none().0, throttle);
216        }
217    }
218
219    #[doc(alias = "gst_base_sink_set_ts_offset")]
220    #[doc(alias = "ts-offset")]
221    fn set_ts_offset(&self, offset: gst::ClockTimeDiff) {
222        unsafe {
223            ffi::gst_base_sink_set_ts_offset(self.as_ref().to_glib_none().0, offset);
224        }
225    }
226
227    #[doc(alias = "gst_base_sink_wait")]
228    fn wait(
229        &self,
230        time: impl Into<Option<gst::ClockTime>>,
231    ) -> (Result<gst::FlowSuccess, gst::FlowError>, gst::ClockTimeDiff) {
232        unsafe {
233            let mut jitter = std::mem::MaybeUninit::uninit();
234            let ret = try_from_glib(ffi::gst_base_sink_wait(
235                self.as_ref().to_glib_none().0,
236                time.into().into_glib(),
237                jitter.as_mut_ptr(),
238            ));
239            (ret, jitter.assume_init())
240        }
241    }
242
243    #[doc(alias = "gst_base_sink_wait_clock")]
244    fn wait_clock(
245        &self,
246        time: gst::ClockTime,
247    ) -> (
248        Result<gst::ClockSuccess, gst::ClockError>,
249        gst::ClockTimeDiff,
250    ) {
251        unsafe {
252            let mut jitter = std::mem::MaybeUninit::uninit();
253            let ret = try_from_glib(ffi::gst_base_sink_wait_clock(
254                self.as_ref().to_glib_none().0,
255                time.into_glib(),
256                jitter.as_mut_ptr(),
257            ));
258            (ret, jitter.assume_init())
259        }
260    }
261
262    #[doc(alias = "gst_base_sink_wait_preroll")]
263    fn wait_preroll(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
264        unsafe {
265            try_from_glib(ffi::gst_base_sink_wait_preroll(
266                self.as_ref().to_glib_none().0,
267            ))
268        }
269    }
270
271    #[doc(alias = "async")]
272    fn is_async(&self) -> bool {
273        ObjectExt::property(self.as_ref(), "async")
274    }
275
276    #[doc(alias = "async")]
277    fn set_async(&self, async_: bool) {
278        ObjectExt::set_property(self.as_ref(), "async", async_)
279    }
280
281    #[doc(alias = "enable-last-sample")]
282    fn enables_last_sample(&self) -> bool {
283        ObjectExt::property(self.as_ref(), "enable-last-sample")
284    }
285
286    #[doc(alias = "enable-last-sample")]
287    fn set_enable_last_sample(&self, enable_last_sample: bool) {
288        ObjectExt::set_property(self.as_ref(), "enable-last-sample", enable_last_sample)
289    }
290
291    fn is_qos(&self) -> bool {
292        ObjectExt::property(self.as_ref(), "qos")
293    }
294
295    fn set_qos(&self, qos: bool) {
296        ObjectExt::set_property(self.as_ref(), "qos", qos)
297    }
298
299    #[doc(alias = "async")]
300    fn connect_async_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
301        unsafe extern "C" fn notify_async_trampoline<
302            P: IsA<BaseSink>,
303            F: Fn(&P) + Send + Sync + 'static,
304        >(
305            this: *mut ffi::GstBaseSink,
306            _param_spec: glib::ffi::gpointer,
307            f: glib::ffi::gpointer,
308        ) {
309            let f: &F = &*(f as *const F);
310            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
311        }
312        unsafe {
313            let f: Box_<F> = Box_::new(f);
314            connect_raw(
315                self.as_ptr() as *mut _,
316                b"notify::async\0".as_ptr() as *const _,
317                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
318                    notify_async_trampoline::<Self, F> as *const (),
319                )),
320                Box_::into_raw(f),
321            )
322        }
323    }
324
325    #[doc(alias = "blocksize")]
326    fn connect_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(
327        &self,
328        f: F,
329    ) -> SignalHandlerId {
330        unsafe extern "C" fn notify_blocksize_trampoline<
331            P: IsA<BaseSink>,
332            F: Fn(&P) + Send + Sync + 'static,
333        >(
334            this: *mut ffi::GstBaseSink,
335            _param_spec: glib::ffi::gpointer,
336            f: glib::ffi::gpointer,
337        ) {
338            let f: &F = &*(f as *const F);
339            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
340        }
341        unsafe {
342            let f: Box_<F> = Box_::new(f);
343            connect_raw(
344                self.as_ptr() as *mut _,
345                b"notify::blocksize\0".as_ptr() as *const _,
346                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
347                    notify_blocksize_trampoline::<Self, F> as *const (),
348                )),
349                Box_::into_raw(f),
350            )
351        }
352    }
353
354    #[doc(alias = "enable-last-sample")]
355    fn connect_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
356        &self,
357        f: F,
358    ) -> SignalHandlerId {
359        unsafe extern "C" fn notify_enable_last_sample_trampoline<
360            P: IsA<BaseSink>,
361            F: Fn(&P) + Send + Sync + 'static,
362        >(
363            this: *mut ffi::GstBaseSink,
364            _param_spec: glib::ffi::gpointer,
365            f: glib::ffi::gpointer,
366        ) {
367            let f: &F = &*(f as *const F);
368            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
369        }
370        unsafe {
371            let f: Box_<F> = Box_::new(f);
372            connect_raw(
373                self.as_ptr() as *mut _,
374                b"notify::enable-last-sample\0".as_ptr() as *const _,
375                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
376                    notify_enable_last_sample_trampoline::<Self, F> as *const (),
377                )),
378                Box_::into_raw(f),
379            )
380        }
381    }
382
383    #[doc(alias = "last-sample")]
384    fn connect_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
385        &self,
386        f: F,
387    ) -> SignalHandlerId {
388        unsafe extern "C" fn notify_last_sample_trampoline<
389            P: IsA<BaseSink>,
390            F: Fn(&P) + Send + Sync + 'static,
391        >(
392            this: *mut ffi::GstBaseSink,
393            _param_spec: glib::ffi::gpointer,
394            f: glib::ffi::gpointer,
395        ) {
396            let f: &F = &*(f as *const F);
397            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
398        }
399        unsafe {
400            let f: Box_<F> = Box_::new(f);
401            connect_raw(
402                self.as_ptr() as *mut _,
403                b"notify::last-sample\0".as_ptr() as *const _,
404                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
405                    notify_last_sample_trampoline::<Self, F> as *const (),
406                )),
407                Box_::into_raw(f),
408            )
409        }
410    }
411
412    #[doc(alias = "max-bitrate")]
413    fn connect_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(
414        &self,
415        f: F,
416    ) -> SignalHandlerId {
417        unsafe extern "C" fn notify_max_bitrate_trampoline<
418            P: IsA<BaseSink>,
419            F: Fn(&P) + Send + Sync + 'static,
420        >(
421            this: *mut ffi::GstBaseSink,
422            _param_spec: glib::ffi::gpointer,
423            f: glib::ffi::gpointer,
424        ) {
425            let f: &F = &*(f as *const F);
426            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
427        }
428        unsafe {
429            let f: Box_<F> = Box_::new(f);
430            connect_raw(
431                self.as_ptr() as *mut _,
432                b"notify::max-bitrate\0".as_ptr() as *const _,
433                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
434                    notify_max_bitrate_trampoline::<Self, F> as *const (),
435                )),
436                Box_::into_raw(f),
437            )
438        }
439    }
440
441    #[doc(alias = "max-lateness")]
442    fn connect_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(
443        &self,
444        f: F,
445    ) -> SignalHandlerId {
446        unsafe extern "C" fn notify_max_lateness_trampoline<
447            P: IsA<BaseSink>,
448            F: Fn(&P) + Send + Sync + 'static,
449        >(
450            this: *mut ffi::GstBaseSink,
451            _param_spec: glib::ffi::gpointer,
452            f: glib::ffi::gpointer,
453        ) {
454            let f: &F = &*(f as *const F);
455            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
456        }
457        unsafe {
458            let f: Box_<F> = Box_::new(f);
459            connect_raw(
460                self.as_ptr() as *mut _,
461                b"notify::max-lateness\0".as_ptr() as *const _,
462                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
463                    notify_max_lateness_trampoline::<Self, F> as *const (),
464                )),
465                Box_::into_raw(f),
466            )
467        }
468    }
469
470    #[cfg(feature = "v1_16")]
471    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
472    #[doc(alias = "processing-deadline")]
473    fn connect_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(
474        &self,
475        f: F,
476    ) -> SignalHandlerId {
477        unsafe extern "C" fn notify_processing_deadline_trampoline<
478            P: IsA<BaseSink>,
479            F: Fn(&P) + Send + Sync + 'static,
480        >(
481            this: *mut ffi::GstBaseSink,
482            _param_spec: glib::ffi::gpointer,
483            f: glib::ffi::gpointer,
484        ) {
485            let f: &F = &*(f as *const F);
486            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
487        }
488        unsafe {
489            let f: Box_<F> = Box_::new(f);
490            connect_raw(
491                self.as_ptr() as *mut _,
492                b"notify::processing-deadline\0".as_ptr() as *const _,
493                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
494                    notify_processing_deadline_trampoline::<Self, F> as *const (),
495                )),
496                Box_::into_raw(f),
497            )
498        }
499    }
500
501    #[doc(alias = "qos")]
502    fn connect_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
503        unsafe extern "C" fn notify_qos_trampoline<
504            P: IsA<BaseSink>,
505            F: Fn(&P) + Send + Sync + 'static,
506        >(
507            this: *mut ffi::GstBaseSink,
508            _param_spec: glib::ffi::gpointer,
509            f: glib::ffi::gpointer,
510        ) {
511            let f: &F = &*(f as *const F);
512            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
513        }
514        unsafe {
515            let f: Box_<F> = Box_::new(f);
516            connect_raw(
517                self.as_ptr() as *mut _,
518                b"notify::qos\0".as_ptr() as *const _,
519                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
520                    notify_qos_trampoline::<Self, F> as *const (),
521                )),
522                Box_::into_raw(f),
523            )
524        }
525    }
526
527    #[doc(alias = "render-delay")]
528    fn connect_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(
529        &self,
530        f: F,
531    ) -> SignalHandlerId {
532        unsafe extern "C" fn notify_render_delay_trampoline<
533            P: IsA<BaseSink>,
534            F: Fn(&P) + Send + Sync + 'static,
535        >(
536            this: *mut ffi::GstBaseSink,
537            _param_spec: glib::ffi::gpointer,
538            f: glib::ffi::gpointer,
539        ) {
540            let f: &F = &*(f as *const F);
541            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
542        }
543        unsafe {
544            let f: Box_<F> = Box_::new(f);
545            connect_raw(
546                self.as_ptr() as *mut _,
547                b"notify::render-delay\0".as_ptr() as *const _,
548                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
549                    notify_render_delay_trampoline::<Self, F> as *const (),
550                )),
551                Box_::into_raw(f),
552            )
553        }
554    }
555
556    #[cfg(feature = "v1_18")]
557    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
558    #[doc(alias = "stats")]
559    fn connect_stats_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
560        unsafe extern "C" fn notify_stats_trampoline<
561            P: IsA<BaseSink>,
562            F: Fn(&P) + Send + Sync + 'static,
563        >(
564            this: *mut ffi::GstBaseSink,
565            _param_spec: glib::ffi::gpointer,
566            f: glib::ffi::gpointer,
567        ) {
568            let f: &F = &*(f as *const F);
569            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
570        }
571        unsafe {
572            let f: Box_<F> = Box_::new(f);
573            connect_raw(
574                self.as_ptr() as *mut _,
575                b"notify::stats\0".as_ptr() as *const _,
576                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
577                    notify_stats_trampoline::<Self, F> as *const (),
578                )),
579                Box_::into_raw(f),
580            )
581        }
582    }
583
584    #[doc(alias = "sync")]
585    fn connect_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
586        unsafe extern "C" fn notify_sync_trampoline<
587            P: IsA<BaseSink>,
588            F: Fn(&P) + Send + Sync + 'static,
589        >(
590            this: *mut ffi::GstBaseSink,
591            _param_spec: glib::ffi::gpointer,
592            f: glib::ffi::gpointer,
593        ) {
594            let f: &F = &*(f as *const F);
595            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
596        }
597        unsafe {
598            let f: Box_<F> = Box_::new(f);
599            connect_raw(
600                self.as_ptr() as *mut _,
601                b"notify::sync\0".as_ptr() as *const _,
602                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
603                    notify_sync_trampoline::<Self, F> as *const (),
604                )),
605                Box_::into_raw(f),
606            )
607        }
608    }
609
610    #[doc(alias = "throttle-time")]
611    fn connect_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
612        &self,
613        f: F,
614    ) -> SignalHandlerId {
615        unsafe extern "C" fn notify_throttle_time_trampoline<
616            P: IsA<BaseSink>,
617            F: Fn(&P) + Send + Sync + 'static,
618        >(
619            this: *mut ffi::GstBaseSink,
620            _param_spec: glib::ffi::gpointer,
621            f: glib::ffi::gpointer,
622        ) {
623            let f: &F = &*(f as *const F);
624            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
625        }
626        unsafe {
627            let f: Box_<F> = Box_::new(f);
628            connect_raw(
629                self.as_ptr() as *mut _,
630                b"notify::throttle-time\0".as_ptr() as *const _,
631                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
632                    notify_throttle_time_trampoline::<Self, F> as *const (),
633                )),
634                Box_::into_raw(f),
635            )
636        }
637    }
638
639    #[doc(alias = "ts-offset")]
640    fn connect_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(
641        &self,
642        f: F,
643    ) -> SignalHandlerId {
644        unsafe extern "C" fn notify_ts_offset_trampoline<
645            P: IsA<BaseSink>,
646            F: Fn(&P) + Send + Sync + 'static,
647        >(
648            this: *mut ffi::GstBaseSink,
649            _param_spec: glib::ffi::gpointer,
650            f: glib::ffi::gpointer,
651        ) {
652            let f: &F = &*(f as *const F);
653            f(BaseSink::from_glib_borrow(this).unsafe_cast_ref())
654        }
655        unsafe {
656            let f: Box_<F> = Box_::new(f);
657            connect_raw(
658                self.as_ptr() as *mut _,
659                b"notify::ts-offset\0".as_ptr() as *const _,
660                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
661                    notify_ts_offset_trampoline::<Self, F> as *const (),
662                )),
663                Box_::into_raw(f),
664            )
665        }
666    }
667}
668
669impl<O: IsA<BaseSink>> BaseSinkExt for O {}
gstreamer_base/auto/base_sink.rs

gstreamer_base/auto/
base_sink.rs
