Trait gstreamer::prelude::PipelineExt

pub trait PipelineExt:
    IsA<Pipeline>
    + Sealed
    + 'static {
    // Provided methods
    fn auto_clock(&self) { ... }
    fn is_auto_flush_bus(&self) -> bool { ... }
    fn configured_latency(&self) -> Option<ClockTime> { ... }
    fn delay(&self) -> ClockTime { ... }
    fn latency(&self) -> Option<ClockTime> { ... }
    fn pipeline_clock(&self) -> Clock { ... }
    fn is_live(&self) -> bool { ... }
    fn set_auto_flush_bus(&self, auto_flush: bool) { ... }
    fn set_delay(&self, delay: ClockTime) { ... }
    fn set_latency(&self, latency: impl Into<Option<ClockTime>>) { ... }
    fn use_clock(&self, clock: Option<&impl IsA<Clock>>) { ... }
    fn connect_auto_flush_bus_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId { ... }
    fn connect_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId { ... }
    fn connect_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId { ... }
}

Trait containing all Pipeline methods.

Implementors

Pipeline

Provided Methods

fn auto_clock(&self)

Let self select a clock automatically. This is the default behaviour.

Use this function if you previous forced a fixed clock with use_clock() and want to restore the default pipeline clock selection algorithm.

MT safe.

fn is_auto_flush_bus(&self) -> bool

Check if self will automatically flush messages when going to the NULL state.

Returns

whether the pipeline will automatically flush its bus when going from READY to NULL state or not.

MT safe.

fn configured_latency(&self) -> Option<ClockTime>

Return the configured latency on self.

Returns

self configured latency, or GST_CLOCK_TIME_NONE if none has been configured because self did not reach the PLAYING state yet.

MT safe.

fn delay(&self) -> ClockTime

Get the configured delay (see set_delay()).

Returns

The configured delay.

MT safe.

fn latency(&self) -> Option<ClockTime>

Gets the latency that should be configured on the pipeline. See set_latency().

Returns

Latency to configure on the pipeline or GST_CLOCK_TIME_NONE

fn pipeline_clock(&self) -> Clock

Gets the current clock used by self.

Unlike ElementExt::clock(), this function will always return a clock, even if the pipeline is not in the PLAYING state.

Returns

a Clock, unref after usage.

fn is_live(&self) -> bool

Check if self is live.

Returns

true if self is live, false if not or if it did not reach the PAUSED state yet.

MT safe.

fn set_auto_flush_bus(&self, auto_flush: bool)

Usually, when a pipeline goes from READY to NULL state, it automatically flushes all pending messages on the bus, which is done for refcounting purposes, to break circular references.

This means that applications that update state using (async) bus messages (e.g. do certain things when a pipeline goes from PAUSED to READY) might not get to see messages when the pipeline is shut down, because they might be flushed before they can be dispatched in the main thread. This behaviour can be disabled using this function.

It is important that all messages on the bus are handled when the automatic flushing is disabled else memory leaks will be introduced.

MT safe.

auto_flush

whether or not to automatically flush the bus when the pipeline goes from READY to NULL state

fn set_delay(&self, delay: ClockTime)

Set the expected delay needed for all elements to perform the PAUSED to PLAYING state change. delay will be added to the base time of the elements so that they wait an additional delay amount of time before starting to process buffers and cannot be GST_CLOCK_TIME_NONE.

This option is used for tuning purposes and should normally not be used.

MT safe.

delay

the delay

fn set_latency(&self, latency: impl Into<Option<ClockTime>>)

Sets the latency that should be configured on the pipeline. Setting GST_CLOCK_TIME_NONE will restore the default behaviour of using the minimum latency from the LATENCY query. Setting this is usually not required and the pipeline will figure out an appropriate latency automatically.

Setting a too low latency, especially lower than the minimum latency from the LATENCY query, will most likely cause the pipeline to fail.

latency

latency to configure

fn use_clock(&self, clock: Option<&impl IsA<Clock>>)

Force self to use the given clock. The pipeline will always use the given clock even if new clock providers are added to this pipeline.

If clock is None all clocking will be disabled which will make the pipeline run as fast as possible.

MT safe.

clock

the clock to use

fn connect_auto_flush_bus_notify<F: Fn(&Self) + Send + Sync + 'static>( &self, f: F, ) -> SignalHandlerId

fn connect_delay_notify<F: Fn(&Self) + Send + Sync + 'static>( &self, f: F, ) -> SignalHandlerId

fn connect_latency_notify<F: Fn(&Self) + Send + Sync + 'static>( &self, f: F, ) -> SignalHandlerId

Object Safety

This trait is not object safe.

Implementors

impl<O: IsA<Pipeline>> PipelineExt for O