Struct gstreamer_net::PtpClock [−][src]
pub struct PtpClock(_);
Expand description
GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain.
The PTP subsystem can be initialized with gst_ptp_init(), which then starts
a helper process to do the actual communication via the PTP ports. This is
required as PTP listens on ports < 1024 and thus requires special
privileges. Once this helper process is started, the main process will
synchronize to all PTP domains that are detected on the selected
interfaces.
new() then allows to create a GstClock that provides the PTP
time from a master clock inside a specific PTP domain. This clock will only
return valid timestamps once the timestamps in the PTP domain are known. To
check this, you can use [ClockExtManual::wait_for_sync()][crate::gst::prelude::ClockExtManual::wait_for_sync()], the GstClock::synced
signal and [ClockExtManual::is_synced()][crate::gst::prelude::ClockExtManual::is_synced()].
To gather statistics about the PTP clock synchronization,
gst_ptp_statistics_callback_add() can be used. This gives the application
the possibility to collect all kinds of statistics from the clock
synchronization.
Implements
gst::prelude::ClockExt, gst::prelude::ObjectExt, trait@glib::ObjectExt
Implementations
pub fn connect_grandmaster_clock_id_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F
) -> SignalHandlerId[src]pub fn connect_internal_clock_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F
) -> SignalHandlerId[src]pub fn connect_master_clock_id_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F
) -> SignalHandlerId[src]Creates a new PTP clock instance that exports the PTP time of the master
clock in domain. This clock can be slaved to other clocks as needed.
If gst_ptp_init() was not called before, this will call gst_ptp_init() with
default parameters.
This clock only returns valid timestamps after it received the first
times from the PTP master clock on the network. Once this happens the
GstPtpClock::internal-clock property will become non-NULL. You can
check this with [ClockExtManual::wait_for_sync()][crate::gst::prelude::ClockExtManual::wait_for_sync()], the GstClock::synced signal and
[ClockExtManual::is_synced()][crate::gst::prelude::ClockExtManual::is_synced()].
name
Name of the clock
domain
PTP domain
Returns
A new gst::Clock
Trait Implementations
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
Returns the type identifier of Self.
Auto Trait Implementations
Blanket Implementations
Mutably borrows from an owned value. Read more
Upcasts an object to a superclass or interface T. Read more
Upcasts an object to a reference of its superclass or interface T. Read more
Tries to downcast to a subclass or interface implementor T. Read more
Tries to downcast to a reference of its subclass or interface implementor T. Read more
Tries to cast to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Tries to cast to reference to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Casts to T unconditionally. Read more
Casts to &T unconditionally. Read more
The time master of the master clock and the time slave of the slave
clock are added to the list of observations. If enough observations
are available, a linear regression algorithm is run on the
observations and self is recalibrated. Read more
Add a clock observation to the internal slaving algorithm the same as
add_observation(), and return the result of the master clock
estimation, without updating the internal calibration. Read more
Converts the given internal clock time to the external time, adjusting for the
rate and reference time set with set_calibration() and making sure
that the returned time is increasing. This function should be called with the
clock’s OBJECT_LOCK held and is mainly used by clock subclasses. Read more
Gets the internal rate and reference time of self. See
set_calibration() for more information. Read more
Gets the current internal time of the given clock. The time is returned unadjusted for the offset and the rate. Read more
Gets the current time of the given clock. The time is always monotonically increasing and adjusted according to the current offset and rate. Read more
Gets the amount of time that master and slave clocks are sampled. Read more
Checks if the clock is currently synced, by looking at whether
ClockFlags::NEEDS_STARTUP_SYNC is set. Read more
Adjusts the rate and time of self. A rate of 1/1 is the normal speed of
the clock. Values bigger than 1/1 make the clock go faster. Read more
Sets the accuracy of the clock. Some clocks have the possibility to operate
with different accuracy at the expense of more resource usage. There is
normally no need to change the default resolution of a clock. The resolution
of a clock can only be changed if the clock has the
ClockFlags::CAN_SET_RESOLUTION flag set. Read more
Sets self to synced and emits the signal::Clock::synced signal, and wakes up any
thread waiting in wait_for_sync(). Read more
Sets the amount of time, in nanoseconds, to sample master and slave clocks Read more
pub fn connect_synced<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Fn(&O, bool) + Send + Sync, [src]pub fn connect_timeout_notify<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Fn(&O) + Send + Sync, [src]pub fn connect_window_size_notify<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Fn(&O) + Send + Sync, [src]pub fn connect_window_threshold_notify<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Fn(&O) + Send + Sync, [src]pub fn periodic_id_reinit(
&self,
id: &PeriodicClockId,
start_time: ClockTime,
interval: ClockTime
) -> Result<(), BoolError>[src]pub fn single_shot_id_reinit(
&self,
id: &SingleShotClockId,
time: ClockTime
) -> Result<(), BoolError>[src]pub fn add_control_binding<P>(&self, binding: &P) -> Result<(), BoolError> where
P: IsA<ControlBinding>, [src]
pub fn add_control_binding<P>(&self, binding: &P) -> Result<(), BoolError> where
P: IsA<ControlBinding>, [src]Attach the ControlBinding to the object. If there already was a
ControlBinding for this property it will be replaced. Read more
A default error function that uses g_printerr() to display the error message
and the optional debug string.. Read more
Gets the corresponding ControlBinding for the property. This should be
unreferenced again after use. Read more
Obtain the control-rate for this self. Audio processing Element
objects will use this rate to sub-divide their processing loop and call
sync_values() in between. The length of the processing segment
should be up to control-rate nanoseconds. Read more
Returns the parent of self. This function increases the refcount
of the parent object so you should gst_object_unref() it after usage. Read more
Generates a string describing the path of self in
the object hierarchy. Only useful (or used) for debugging. Read more
Gets the value for the given controlled property at the requested time. Read more
pub fn connect_parent_notify<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Fn(&O) + Send + Sync, [src]Returns true if the object is an instance of (can be cast to) T.
pub fn set_properties(
&self,
property_values: &[(&str, &dyn ToValue)]
) -> Result<(), BoolError>[src]pub fn set_properties_from_value(
&self,
property_values: &[(&str, Value)]
) -> Result<(), BoolError>[src]pub fn set_property<'a, N, V>(
&self,
property_name: N,
value: V
) -> Result<(), BoolError> where
V: ToValue,
N: Into<&'a str>, [src]pub fn set_property_from_value<'a, N>(
&self,
property_name: N,
value: &Value
) -> Result<(), BoolError> where
N: Into<&'a str>, [src]pub fn property<'a, N>(&self, property_name: N) -> Result<Value, BoolError> where
N: Into<&'a str>, [src]Safety Read more
Safety Read more
Safety Read more
Safety Read more
pub fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec) + Send + Sync, [src]pub fn connect_notify_local<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec), [src]pub unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec), [src]pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>, [src]pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>, [src]pub fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
N: Into<&'a str>, [src]Same as connect but takes a SignalId instead of a signal name.
pub fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + 'static,
N: Into<&'a str>, [src]Same as connect_local but takes a SignalId instead of a signal name.
pub unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value>,
N: Into<&'a str>, [src]Same as connect_unsafe but takes a SignalId instead of a signal name.
Emit signal by signal id.
Emit signal with details by signal id.
Emit signal by it’s name.
pub fn bind_property<'a, O, N, M>(
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
N: Into<&'a str>,
O: ObjectType,
M: Into<&'a str>, [src]Same as emit but takes Value for the arguments.
Same as emit_by_name but takes Value for the arguments.
Returns a SendValue clone of self.
impl<'a, T, C> FromValueOptional<'a> for T where
C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError>,
T: FromValue<'a, Checker = C>, [src]