From 76cd3ff183d261401fcbd6200aa923b916755244 Mon Sep 17 00:00:00 2001 From: Nicolas Dufresne Date: Wed, 5 May 2021 15:45:40 -0400 Subject: [PATCH] doc: base: Fix reference to virtual function The hotdoc syntax is #ClassName::function, but the code was using without anything before. Part-of: --- libs/gst/base/gstaggregator.c | 8 +++--- libs/gst/base/gstbaseparse.c | 32 ++++++++++++------------ libs/gst/base/gstbaseparse.h | 4 +-- libs/gst/base/gstbasesink.c | 42 ++++++++++++++++---------------- libs/gst/base/gstbasesink.h | 4 +-- libs/gst/base/gstbasesrc.c | 34 +++++++++++++------------- libs/gst/base/gstbasesrc.h | 10 ++++---- libs/gst/base/gstbasetransform.c | 12 ++++----- 8 files changed, 73 insertions(+), 73 deletions(-) diff --git a/libs/gst/base/gstaggregator.c b/libs/gst/base/gstaggregator.c index f4ee40c869..5a6e30f42d 100644 --- a/libs/gst/base/gstaggregator.c +++ b/libs/gst/base/gstaggregator.c @@ -30,12 +30,12 @@ * Control is given to the subclass when all pads have data. * * * Base class for mixers and muxers. Subclasses should at least implement - * the #GstAggregatorClass.aggregate() virtual method. + * the #GstAggregatorClass::aggregate virtual method. * * * Installs a #GstPadChainFunction, a #GstPadEventFullFunction and a * #GstPadQueryFunction to queue all serialized data packets per sink pad. * Subclasses should not overwrite those, but instead implement - * #GstAggregatorClass.sink_event() and #GstAggregatorClass.sink_query() as + * #GstAggregatorClass::sink_event and #GstAggregatorClass::sink_query as * needed. * * * When data is queued on all pads, the aggregate vmethod is called. @@ -1282,7 +1282,7 @@ gst_aggregator_negotiate_unlocked (GstAggregator * self) * * Negotiates src pad caps with downstream elements. * Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again - * if #GstAggregatorClass.negotiate() fails. + * if #GstAggregatorClass::negotiate fails. * * Returns: %TRUE if the negotiation succeeded, else %FALSE. * @@ -3664,7 +3664,7 @@ gst_aggregator_get_allocator (GstAggregator * self, * gst_aggregator_simple_get_next_time: * @self: A #GstAggregator * - * This is a simple #GstAggregatorClass.get_next_time() implementation that + * This is a simple #GstAggregatorClass::get_next_time implementation that * just looks at the #GstSegment on the srcpad of the aggregator and bases * the next time on the running time there. * diff --git a/libs/gst/base/gstbaseparse.c b/libs/gst/base/gstbaseparse.c index fb178b07d9..f1f34798b9 100644 --- a/libs/gst/base/gstbaseparse.c +++ b/libs/gst/base/gstbaseparse.c @@ -47,10 +47,10 @@ * * ## Set-up phase * - * * #GstBaseParse calls #GstBaseParseClass.start() to inform subclass + * * #GstBaseParse calls #GstBaseParseClass::start to inform subclass * that data processing is about to start now. * - * * #GstBaseParse class calls #GstBaseParseClass.set_sink_caps() to + * * #GstBaseParse class calls #GstBaseParseClass::set_sink_caps to * inform the subclass about incoming sinkpad caps. Subclass could * already set the srcpad caps accordingly, but this might be delayed * until calling gst_base_parse_finish_frame() with a non-queued frame. @@ -69,11 +69,11 @@ * #GstAdapter. * * * A buffer of (at least) min_frame_size bytes is passed to subclass - * with #GstBaseParseClass.handle_frame(). Subclass checks the contents + * with #GstBaseParseClass::handle_frame. Subclass checks the contents * and can optionally return #GST_FLOW_OK along with an amount of data * to be skipped to find a valid frame (which will result in a * subsequent DISCONT). If, otherwise, the buffer does not hold a - * complete frame, #GstBaseParseClass.handle_frame() can merely return + * complete frame, #GstBaseParseClass::handle_frame can merely return * and will be called again when additional data is available. In push * mode this amounts to an additional input buffer (thus minimal * additional latency), in pull mode this amounts to some arbitrary @@ -88,7 +88,7 @@ * data while simultaneously providing custom output data. Note that * baseclass performs some processing (such as tracking overall consumed * data rate versus duration) for each finished frame, but other state - * is only updated upon each call to #GstBaseParseClass.handle_frame() + * is only updated upon each call to #GstBaseParseClass::handle_frame * (such as tracking upstream input timestamp). * * Subclass is also responsible for setting the buffer metadata @@ -99,30 +99,30 @@ * duration obtained from configuration (see below), and offset * if meaningful (in pull mode). * - * Note that #GstBaseParseClass.handle_frame() might receive any small + * Note that #GstBaseParseClass::handle_frame might receive any small * amount of input data when leftover data is being drained (e.g. at * EOS). * * * As part of finish frame processing, just prior to actually pushing * the buffer in question, it is passed to - * #GstBaseParseClass.pre_push_frame() which gives subclass yet one last + * #GstBaseParseClass::pre_push_frame which gives subclass yet one last * chance to examine buffer metadata, or to send some custom (tag) * events, or to perform custom (segment) filtering. * * * During the parsing process #GstBaseParseClass will handle both srcpad * and sinkpad events. They will be passed to subclass if - * #GstBaseParseClass.sink_event() or #GstBaseParseClass.src_event() + * #GstBaseParseClass::sink_event or #GstBaseParseClass::src_event * implementations have been provided. * * ## Shutdown phase * - * * #GstBaseParse class calls #GstBaseParseClass.stop() to inform the + * * #GstBaseParse class calls #GstBaseParseClass::stop to inform the * subclass that data parsing will be stopped. * * Subclass is responsible for providing pad template caps for source and * sink pads. The pads need to be named "sink" and "src". It also needs to * set the fixed caps on srcpad, when the format is ensured (e.g. when - * base class calls subclass' #GstBaseParseClass.set_sink_caps() function). + * base class calls subclass' #GstBaseParseClass::set_sink_caps function). * * This base class uses %GST_FORMAT_DEFAULT as a meaning of frames. So, * subclass conversion routine needs to know that conversion from @@ -142,7 +142,7 @@ * * Inform base class how big data chunks should be retrieved. This is * done with gst_base_parse_set_min_frame_size() function. * * Examine data chunks passed to subclass with - * #GstBaseParseClass.handle_frame() and pass proper frame(s) to + * #GstBaseParseClass::handle_frame and pass proper frame(s) to * gst_base_parse_finish_frame(), and setting src pad caps and timestamps * on frame. * * Provide conversion functions @@ -158,7 +158,7 @@ * metadata (which will be taken from upstream as much as * possible). Internally keeping track of frame durations and respective * sizes that have been pushed provides #GstBaseParse with an estimated - * bitrate. A default #GstBaseParseClass.convert() (used if not + * bitrate. A default #GstBaseParseClass::convert (used if not * overridden) will then use these rates to perform obvious conversions. * These rates are also used to update (estimated) duration at regular * frame intervals. @@ -1742,7 +1742,7 @@ gst_base_parse_src_event_default (GstBaseParse * parse, GstEvent * event) * @dest_format: #GstFormat defining the converted format. * @dest_value: (out): Pointer where the conversion result will be put. * - * Default implementation of #GstBaseParseClass.convert(). + * Default implementation of #GstBaseParseClass::convert. * * Returns: %TRUE if conversion was successful. */ @@ -4014,10 +4014,10 @@ gst_base_parse_set_syncable (GstBaseParse * parse, gboolean syncable) * Set if the nature of the format or configuration does not allow (much) * parsing, and the parser should operate in passthrough mode (which only * applies when operating in push mode). That is, incoming buffers are - * pushed through unmodified, i.e. no #GstBaseParseClass.handle_frame() - * will be invoked, but #GstBaseParseClass.pre_push_frame() will still be + * pushed through unmodified, i.e. no #GstBaseParseClass::handle_frame + * will be invoked, but #GstBaseParseClass::pre_push_frame will still be * invoked, so subclass can perform as much or as little is appropriate for - * passthrough semantics in #GstBaseParseClass.pre_push_frame(). + * passthrough semantics in #GstBaseParseClass::pre_push_frame. */ void gst_base_parse_set_passthrough (GstBaseParse * parse, gboolean passthrough) diff --git a/libs/gst/base/gstbaseparse.h b/libs/gst/base/gstbaseparse.h index a9fe9e3ba0..2614e22f5e 100644 --- a/libs/gst/base/gstbaseparse.h +++ b/libs/gst/base/gstbaseparse.h @@ -55,8 +55,8 @@ G_BEGIN_DECLS * GST_BASE_PARSE_FLOW_DROPPED: * * A #GstFlowReturn that can be returned from - * #GstBaseParseClass.handle_frame() to indicate that no output buffer was - * generated, or from #GstBaseParseClass.pre_push_frame() to to forego + * #GstBaseParseClass::handle_frame to indicate that no output buffer was + * generated, or from #GstBaseParseClass::pre_push_frame to to forego * pushing buffer. */ #define GST_BASE_PARSE_FLOW_DROPPED GST_FLOW_CUSTOM_SUCCESS diff --git a/libs/gst/base/gstbasesink.c b/libs/gst/base/gstbasesink.c index 5f02e63904..b5b5f13076 100644 --- a/libs/gst/base/gstbasesink.c +++ b/libs/gst/base/gstbasesink.c @@ -59,19 +59,19 @@ * #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 - * #GstBaseSinkClass.preroll() vmethod with this preroll buffer and will then + * #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 #GstBaseSinkClass.get_times(). If this + * 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 #GstBaseSinkClass.render() will be + * After synchronisation the virtual method #GstBaseSinkClass::render will be * called. Subclasses should minimally implement this method. * - * Subclasses that synchronise on the clock in the #GstBaseSinkClass.render() + * 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. @@ -80,7 +80,7 @@ * * 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 - * #GstBaseSinkClass.get_times() call before posting an EOS message. When the + * #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. * @@ -95,24 +95,24 @@ * If no clock has been set on the element, the query will be forwarded * upstream. * - * The #GstBaseSinkClass.set_caps() function will be called when the subclass + * The #GstBaseSinkClass::set_caps function will be called when the subclass * should configure itself to process a specific media type. * - * The #GstBaseSinkClass.start() and #GstBaseSinkClass.stop() virtual methods + * 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. + * #GstBaseSinkClass::preroll, #GstBaseSinkClass::render and + * #GstBaseSinkClass::set_caps function will be called between the + * #GstBaseSinkClass::start and #GstBaseSinkClass::stop calls. * - * The #GstBaseSinkClass.event() virtual method will be called when an event is + * The #GstBaseSinkClass::event virtual method will be called when an event is * received by #GstBaseSink. Normally this method should only be overridden by * very specific elements (such as file sinks) which need to handle the * newsegment event specially. * - * The #GstBaseSinkClass.unlock() method is called when the elements should + * 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 + * #GstBaseSinkClass::render method. This is mostly useful when the + * #GstBaseSinkClass::render method performs a blocking write on a file * descriptor, for example. * * The #GstBaseSink:max-lateness property affects how the sink deals with @@ -123,7 +123,7 @@ * 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 - * #GstBaseSinkClass.get_times() method does not return a valid start time or + * #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. @@ -2305,9 +2305,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 #GstBaseSinkClass.event() vmethod or when + * receiving an EOS event in the #GstBaseSinkClass::event vmethod or when * receiving a buffer in - * the #GstBaseSinkClass.render() vmethod. + * 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 @@ -2395,14 +2395,14 @@ no_clock: * gst_base_sink_wait_preroll: * @sink: the sink * - * If the #GstBaseSinkClass.render() method performs its own synchronisation + * 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 can block on something else than + * If the #GstBaseSinkClass::render method can block on something else than * the clock, it must also be ready to unblock immediately on - * the #GstBaseSinkClass.unlock() method and cause the - * #GstBaseSinkClass.render() method to immediately call this function. + * the #GstBaseSinkClass::unlock method and cause the + * #GstBaseSinkClass::render method to immediately call this function. * In this case, the subclass must be prepared to continue rendering where it * left off if this function returns %GST_FLOW_OK. * diff --git a/libs/gst/base/gstbasesink.h b/libs/gst/base/gstbasesink.h index 7ce86509bb..3745fa20ab 100644 --- a/libs/gst/base/gstbasesink.h +++ b/libs/gst/base/gstbasesink.h @@ -125,10 +125,10 @@ struct _GstBaseSink { * @unlock: Unlock any pending access to the resource. Subclasses should * unblock any blocked function ASAP and call gst_base_sink_wait_preroll() * @unlock_stop: Clear the previous unlock request. Subclasses should clear - * any state they set during #GstBaseSinkClass.unlock(), and be ready to + * any state they set during #GstBaseSinkClass::unlock, and be ready to * continue where they left off after gst_base_sink_wait_preroll(), * gst_base_sink_wait() or gst_wait_sink_wait_clock() return or - * #GstBaseSinkClass.render() is called again. + * #GstBaseSinkClass::render is called again. * @query: perform a #GstQuery on the element. * @event: Override this to handle events arriving on the sink pad * @wait_event: Override this to implement custom logic to wait for the event diff --git a/libs/gst/base/gstbasesrc.c b/libs/gst/base/gstbasesrc.c index 0171b07aec..910cf218f9 100644 --- a/libs/gst/base/gstbasesrc.c +++ b/libs/gst/base/gstbasesrc.c @@ -42,25 +42,25 @@ * conditions are met, it also supports pull mode scheduling: * * * The format is set to %GST_FORMAT_BYTES (default). - * * #GstBaseSrcClass.is_seekable() returns %TRUE. + * * #GstBaseSrcClass::is_seekable 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 * be met to make the element seekable in push mode when the format is not * %GST_FORMAT_BYTES: * - * * #GstBaseSrcClass.is_seekable() returns %TRUE. - * * #GstBaseSrcClass.query() can convert all supported seek formats to the + * * #GstBaseSrcClass::is_seekable returns %TRUE. + * * #GstBaseSrcClass::query can convert all supported seek formats to the * internal format as set with gst_base_src_set_format(). - * * #GstBaseSrcClass.do_seek() is implemented, performs the seek and returns + * * #GstBaseSrcClass::do_seek is implemented, performs the seek and returns * %TRUE. * * 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. + * 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 #GstBaseSrcClass.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 @@ -69,7 +69,7 @@ * 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 - * #GstBaseSrcClass.create() method will not be called in PAUSED but only in + * #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. @@ -81,12 +81,12 @@ * * Live sources that synchronize and block on the clock (an audio source, for * example) can use gst_base_src_wait_playing() when the - * #GstBaseSrcClass.create() function was interrupted by a state change to + * #GstBaseSrcClass::create function was interrupted by a state change to * PAUSED. * - * 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() + * 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 @@ -533,7 +533,7 @@ flushing: * gst_base_src_wait_playing: * @src: the src * - * If the #GstBaseSrcClass.create() method performs its own synchronisation + * 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. * @@ -614,7 +614,7 @@ gst_base_src_is_live (GstBaseSrc * src) * for sending 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 #GstBaseSrcClass.is_seekable() returns %TRUE. + * operate in pull mode if the #GstBaseSrcClass::is_seekable returns %TRUE. * * This function must only be called in states < %GST_STATE_PAUSED. */ @@ -659,7 +659,7 @@ gst_base_src_set_dynamic_size (GstBaseSrc * src, gboolean dynamic) * When @src operates in %GST_FORMAT_TIME, #GstBaseSrc will send an EOS * when a buffer outside of the currently configured segment is pushed if * @automatic_eos is %TRUE. Since 1.16, if @automatic_eos is %FALSE an - * EOS will be pushed only when the #GstBaseSrcClass.create() implementation + * EOS will be pushed only when the #GstBaseSrcClass::create implementation * returns %GST_FLOW_EOS. * * Since: 1.4 @@ -3462,10 +3462,10 @@ gst_base_src_negotiate_unlocked (GstBaseSrc * basesrc) * * Negotiates src pad caps with downstream elements. * Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again - * if #GstBaseSrcClass.negotiate() fails. + * if #GstBaseSrcClass::negotiate fails. * - * Do not call this in the #GstBaseSrcClass.fill() vmethod. Call this in - * #GstBaseSrcClass.create() or in #GstBaseSrcClass.alloc(), _before_ any + * Do not call this in the #GstBaseSrcClass::fill vmethod. Call this in + * #GstBaseSrcClass::create or in #GstBaseSrcClass::alloc, _before_ any * buffer is allocated. * * Returns: %TRUE if the negotiation succeeded, else %FALSE. diff --git a/libs/gst/base/gstbasesrc.h b/libs/gst/base/gstbasesrc.h index 13a7c66463..04304bfd06 100644 --- a/libs/gst/base/gstbasesrc.h +++ b/libs/gst/base/gstbasesrc.h @@ -135,7 +135,7 @@ struct _GstBaseSrc { * gst_base_src_set_format(). * @is_seekable: Check if the source can seek * @prepare_seek_segment: Prepare the #GstSegment that will be passed to the - * #GstBaseSrcClass.do_seek() vmethod for executing a seek + * #GstBaseSrcClass::do_seek vmethod for executing a seek * request. Sub-classes should override this if they support seeking in * formats other than the configured native format. By default, it tries to * convert the seek arguments to the configured native format and prepare a @@ -144,11 +144,11 @@ struct _GstBaseSrc { * @unlock: Unlock any pending access to the resource. Subclasses should unblock * any blocked function ASAP. In particular, any `create()` function in * progress should be unblocked and should return GST_FLOW_FLUSHING. Any - * future #GstBaseSrcClass.create() function call should also return - * GST_FLOW_FLUSHING until the #GstBaseSrcClass.unlock_stop() function has + * future #GstBaseSrcClass::create function call should also return + * GST_FLOW_FLUSHING until the #GstBaseSrcClass::unlock_stop function has * been called. * @unlock_stop: Clear the previous unlock request. Subclasses should clear any - * state they set during #GstBaseSrcClass.unlock(), such as clearing command + * state they set during #GstBaseSrcClass::unlock, such as clearing command * queues. * @query: Handle a requested query. * @event: Override this to implement custom event handling. @@ -158,7 +158,7 @@ struct _GstBaseSrc { * buffer should be returned when the return value is different from * GST_FLOW_OK. A return value of GST_FLOW_EOS signifies that the end of * stream is reached. The default implementation will call - * #GstBaseSrcClass.alloc() and then call #GstBaseSrcClass.fill(). + * #GstBaseSrcClass::alloc and then call #GstBaseSrcClass::fill. * @alloc: Ask the subclass to allocate a buffer with for offset and size. The * default implementation will create a new buffer from the negotiated allocator. * @fill: Ask the subclass to fill the buffer with data for offset and size. The diff --git a/libs/gst/base/gstbasetransform.c b/libs/gst/base/gstbasetransform.c index 240e7c7d29..f963046745 100644 --- a/libs/gst/base/gstbasetransform.c +++ b/libs/gst/base/gstbasetransform.c @@ -1452,15 +1452,15 @@ done: * marked as needing reconfiguring. Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in * any case. But marks it again if negotiation fails. * - * Do not call this in the #GstBaseTransformClass.transform() or - * #GstBaseTransformClass.transform_ip() vmethod. Call this in - * #GstBaseTransformClass.submit_input_buffer(), - * #GstBaseTransformClass.prepare_output_buffer() or in - * #GstBaseTransformClass.generate_output() _before_ any output buffer is + * Do not call this in the #GstBaseTransformClass::transform or + * #GstBaseTransformClass::transform_ip vmethod. Call this in + * #GstBaseTransformClass::submit_input_buffer, + * #GstBaseTransformClass::prepare_output_buffer or in + * #GstBaseTransformClass::generate_output _before_ any output buffer is * allocated. * * It will be default be called when handling an ALLOCATION query or at the - * very beginning of the default #GstBaseTransformClass.submit_input_buffer() + * very beginning of the default #GstBaseTransformClass::submit_input_buffer * implementation. * * Returns: %TRUE if the negotiation succeeded, else %FALSE.