Package ch.bailu.gtk.gst

Klasse Segment

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.gst.Segment
Alle implementierten Schnittstellen:
PointerInterface
public class Segment extends Record
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).

https://gstreamer.freedesktop.org/documentation/gstreamer/gi-index.html

  • Feldübersicht

    Felder
    Modifizierer und Typ
    Feld
    Beschreibung
    static final String
    APPLIED_RATE
    The applied rate is the rate that has been applied to the stream.
    static final String
    BASE
    the running time (plus elapsed time, see offset) of the
    segment [start](GstSegment.start) ([stop](GstSegment.stop) if
    rate < 0.0).
    static final String
    DURATION
    the duration of the segment is the maximum absolute difference
    between #GstSegment.start and #GstSegment.stop if stop is not
    set, otherwise it should be the difference between those
    two values.
    static final String
    FLAGS
    flags for this segment
    static final String
    FORMAT
    the unit used for all of the segment's values.
    static final String
    OFFSET
    the offset expresses the elapsed time (in buffer timestamps)
    before a seek with its start (stop if rate < 0.0) seek type
    set to #GST_SEEK_TYPE_NONE, the value is set to the position
    of the segment at the time of the seek.
    static final String
    POSITION
    the buffer timestamp position in the segment is supposed to be
    updated by elements such as sources, demuxers or parsers to
    track progress by setting it to the last pushed buffer' end time
    ([timestamp](GstBuffer.pts) + #GstBuffer.duration) for that
    specific segment.
    static final String
    RATE
    the playback rate of the segment is set in response to a seek
    event and, without any seek, the value should be `1.0`.
    static final String
    START
    the start time of the segment (in buffer timestamps)
    [(PTS)](GstBuffer.pts), that is the timestamp of the first
    buffer to output inside the segment (last one during
    reverse playback).
    static final String
    STOP
    the stop time of the segment (in buffer timestamps)
    [(PTS)](GstBuffer.pts), that is the timestamp of the last
    buffer to output inside the segment (first one during
    reverse playback).
    static final String
    TIME
    the stream time of the segment [start](GstSegment.start)
    ([stop](GstSegment.stop) if rate < 0.0).

    Von Klasse geerbte Felder ch.bailu.gtk.type.Pointer

    NULL

  • Konstruktorübersicht

    Konstruktoren
    Konstruktor
    Beschreibung
    Segment()
    Allocate a new #GstSegment structure and initialize it using
    gst_segment_init().
    Segment(PointerContainer pointer)
     

  • Methodenübersicht

    Modifizierer und Typ
    Methode
    Beschreibung
    Segment
    copy()
    Create a copy of given @segment.
    void
    copyInto(Segment dest)
    Copy the contents of @src into @dest.
    boolean
    doSeek(double rate, int format, int flags, int start_type, long start, int stop_type, long stop, Int update)
    Update the segment structure with the field values of a seek event (see
    gst_event_new_seek()).
    void
    free()
    Free the allocated segment @segment.
    static ClassHandler
    getClassHandler()
     
    double
    getFieldAppliedRate()
    The applied rate is the rate that has been applied to the stream.
    long
    getFieldBase()
    the running time (plus elapsed time, see offset) of the
    segment [start](GstSegment.start) ([stop](GstSegment.stop) if
    rate < 0.0).
    long
    getFieldDuration()
    the duration of the segment is the maximum absolute difference
    between #GstSegment.start and #GstSegment.stop if stop is not
    set, otherwise it should be the difference between those
    two values.
    int
    getFieldFlags()
    flags for this segment
    int
    getFieldFormat()
    the unit used for all of the segment's values.
    long
    getFieldOffset()
    the offset expresses the elapsed time (in buffer timestamps)
    before a seek with its start (stop if rate < 0.0) seek type
    set to #GST_SEEK_TYPE_NONE, the value is set to the position
    of the segment at the time of the seek.
    long
    getFieldPosition()
    the buffer timestamp position in the segment is supposed to be
    updated by elements such as sources, demuxers or parsers to
    track progress by setting it to the last pushed buffer' end time
    ([timestamp](GstBuffer.pts) + #GstBuffer.duration) for that
    specific segment.
    double
    getFieldRate()
    the playback rate of the segment is set in response to a seek
    event and, without any seek, the value should be `1.0`.
    long
    getFieldStart()
    the start time of the segment (in buffer timestamps)
    [(PTS)](GstBuffer.pts), that is the timestamp of the first
    buffer to output inside the segment (last one during
    reverse playback).
    long
    getFieldStop()
    the stop time of the segment (in buffer timestamps)
    [(PTS)](GstBuffer.pts), that is the timestamp of the last
    buffer to output inside the segment (first one during
    reverse playback).
    long
    getFieldTime()
    the stream time of the segment [start](GstSegment.start)
    ([stop](GstSegment.stop) if rate < 0.0).
    static int
    getInstanceSize()
     
    static long
    getParentTypeID()
     
    static TypeSystem.TypeSize
    getParentTypeSize()
     
    static long
    getTypeID()
     
    static TypeSystem.TypeSize
    getTypeSize()
     
    void
    init(int format)
    The start/position fields are set to 0 and the stop/duration
    fields are set to -1 (unknown).
    boolean
    isEqual(Segment s1)
    Checks for two segments being equal.
    boolean
    offsetRunningTime(int format, long offset)
    Adjust the values in @segment so that @offset is applied to all
    future running-time calculations.
    long
    positionFromRunningTime(int format, long running_time)
    Convert @running_time into a position in the segment so that
    gst_segment_to_running_time() with that position returns @running_time.
    long
    positionFromStreamTime(int format, long stream_time)
    Convert @stream_time into a position in the segment so that
    gst_segment_to_stream_time() with that position returns @stream_time.
    void
    setFieldAppliedRate(double applied_rate)
    The applied rate is the rate that has been applied to the stream.
    void
    setFieldBase(long base)
    the running time (plus elapsed time, see offset) of the
    segment [start](GstSegment.start) ([stop](GstSegment.stop) if
    rate < 0.0).
    void
    setFieldDuration(long duration)
    the duration of the segment is the maximum absolute difference
    between #GstSegment.start and #GstSegment.stop if stop is not
    set, otherwise it should be the difference between those
    two values.
    void
    setFieldFlags(int flags)
    flags for this segment
    void
    setFieldFormat(int format)
    the unit used for all of the segment's values.
    void
    setFieldOffset(long offset)
    the offset expresses the elapsed time (in buffer timestamps)
    before a seek with its start (stop if rate < 0.0) seek type
    set to #GST_SEEK_TYPE_NONE, the value is set to the position
    of the segment at the time of the seek.
    void
    setFieldPosition(long position)
    the buffer timestamp position in the segment is supposed to be
    updated by elements such as sources, demuxers or parsers to
    track progress by setting it to the last pushed buffer' end time
    ([timestamp](GstBuffer.pts) + #GstBuffer.duration) for that
    specific segment.
    void
    setFieldRate(double rate)
    the playback rate of the segment is set in response to a seek
    event and, without any seek, the value should be `1.0`.
    void
    setFieldStart(long start)
    the start time of the segment (in buffer timestamps)
    [(PTS)](GstBuffer.pts), that is the timestamp of the first
    buffer to output inside the segment (last one during
    reverse playback).
    void
    setFieldStop(long stop)
    the stop time of the segment (in buffer timestamps)
    [(PTS)](GstBuffer.pts), that is the timestamp of the last
    buffer to output inside the segment (first one during
    reverse playback).
    void
    setFieldTime(long time)
    the stream time of the segment [start](GstSegment.start)
    ([stop](GstSegment.stop) if rate < 0.0).
    boolean
    setRunningTime(int format, long running_time)
    Adjust the start/stop and base values of @segment such that the next valid
    buffer will be one with @running_time.
    long
    toPosition(int format, long running_time)
    Veraltet.
    long
    toRunningTime(int format, long position)
    Translate @position to the total running time using the currently configured
    segment.
    long
    toStreamTime(int format, long position)
    Translate @position to stream time using the currently configured
    segment.

    Von Klasse geerbte Methoden ch.bailu.gtk.type.Record

    destroy

    Von Klasse geerbte Methoden ch.bailu.gtk.type.Pointer

    asCPointer, cast, connectSignal, disconnectSignals, disconnectSignals, equals, hashCode, throwIfNull, throwNullPointerException, toString, unregisterCallbacks, unregisterCallbacks

    Von Klasse geerbte Methoden ch.bailu.gtk.type.Type

    asCPointer, asCPointer, asCPointerNotNull, asJnaPointer, asJnaPointer, asPointer, asPointer, cast, cast, throwIfNull

    Von Klasse geerbte Methoden java.lang.Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

    Von Schnittstelle geerbte Methoden ch.bailu.gtk.type.PointerInterface

    asCPointerNotNull, asJnaPointer, asPointer, isNotNull, isNull

  • Felddetails

    • FLAGS

      public static final String FLAGS
      flags for this segment
      Siehe auch:

    • RATE

      public static final String RATE
      the playback rate of the segment is set in response to a seek
      event and, without any seek, the value should be `1.0`. This
      value is used by elements that synchronize buffer [running
      times](additional/design/synchronisation.md#running-time) on
      the clock (usually the sink elements), leading to consuming
      buffers faster (for a value `> 1.0`) or slower (for `0.0 <
      value < 1.0`) than normal playback speed. The rate also
      defines the playback direction, meaning that when the value is
      lower than `0.0`, the playback happens in reverse, and the
      [stream-time](additional/design/synchronisation.md#stream-time)
      is going backward. The `rate` value should never be `0.0`.
      Siehe auch:

    • APPLIED_RATE

      public static final String APPLIED_RATE
      The applied rate is the rate that has been applied to the stream.
      The effective/resulting playback rate of a stream is
      `rate * applied_rate`.
      The applied rate can be set by source elements when a server is
      sending the stream with an already modified playback speed
      rate. Filter elements that modify the stream in a way that
      modifies the playback speed should also modify the applied
      rate. For example the #videorate element when its
      #videorate:rate property is set will set the applied rate of
      the segment it pushed downstream. Also #scaletempo applies the
      input segment rate to the stream and outputs a segment with
      rate=1.0 and applied_rate=<inputsegment.rate>.
      Siehe auch:

    • FORMAT

      public static final String FORMAT
      the unit used for all of the segment's values.
      Siehe auch:

    • BASE

      public static final String BASE
      the running time (plus elapsed time, see offset) of the
      segment [start](GstSegment.start) ([stop](GstSegment.stop) if
      rate < 0.0).
      Siehe auch:

    • OFFSET

      public static final String OFFSET
      the offset expresses the elapsed time (in buffer timestamps)
      before a seek with its start (stop if rate < 0.0) seek type
      set to #GST_SEEK_TYPE_NONE, the value is set to the position
      of the segment at the time of the seek.
      Siehe auch:

    • START

      public static final String START
      the start time of the segment (in buffer timestamps)
      [(PTS)](GstBuffer.pts), that is the timestamp of the first
      buffer to output inside the segment (last one during
      reverse playback). For example decoders will
      [clip](gst_segment_clip) out the buffers before the start
      time.
      Siehe auch:

    • STOP

      public static final String STOP
      the stop time of the segment (in buffer timestamps)
      [(PTS)](GstBuffer.pts), that is the timestamp of the last
      buffer to output inside the segment (first one during
      reverse playback). For example decoders will
      [clip](gst_segment_clip) out buffers after the stop time.
      Siehe auch:

    • TIME

      public static final String TIME
      the stream time of the segment [start](GstSegment.start)
      ([stop](GstSegment.stop) if rate < 0.0).
      Siehe auch:

    • POSITION

      public static final String POSITION
      the buffer timestamp position in the segment is supposed to be
      updated by elements such as sources, demuxers or parsers to
      track progress by setting it to the last pushed buffer' end time
      ([timestamp](GstBuffer.pts) + #GstBuffer.duration) for that
      specific segment. The position is used when reconfiguring the
      segment with #gst_segment_do_seek when the seek is only
      updating the segment (see [offset](GstSegment.offset)).
      Siehe auch:

    • DURATION

      public static final String DURATION
      the duration of the segment is the maximum absolute difference
      between #GstSegment.start and #GstSegment.stop if stop is not
      set, otherwise it should be the difference between those
      two values. This should be set by elements that know the
      overall stream duration (like demuxers) and will be used when
      seeking with #GST_SEEK_TYPE_END.
      Siehe auch:

  • Konstruktordetails

    • Segment

      public Segment(PointerContainer pointer)

    • Segment

      public Segment()
      Allocate a new #GstSegment structure and initialize it using
      gst_segment_init().

      Free-function: gst_segment_free

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • setFieldFlags

      public void setFieldFlags(int flags)
      flags for this segment

    • getFieldFlags

      public int getFieldFlags()
      flags for this segment

    • setFieldRate

      public void setFieldRate(double rate)
      the playback rate of the segment is set in response to a seek
      event and, without any seek, the value should be `1.0`. This
      value is used by elements that synchronize buffer [running
      times](additional/design/synchronisation.md#running-time) on
      the clock (usually the sink elements), leading to consuming
      buffers faster (for a value `> 1.0`) or slower (for `0.0 <
      value < 1.0`) than normal playback speed. The rate also
      defines the playback direction, meaning that when the value is
      lower than `0.0`, the playback happens in reverse, and the
      [stream-time](additional/design/synchronisation.md#stream-time)
      is going backward. The `rate` value should never be `0.0`.

    • getFieldRate

      public double getFieldRate()
      the playback rate of the segment is set in response to a seek
      event and, without any seek, the value should be `1.0`. This
      value is used by elements that synchronize buffer [running
      times](additional/design/synchronisation.md#running-time) on
      the clock (usually the sink elements), leading to consuming
      buffers faster (for a value `> 1.0`) or slower (for `0.0 <
      value < 1.0`) than normal playback speed. The rate also
      defines the playback direction, meaning that when the value is
      lower than `0.0`, the playback happens in reverse, and the
      [stream-time](additional/design/synchronisation.md#stream-time)
      is going backward. The `rate` value should never be `0.0`.

    • setFieldAppliedRate

      public void setFieldAppliedRate(double applied_rate)
      The applied rate is the rate that has been applied to the stream.
      The effective/resulting playback rate of a stream is
      `rate * applied_rate`.
      The applied rate can be set by source elements when a server is
      sending the stream with an already modified playback speed
      rate. Filter elements that modify the stream in a way that
      modifies the playback speed should also modify the applied
      rate. For example the #videorate element when its
      #videorate:rate property is set will set the applied rate of
      the segment it pushed downstream. Also #scaletempo applies the
      input segment rate to the stream and outputs a segment with
      rate=1.0 and applied_rate=<inputsegment.rate>.

    • getFieldAppliedRate

      public double getFieldAppliedRate()
      The applied rate is the rate that has been applied to the stream.
      The effective/resulting playback rate of a stream is
      `rate * applied_rate`.
      The applied rate can be set by source elements when a server is
      sending the stream with an already modified playback speed
      rate. Filter elements that modify the stream in a way that
      modifies the playback speed should also modify the applied
      rate. For example the #videorate element when its
      #videorate:rate property is set will set the applied rate of
      the segment it pushed downstream. Also #scaletempo applies the
      input segment rate to the stream and outputs a segment with
      rate=1.0 and applied_rate=<inputsegment.rate>.

    • setFieldFormat

      public void setFieldFormat(int format)
      the unit used for all of the segment's values.

    • getFieldFormat

      public int getFieldFormat()
      the unit used for all of the segment's values.

    • setFieldBase

      public void setFieldBase(long base)
      the running time (plus elapsed time, see offset) of the
      segment [start](GstSegment.start) ([stop](GstSegment.stop) if
      rate < 0.0).

    • getFieldBase

      public long getFieldBase()
      the running time (plus elapsed time, see offset) of the
      segment [start](GstSegment.start) ([stop](GstSegment.stop) if
      rate < 0.0).

    • setFieldOffset

      public void setFieldOffset(long offset)
      the offset expresses the elapsed time (in buffer timestamps)
      before a seek with its start (stop if rate < 0.0) seek type
      set to #GST_SEEK_TYPE_NONE, the value is set to the position
      of the segment at the time of the seek.

    • getFieldOffset

      public long getFieldOffset()
      the offset expresses the elapsed time (in buffer timestamps)
      before a seek with its start (stop if rate < 0.0) seek type
      set to #GST_SEEK_TYPE_NONE, the value is set to the position
      of the segment at the time of the seek.

    • setFieldStart

      public void setFieldStart(long start)
      the start time of the segment (in buffer timestamps)
      [(PTS)](GstBuffer.pts), that is the timestamp of the first
      buffer to output inside the segment (last one during
      reverse playback). For example decoders will
      [clip](gst_segment_clip) out the buffers before the start
      time.

    • getFieldStart

      public long getFieldStart()
      the start time of the segment (in buffer timestamps)
      [(PTS)](GstBuffer.pts), that is the timestamp of the first
      buffer to output inside the segment (last one during
      reverse playback). For example decoders will
      [clip](gst_segment_clip) out the buffers before the start
      time.

    • setFieldStop

      public void setFieldStop(long stop)
      the stop time of the segment (in buffer timestamps)
      [(PTS)](GstBuffer.pts), that is the timestamp of the last
      buffer to output inside the segment (first one during
      reverse playback). For example decoders will
      [clip](gst_segment_clip) out buffers after the stop time.

    • getFieldStop

      public long getFieldStop()
      the stop time of the segment (in buffer timestamps)
      [(PTS)](GstBuffer.pts), that is the timestamp of the last
      buffer to output inside the segment (first one during
      reverse playback). For example decoders will
      [clip](gst_segment_clip) out buffers after the stop time.

    • setFieldTime

      public void setFieldTime(long time)
      the stream time of the segment [start](GstSegment.start)
      ([stop](GstSegment.stop) if rate < 0.0).

    • getFieldTime

      public long getFieldTime()
      the stream time of the segment [start](GstSegment.start)
      ([stop](GstSegment.stop) if rate < 0.0).

    • setFieldPosition

      public void setFieldPosition(long position)
      the buffer timestamp position in the segment is supposed to be
      updated by elements such as sources, demuxers or parsers to
      track progress by setting it to the last pushed buffer' end time
      ([timestamp](GstBuffer.pts) + #GstBuffer.duration) for that
      specific segment. The position is used when reconfiguring the
      segment with #gst_segment_do_seek when the seek is only
      updating the segment (see [offset](GstSegment.offset)).

    • getFieldPosition

      public long getFieldPosition()
      the buffer timestamp position in the segment is supposed to be
      updated by elements such as sources, demuxers or parsers to
      track progress by setting it to the last pushed buffer' end time
      ([timestamp](GstBuffer.pts) + #GstBuffer.duration) for that
      specific segment. The position is used when reconfiguring the
      segment with #gst_segment_do_seek when the seek is only
      updating the segment (see [offset](GstSegment.offset)).

    • setFieldDuration

      public void setFieldDuration(long duration)
      the duration of the segment is the maximum absolute difference
      between #GstSegment.start and #GstSegment.stop if stop is not
      set, otherwise it should be the difference between those
      two values. This should be set by elements that know the
      overall stream duration (like demuxers) and will be used when
      seeking with #GST_SEEK_TYPE_END.

    • getFieldDuration

      public long getFieldDuration()
      the duration of the segment is the maximum absolute difference
      between #GstSegment.start and #GstSegment.stop if stop is not
      set, otherwise it should be the difference between those
      two values. This should be set by elements that know the
      overall stream duration (like demuxers) and will be used when
      seeking with #GST_SEEK_TYPE_END.

    • copy

      public Segment copy()
      Create a copy of given @segment.

      Free-function: gst_segment_free
      Gibt zurück:
      a new #GstSegment, free with gst_segment_free().

    • copyInto

      public void copyInto(@Nonnull Segment dest)
      Copy the contents of @src into @dest.
      Parameter:
      dest - a #GstSegment

    • doSeek

      public boolean doSeek(double rate, int format, int flags, int start_type, long start, int stop_type, long stop, @Nullable 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.
      Parameter:
      rate - the rate of the segment.
      format - the format of the segment.
      flags - the segment flags for the segment
      start_type - the seek method
      start - the seek start value
      stop_type - the seek method
      stop - the seek stop value
      update - boolean holding whether position was updated.
      Gibt zurück:
      %TRUE if the seek could be performed.

    • free

      public void free()
      Free the allocated segment @segment.

    • init

      public void init(int 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.
      Parameter:
      format - the format of the segment.

    • isEqual

      public boolean isEqual(@Nonnull Segment s1)
      Checks for two segments being equal. Equality here is defined
      as perfect equality, including floating point values.
      Parameter:
      s1 - a #GstSegment structure.
      Gibt zurück:
      %TRUE if the segments are equal, %FALSE otherwise.

    • offsetRunningTime

      public boolean offsetRunningTime(int format, long offset)
      Adjust the values in @segment so that @offset is applied to all
      future running-time calculations.
      Parameter:
      format - the format of the segment.
      offset - the offset to apply in the segment
      Gibt zurück:
      %TRUE if the segment could be updated successfully. If %FALSE is returned, @offset is not in @segment.

    • positionFromRunningTime

      public long positionFromRunningTime(int format, long running_time)
      Convert @running_time into a position in the segment so that
      gst_segment_to_running_time() with that position returns @running_time.
      Parameter:
      format - the format of the segment.
      running_time - the running_time in the segment
      Gibt zurück:
      the position in the segment for @running_time. This function returns -1 when @running_time is -1 or when it is not inside @segment.

    • positionFromStreamTime

      public long positionFromStreamTime(int format, long stream_time)
      Convert @stream_time into a position in the segment so that
      gst_segment_to_stream_time() with that position returns @stream_time.
      Parameter:
      format - the format of the segment.
      stream_time - the stream_time in the segment
      Gibt zurück:
      the position in the segment for @stream_time. This function returns -1 when @stream_time is -1 or when it is not inside @segment.

    • setRunningTime

      public boolean setRunningTime(int format, long running_time)
      Adjust the start/stop and base values of @segment such that the next valid
      buffer will be one with @running_time.
      Parameter:
      format - the format of the segment.
      running_time - the running_time in the segment
      Gibt zurück:
      %TRUE if the segment could be updated successfully. If %FALSE is returned, @running_time is -1 or not in @segment.

    • toPosition

      @Deprecated public long toPosition(int format, long running_time)
      Veraltet.
      Convert @running_time into a position in the segment so that
      gst_segment_to_running_time() with that position returns @running_time.
      Parameter:
      format - the format of the segment.
      running_time - the running_time in the segment
      Gibt zurück:
      the position in the segment for @running_time. This function returns -1 when @running_time is -1 or when it is not inside @segment.

    • toRunningTime

      public long toRunningTime(int format, long 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 running 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.
      Parameter:
      format - the format of the segment.
      position - the position in the segment
      Gibt zurück:
      the position as the total running time or -1 when an invalid position was given.

    • toStreamTime

      public long toStreamTime(int format, long 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.
      Parameter:
      format - the format of the segment.
      position - the position in the segment
      Gibt zurück:
      the position in stream_time or -1 when an invalid position was given.

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()