+2007-05-22 Stefan Kost <ensonic@users.sf.net>
+
+ * gst/gstelement.c (gst_element_requires_clock,
+ gst_element_provides_clock, gst_element_request_pad,
+ gst_element_class_set_details, gst_element_class_set_details_simple,
+ gst_element_default_send_event, gst_element_abort_state,
+ gst_element_continue_state, gst_element_set_state,
+ gst_element_set_state_func, iterator_activate_fold_with_resync):
+ * gst/gstpad.c (gst_pad_activate_pull, gst_pad_set_getcaps_function,
+ gst_pad_fixate_caps, gst_pad_configure_sink, gst_pad_configure_src,
+ gst_pad_query, gst_pad_save_thyself, handle_pad_block, gst_pad_push,
+ gst_pad_get_range, gst_pad_pull_range):
+ * gst/gstpad.h (GST_PAD_LINK_SUCCESSFUL, GST_FLOW_CUSTOM_SUCCESS,
+ GST_FLOW_NOT_SUPPORTED, GST_FLOW_IS_FATAL, GstPadActivateFunction,
+ GstPadActivateModeFunction, GstPadChainFunction,
+ GstPadGetCapsFunction, GstPadAcceptCapsFunction,
+ GstPadFixateCapsFunction, GstPadTemplate):
+ * gst/gstpipeline.c (gst_pipeline_change_state,
+ gst_pipeline_set_new_stream_time, gst_pipeline_use_clock,
+ gst_pipeline_set_clock, gst_pipeline_auto_clock,
+ gst_pipeline_get_delay):
+ Whitespace and docs fixes.
+
2007-05-21 Sebastian Dröge <slomo@circular-chaos.org>
* libs/gst/controller/gstinterpolation.c:
* @short_description: Abstract base class for all pipeline elements
* @see_also: #GstElementFactory, #GstPad
*
- * GstElement is the abstract base class needed to construct an element that
+ * GstElement is the abstract base class needed to construct an element that
* can be used in a GStreamer pipeline. Please refer to the plugin writers
* guide for more information on creating #GstElement subclasses.
*
* @element: a #GstElement to query
*
* Query if the element provides a clock. A #GstClock provided by an
- * element can be used as the global #GstClock for the pipeline.
+ * element can be used as the global #GstClock for the pipeline.
* An element that can provide a clock is only required to do so in the PAUSED
* state, this means when it is fully negotiated and has allocated the resources
* to operate the clock.
* gst_element_provide_clock:
* @element: a #GstElement to query
*
- * Get the clock provided by the given element.
+ * Get the clock provided by the given element.
* <note>An element is only required to provide a clock in the PAUSED
* state. Some elements can provide a clock in other states.</note>
*
* @name: the name of the request #GstPad to retrieve.
*
* Retrieves a pad from the element by name. This version only retrieves
- * request pads. The pad should be released with
+ * request pads. The pad should be released with
* gst_element_release_request_pad().
*
* Returns: requested #GstPad if found, otherwise %NULL. Release after usage.
*
* Sends an event to an element. If the element doesn't implement an
* event handler, the event will be pushed on a random linked sink pad for
- * upstream events or a random linked source pad for downstream events.
+ * upstream events or a random linked source pad for downstream events.
*
* This function takes owership of the provided event so you should
* gst_event_ref() it if you want to reuse the event after this call.
}
/**
- * gst_element_continue_state:
- * @element: a #GstElement to continue the state change of.
+ * gst_element_continue_state:
+ * @element: a #GstElement to continue the state change of.
* @ret: The previous state return value
- *
- * Commit the state change of the element and proceed to the next
- * pending state if any. This function is used
- * by elements that do asynchronous state changes.
- * The core will normally call this method automatically when an
- * element returned %GST_STATE_CHANGE_SUCCESS from the state change function.
- *
- * If after calling this method the element still has not reached
- * the pending state, the next state change is performed.
- *
+ *
+ * Commit the state change of the element and proceed to the next
+ * pending state if any. This function is used
+ * by elements that do asynchronous state changes.
+ * The core will normally call this method automatically when an
+ * element returned %GST_STATE_CHANGE_SUCCESS from the state change function.
+ *
+ * If after calling this method the element still has not reached
+ * the pending state, the next state change is performed.
+ *
* This method is used internally and should normally not be called by plugins
* or applications.
- *
- * Returns: The result of the commit state change.
- *
- * MT safe.
+ *
+ * Returns: The result of the commit state change.
+ *
+ * MT safe.
*/
GstStateChangeReturn
gst_element_continue_state (GstElement * element, GstStateChangeReturn ret)
/* don't post silly messages with the same state. This can happen
* when an element state is changed to what it already was. For bins
* this can be the result of a lost state, which we check with the
- * previous return value.
- * We do signal the cond though as a _get_state() might be blocking
+ * previous return value.
+ * We do signal the cond though as a _get_state() might be blocking
* on it. */
if (old_state != old_next || old_ret == GST_STATE_CHANGE_ASYNC) {
message = gst_message_new_state_changed (GST_OBJECT_CAST (element),
/*
* default set state function, calculates the next state based
- * on current state and calls the change_state function
+ * on current state and calls the change_state function
*/
static GstStateChangeReturn
gst_element_set_state_func (GstElement * element, GstState state)
GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element, "set_state to %s",
gst_element_state_get_name (state));
- /* state lock is taken to protect the set_state() and get_state()
+ /* state lock is taken to protect the set_state() and get_state()
* procedures, it does not lock any variables. */
GST_STATE_LOCK (element);
/* all pads iterated, return collected value */
goto done;
default:
- /* iterator returned _ERROR or premature end with _OK,
+ /* iterator returned _ERROR or premature end with _OK,
* mark an error and exit */
g_value_set_boolean (&ret, FALSE);
goto done;
/* is called with STATE_LOCK
*
- * Pads are activated from source pads to sinkpads.
+ * Pads are activated from source pads to sinkpads.
*/
static gboolean
gst_element_pads_activate (GstElement * element, gboolean active)
}
} else {
if (G_UNLIKELY (GST_PAD_GETRANGEFUNC (pad) == NULL))
- goto failure; /* Can't activate pull on a src without a
+ goto failure; /* Can't activate pull on a src without a
getrange function */
}
*
* Sets the given acceptcaps function for the pad. The acceptcaps function
* will be called to check if the pad can accept the given caps. Setting the
- * acceptcaps function to NULL restores the default behaviour of allowing
+ * acceptcaps function to NULL restores the default behaviour of allowing
* any caps that matches the caps from gst_pad_get_caps.
*/
void
}
}
-/* Default accept caps implementation just checks against
+/* Default accept caps implementation just checks against
* against the allowed caps for the pad */
static gboolean
gst_pad_acceptcaps_default (GstPad * pad, GstCaps * caps)
return gst_static_caps_get (&anycaps);
}
-
/**
* gst_pad_get_peer:
* @pad: a #GstPad to get the peer of.
* @pad: a #GstPad to call the default query handler on.
* @query: the #GstQuery to handle.
*
- * Invokes the default query handler for the given pad.
- * The query is sent to all pads internally linked to @pad. Note that
- * if there are many possible sink pads that are internally linked to
+ * Invokes the default query handler for the given pad.
+ * The query is sent to all pads internally linked to @pad. Note that
+ * if there are many possible sink pads that are internally linked to
* @pad, only one will be sent the query.
* Multi-sinkpad elements should implement custom query handlers.
*
#endif /* GST_DISABLE_LOADSAVE */
/*
- * should be called with pad OBJECT_LOCK and STREAM_LOCK held.
+ * should be called with pad OBJECT_LOCK and STREAM_LOCK held.
* GST_PAD_IS_BLOCKED (pad) == TRUE when this function is
* called.
*
* This function performs the pad blocking when an event, buffer push
* or buffer_alloc is performed on a _SRC_ pad. It blocks the
- * streaming thread after informing the pad has been blocked.
+ * streaming thread after informing the pad has been blocked.
*
* An application can with this method wait and block any streaming
* thread and perform operations such as seeking or linking.
*
* Two methods are available for notifying the application of the
- * block:
+ * block:
* - the callback method, which happens in the STREAMING thread with
* the STREAM_LOCK held. With this method, the most useful way of
* dealing with the callback is to post a message to the main thread
/* we grab an extra ref for the callbacks, this is probably not
* needed (callback code does not have a ref and cannot unref). I
* think this was done to make it possible to unref the element in
- * the callback, which is in the end totally impossible as it
+ * the callback, which is in the end totally impossible as it
* requires grabbing the STREAM_LOCK and OBJECT_LOCK which are
* all taken when calling this function. */
gst_object_ref (pad);
* then could have made the pad unblock so we need to check the blocking
* condition again. */
while (GST_PAD_IS_BLOCKED (pad)) {
- /* now we block the streaming thread. It can be unlocked when we
+ /* now we block the streaming thread. It can be unlocked when we
* deactivate the pad (which will also set the FLUSHING flag) or
* when the pad is unblocked. A flushing event will also unblock
* the pad after setting the FLUSHING flag. */
/* take ref to peer pad before releasing the lock */
gst_object_ref (peer);
- /* Before pushing the buffer to the peer pad, ensure that caps
+ /* Before pushing the buffer to the peer pad, ensure that caps
* are set on this pad */
caps = GST_BUFFER_CAPS (buffer);
caps_changed = caps && caps != GST_PAD_CAPS (pad);
gboolean caps_changed;
GST_OBJECT_LOCK (pad);
- /* Before pushing the buffer to the peer pad, ensure that caps
+ /* Before pushing the buffer to the peer pad, ensure that caps
* are set on this pad */
caps = GST_BUFFER_CAPS (*buffer);
caps_changed = caps && caps != GST_PAD_CAPS (pad);
* Returns: a #GstFlowReturn from the peer pad.
* When this function returns #GST_FLOW_OK, @buffer will contain a valid
* #GstBuffer that should be freed with gst_buffer_unref() after usage.
- * @buffer may not be used or freed when any other return value than
+ * @buffer may not be used or freed when any other return value than
* #GST_FLOW_OK is returned.
*
* MT safe.
gboolean caps_changed;
GST_OBJECT_LOCK (pad);
- /* Before pushing the buffer to the peer pad, ensure that caps
+ /* Before pushing the buffer to the peer pad, ensure that caps
* are set on this pad */
caps = GST_BUFFER_CAPS (*buffer);
caps_changed = caps && caps != GST_PAD_CAPS (pad);
/**
* GstFlowReturn:
* @GST_FLOW_CUSTOM_SUCCESS: Elements can use values starting from
- * this to define custom success codes.
+ * this to define custom success codes.
* Since 0.10.7.
- * @GST_FLOW_RESEND: Resend buffer, possibly with new caps.
+ * @GST_FLOW_RESEND: Resend buffer, possibly with new caps (not
+ * send yet).
* @GST_FLOW_OK: Data passing was ok.
* @GST_FLOW_NOT_LINKED: Pad is not linked.
* @GST_FLOW_WRONG_STATE: Pad is in wrong state.
* @GST_FLOW_CUSTOM_ERROR: Elements can use values starting from
* this to define custom error codes. Since 0.10.7.
*
- * The result of passing data to a pad.
+ * The result of passing data to a pad.
*
- * Note that the custom return values should not be exposed outside of the
+ * Note that the custom return values should not be exposed outside of the
* element scope and are available since 0.10.7.
*/
typedef enum {
- /* custom success starts here */
+ /* custom success starts here */
GST_FLOW_CUSTOM_SUCCESS = 100,
- /* core predefined */
+ /* core predefined */
GST_FLOW_RESEND = 1,
GST_FLOW_OK = 0,
/* expected failures */
GST_FLOW_ERROR = -5,
GST_FLOW_NOT_SUPPORTED = -6,
- /* custom error starts here */
+ /* custom error starts here */
GST_FLOW_CUSTOM_ERROR = -100
} GstFlowReturn;
* GST_FLOW_IS_SUCCESS:
* @ret: a #GstFlowReturn value
*
- * Macro to test if the given #GstFlowReturn value indicates a
+ * Macro to test if the given #GstFlowReturn value indicates a
* successfull result
* This macro is mainly used in elements to decide if the processing
* of a buffer was successfull.
* @pad: a #GstPad
* @active: activate or deactivate the pad.
*
- * The prototype of the push and pull activate functions.
+ * The prototype of the push and pull activate functions.
*
* Returns: TRUE if the pad could be activated or deactivated.
*/
* @buffer: the #GstBuffer that is chained, not %NULL.
*
* A function that will be called on sinkpads when chaining buffers.
- * The function typically processes the data contained in the buffer and
+ * The function typically processes the data contained in the buffer and
* either consumes the data or passes it on to the internally linked pad(s).
*
* The implementer of this function receives a refcount to @buffer and should
*
* This function will be called on source pads when a peer element
* request a buffer at the specified @offset and @length. If this function
- * returns #GST_FLOW_OK, the result buffer will be stored in @buffer. The
+ * returns #GST_FLOW_OK, the result buffer will be stored in @buffer. The
* contents of @buffer is invalid for any other return value.
*
* This function is installed on a source pad with
- * gst_pad_set_getrange_function() and can only be called on source pads after
+ * gst_pad_set_getrange_function() and can only be called on source pads after
* they are successfully activated with gst_pad_activate_pull().
*
* @offset and @length are always given in byte units. @offset must normally be a value
* between 0 and the length in bytes of the data available on @pad. The
* length (duration in bytes) can be retrieved with a #GST_QUERY_DURATION or with a
- * #GST_QUERY_SEEKING.
+ * #GST_QUERY_SEEKING.
*
* Any @offset larger or equal than the length will make the function return
* #GST_FLOW_UNEXPECTED, which corresponds to EOS. In this case @buffer does not
* The buffer size of @buffer might be smaller than @length when @offset is near
* the end of the stream.
*
- * It is allowed to call this function with a 0 @length and valid @offset, in
+ * It is allowed to call this function with a 0 @length and valid @offset, in
* which case @buffer will contain a 0-sized buffer and the function returns
* #GST_FLOW_OK.
*
* When this function is called with a -1 @offset, the sequentially next buffer
- * of length @length in the stream is returned.
+ * of length @length in the stream is returned.
*
* When this function is called with a -1 @length, a buffer with a default
* optimal length is returned in @buffer. The length might depend on the value
* @caps: the #GstCaps to set
*
* Set @caps on @pad. By default this function updates the caps of the
- * pad but the function can be overriden by elements to perform extra
+ * pad but the function can be overriden by elements to perform extra
* actions or verifications.
*
* Returns: TRUE if the caps could be set on the pad.
typedef gboolean (*GstPadAcceptCapsFunction) (GstPad *pad, GstCaps *caps);
/**
* GstPadFixateCapsFunction:
- * @pad: a #GstPad
+ * @pad: a #GstPad
* @caps: the #GstCaps to fixate
*
- * Given possibly unfixed caps @caps, let @pad use its default prefered
+ * Given possibly unfixed caps @caps, let @pad use its default prefered
* format to make a fixed caps. @caps should be writable. By default this
* function will pick the first value of any ranges or lists in the caps but
* elements can override this function to perform other behaviour.
typedef void (*GstPadFixateCapsFunction) (GstPad *pad, GstCaps *caps);
/**
* GstPadBufferAllocFunction:
- * @pad: a sink #GstPad
+ * @pad: a sink #GstPad
* @offset: the desired offset of the buffer
* @size: the desired size of the buffer
* @caps: the desired caps of the buffer
* @bufferallocfunc: function to allocate a buffer for this pad
* @do_buffer_signals: counter counting installed buffer signals
* @do_event_signals: counter counting installed event signals
- *
+ *
* The #GstPad structure. Use the functions to update the variables.
*/
struct _GstPad {
* @see_also: #GstElement, #GstBin, #GstClock, #GstBus
*
* A #GstPipeline is a special #GstBin used as the toplevel container for
- * the filter graph. The #GstPipeline will manage the selection and
- * distribution of a global #GstClock as well as provide a #GstBus to the
+ * the filter graph. The #GstPipeline will manage the selection and
+ * distribution of a global #GstClock as well as provide a #GstBus to the
* application. It will also implement a default behavour for managing
* seek events (see gst_element_seek()).
*
* the pipeline, use gst_object_unref() to free its resources including all
* added #GstElement objects (if not otherwise referenced).
*
- * Elements are added and removed from the pipeline using the #GstBin
+ * Elements are added and removed from the pipeline using the #GstBin
* methods like gst_bin_add() and gst_bin_remove() (see #GstBin).
*
* Before changing the state of the #GstPipeline (see #GstElement) a #GstBus
*
* When the #GstPipeline 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
+ * default select a clock provided by an element that is most upstream
+ * (closest to the source). For live pipelines (ones that return
* #GST_STATE_CHANGE_NO_PREROLL from the gst_element_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
*
* The clock selection can be controlled with the gst_pipeline_use_clock()
* method, which will enforce a given clock on the pipeline. With
- * gst_pipeline_auto_clock() the default clock selection algorithm can be
+ * gst_pipeline_auto_clock() the default clock selection algorithm can be
* restored.
*
* A #GstPipeline maintains a stream time for the elements. The stream
* 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 stream time is reset to 0. When the pipeline is
- * set from PLAYING to PAUSED, the current clock time is sampled and used to
+ * 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. This default behaviour can be changed with the
- * gst_pipeline_set_new_stream_time() method.
- *
- * When sending a flushing seek event to a GstPipeline (see
- * gst_element_seek()), it will make sure that the pipeline is properly
+ * gst_pipeline_set_new_stream_time() method.
+ *
+ * When sending a flushing seek event to a GstPipeline (see
+ * gst_element_seek()), it will make sure that the pipeline is properly
* PAUSED and resumed as well as set the new stream time to 0 when the
* seek succeeded.
*
GST_DEBUG_FUNCPTR (gst_pipeline_change_state);
gstelement_class->provide_clock =
GST_DEBUG_FUNCPTR (gst_pipeline_provide_clock_func);
-
gstbin_class->handle_message =
GST_DEBUG_FUNCPTR (gst_pipeline_handle_message);
}
if (!gst_element_set_clock (element, clock))
goto invalid_clock;
- /* if we selected and distributed a new clock, let the app
+ /* if we selected and distributed a new clock, let the app
* know about it */
gst_element_post_message (element,
gst_message_new_new_clock (GST_OBJECT_CAST (element), clock));
GST_BIN_CLASS (parent_class)->handle_message (bin, message);
}
-
/**
* gst_pipeline_get_bus:
* @pipeline: a #GstPipeline
*
* Gets the last stream time of @pipeline. If the pipeline is PLAYING,
* the returned time is the stream time used to configure the element's
- * base time in the PAUSED->PLAYING state. If the pipeline is PAUSED, the
+ * base time in the PAUSED->PLAYING state. If the pipeline is PAUSED, the
* returned time is the stream time when the pipeline was paused.
*
* This function returns #GST_CLOCK_TIME_NONE if the pipeline was
- * configured to not handle the management of the element's base time
+ * configured to not handle the management of the element's base time
* (see gst_pipeline_set_new_stream_time()).
*
* Returns: a #GstClockTime.
* @clock: the clock to set
*
* Set the clock for @pipeline. The clock will be distributed
- * to all the elements managed by the pipeline.
+ * to all the elements managed by the pipeline.
*
* Returns: TRUE if the clock could be set on the pipeline. FALSE if
* some element did not accept the clock.
* @pipeline: a #GstPipeline
*
* Let @pipeline select a clock automatically. This is the default
- * behaviour.
+ * behaviour.
*
- * Use this function if you previous forced a fixed clock with
+ * Use this function if you previous forced a fixed clock with
* gst_pipeline_use_clock() and want to restore the default
* pipeline clock selection algorithm.
*
* amount of time before starting to process buffers and cannot be
* #GST_CLOCK_TIME_NONE.
*
- * This option is used for tuning purposes and should normally not be
+ * This option is used for tuning purposes and should normally not be
* used.
*
* MT safe.
*
* 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.
+ * 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
+ * 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
+ * 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.
projects / platform / upstream / gstreamer.git / commitdiff