Pipeline

A gstreamer.Pipeline is a special gstreamer.Bin used as the toplevel container for the filter graph. The gstreamer.Pipeline will manage the selection and distribution of a global gstreamer.Clock as well as provide a gstreamer.Bus to the application.

Pipeline.new is used to create a pipeline. when you are done with the pipeline, use gst_object_unref() to free its resources including all added gstreamer.Element objects (if not otherwise referenced).

Elements are added and removed from the pipeline using the gstreamer.Bin methods like Bin.add and Bin.remove (see gstreamer.Bin).

Before changing the state of the gstreamer.Pipeline (see gstreamer.Element) a gstreamer.Bus can be retrieved with Pipeline.getBus. This bus can then be used to receive gstreamer.Message from the elements in the pipeline.

By default, a gstreamer.Pipeline will automatically flush the pending gstreamer.Bus messages when going to the NULL state to ensure that no circular references exist when no messages are read from the gstreamer.Bus This behaviour can be changed with Pipeline.setAutoFlushBus.

When the gstreamer.Pipeline performs the PAUSED to PLAYING state change it will select a clock for the elements. The clock selection algorithm will by default select a clock provided by an element that is most upstream (closest to the source). For live pipelines (ones that return GST_STATE_CHANGE_NO_PREROLL from the Element.setState call) this will select the clock provided by the live source. For normal pipelines this will select a clock provided by the sinks (most likely the audio sink). If no element provides a clock, a default gstreamer.SystemClock is used.

The clock selection can be controlled with the Pipeline.useClock method, which will enforce a given clock on the pipeline. With Pipeline.autoClock the default clock selection algorithm can be restored.

A gstreamer.Pipeline maintains a running time for the elements. The running time is defined as the difference between the current clock time and the base time. When the pipeline goes to READY or a flushing seek is performed on it, the running time is reset to 0. When the pipeline is set from PLAYING to PAUSED, the current clock time is sampled and used to configure the base time for the elements when the pipeline is set to PLAYING again. The effect is that the running time (as the difference between the clock time and the base time) will count how much time was spent in the PLAYING state. This default behaviour can be changed with the Element.setStartTime method.

Constructors

this
this(GstPipeline* gstPipeline, bool ownedRef = false)

Sets our main struct and passes it to the parent class.

this
this(string name)

Create a new pipeline with the given name.

Members

Functions

autoClock
void autoClock()

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

getAutoFlushBus
bool getAutoFlushBus()

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

getBus
Bus getBus()

Gets the gstreamer.Bus of pipeline. The bus allows applications to receive gstreamer.Message packets.

getClock
Clock getClock()

Gets the current clock used by pipeline. Users of object oriented languages should use Pipeline.getPipelineClock to avoid confusion with Element.getClock which has a different behavior.

getDelay
GstClockTime getDelay()

Get the configured delay (see Pipeline.setDelay).

getLatency
GstClockTime getLatency()

Gets the latency that should be configured on the pipeline. See Pipeline.setLatency.

getPipelineClock
Clock getPipelineClock()

Gets the current clock used by pipeline.

getPipelineStruct
GstPipeline* getPipelineStruct(bool transferOwnership = false)

Get the main Gtk struct

getStruct
void* getStruct()

the main Gtk struct as a void*

setAutoFlushBus
void setAutoFlushBus(bool autoFlush)

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.

setClock
bool setClock(Clock clock)

Set the clock for pipeline. The clock will be distributed to all the elements managed by the pipeline.

setDelay
void setDelay(GstClockTime delay)

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

setLatency
void setLatency(GstClockTime latency)

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.

useClock
void useClock(Clock clock)

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

Static functions

getType
GType getType()

Variables

gstPipeline
GstPipeline* gstPipeline;

the main Gtk struct

Inherited Members

From Bin

gstBin
GstBin* gstBin;

the main Gtk struct

getBinStruct
GstBin* getBinStruct(bool transferOwnership = false)

Get the main Gtk struct

getStruct
void* getStruct()

the main Gtk struct as a void*

addMany
void addMany(Element[] elems...)

Adds a list of elements to a bin. This function is equivalent to calling add() for each member of the list. The return value of each add() is ignored.

