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 178 179 180 181 182 183 184 185 186 187 188 189
// Copyright (C) 2018 Sebastian Dröge <sebastian@centricular.com> // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use glib::translate::*; use gst; use gst_check_sys; use std::ptr; use TestClock; impl TestClock { /// Checks whether `self` was requested to provide the clock notification /// given by `id`. /// /// MT safe. /// ## `id` /// a `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(gst_check_sys::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 `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(gst_check_sys::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. /// /// Feature: `v1_18` /// /// ## `pending_id` /// `gst::ClockID` #[cfg(any(feature = "v1_18", feature = "dox"))] pub fn process_id(&self, pending_id: &gst::ClockId) -> bool { unsafe { from_glib(gst_check_sys::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 { gst_check_sys::gst_test_clock_process_id_list( self.to_glib_none().0, pending_list.to_glib_none().0, ) } } /// MT safe. /// /// # Returns /// /// a `gst::ClockID` containing the next pending clock /// notification. pub fn process_next_clock_id(&self) -> Option<gst::ClockId> { unsafe { from_glib_full(gst_check_sys::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 /// `TestClock`. /// /// MT safe. /// ## `count` /// the number of pending clock notifications to wait for /// ## `pending_list` /// Address /// of a `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(); gst_check_sys::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 `TestClock`. A reference /// to the pending clock notification is stored in `pending_id`. /// /// MT safe. /// ## `pending_id` /// `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(); gst_check_sys::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. /// /// Feature: `v1_16` /// /// ## `count` /// the number of pending clock notifications to wait for /// ## `timeout_ms` /// the timeout in milliseconds /// ## `pending_list` /// Address /// of a `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"))] 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 = gst_check_sys::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), ) } } }