gstreamer/subclass/
clock.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use glib::{prelude::*, subclass::prelude::*, translate::*};
4
5use super::prelude::*;
6use crate::{Clock, ClockError, ClockId, ClockReturn, ClockSuccess, ClockTime, ClockTimeDiff, ffi};
7
8pub trait ClockImpl: GstObjectImpl + ObjectSubclass<Type: IsA<Clock>> {
9    fn change_resolution(&self, old_resolution: ClockTime, new_resolution: ClockTime) -> ClockTime {
10        self.parent_change_resolution(old_resolution, new_resolution)
11    }
12
13    fn resolution(&self) -> ClockTime {
14        self.parent_resolution()
15    }
16
17    fn internal_time(&self) -> ClockTime {
18        self.parent_internal_time()
19    }
20
21    fn wait(&self, id: &ClockId) -> (Result<ClockSuccess, ClockError>, ClockTimeDiff) {
22        self.parent_wait(id)
23    }
24
25    fn wait_async(&self, id: &ClockId) -> Result<ClockSuccess, ClockError> {
26        self.parent_wait_async(id)
27    }
28
29    fn unschedule(&self, id: &ClockId) {
30        self.parent_unschedule(id)
31    }
32}
33
34pub trait ClockImplExt: ClockImpl {
35    fn parent_change_resolution(
36        &self,
37        old_resolution: ClockTime,
38        new_resolution: ClockTime,
39    ) -> ClockTime;
40
41    fn parent_resolution(&self) -> ClockTime {
42        unsafe {
43            let data = Self::type_data();
44            let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass;
45
46            try_from_glib(
47                (*parent_class)
48                    .get_resolution
49                    .map(|f| f(self.obj().unsafe_cast_ref::<Clock>().to_glib_none().0))
50                    .unwrap_or(1),
51            )
52            .expect("undefined resolution")
53        }
54    }
55
56    fn parent_internal_time(&self) -> ClockTime {
57        unsafe {
58            let data = Self::type_data();
59            let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass;
60
61            try_from_glib(
62                (*parent_class)
63                    .get_internal_time
64                    .map(|f| f(self.obj().unsafe_cast_ref::<Clock>().to_glib_none().0))
65                    .unwrap_or(0),
66            )
67            .expect("undefined internal_time")
68        }
69    }
70
71    fn parent_wait(&self, id: &ClockId) -> (Result<ClockSuccess, ClockError>, ClockTimeDiff) {
72        unsafe {
73            let data = Self::type_data();
74            let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass;
75            let mut jitter = 0;
76
77            (
78                try_from_glib(
79                    (*parent_class)
80                        .wait
81                        .map(|f| {
82                            f(
83                                self.obj().unsafe_cast_ref::<Clock>().to_glib_none().0,
84                                id.as_ptr() as *mut ffi::GstClockEntry,
85                                &mut jitter,
86                            )
87                        })
88                        .unwrap_or(ffi::GST_CLOCK_UNSUPPORTED),
89                ),
90                jitter,
91            )
92        }
93    }
94
95    fn parent_wait_async(&self, id: &ClockId) -> Result<ClockSuccess, ClockError> {
96        unsafe {
97            let data = Self::type_data();
98            let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass;
99            try_from_glib(
100                (*parent_class)
101                    .wait_async
102                    .map(|f| {
103                        f(
104                            self.obj().unsafe_cast_ref::<Clock>().to_glib_none().0,
105                            id.as_ptr() as *mut ffi::GstClockEntry,
106                        )
107                    })
108                    .unwrap_or(ffi::GST_CLOCK_UNSUPPORTED),
109            )
110        }
111    }
112
113    fn parent_unschedule(&self, id: &ClockId) {
114        unsafe {
115            let data = Self::type_data();
116            let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass;
117            if let Some(func) = (*parent_class).unschedule {
118                func(
119                    self.obj().unsafe_cast_ref::<Clock>().to_glib_none().0,
120                    id.as_ptr() as *mut ffi::GstClockEntry,
121                );
122            }
123        }
124    }
125
126    fn wake_id(&self, id: &ClockId) {
127        let clock = self.obj();
128        let clock = unsafe { clock.unsafe_cast_ref::<Clock>() };
129
130        cfg_if::cfg_if! {
131            if #[cfg(feature = "v1_16")] {
132                assert!(id.uses_clock(clock));
133            } else {
134                unsafe {
135                    let ptr = id.as_ptr() as *mut ffi::GstClockEntry;
136                    assert_eq!((*ptr).clock, clock.to_glib_none().0);
137                }
138            }
139        }
140
141        unsafe {
142            let ptr = id.as_ptr() as *mut ffi::GstClockEntry;
143            if let Some(func) = (*ptr).func {
144                func(
145                    clock.to_glib_none().0,
146                    (*ptr).time,
147                    ptr as ffi::GstClockID,
148                    (*ptr).user_data,
149                );
150            }
151            if (*ptr).type_ == ffi::GST_CLOCK_ENTRY_PERIODIC {
152                (*ptr).time += (*ptr).interval;
153            }
154        }
155    }
156}
157
158impl<T: ClockImpl> ClockImplExt for T {
159    fn parent_change_resolution(
160        &self,
161        old_resolution: ClockTime,
162        new_resolution: ClockTime,
163    ) -> ClockTime {
164        unsafe {
165            let data = Self::type_data();
166            let parent_class = data.as_ref().parent_class() as *mut ffi::GstClockClass;
167
168            if let Some(func) = (*parent_class).change_resolution {
169                try_from_glib(func(
170                    self.obj().unsafe_cast_ref::<Clock>().to_glib_none().0,
171                    old_resolution.into_glib(),
172                    new_resolution.into_glib(),
173                ))
174                .expect("undefined resolution")
175            } else {
176                self.resolution()
177            }
178        }
179    }
180}
181
182unsafe impl<T: ClockImpl> IsSubclassable<T> for Clock {
183    fn class_init(klass: &mut glib::Class<Self>) {
184        Self::parent_class_init::<T>(klass);
185        let klass = klass.as_mut();
186        klass.change_resolution = Some(clock_change_resolution::<T>);
187        klass.get_resolution = Some(clock_get_resolution::<T>);
188        klass.get_internal_time = Some(clock_get_internal_time::<T>);
189        klass.wait = Some(clock_wait::<T>);
190        klass.wait_async = Some(clock_wait_async::<T>);
191        klass.unschedule = Some(clock_unschedule::<T>);
192    }
193}
194
195unsafe extern "C" fn clock_change_resolution<T: ClockImpl>(
196    ptr: *mut ffi::GstClock,
197    old_resolution: ffi::GstClockTime,
198    new_resolution: ffi::GstClockTime,
199) -> ffi::GstClockTime {
200    unsafe {
201        let instance = &*(ptr as *mut T::Instance);
202        let imp = instance.imp();
203
204        let old_resolution = match from_glib(old_resolution) {
205            Some(old_resolution) => old_resolution,
206            None => return ffi::GST_CLOCK_TIME_NONE,
207        };
208        let new_resolution = match from_glib(new_resolution) {
209            Some(new_resolution) => new_resolution,
210            None => return ffi::GST_CLOCK_TIME_NONE,
211        };
212
213        imp.change_resolution(old_resolution, new_resolution)
214            .into_glib()
215    }
216}
217
218unsafe extern "C" fn clock_get_resolution<T: ClockImpl>(
219    ptr: *mut ffi::GstClock,
220) -> ffi::GstClockTime {
221    unsafe {
222        let instance = &*(ptr as *mut T::Instance);
223        let imp = instance.imp();
224
225        imp.resolution().into_glib()
226    }
227}
228
229unsafe extern "C" fn clock_get_internal_time<T: ClockImpl>(
230    ptr: *mut ffi::GstClock,
231) -> ffi::GstClockTime {
232    unsafe {
233        let instance = &*(ptr as *mut T::Instance);
234        let imp = instance.imp();
235
236        imp.internal_time().into_glib()
237    }
238}
239
240unsafe extern "C" fn clock_wait<T: ClockImpl>(
241    ptr: *mut ffi::GstClock,
242    id: *mut ffi::GstClockEntry,
243    jitter: *mut ffi::GstClockTimeDiff,
244) -> ffi::GstClockReturn {
245    unsafe {
246        let instance = &*(ptr as *mut T::Instance);
247        let imp = instance.imp();
248
249        let (res, j) = imp.wait(&from_glib_borrow(id as ffi::GstClockID));
250        if !jitter.is_null() {
251            *jitter = j;
252        }
253
254        ClockReturn::from(res).into_glib()
255    }
256}
257
258unsafe extern "C" fn clock_wait_async<T: ClockImpl>(
259    ptr: *mut ffi::GstClock,
260    id: *mut ffi::GstClockEntry,
261) -> ffi::GstClockReturn {
262    unsafe {
263        let instance = &*(ptr as *mut T::Instance);
264        let imp = instance.imp();
265
266        ClockReturn::from(imp.wait_async(&from_glib_borrow(id as ffi::GstClockID))).into_glib()
267    }
268}
269
270unsafe extern "C" fn clock_unschedule<T: ClockImpl>(
271    ptr: *mut ffi::GstClock,
272    id: *mut ffi::GstClockEntry,
273) {
274    unsafe {
275        let instance = &*(ptr as *mut T::Instance);
276        let imp = instance.imp();
277
278        imp.unschedule(&from_glib_borrow(id as ffi::GstClockID));
279    }
280}
gstreamer/subclass/clock.rs

gstreamer/subclass/
clock.rs
