Pipeline

Object Hierarchy:

Description:

public class Pipeline : Bin, ChildProxy

A Pipeline is a special Bin used as the toplevel container for the filter graph. The Pipeline will manage the selection and distribution of a global Clock as well as provide a Bus to the application. It will also implement a default behavour for managing seek events (see seek ). Pipeline is used to create a pipeline. when you are done with the pipeline, use unref to free its resources including all added Element objects (if not otherwise referenced). Elements are added and removed from the pipeline using the Bin methods like add and remove (see Bin). Before changing the state of the Pipeline (see Element) a Bus can be retrieved with get_bus. This bus can then be used to receive Message from the elements in the pipeline. By default, a Pipeline will automatically flush the pending Bus messages when going to the NULL state to ensure that no circular references exist when no messages are read from the Bus. This behaviour can be changed with set_auto_flush_bus. When the 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 NO_PREROLL from the set_state 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 SystemClock is used. The clock selection can be controlled with the use_clock method, which will enforce a given clock on the pipeline. With auto_clock the default clock selection algorithm can be restored. A 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 set_start_time method. When sending a flushing seek event to a GstPipeline (see seek), it will make sure that the pipeline is properly PAUSED and resumed as well as set the new running time to 0 when the seek succeeded. Last reviewed on 2009-05-29 (0.10.24)

Namespace: Gst

Package: gstreamer-0.10

Content:

Properties:

public bool auto_flush_bus { set; get; }
Whether or not to automatically flush all messages on the pipeline's bus when going from READY to NULL state. Please see set_auto_flush_bus for more information on this option.
public uint64 delay { set; get; }
The expected delay needed for elements to spin up to the PLAYING state expressed in nanoseconds. see set_delay for more information on this option.

Creation methods:

public Pipeline (string? name)
Create a new pipeline with the given name. MT safe.

Methods:

public void auto_clock ()
Let pipeline 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.
public bool get_auto_flush_bus ()
Check if pipeline will automatically flush messages when going to the NULL state. going from READY to NULL state or not. MT safe.
public Bus get_bus ()
Gets the Bus of pipeline. The bus allows applications to receive Message packets. MT safe.
public Clock? get_clock ()
Gets the current clock used by pipeline.
public ClockTime get_delay ()
Get the configured delay (see set_delay). MT safe.
public ClockTime get_last_stream_time ()
Gets the last running time of pipeline. If the pipeline is PLAYING, the returned time is the running time used to configure the element's base time in the PAUSED->PLAYING state. If the pipeline is PAUSED, the returned time is the running time when the pipeline was paused. This function returns CLOCK_TIME_NONE if the pipeline was configured to not handle the management of the element's base time (see set_new_stream_time). MT safe. get_start_time.
public void set_auto_flush_bus (bool auto_flush)
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.
public bool set_clock (Clock? clock)
Set the clock for pipeline. The clock will be distributed to all the elements managed by the pipeline. some element did not accept the clock. MT safe.
public void set_delay (ClockTime 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 CLOCK_TIME_NONE. This option is used for tuning purposes and should normally not be used. MT safe.
public void set_new_stream_time (ClockTime time)
Set the new start time of pipeline to time. The start time is used to set the base time on the elements (see set_base_time) in the PAUSED->PLAYING state transition. Setting time to CLOCK_TIME_NONE will disable the pipeline's management of element base time. The application will then be responsible for performing base time distribution. This is sometimes useful if you want to synchronize capture from multiple pipelines, and you can also ensure that the pipelines have the same clock. MT safe. set_start_time.
public void use_clock (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. If clock is NULL all clocking will be disabled which will make the pipeline run as fast as possible. MT safe.