Segment

This helper structure holds the relevant values for tracking the region of interest in a media file, called a segment.

The structure can be used for two purposes:

performing seeks (handling seek events)

tracking playback regions (handling newsegment events)

The segment is usually configured by the application with a seek event which is propagated upstream and eventually handled by an element that performs the seek.

The configured segment is then propagated back downstream with a newsegment event. This information is then used to clip media to the segment boundaries.

A segment structure is initialized with gst_segment_init(), which takes a GstFormat that will be used as the format of the segment values. The segment will be configured with a start value of 0 and a stop/duration of -1, which is undefined. The default rate and applied_rate is 1.0.

The public duration field contains the duration of the segment. When using the segment for seeking, the start and time members should normally be left to their default 0 value. The stop position is left to -1 unless explicitly configured to a different value after a seek event.

The current position in the segment should be set by changing the position member in the structure.

For elements that perform seeks, the current segment should be updated with the gst_segment_do_seek() and the values from the seek event. This method will update all the segment fields. The position field will contain the new playback position. If the start_type was different from GST_SEEK_TYPE_NONE, playback continues from the position position, possibly with updated flags or rate.

For elements that want to use GstSegment to track the playback region, update the segment fields with the information from the newsegment event. The gst_segment_clip() method can be used to check and clip the media data to the segment boundaries.

For elements that want to synchronize to the pipeline clock, gst_segment_to_running_time() can be used to convert a timestamp to a value that can be used to synchronize to the clock. This function takes into account the base as well as any rate or applied_rate conversions.

For elements that need to perform operations on media data in stream_time, gst_segment_to_stream_time() can be used to convert a timestamp and the segment info to stream time (which is always between 0 and the duration of the stream).

Last reviewed on 2012-03-29 (0.11.3)

Constructors

this
this(GstSegment* gstSegment)

Sets our main struct and passes it to the parent class

this
this()

Allocate a new GstSegment structure and initialize it using gst_segment_init(). Free-function: gst_segment_free

Members

Functions

clip
int clip(GstFormat format, ulong start, ulong stop, ulong clipStart, ulong clipStop)

Clip the given start and stop values to the segment boundaries given in segment. start and stop are compared and clipped to segment start and stop values. If the function returns FALSE, start and stop are known to fall outside of segment and clip_start and clip_stop are not updated. When the function returns TRUE, clip_start and clip_stop will be updated. If clip_start or clip_stop are different from start or stop respectively, the region fell partially in the segment. Note that when stop is -1, clip_stop will be set to the end of the segment. Depending on the use case, this may or may not be what you want.

copy
Segment copy()

Create a copy of given segment. Free-function: gst_segment_free

copyInto
void copyInto(Segment dest)

Copy the contents of src into dest.

doSeek
int doSeek(double rate, GstFormat format, GstSeekFlags flags, GstSeekType startType, ulong start, GstSeekType stopType, ulong stop, int update)

Update the segment structure with the field values of a seek event (see gst_event_new_seek()). After calling this method, the segment field position and time will contain the requested new position in the segment. The new requested position in the segment depends on rate and start_type and stop_type. For positive rate, the new position in the segment is the new segment start field when it was updated with a start_type different from GST_SEEK_TYPE_NONE. If no update was performed on segment start position (GST_SEEK_TYPE_NONE), start is ignored and segment position is unmodified. For negative rate, the new position in the segment is the new segment stop field when it was updated with a stop_type different from GST_SEEK_TYPE_NONE. If no stop was previously configured in the segment, the duration of the segment will be used to update the stop position. If no update was performed on segment stop position (GST_SEEK_TYPE_NONE), stop is ignored and segment position is unmodified. The applied rate of the segment will be set to 1.0 by default. If the caller can apply a rate change, it should update segment rate and applied_rate after calling this function. update will be set to TRUE if a seek should be performed to the segment position field. This field can be FALSE if, for example, only the rate has been changed but not the playback position.

free
void free()

Free the allocated segment segment.

getSegmentStruct
GstSegment* getSegmentStruct()

Get the main Gtk struct

getStruct
void* getStruct()

the main Gtk struct as a void*

init
void init(GstFormat format)

The start/position fields are set to 0 and the stop/duration fields are set to -1 (unknown). The default rate of 1.0 and no flags are set. Initialize segment to its default values.

setRunningTime
int setRunningTime(GstFormat format, ulong runningTime)

Adjust the start/stop and base values of segment such that the next valid buffer will be one with running_time.

toPosition
ulong toPosition(GstFormat format, ulong runningTime)

Convert running_time into a position in the segment so that gst_segment_to_running_time() with that position returns running_time.

toRunningTime
ulong toRunningTime(GstFormat format, ulong position)

Translate position to the total running time using the currently configured segment. Position is a value between segment start and stop time. This function is typically used by elements that need to synchronize to the global clock in a pipeline. The runnning time is a constantly increasing value starting from 0. When gst_segment_init() is called, this value will reset to 0. This function returns -1 if the position is outside of segment start and stop.

toStreamTime
ulong toStreamTime(GstFormat format, ulong position)

Translate position to stream time using the currently configured segment. The position value must be between segment start and stop value. This function is typically used by elements that need to operate on the stream time of the buffers it receives, such as effect plugins. In those use cases, position is typically the buffer timestamp or clock time that one wants to convert to the stream time. The stream time is always between 0 and the total duration of the media stream.

Variables

gstSegment
GstSegment* gstSegment;

the main Gtk struct

Meta