1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
// Take a look at the license at the top of the repository in the LICENSE file.

use crate::TestClock;
use glib::translate::*;
use std::ptr;

impl TestClock {
    /// Checks whether `self` was requested to provide the clock notification
    /// given by `id`.
    ///
    /// MT safe.
    /// ## `id`
    /// a [`crate::gst::ClockID`] clock notification
    ///
    /// # Returns
    ///
    /// [`true`] if the clock has been asked to provide the given clock
    /// notification, [`false`] otherwise.
    pub fn has_id(&self, id: &gst::ClockId) -> bool {
        unsafe {
            from_glib(ffi::gst_test_clock_has_id(
                self.to_glib_none().0,
                id.to_glib_none().0,
            ))
        }
    }

    /// Determines if the `pending_id` is the next clock notification scheduled to
    /// be triggered given the current time of the `self`.
    ///
    /// MT safe.
    /// ## `pending_id`
    /// a [`crate::gst::ClockID`] clock
    /// notification to look for
    ///
    /// # Returns
    ///
    /// [`true`] if `pending_id` is the next clock notification to be
    /// triggered, [`false`] otherwise.
    pub fn peek_next_pending_id(&self) -> Option<gst::ClockId> {
        unsafe {
            let mut id = ptr::null_mut();
            let ret: bool = from_glib(ffi::gst_test_clock_peek_next_pending_id(
                self.to_glib_none().0,
                &mut id,
            ));
            if ret {
                from_glib_full(id)
            } else {
                None
            }
        }
    }

    /// Processes and releases the pending ID.
    ///
    /// MT safe.
    /// ## `pending_id`
    /// [`crate::gst::ClockID`]
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    pub fn process_id(&self, pending_id: &gst::ClockId) -> bool {
        unsafe {
            from_glib(ffi::gst_test_clock_process_id(
                self.to_glib_none().0,
                pending_id.to_glib_none().0,
            ))
        }
    }

    /// Processes and releases the pending IDs in the list.
    ///
    /// MT safe.
    /// ## `pending_list`
    /// List
    ///  of pending `GstClockIDs`
    pub fn process_id_list(&self, pending_list: &[&gst::ClockId]) -> u32 {
        unsafe {
            ffi::gst_test_clock_process_id_list(
                self.to_glib_none().0,
                pending_list.to_glib_none().0,
            )
        }
    }

    /// MT safe.
    ///
    /// # Returns
    ///
    /// a [`crate::gst::ClockID`] containing the next pending clock
    /// notification.
    pub fn process_next_clock_id(&self) -> Option<gst::ClockId> {
        unsafe {
            from_glib_full(ffi::gst_test_clock_process_next_clock_id(
                self.to_glib_none().0,
            ))
        }
    }

    /// Blocks until at least `count` clock notifications have been requested from
    /// `self`. There is no timeout for this wait, see the main description of
    /// [`crate::TestClock`].
    ///
    /// MT safe.
    /// ## `count`
    /// the number of pending clock notifications to wait for
    /// ## `pending_list`
    /// Address
    ///  of a [`crate::glib::List`] pointer variable to store the list of pending `GstClockIDs`
    ///  that expired, or [`None`]
    pub fn wait_for_multiple_pending_ids(&self, count: u32) -> Vec<gst::ClockId> {
        unsafe {
            let mut pending_list = ptr::null_mut();
            ffi::gst_test_clock_wait_for_multiple_pending_ids(
                self.to_glib_none().0,
                count,
                &mut pending_list,
            );
            FromGlibPtrContainer::from_glib_full(pending_list)
        }
    }

    /// Waits until a clock notification is requested from `self`. There is no
    /// timeout for this wait, see the main description of [`crate::TestClock`]. A reference
    /// to the pending clock notification is stored in `pending_id`.
    ///
    /// MT safe.
    /// ## `pending_id`
    /// [`crate::gst::ClockID`]
    /// with information about the pending clock notification
    pub fn wait_for_next_pending_id(&self) -> gst::ClockId {
        unsafe {
            let mut id = ptr::null_mut();
            ffi::gst_test_clock_wait_for_next_pending_id(self.to_glib_none().0, &mut id);
            from_glib_full(id)
        }
    }

    /// Blocks until at least `count` clock notifications have been requested from
    /// `self`, or the timeout expires.
    ///
    /// MT safe.
    /// ## `count`
    /// the number of pending clock notifications to wait for
    /// ## `timeout_ms`
    /// the timeout in milliseconds
    /// ## `pending_list`
    /// Address
    ///  of a [`crate::glib::List`] pointer variable to store the list of pending `GstClockIDs`
    ///  that expired, or [`None`]
    ///
    /// # Returns
    ///
    /// a `gboolean` [`true`] if the waits have been registered, [`false`] if not.
    /// (Could be that it timed out waiting or that more waits than waits was found)
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
    pub fn timed_wait_for_multiple_pending_ids(
        &self,
        count: u32,
        timeout_ms: u32,
    ) -> (bool, Vec<gst::ClockId>) {
        unsafe {
            let mut pending_list = ptr::null_mut();
            let res = ffi::gst_test_clock_timed_wait_for_multiple_pending_ids(
                self.to_glib_none().0,
                count,
                timeout_ms,
                &mut pending_list,
            );
            (
                from_glib(res),
                FromGlibPtrContainer::from_glib_full(pending_list),
            )
        }
    }
}