removeMany
void removeMany(Element[] elems...)

Remove a list of elements from a bin. This function is equivalent to calling remove() with each member of the list.

getType
GType getType()
add
bool add(Element element)

Adds the given element to the bin. Sets the element's parent, and thus takes ownership of the element. An element can only be added to one bin.

findUnlinkedPad
Pad findUnlinkedPad(GstPadDirection direction)

Recursively looks for elements with an unlinked pad of the given direction within the specified bin and returns an unlinked pad if one is found, or NULL otherwise. If a pad is found, the caller owns a reference to it and should use gst_object_unref() on the pad when it is not needed any longer.

getByInterface
Element getByInterface(GType iface)

Looks for an element inside the bin that implements the given interface. If such an element is found, it returns the element. You can cast this element to the given interface afterwards. If you want all elements that implement the interface, use Bin.iterateAllByInterface. This function recurses into child bins.

getByName
Element getByName(string name)

Gets the element with the given name from a bin. This function recurses into child bins.

getByNameRecurseUp
Element getByNameRecurseUp(string name)

Gets the element with the given name from this bin. If the element is not found, a recursion is performed on the parent bin.

getSuppressedFlags
GstElementFlags getSuppressedFlags()

Return the suppressed flags of the bin.

iterateAllByInterface
Iterator iterateAllByInterface(GType iface)

Looks for all elements inside the bin that implements the given interface. You can safely cast all returned elements to the given interface. The function recurses inside child bins. The iterator will yield a series of gstreamer.Element that should be unreffed after use.

iterateElements
Iterator iterateElements()

Gets an iterator for the elements in this bin.

iterateRecurse
Iterator iterateRecurse()

Gets an iterator for the elements in this bin. This iterator recurses into GstBin children.

iterateSinks
Iterator iterateSinks()

Gets an iterator for all elements in the bin that have the GST_ELEMENT_FLAG_SINK flag set.

iterateSorted
Iterator iterateSorted()

Gets an iterator for the elements in this bin in topologically sorted order. This means that the elements are returned from the most downstream elements (sinks) to the sources.

iterateSources
Iterator iterateSources()

Gets an iterator for all elements in the bin that have the GST_ELEMENT_FLAG_SOURCE flag set.

recalculateLatency
bool recalculateLatency()

Query bin for the current latency using and reconfigures this latency to all the elements with a LATENCY event.

remove
bool remove(Element element)

Removes the element from the bin, unparenting it as well. Unparenting the element means that the element will be dereferenced, so if the bin holds the only reference to the element, the element will be freed in the process of removing it from the bin. If you want the element to still exist after removing, you need to call gst_object_ref() before removing it from the bin.

setSuppressedFlags
void setSuppressedFlags(GstElementFlags flags)

Suppress the given flags on the bin. GstElementFlags of a child element are propagated when it is added to the bin. When suppressed flags are set, those specified flags will not be propagated to the bin.

syncChildrenStates
bool syncChildrenStates()

Synchronizes the state of every child of bin with the state of bin. See also Element.syncStateWithParent.

addOnDeepElementAdded
gulong addOnDeepElementAdded(void delegate(Bin, Element, Bin) dlg, ConnectFlags connectFlags = cast(ConnectFlags)0)

Will be emitted after the element was added to sub_bin.

addOnDeepElementRemoved
gulong addOnDeepElementRemoved(void delegate(Bin, Element, Bin) dlg, ConnectFlags connectFlags = cast(ConnectFlags)0)

Will be emitted after the element was removed from sub_bin.

addOnDoLatency
gulong addOnDoLatency(bool delegate(Bin) dlg, ConnectFlags connectFlags = cast(ConnectFlags)0)

Will be emitted when the bin needs to perform latency calculations. This signal is only emitted for toplevel bins or when async-handling is enabled.

addOnElementAdded
gulong addOnElementAdded(void delegate(Element, Bin) dlg, ConnectFlags connectFlags = cast(ConnectFlags)0)

Will be emitted after the element was added to the bin.

addOnElementRemoved
gulong addOnElementRemoved(void delegate(Element, Bin) dlg, ConnectFlags connectFlags = cast(ConnectFlags)0)

Will be emitted after the element was removed from the bin.

Meta