gstreamer_app/auto/
app_src.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
6#[cfg(feature = "v1_20")]
7#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
8use crate::AppLeakyType;
9use crate::{ffi, AppStreamType};
10use glib::{
11    prelude::*,
12    signal::{connect_raw, SignalHandlerId},
13    translate::*,
14};
15use std::boxed::Box as Box_;
16
17glib::wrapper! {
18    #[doc(alias = "GstAppSrc")]
19    pub struct AppSrc(Object<ffi::GstAppSrc, ffi::GstAppSrcClass>) @extends gst::Element, gst::Object, @implements gst::URIHandler;
20
21    match fn {
22        type_ => || ffi::gst_app_src_get_type(),
23    }
24}
25
26impl AppSrc {
27    #[doc(alias = "gst_app_src_end_of_stream")]
28    pub fn end_of_stream(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
29        unsafe { try_from_glib(ffi::gst_app_src_end_of_stream(self.to_glib_none().0)) }
30    }
31
32    #[doc(alias = "gst_app_src_get_caps")]
33    #[doc(alias = "get_caps")]
34    pub fn caps(&self) -> Option<gst::Caps> {
35        unsafe { from_glib_full(ffi::gst_app_src_get_caps(self.to_glib_none().0)) }
36    }
37
38    #[cfg(feature = "v1_20")]
39    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
40    #[doc(alias = "gst_app_src_get_current_level_buffers")]
41    #[doc(alias = "get_current_level_buffers")]
42    #[doc(alias = "current-level-buffers")]
43    pub fn current_level_buffers(&self) -> u64 {
44        unsafe { ffi::gst_app_src_get_current_level_buffers(self.to_glib_none().0) }
45    }
46
47    #[doc(alias = "gst_app_src_get_current_level_bytes")]
48    #[doc(alias = "get_current_level_bytes")]
49    #[doc(alias = "current-level-bytes")]
50    pub fn current_level_bytes(&self) -> u64 {
51        unsafe { ffi::gst_app_src_get_current_level_bytes(self.to_glib_none().0) }
52    }
53
54    #[cfg(feature = "v1_20")]
55    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
56    #[doc(alias = "gst_app_src_get_current_level_time")]
57    #[doc(alias = "get_current_level_time")]
58    #[doc(alias = "current-level-time")]
59    pub fn current_level_time(&self) -> Option<gst::ClockTime> {
60        unsafe {
61            from_glib(ffi::gst_app_src_get_current_level_time(
62                self.to_glib_none().0,
63            ))
64        }
65    }
66
67    #[doc(alias = "gst_app_src_get_duration")]
68    #[doc(alias = "get_duration")]
69    pub fn duration(&self) -> Option<gst::ClockTime> {
70        unsafe { from_glib(ffi::gst_app_src_get_duration(self.to_glib_none().0)) }
71    }
72
73    #[cfg(feature = "v1_20")]
74    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
75    #[doc(alias = "gst_app_src_get_leaky_type")]
76    #[doc(alias = "get_leaky_type")]
77    #[doc(alias = "leaky-type")]
78    pub fn leaky_type(&self) -> AppLeakyType {
79        unsafe { from_glib(ffi::gst_app_src_get_leaky_type(self.to_glib_none().0)) }
80    }
81
82    #[cfg(feature = "v1_20")]
83    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
84    #[doc(alias = "gst_app_src_get_max_buffers")]
85    #[doc(alias = "get_max_buffers")]
86    #[doc(alias = "max-buffers")]
87    pub fn max_buffers(&self) -> u64 {
88        unsafe { ffi::gst_app_src_get_max_buffers(self.to_glib_none().0) }
89    }
90
91    #[doc(alias = "gst_app_src_get_max_bytes")]
92    #[doc(alias = "get_max_bytes")]
93    #[doc(alias = "max-bytes")]
94    pub fn max_bytes(&self) -> u64 {
95        unsafe { ffi::gst_app_src_get_max_bytes(self.to_glib_none().0) }
96    }
97
98    #[cfg(feature = "v1_20")]
99    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
100    #[doc(alias = "gst_app_src_get_max_time")]
101    #[doc(alias = "get_max_time")]
102    #[doc(alias = "max-time")]
103    pub fn max_time(&self) -> Option<gst::ClockTime> {
104        unsafe { from_glib(ffi::gst_app_src_get_max_time(self.to_glib_none().0)) }
105    }
106
107    #[doc(alias = "gst_app_src_get_size")]
108    #[doc(alias = "get_size")]
109    pub fn size(&self) -> i64 {
110        unsafe { ffi::gst_app_src_get_size(self.to_glib_none().0) }
111    }
112
113    #[doc(alias = "gst_app_src_get_stream_type")]
114    #[doc(alias = "get_stream_type")]
115    #[doc(alias = "stream-type")]
116    pub fn stream_type(&self) -> AppStreamType {
117        unsafe { from_glib(ffi::gst_app_src_get_stream_type(self.to_glib_none().0)) }
118    }
119
120    #[doc(alias = "gst_app_src_push_buffer")]
121    pub fn push_buffer(&self, buffer: gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError> {
122        unsafe {
123            try_from_glib(ffi::gst_app_src_push_buffer(
124                self.to_glib_none().0,
125                buffer.into_glib_ptr(),
126            ))
127        }
128    }
129
130    #[doc(alias = "gst_app_src_push_buffer_list")]
131    pub fn push_buffer_list(
132        &self,
133        buffer_list: gst::BufferList,
134    ) -> Result<gst::FlowSuccess, gst::FlowError> {
135        unsafe {
136            try_from_glib(ffi::gst_app_src_push_buffer_list(
137                self.to_glib_none().0,
138                buffer_list.into_glib_ptr(),
139            ))
140        }
141    }
142
143    #[doc(alias = "gst_app_src_push_sample")]
144    pub fn push_sample(&self, sample: &gst::Sample) -> Result<gst::FlowSuccess, gst::FlowError> {
145        unsafe {
146            try_from_glib(ffi::gst_app_src_push_sample(
147                self.to_glib_none().0,
148                sample.to_glib_none().0,
149            ))
150        }
151    }
152
153    //#[doc(alias = "gst_app_src_set_callbacks")]
154    //pub fn set_callbacks(&self, callbacks: /*Ignored*/&mut AppSrcCallbacks, user_data: /*Unimplemented*/Option<Basic: Pointer>) {
155    //    unsafe { TODO: call ffi:gst_app_src_set_callbacks() }
156    //}
157
158    #[doc(alias = "gst_app_src_set_caps")]
159    #[doc(alias = "caps")]
160    pub fn set_caps(&self, caps: Option<&gst::Caps>) {
161        unsafe {
162            ffi::gst_app_src_set_caps(self.to_glib_none().0, caps.to_glib_none().0);
163        }
164    }
165
166    #[doc(alias = "gst_app_src_set_duration")]
167    #[doc(alias = "duration")]
168    pub fn set_duration(&self, duration: impl Into<Option<gst::ClockTime>>) {
169        unsafe {
170            ffi::gst_app_src_set_duration(self.to_glib_none().0, duration.into().into_glib());
171        }
172    }
173
174    #[cfg(feature = "v1_20")]
175    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
176    #[doc(alias = "gst_app_src_set_leaky_type")]
177    #[doc(alias = "leaky-type")]
178    pub fn set_leaky_type(&self, leaky: AppLeakyType) {
179        unsafe {
180            ffi::gst_app_src_set_leaky_type(self.to_glib_none().0, leaky.into_glib());
181        }
182    }
183
184    #[cfg(feature = "v1_20")]
185    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
186    #[doc(alias = "gst_app_src_set_max_buffers")]
187    #[doc(alias = "max-buffers")]
188    pub fn set_max_buffers(&self, max: u64) {
189        unsafe {
190            ffi::gst_app_src_set_max_buffers(self.to_glib_none().0, max);
191        }
192    }
193
194    #[doc(alias = "gst_app_src_set_max_bytes")]
195    #[doc(alias = "max-bytes")]
196    pub fn set_max_bytes(&self, max: u64) {
197        unsafe {
198            ffi::gst_app_src_set_max_bytes(self.to_glib_none().0, max);
199        }
200    }
201
202    #[cfg(feature = "v1_20")]
203    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
204    #[doc(alias = "gst_app_src_set_max_time")]
205    #[doc(alias = "max-time")]
206    pub fn set_max_time(&self, max: impl Into<Option<gst::ClockTime>>) {
207        unsafe {
208            ffi::gst_app_src_set_max_time(self.to_glib_none().0, max.into().into_glib());
209        }
210    }
211
212    #[doc(alias = "gst_app_src_set_size")]
213    #[doc(alias = "size")]
214    pub fn set_size(&self, size: i64) {
215        unsafe {
216            ffi::gst_app_src_set_size(self.to_glib_none().0, size);
217        }
218    }
219
220    #[doc(alias = "gst_app_src_set_stream_type")]
221    #[doc(alias = "stream-type")]
222    pub fn set_stream_type(&self, type_: AppStreamType) {
223        unsafe {
224            ffi::gst_app_src_set_stream_type(self.to_glib_none().0, type_.into_glib());
225        }
226    }
227
228    pub fn is_block(&self) -> bool {
229        ObjectExt::property(self, "block")
230    }
231
232    pub fn set_block(&self, block: bool) {
233        ObjectExt::set_property(self, "block", block)
234    }
235
236    pub fn format(&self) -> gst::Format {
237        ObjectExt::property(self, "format")
238    }
239
240    pub fn set_format(&self, format: gst::Format) {
241        ObjectExt::set_property(self, "format", format)
242    }
243
244    #[cfg(feature = "v1_18")]
245    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
246    #[doc(alias = "handle-segment-change")]
247    pub fn is_handle_segment_change(&self) -> bool {
248        ObjectExt::property(self, "handle-segment-change")
249    }
250
251    #[cfg(feature = "v1_18")]
252    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
253    #[doc(alias = "handle-segment-change")]
254    pub fn set_handle_segment_change(&self, handle_segment_change: bool) {
255        ObjectExt::set_property(self, "handle-segment-change", handle_segment_change)
256    }
257
258    #[doc(alias = "is-live")]
259    pub fn is_live(&self) -> bool {
260        ObjectExt::property(self, "is-live")
261    }
262
263    #[doc(alias = "is-live")]
264    pub fn set_is_live(&self, is_live: bool) {
265        ObjectExt::set_property(self, "is-live", is_live)
266    }
267
268    #[doc(alias = "max-latency")]
269    pub fn max_latency(&self) -> i64 {
270        ObjectExt::property(self, "max-latency")
271    }
272
273    #[doc(alias = "max-latency")]
274    pub fn set_max_latency(&self, max_latency: i64) {
275        ObjectExt::set_property(self, "max-latency", max_latency)
276    }
277
278    #[doc(alias = "min-latency")]
279    pub fn min_latency(&self) -> i64 {
280        ObjectExt::property(self, "min-latency")
281    }
282
283    #[doc(alias = "min-latency")]
284    pub fn set_min_latency(&self, min_latency: i64) {
285        ObjectExt::set_property(self, "min-latency", min_latency)
286    }
287
288    #[doc(alias = "min-percent")]
289    pub fn min_percent(&self) -> u32 {
290        ObjectExt::property(self, "min-percent")
291    }
292
293    #[doc(alias = "min-percent")]
294    pub fn set_min_percent(&self, min_percent: u32) {
295        ObjectExt::set_property(self, "min-percent", min_percent)
296    }
297
298    #[doc(alias = "block")]
299    pub fn connect_block_notify<F: Fn(&Self) + Send + Sync + 'static>(
300        &self,
301        f: F,
302    ) -> SignalHandlerId {
303        unsafe extern "C" fn notify_block_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
304            this: *mut ffi::GstAppSrc,
305            _param_spec: glib::ffi::gpointer,
306            f: glib::ffi::gpointer,
307        ) {
308            let f: &F = &*(f as *const F);
309            f(&from_glib_borrow(this))
310        }
311        unsafe {
312            let f: Box_<F> = Box_::new(f);
313            connect_raw(
314                self.as_ptr() as *mut _,
315                b"notify::block\0".as_ptr() as *const _,
316                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
317                    notify_block_trampoline::<F> as *const (),
318                )),
319                Box_::into_raw(f),
320            )
321        }
322    }
323
324    #[doc(alias = "caps")]
325    pub fn connect_caps_notify<F: Fn(&Self) + Send + Sync + 'static>(
326        &self,
327        f: F,
328    ) -> SignalHandlerId {
329        unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
330            this: *mut ffi::GstAppSrc,
331            _param_spec: glib::ffi::gpointer,
332            f: glib::ffi::gpointer,
333        ) {
334            let f: &F = &*(f as *const F);
335            f(&from_glib_borrow(this))
336        }
337        unsafe {
338            let f: Box_<F> = Box_::new(f);
339            connect_raw(
340                self.as_ptr() as *mut _,
341                b"notify::caps\0".as_ptr() as *const _,
342                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
343                    notify_caps_trampoline::<F> as *const (),
344                )),
345                Box_::into_raw(f),
346            )
347        }
348    }
349
350    #[cfg(feature = "v1_20")]
351    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
352    #[doc(alias = "current-level-buffers")]
353    pub fn connect_current_level_buffers_notify<F: Fn(&Self) + Send + Sync + 'static>(
354        &self,
355        f: F,
356    ) -> SignalHandlerId {
357        unsafe extern "C" fn notify_current_level_buffers_trampoline<
358            F: Fn(&AppSrc) + Send + Sync + 'static,
359        >(
360            this: *mut ffi::GstAppSrc,
361            _param_spec: glib::ffi::gpointer,
362            f: glib::ffi::gpointer,
363        ) {
364            let f: &F = &*(f as *const F);
365            f(&from_glib_borrow(this))
366        }
367        unsafe {
368            let f: Box_<F> = Box_::new(f);
369            connect_raw(
370                self.as_ptr() as *mut _,
371                b"notify::current-level-buffers\0".as_ptr() as *const _,
372                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
373                    notify_current_level_buffers_trampoline::<F> as *const (),
374                )),
375                Box_::into_raw(f),
376            )
377        }
378    }
379
380    #[doc(alias = "current-level-bytes")]
381    pub fn connect_current_level_bytes_notify<F: Fn(&Self) + Send + Sync + 'static>(
382        &self,
383        f: F,
384    ) -> SignalHandlerId {
385        unsafe extern "C" fn notify_current_level_bytes_trampoline<
386            F: Fn(&AppSrc) + Send + Sync + 'static,
387        >(
388            this: *mut ffi::GstAppSrc,
389            _param_spec: glib::ffi::gpointer,
390            f: glib::ffi::gpointer,
391        ) {
392            let f: &F = &*(f as *const F);
393            f(&from_glib_borrow(this))
394        }
395        unsafe {
396            let f: Box_<F> = Box_::new(f);
397            connect_raw(
398                self.as_ptr() as *mut _,
399                b"notify::current-level-bytes\0".as_ptr() as *const _,
400                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
401                    notify_current_level_bytes_trampoline::<F> as *const (),
402                )),
403                Box_::into_raw(f),
404            )
405        }
406    }
407
408    #[cfg(feature = "v1_20")]
409    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
410    #[doc(alias = "current-level-time")]
411    pub fn connect_current_level_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
412        &self,
413        f: F,
414    ) -> SignalHandlerId {
415        unsafe extern "C" fn notify_current_level_time_trampoline<
416            F: Fn(&AppSrc) + Send + Sync + 'static,
417        >(
418            this: *mut ffi::GstAppSrc,
419            _param_spec: glib::ffi::gpointer,
420            f: glib::ffi::gpointer,
421        ) {
422            let f: &F = &*(f as *const F);
423            f(&from_glib_borrow(this))
424        }
425        unsafe {
426            let f: Box_<F> = Box_::new(f);
427            connect_raw(
428                self.as_ptr() as *mut _,
429                b"notify::current-level-time\0".as_ptr() as *const _,
430                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
431                    notify_current_level_time_trampoline::<F> as *const (),
432                )),
433                Box_::into_raw(f),
434            )
435        }
436    }
437
438    #[doc(alias = "duration")]
439    pub fn connect_duration_notify<F: Fn(&Self) + Send + Sync + 'static>(
440        &self,
441        f: F,
442    ) -> SignalHandlerId {
443        unsafe extern "C" fn notify_duration_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
444            this: *mut ffi::GstAppSrc,
445            _param_spec: glib::ffi::gpointer,
446            f: glib::ffi::gpointer,
447        ) {
448            let f: &F = &*(f as *const F);
449            f(&from_glib_borrow(this))
450        }
451        unsafe {
452            let f: Box_<F> = Box_::new(f);
453            connect_raw(
454                self.as_ptr() as *mut _,
455                b"notify::duration\0".as_ptr() as *const _,
456                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
457                    notify_duration_trampoline::<F> as *const (),
458                )),
459                Box_::into_raw(f),
460            )
461        }
462    }
463
464    #[doc(alias = "format")]
465    pub fn connect_format_notify<F: Fn(&Self) + Send + Sync + 'static>(
466        &self,
467        f: F,
468    ) -> SignalHandlerId {
469        unsafe extern "C" fn notify_format_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
470            this: *mut ffi::GstAppSrc,
471            _param_spec: glib::ffi::gpointer,
472            f: glib::ffi::gpointer,
473        ) {
474            let f: &F = &*(f as *const F);
475            f(&from_glib_borrow(this))
476        }
477        unsafe {
478            let f: Box_<F> = Box_::new(f);
479            connect_raw(
480                self.as_ptr() as *mut _,
481                b"notify::format\0".as_ptr() as *const _,
482                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
483                    notify_format_trampoline::<F> as *const (),
484                )),
485                Box_::into_raw(f),
486            )
487        }
488    }
489
490    #[cfg(feature = "v1_18")]
491    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
492    #[doc(alias = "handle-segment-change")]
493    pub fn connect_handle_segment_change_notify<F: Fn(&Self) + Send + Sync + 'static>(
494        &self,
495        f: F,
496    ) -> SignalHandlerId {
497        unsafe extern "C" fn notify_handle_segment_change_trampoline<
498            F: Fn(&AppSrc) + Send + Sync + 'static,
499        >(
500            this: *mut ffi::GstAppSrc,
501            _param_spec: glib::ffi::gpointer,
502            f: glib::ffi::gpointer,
503        ) {
504            let f: &F = &*(f as *const F);
505            f(&from_glib_borrow(this))
506        }
507        unsafe {
508            let f: Box_<F> = Box_::new(f);
509            connect_raw(
510                self.as_ptr() as *mut _,
511                b"notify::handle-segment-change\0".as_ptr() as *const _,
512                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
513                    notify_handle_segment_change_trampoline::<F> as *const (),
514                )),
515                Box_::into_raw(f),
516            )
517        }
518    }
519
520    #[doc(alias = "is-live")]
521    pub fn connect_is_live_notify<F: Fn(&Self) + Send + Sync + 'static>(
522        &self,
523        f: F,
524    ) -> SignalHandlerId {
525        unsafe extern "C" fn notify_is_live_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
526            this: *mut ffi::GstAppSrc,
527            _param_spec: glib::ffi::gpointer,
528            f: glib::ffi::gpointer,
529        ) {
530            let f: &F = &*(f as *const F);
531            f(&from_glib_borrow(this))
532        }
533        unsafe {
534            let f: Box_<F> = Box_::new(f);
535            connect_raw(
536                self.as_ptr() as *mut _,
537                b"notify::is-live\0".as_ptr() as *const _,
538                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
539                    notify_is_live_trampoline::<F> as *const (),
540                )),
541                Box_::into_raw(f),
542            )
543        }
544    }
545
546    #[cfg(feature = "v1_20")]
547    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
548    #[doc(alias = "leaky-type")]
549    pub fn connect_leaky_type_notify<F: Fn(&Self) + Send + Sync + 'static>(
550        &self,
551        f: F,
552    ) -> SignalHandlerId {
553        unsafe extern "C" fn notify_leaky_type_trampoline<
554            F: Fn(&AppSrc) + Send + Sync + 'static,
555        >(
556            this: *mut ffi::GstAppSrc,
557            _param_spec: glib::ffi::gpointer,
558            f: glib::ffi::gpointer,
559        ) {
560            let f: &F = &*(f as *const F);
561            f(&from_glib_borrow(this))
562        }
563        unsafe {
564            let f: Box_<F> = Box_::new(f);
565            connect_raw(
566                self.as_ptr() as *mut _,
567                b"notify::leaky-type\0".as_ptr() as *const _,
568                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
569                    notify_leaky_type_trampoline::<F> as *const (),
570                )),
571                Box_::into_raw(f),
572            )
573        }
574    }
575
576    #[cfg(feature = "v1_20")]
577    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
578    #[doc(alias = "max-buffers")]
579    pub fn connect_max_buffers_notify<F: Fn(&Self) + Send + Sync + 'static>(
580        &self,
581        f: F,
582    ) -> SignalHandlerId {
583        unsafe extern "C" fn notify_max_buffers_trampoline<
584            F: Fn(&AppSrc) + Send + Sync + 'static,
585        >(
586            this: *mut ffi::GstAppSrc,
587            _param_spec: glib::ffi::gpointer,
588            f: glib::ffi::gpointer,
589        ) {
590            let f: &F = &*(f as *const F);
591            f(&from_glib_borrow(this))
592        }
593        unsafe {
594            let f: Box_<F> = Box_::new(f);
595            connect_raw(
596                self.as_ptr() as *mut _,
597                b"notify::max-buffers\0".as_ptr() as *const _,
598                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
599                    notify_max_buffers_trampoline::<F> as *const (),
600                )),
601                Box_::into_raw(f),
602            )
603        }
604    }
605
606    #[doc(alias = "max-bytes")]
607    pub fn connect_max_bytes_notify<F: Fn(&Self) + Send + Sync + 'static>(
608        &self,
609        f: F,
610    ) -> SignalHandlerId {
611        unsafe extern "C" fn notify_max_bytes_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
612            this: *mut ffi::GstAppSrc,
613            _param_spec: glib::ffi::gpointer,
614            f: glib::ffi::gpointer,
615        ) {
616            let f: &F = &*(f as *const F);
617            f(&from_glib_borrow(this))
618        }
619        unsafe {
620            let f: Box_<F> = Box_::new(f);
621            connect_raw(
622                self.as_ptr() as *mut _,
623                b"notify::max-bytes\0".as_ptr() as *const _,
624                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
625                    notify_max_bytes_trampoline::<F> as *const (),
626                )),
627                Box_::into_raw(f),
628            )
629        }
630    }
631
632    #[doc(alias = "max-latency")]
633    pub fn connect_max_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(
634        &self,
635        f: F,
636    ) -> SignalHandlerId {
637        unsafe extern "C" fn notify_max_latency_trampoline<
638            F: Fn(&AppSrc) + Send + Sync + 'static,
639        >(
640            this: *mut ffi::GstAppSrc,
641            _param_spec: glib::ffi::gpointer,
642            f: glib::ffi::gpointer,
643        ) {
644            let f: &F = &*(f as *const F);
645            f(&from_glib_borrow(this))
646        }
647        unsafe {
648            let f: Box_<F> = Box_::new(f);
649            connect_raw(
650                self.as_ptr() as *mut _,
651                b"notify::max-latency\0".as_ptr() as *const _,
652                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
653                    notify_max_latency_trampoline::<F> as *const (),
654                )),
655                Box_::into_raw(f),
656            )
657        }
658    }
659
660    #[cfg(feature = "v1_20")]
661    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
662    #[doc(alias = "max-time")]
663    pub fn connect_max_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
664        &self,
665        f: F,
666    ) -> SignalHandlerId {
667        unsafe extern "C" fn notify_max_time_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
668            this: *mut ffi::GstAppSrc,
669            _param_spec: glib::ffi::gpointer,
670            f: glib::ffi::gpointer,
671        ) {
672            let f: &F = &*(f as *const F);
673            f(&from_glib_borrow(this))
674        }
675        unsafe {
676            let f: Box_<F> = Box_::new(f);
677            connect_raw(
678                self.as_ptr() as *mut _,
679                b"notify::max-time\0".as_ptr() as *const _,
680                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
681                    notify_max_time_trampoline::<F> as *const (),
682                )),
683                Box_::into_raw(f),
684            )
685        }
686    }
687
688    #[doc(alias = "min-latency")]
689    pub fn connect_min_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(
690        &self,
691        f: F,
692    ) -> SignalHandlerId {
693        unsafe extern "C" fn notify_min_latency_trampoline<
694            F: Fn(&AppSrc) + Send + Sync + 'static,
695        >(
696            this: *mut ffi::GstAppSrc,
697            _param_spec: glib::ffi::gpointer,
698            f: glib::ffi::gpointer,
699        ) {
700            let f: &F = &*(f as *const F);
701            f(&from_glib_borrow(this))
702        }
703        unsafe {
704            let f: Box_<F> = Box_::new(f);
705            connect_raw(
706                self.as_ptr() as *mut _,
707                b"notify::min-latency\0".as_ptr() as *const _,
708                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
709                    notify_min_latency_trampoline::<F> as *const (),
710                )),
711                Box_::into_raw(f),
712            )
713        }
714    }
715
716    #[doc(alias = "min-percent")]
717    pub fn connect_min_percent_notify<F: Fn(&Self) + Send + Sync + 'static>(
718        &self,
719        f: F,
720    ) -> SignalHandlerId {
721        unsafe extern "C" fn notify_min_percent_trampoline<
722            F: Fn(&AppSrc) + Send + Sync + 'static,
723        >(
724            this: *mut ffi::GstAppSrc,
725            _param_spec: glib::ffi::gpointer,
726            f: glib::ffi::gpointer,
727        ) {
728            let f: &F = &*(f as *const F);
729            f(&from_glib_borrow(this))
730        }
731        unsafe {
732            let f: Box_<F> = Box_::new(f);
733            connect_raw(
734                self.as_ptr() as *mut _,
735                b"notify::min-percent\0".as_ptr() as *const _,
736                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
737                    notify_min_percent_trampoline::<F> as *const (),
738                )),
739                Box_::into_raw(f),
740            )
741        }
742    }
743
744    #[doc(alias = "size")]
745    pub fn connect_size_notify<F: Fn(&Self) + Send + Sync + 'static>(
746        &self,
747        f: F,
748    ) -> SignalHandlerId {
749        unsafe extern "C" fn notify_size_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
750            this: *mut ffi::GstAppSrc,
751            _param_spec: glib::ffi::gpointer,
752            f: glib::ffi::gpointer,
753        ) {
754            let f: &F = &*(f as *const F);
755            f(&from_glib_borrow(this))
756        }
757        unsafe {
758            let f: Box_<F> = Box_::new(f);
759            connect_raw(
760                self.as_ptr() as *mut _,
761                b"notify::size\0".as_ptr() as *const _,
762                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
763                    notify_size_trampoline::<F> as *const (),
764                )),
765                Box_::into_raw(f),
766            )
767        }
768    }
769
770    #[doc(alias = "stream-type")]
771    pub fn connect_stream_type_notify<F: Fn(&Self) + Send + Sync + 'static>(
772        &self,
773        f: F,
774    ) -> SignalHandlerId {
775        unsafe extern "C" fn notify_stream_type_trampoline<
776            F: Fn(&AppSrc) + Send + Sync + 'static,
777        >(
778            this: *mut ffi::GstAppSrc,
779            _param_spec: glib::ffi::gpointer,
780            f: glib::ffi::gpointer,
781        ) {
782            let f: &F = &*(f as *const F);
783            f(&from_glib_borrow(this))
784        }
785        unsafe {
786            let f: Box_<F> = Box_::new(f);
787            connect_raw(
788                self.as_ptr() as *mut _,
789                b"notify::stream-type\0".as_ptr() as *const _,
790                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
791                    notify_stream_type_trampoline::<F> as *const (),
792                )),
793                Box_::into_raw(f),
794            )
795        }
796    }
797}
798
799unsafe impl Send for AppSrc {}
800unsafe impl Sync for AppSrc {}
gstreamer_app/auto/app_src.rs

gstreamer_app/auto/
app_src.rs
