mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-29 15:22:17 +00:00
docs: fix broken xrefs
This commit is contained in:
Stefan Kost
parent
2ba8b37d15
commit
a9a6c0f0cd
2 changed files with 86 additions and 78 deletions
|
|
@ -37,7 +37,7 @@
|
|||
* #GstBaseSink provides support for exactly one sink pad, which should be
|
||||
* named "sink". A sink implementation (subclass of #GstBaseSink) should
|
||||
* install a pad template in its base_init function, like so:
|
||||
* <programlisting>
|
||||
* |[
|
||||
* static void
|
||||
* my_element_base_init (gpointer g_class)
|
||||
* {
|
||||
|
|
@ -50,34 +50,35 @@
|
|||
* // see #GstElementDetails
|
||||
* gst_element_class_set_details (gstelement_class, &details);
|
||||
* }
|
||||
* </programlisting>
|
||||
* ]|
|
||||
*
|
||||
* #GstBaseSink will handle the prerolling correctly. This means that it will
|
||||
* return #GST_STATE_CHANGE_ASYNC from a state change to PAUSED until the first
|
||||
* buffer arrives in this element. The base class will call the
|
||||
* #GstBaseSink::preroll vmethod with this preroll buffer and will then commit
|
||||
* the state change to the next asynchronously pending state.
|
||||
* #GstBaseSinkClass.preroll() vmethod with this preroll buffer and will then
|
||||
* commit the state change to the next asynchronously pending state.
|
||||
*
|
||||
* When the element is set to PLAYING, #GstBaseSink will synchronise on the
|
||||
* clock using the times returned from ::get_times. If this function returns
|
||||
* #GST_CLOCK_TIME_NONE for the start time, no synchronisation will be done.
|
||||
* Synchronisation can be disabled entirely by setting the object "sync"
|
||||
* property to %FALSE.
|
||||
* clock using the times returned from #GstBaseSinkClass.get_times(). If this
|
||||
* function returns #GST_CLOCK_TIME_NONE for the start time, no synchronisation
|
||||
* will be done. Synchronisation can be disabled entirely by setting the object
|
||||
* #GstBaseSink:sync property to %FALSE.
|
||||
*
|
||||
* After synchronisation the virtual method #GstBaseSink::render will be called.
|
||||
* Subclasses should minimally implement this method.
|
||||
* After synchronisation the virtual method #GstBaseSinkClass.render() will be
|
||||
* called. Subclasses should minimally implement this method.
|
||||
*
|
||||
* Since 0.10.3 subclasses that synchronise on the clock in the ::render method
|
||||
* are supported as well. These classes typically receive a buffer in the render
|
||||
* method and can then potentially block on the clock while rendering. A typical
|
||||
* example is an audiosink. Since 0.10.11 these subclasses can use
|
||||
* gst_base_sink_wait_preroll() to perform the blocking wait.
|
||||
* Since 0.10.3 subclasses that synchronise on the clock in the
|
||||
* #GstBaseSinkClass.render() method are supported as well. These classes
|
||||
* typically receive a buffer in the render method and can then potentially
|
||||
* block on the clock while rendering. A typical example is an audiosink.
|
||||
* Since 0.10.11 these subclasses can use gst_base_sink_wait_preroll() to
|
||||
* perform the blocking wait.
|
||||
*
|
||||
* Upon receiving the EOS event in the PLAYING state, #GstBaseSink will wait
|
||||
* for the clock to reach the time indicated by the stop time of the last
|
||||
* ::get_times call before posting an EOS message. When the element receives
|
||||
* EOS in PAUSED, preroll completes, the event is queued and an EOS message is
|
||||
* posted when going to PLAYING.
|
||||
* #GstBaseSinkClass.get_times() call before posting an EOS message. When the
|
||||
* element receives EOS in PAUSED, preroll completes, the event is queued and an
|
||||
* EOS message is posted when going to PLAYING.
|
||||
*
|
||||
* #GstBaseSink will internally use the #GST_EVENT_NEWSEGMENT events to schedule
|
||||
* synchronisation and clipping of buffers. Buffers that fall completely outside
|
||||
|
|
@ -90,49 +91,53 @@
|
|||
* If no clock has been set on the element, the query will be forwarded
|
||||
* upstream.
|
||||
*
|
||||
* The ::set_caps function will be called when the subclass should configure
|
||||
* itself to process a specific media type.
|
||||
* The #GstBaseSinkClass.set_caps() function will be called when the subclass
|
||||
* should configure itself to process a specific media type.
|
||||
*
|
||||
* The ::start and ::stop virtual methods will be called when resources should
|
||||
* be allocated. Any ::preroll, ::render and ::set_caps function will be
|
||||
* called between the ::start and ::stop calls.
|
||||
* The #GstBaseSinkClass.start() and #GstBaseSinkClass.stop() virtual methods
|
||||
* will be called when resources should be allocated. Any
|
||||
* #GstBaseSinkClass.preroll(), #GstBaseSinkClass.render() and
|
||||
* #GstBaseSinkClass.set_caps() function will be called between the
|
||||
* #GstBaseSinkClass.start() and #GstBaseSinkClass.stop() calls.
|
||||
*
|
||||
* The ::event virtual method will be called when an event is received by
|
||||
* #GstBaseSink. Normally this method should only be overriden by very specific
|
||||
* elements (such as file sinks) which need to handle the newsegment event
|
||||
* specially.
|
||||
* The #GstBaseSinkClass.event() virtual method will be called when an event is
|
||||
* received by #GstBaseSink. Normally this method should only be overriden by
|
||||
* very specific elements (such as file sinks) which need to handle the
|
||||
* newsegment event specially.
|
||||
*
|
||||
* #GstBaseSink provides an overridable ::buffer_alloc function that can be
|
||||
* used by sinks that want to do reverse negotiation or to provide
|
||||
* custom buffers (hardware buffers for example) to upstream elements.
|
||||
* #GstBaseSink provides an overridable #GstBaseSinkClass.buffer_alloc()
|
||||
* function that can be used by sinks that want to do reverse negotiation or to
|
||||
* provide custom buffers (hardware buffers for example) to upstream elements.
|
||||
*
|
||||
* The ::unlock method is called when the elements should unblock any blocking
|
||||
* operations they perform in the ::render method. This is mostly useful when
|
||||
* the ::render method performs a blocking write on a file descriptor, for
|
||||
* example.
|
||||
* The #GstBaseSinkClass.unlock() method is called when the elements should
|
||||
* unblock any blocking operations they perform in the
|
||||
* #GstBaseSinkClass.render() method. This is mostly useful when the
|
||||
* #GstBaseSinkClass.render() method performs a blocking write on a file
|
||||
* descriptor, for example.
|
||||
*
|
||||
* The max-lateness property affects how the sink deals with buffers that
|
||||
* arrive too late in the sink. A buffer arrives too late in the sink when
|
||||
* the presentation time (as a combination of the last segment, buffer
|
||||
* The #GstBaseSink:max-lateness property affects how the sink deals with
|
||||
* buffers that arrive too late in the sink. A buffer arrives too late in the
|
||||
* sink when the presentation time (as a combination of the last segment, buffer
|
||||
* timestamp and element base_time) plus the duration is before the current
|
||||
* time of the clock.
|
||||
* If the frame is later than max-lateness, the sink will drop the buffer
|
||||
* without calling the render method.
|
||||
* This feature is disabled if sync is disabled, the ::get-times method does
|
||||
* not return a valid start time or max-lateness is set to -1 (the default).
|
||||
* This feature is disabled if sync is disabled, the
|
||||
* #GstBaseSinkClass.get_times() method does not return a valid start time or
|
||||
* max-lateness is set to -1 (the default).
|
||||
* Subclasses can use gst_base_sink_set_max_lateness() to configure the
|
||||
* max-lateness value.
|
||||
*
|
||||
* The qos property will enable the quality-of-service features of the basesink
|
||||
* which gather statistics about the real-time performance of the clock
|
||||
* synchronisation. For each buffer received in the sink, statistics are
|
||||
* The #GstBaseSink:qos property will enable the quality-of-service features of
|
||||
* the basesink which gather statistics about the real-time performance of the
|
||||
* clock synchronisation. For each buffer received in the sink, statistics are
|
||||
* gathered and a QOS event is sent upstream with these numbers. This
|
||||
* information can then be used by upstream elements to reduce their processing
|
||||
* rate, for example.
|
||||
*
|
||||
* Since 0.10.15 the async property can be used to instruct the sink to never
|
||||
* perform an ASYNC state change. This feature is mostly usable when dealing
|
||||
* with non-synchronized streams or sparse streams.
|
||||
* Since 0.10.15 the #GstBaseSink:async property can be used to instruct the
|
||||
* sink to never perform an ASYNC state change. This feature is mostly usable
|
||||
* when dealing with non-synchronized streams or sparse streams.
|
||||
*
|
||||
* Last reviewed on 2007-08-29 (0.10.15)
|
||||
*/
|
||||
|
|
@ -1931,8 +1936,9 @@ gst_base_sink_adjust_time (GstBaseSink * basesink, GstClockTime time)
|
|||
* is no clock, no synchronisation is done and #GST_CLOCK_BADTIME is returned.
|
||||
*
|
||||
* This function should only be called with the PREROLL_LOCK held, like when
|
||||
* receiving an EOS event in the ::event vmethod or when receiving a buffer in
|
||||
* the ::render vmethod.
|
||||
* receiving an EOS event in the #GstBaseSinkClass.event() vmethod or when
|
||||
* receiving a buffer in
|
||||
* the #GstBaseSinkClass.render() vmethod.
|
||||
*
|
||||
* The @time argument should be the running_time of when this method should
|
||||
* return and is not adjusted with any latency or offset configured in the
|
||||
|
|
@ -2006,9 +2012,9 @@ no_clock:
|
|||
* gst_base_sink_wait_preroll:
|
||||
* @sink: the sink
|
||||
*
|
||||
* If the #GstBaseSinkClass::render method performs its own synchronisation against
|
||||
* the clock it must unblock when going from PLAYING to the PAUSED state and call
|
||||
* this method before continuing to render the remaining data.
|
||||
* If the #GstBaseSinkClass.render() method performs its own synchronisation
|
||||
* against the clock it must unblock when going from PLAYING to the PAUSED state
|
||||
* and call this method before continuing to render the remaining data.
|
||||
*
|
||||
* This function will block until a state change to PLAYING happens (in which
|
||||
* case this function returns #GST_FLOW_OK) or the processing must be stopped due
|
||||
|
|
|
|||
|
|
@ -43,12 +43,12 @@
|
|||
* <itemizedlist>
|
||||
* <listitem><para>The format is set to #GST_FORMAT_BYTES (default).</para>
|
||||
* </listitem>
|
||||
* <listitem><para>#GstBaseSrc::is_seekable returns %TRUE.</para>
|
||||
* <listitem><para>#GstBaseSrcClass.is_seekable() returns %TRUE.</para>
|
||||
* </listitem>
|
||||
* </itemizedlist>
|
||||
*
|
||||
* Since 0.10.9, any #GstBaseSrc can enable pull based scheduling at any
|
||||
* time by overriding #GstBaseSrc::check_get_range so that it returns %TRUE.
|
||||
* Since 0.10.9, any #GstBaseSrc can enable pull based scheduling at any time
|
||||
* by overriding #GstBaseSrcClass.check_get_range() so that it returns %TRUE.
|
||||
*
|
||||
* If all the conditions are met for operating in pull mode, #GstBaseSrc is
|
||||
* automatically seekable in push mode as well. The following conditions must
|
||||
|
|
@ -56,23 +56,24 @@
|
|||
* #GST_FORMAT_BYTES:
|
||||
* <itemizedlist>
|
||||
* <listitem><para>
|
||||
* #GstBaseSrc::is_seekable returns %TRUE.
|
||||
* #GstBaseSrcClass.is_seekable() returns %TRUE.
|
||||
* </para></listitem>
|
||||
* <listitem><para>
|
||||
* #GstBaseSrc::query can convert all supported seek formats to the
|
||||
* #GstBaseSrc:Class.query() can convert all supported seek formats to the
|
||||
* internal format as set with gst_base_src_set_format().
|
||||
* </para></listitem>
|
||||
* <listitem><para>
|
||||
* #GstBaseSrc::do_seek is implemented, performs the seek and returns %TRUE.
|
||||
* #GstBaseSrcClass.do_seek() is implemented, performs the seek and returns
|
||||
* %TRUE.
|
||||
* </para></listitem>
|
||||
* </itemizedlist>
|
||||
*
|
||||
* When the element does not meet the requirements to operate in pull mode,
|
||||
* the offset and length in the #GstBaseSrc::create method should be ignored.
|
||||
* When the element does not meet the requirements to operate in pull mode, the
|
||||
* offset and length in the #GstBaseSrcClass.create() method should be ignored.
|
||||
* It is recommended to subclass #GstPushSrc instead, in this situation. If the
|
||||
* element can operate in pull mode but only with specific offsets and
|
||||
* lengths, it is allowed to generate an error when the wrong values are passed
|
||||
* to the #GstBaseSrc::create function.
|
||||
* to the #GstBaseSrcClass.create() function.
|
||||
*
|
||||
* #GstBaseSrc has support for live sources. Live sources are sources that when
|
||||
* paused discard data, such as audio or video capture devices. A typical live
|
||||
|
|
@ -81,9 +82,10 @@
|
|||
* Use gst_base_src_set_live() to activate the live source mode.
|
||||
*
|
||||
* A live source does not produce data in the PAUSED state. This means that the
|
||||
* #GstBaseSrc::create method will not be called in PAUSED but only in PLAYING.
|
||||
* To signal the pipeline that the element will not produce data, the return
|
||||
* value from the READY to PAUSED state will be #GST_STATE_CHANGE_NO_PREROLL.
|
||||
* #GstBaseSrcClass.create() method will not be called in PAUSED but only in
|
||||
* PLAYING. To signal the pipeline that the element will not produce data, the
|
||||
* return value from the READY to PAUSED state will be
|
||||
* #GST_STATE_CHANGE_NO_PREROLL.
|
||||
*
|
||||
* A typical live source will timestamp the buffers it creates with the
|
||||
* current running time of the pipeline. This is one reason why a live source
|
||||
|
|
@ -91,17 +93,17 @@
|
|||
* distributed and running.
|
||||
*
|
||||
* Live sources that synchronize and block on the clock (an audio source, for
|
||||
* example) can since 0.10.12 use gst_base_src_wait_playing() when the ::create
|
||||
* function was interrupted by a state change to PAUSED.
|
||||
* example) can since 0.10.12 use gst_base_src_wait_playing() when the
|
||||
* #GstBaseSrcClass.create() function was interrupted by a state change to
|
||||
* PAUSED.
|
||||
*
|
||||
* The #GstBaseSrc::get_times method can be used to implement pseudo-live
|
||||
* sources.
|
||||
* It only makes sense to implement the ::get_times function if the source is
|
||||
* a live source. The ::get_times function should return timestamps starting
|
||||
* from 0, as if it were a non-live source. The base class will make sure that
|
||||
* the timestamps are transformed into the current running_time.
|
||||
* The base source will then wait for the calculated running_time before pushing
|
||||
* out the buffer.
|
||||
* The #GstBaseSrcClass.get_times() method can be used to implement pseudo-live
|
||||
* sources. It only makes sense to implement the #GstBaseSrcClass.get_times()
|
||||
* function if the source is a live source. The #GstBaseSrcClass.get_times()
|
||||
* function should return timestamps starting from 0, as if it were a non-live
|
||||
* source. The base class will make sure that the timestamps are transformed
|
||||
* into the current running_time. The base source will then wait for the
|
||||
* calculated running_time before pushing out the buffer.
|
||||
*
|
||||
* For live sources, the base class will by default report a latency of 0.
|
||||
* For pseudo live sources, the base class will by default measure the difference
|
||||
|
|
@ -113,7 +115,7 @@
|
|||
* There is only support in #GstBaseSrc for exactly one source pad, which
|
||||
* should be named "src". A source implementation (subclass of #GstBaseSrc)
|
||||
* should install a pad template in its class_init function, like so:
|
||||
* <programlisting>
|
||||
* |[
|
||||
* static void
|
||||
* my_element_class_init (GstMyElementClass *klass)
|
||||
* {
|
||||
|
|
@ -125,7 +127,7 @@
|
|||
* // see #GstElementDetails
|
||||
* gst_element_class_set_details (gstelement_class, &details);
|
||||
* }
|
||||
* </programlisting>
|
||||
* ]|
|
||||
*
|
||||
* <refsect2>
|
||||
* <title>Controlled shutdown of live sources in applications</title>
|
||||
|
|
@ -453,9 +455,9 @@ gst_base_src_finalize (GObject * object)
|
|||
* gst_base_src_wait_playing:
|
||||
* @src: the src
|
||||
*
|
||||
* If the #GstBaseSrcClass::create method performs its own synchronisation against
|
||||
* the clock it must unblock when going from PLAYING to the PAUSED state and call
|
||||
* this method before continuing to produce the remaining data.
|
||||
* If the #GstBaseSrcClass.create() method performs its own synchronisation
|
||||
* against the clock it must unblock when going from PLAYING to the PAUSED state
|
||||
* and call this method before continuing to produce the remaining data.
|
||||
*
|
||||
* This function will block until a state change to PLAYING happens (in which
|
||||
* case this function returns #GST_FLOW_OK) or the processing must be stopped due
|
||||
|
|
@ -544,7 +546,7 @@ gst_base_src_is_live (GstBaseSrc * src)
|
|||
* for sending NEW_SEGMENT events and for performing seeks.
|
||||
*
|
||||
* If a format of GST_FORMAT_BYTES is set, the element will be able to
|
||||
* operate in pull mode if the #GstBaseSrc::is_seekable returns TRUE.
|
||||
* operate in pull mode if the #GstBaseSrc.is_seekable() returns TRUE.
|
||||
*
|
||||
* Since: 0.10.1
|
||||
*/
|
||||
|
|
|
|||
Loading…
Reference in a new issue