* @short_description: object to splice and merge buffers to desired size
* @see_also: #GstBytestream, #GstFilePad
*
- * This class is for elements that receive buffers in an undesired size.
- * While for example raw video contains one image per buffer, the same is not
- * true for a lot of other formats, especially those that come directly from
- * a file. So if you have undefined buffer sizes and require a specific size,
+ * This class is for elements that receive buffers in an undesired size.
+ * While for example raw video contains one image per buffer, the same is not
+ * true for a lot of other formats, especially those that come directly from
+ * a file. So if you have undefined buffer sizes and require a specific size,
* this object is for you.
*
* The theory of operation is like this: All buffers received are put
- * into the adapter using gst_adapter_push() and the data is then read back
+ * into the adapter using gst_adapter_push() and the data is then read back
* in chunks of the desired size using gst_adapter_peek(). After the data is
* processed, it is freed using gst_adapter_flush(). An example function that
* needs to process data in 10 byte chunks could look like this:
* For another example, a simple element inside GStreamer that uses GstAdapter
* is the libvisual element.
*
- * A last thing to note is that while GstAdapter is pretty optimized,
- * merging buffers still might be an operation that requires a memcpy()
- * operation, and this operation is not the fastest. Because of this, some
- * functions like gst_adapter_available_fast() are provided to help speed up
+ * A last thing to note is that while GstAdapter is pretty optimized,
+ * merging buffers still might be an operation that requires a memcpy()
+ * operation, and this operation is not the fastest. Because of this, some
+ * functions like gst_adapter_available_fast() are provided to help speed up
* such cases should you want to.
*/
* @adapter: a #GstAdapter
* @buf: the #GstBuffer to queue into the adapter
*
- * Adds the data from @buf to the data stored inside @adapter and takes
+ * Adds the data from @buf to the data stored inside @adapter and takes
* ownership of the buffer.
*/
void
* gst_adapter_available:
* @adapter: a #GstAdapter
*
- * Gets the maximum amount of bytes available, that is it returns the maximum
- * value that can be supplied to gst_adapter_peek() without that function
+ * Gets the maximum amount of bytes available, that is it returns the maximum
+ * value that can be supplied to gst_adapter_peek() without that function
* returning NULL.
*
* Returns: amount of bytes available in @adapter
}
/* perform synchronisation on a buffer
- *
+ *
* 1) check if we have a clock, if not, do nothing
* 2) calculate the start and end time of the buffer
* 3) create a single shot notification to wait on
* interested in modifying the buffers.
* </para></listitem>
* <listitem><para>
- * Elements which are always in passthrough mode whenever the same caps has
- * been negotiated on both pads can set the class variable
+ * Elements which are always in passthrough mode whenever the same caps has
+ * been negotiated on both pads can set the class variable
* passthrough_on_same_caps to have this behaviour automatically.
* </para></listitem>
* </itemizedlist>
return ret;
}
- /* If the output buffer metadata is modifiable, copy timestamps and
+ /* If the output buffer metadata is modifiable, copy timestamps and
* buffer flags */
if (*buf != input && GST_MINI_OBJECT_REFCOUNT_VALUE (*buf) == 1) {
*outbuf = NULL;
if (want_in_place) {
- /* If want_in_place is TRUE, we may need to prepare a new output buffer
+ /* If want_in_place is TRUE, we may need to prepare a new output buffer
* Sub-classes can implement a prepare_output_buffer function as they
* wish. */
GST_LOG_OBJECT (trans, "doing inplace transform");
* @passthrough: boolean indicating passthrough mode.
*
* Set passthrough mode for this filter by default. This is mostly
- * useful for filters that do not care about negotiation.
- *
- * Always TRUE for filters which don't implement either a transform
+ * useful for filters that do not care about negotiation.
+ *
+ * Always TRUE for filters which don't implement either a transform
* or transform_ip method.
*
* MT safe.
* @in_place: Boolean value indicating that we would like to operate
* on in_place buffers.
*
- * Determines whether a non-writable buffer will be copied before passing
+ * Determines whether a non-writable buffer will be copied before passing
* to the transform_ip function.
* <itemizedlist>
* <listitem>Always TRUE if no transform function is implemented.</listitem>
gboolean passthrough_on_same_caps;
/* Subclasses can override this to do their own allocation of output buffers.
- * Elements that only do analysis can return a subbuffer or even just
+ * Elements that only do analysis can return a subbuffer or even just
* increment the reference to the input buffer (if in passthrough mode)
*/
- GstFlowReturn (*prepare_output_buffer) (GstBaseTransform * trans,
+ GstFlowReturn (*prepare_output_buffer) (GstBaseTransform * trans,
GstBuffer *input, gint size, GstCaps *caps, GstBuffer **buf);
/*< private >*/
gpointer _gst_reserved[GST_PADDING - 2];
};
-void gst_base_transform_set_passthrough (GstBaseTransform *trans,
+void gst_base_transform_set_passthrough (GstBaseTransform *trans,
gboolean passthrough);
gboolean gst_base_transform_is_passthrough (GstBaseTransform *trans);
-void gst_base_transform_set_in_place (GstBaseTransform *trans,
+void gst_base_transform_set_in_place (GstBaseTransform *trans,
gboolean in_place);
gboolean gst_base_transform_is_in_place (GstBaseTransform *trans);
/* GStreamer
* Copyright (C) 2005 Wim Taymans <wim@fluendo.com>
*
- * gstcollectpads.c:
+ * gstcollectpads.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
/**
* SECTION:gstcollectpads
* @short_description: manages a set of pads that operate in collect mode
- * @see_also:
+ * @see_also:
*
* Manages a set of pads that operate in collect mode. This means that control
* is given to the manager of this object when all pads have data.
* When data is queued on all pads, a callback function is called.
* </para></listitem>
* <listitem><para>
- * Data can be dequeued from the pad with the _pop() method.
+ * Data can be dequeued from the pad with the _pop() method.
* One can _peek() at the data with the peek function.
* </para></listitem>
* <listitem><para>
* gst_collectpads_new:
*
* Create a new instance of #GstCollectsPads.
- *
+ *
* Returns: a new #GstCollectPads, or NULL in case of an error.
*
* MT safe.
* This function should be called with @pads LOCK held, such as
* in the callback.
*
- * Returns: The maximum number of bytes queued on all pad. This function
+ * Returns: The maximum number of bytes queued on all pad. This function
* returns 0 if a pad has no queued buffer.
*
* MT safe.
* gst_collectpads_read:
* @pads: the collectspads to query
* @data: the data to use
- * @bytes: a pointer to a byte array
+ * @bytes: a pointer to a byte array
* @size: the number of bytes to read
*
* Get a pointer in @bytes where @size bytes can be read from the
* @data: the data to use
* @size: the number of bytes to flush
*
- * Flush @size bytes from the pad @data.
+ * Flush @size bytes from the pad @data.
*
* This function should be called with @pads LOCK held, such as
* in the callback.
/* GStreamer
* Copyright (C) 2005 Wim Taymans <wim@fluendo.com>
*
- * gstcollectpads.h:
+ * gstcollectpads.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
/* get collected bytes */
guint gst_collectpads_available (GstCollectPads *pads);
-guint gst_collectpads_read (GstCollectPads *pads, GstCollectData *data,
+guint gst_collectpads_read (GstCollectPads *pads, GstCollectData *data,
guint8 **bytes, guint size);
-guint gst_collectpads_flush (GstCollectPads *pads, GstCollectData *data,
+guint gst_collectpads_flush (GstCollectPads *pads, GstCollectData *data,
guint size);
G_END_DECLS
* 2000 Wim Taymans <wtay@chello.be>
* 2005 Wim Taymans <wim@fluendo.com>
*
- * gstpushsrc.h:
+ * gstpushsrc.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000,2005 Wim Taymans <wim@fluendo.com>
*
- * gsttypefindhelper.c:
+ * gsttypefindhelper.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000,2005 Wim Taymans <wim@fluendo.com>
*
- * gsttypefindhelper.h:
+ * gsttypefindhelper.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* @store: a bufferstore
* @buffer: the buffer to add
*
- * Adds a buffer to the buffer store.
+ * Adds a buffer to the buffer store.
*
* Returns: TRUE, if the buffer was added, FALSE if an error occured.
*/
* data is not available inside the store, NULL is returned. You have to unref
* the buffer after use.
*
- * Returns: a buffer with the requested data or NULL if the data was not
+ * Returns: a buffer with the requested data or NULL if the data was not
* available.
*/
GstBuffer *
/* Output buffer preparation... if the buffer has no caps, and
* our allowed output caps is fixed, then give the caps to the
* buffer.
- * This ensures that outgoing buffers have caps if we can, so
+ * This ensures that outgoing buffers have caps if we can, so
* that pipelines like:
- * gst-launch filesrc location=rawsamples.raw !
+ * gst-launch filesrc location=rawsamples.raw !
* audio/x-raw-int,width=16,depth=16,rate=48000,channels=2,
* endianness=4321,signed='(boolean)'true ! alsasink
* will work.
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2005 Wim Taymans <wim@fluendo.com>
*
- * gstfakesink.c:
+ * gstfakesink.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
- * gstfdsink.c:
+ * gstfdsink.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
- * gstfdsink.h:
+ * gstfdsink.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* 2000 Wim Taymans <wtay@chello.be>
* 2005 Philippe Khalaf <burger@speedy.org>
*
- * gstfdsrc.c:
+ * gstfdsrc.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* 2000 Wim Taymans <wtay@chello.be>
* 2005 Philippe Khalaf <burger@speedy.org>
*
- * gstfdsrc.h:
+ * gstfdsrc.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
} else
#endif
{
- /* If not in mmap mode, we need to check if the underlying file is
+ /* If not in mmap mode, we need to check if the underlying file is
* seekable. */
off_t res = lseek (src->fd, 0, SEEK_CUR);
* 2000 Wim Taymans <wtay@chello.be>
* 2005 Wim Taymans <wim@fluendo.com>
*
- * gstidentity.c:
+ * gstidentity.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
- * gstidentity.h:
+ * gstidentity.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000,2001,2002,2003,2004,2005 Wim Taymans <wim@fluendo.com>
- *
+ *
*
* gsttee.c: Tee element, one in N out
*
gint pad_counter;
guint64 offset;
GstActivateMode sink_mode;
-
+
gchar *last_message;
};
* 4) if a function returns a value >= ARG_MAXIMUM goto 8
* 5) all functions with a result > ARG_MINIMUM or functions that did not get
* all requested data (where peek returned NULL) stay in list
- * 6) seek to requested offset of best function that still has open data
+ * 6) seek to requested offset of best function that still has open data
* requests
* 7) goto 2
* 8) take best available result and use its caps
* 1) chain based, it will collect buffers and run the typefind function on
* the buffer until something is found.
* 2) getrange based, it will proxy the getrange function to the sinkpad. It
- * is assumed that the peer element is happy with whatever format we
+ * is assumed that the peer element is happy with whatever format we
* eventually read.
*
* When the element has no connected srcpad, and the sinkpad can operate in
- * getrange based mode, the element starts its own task to figure out the
+ * getrange based mode, the element starts its own task to figure out the
* type of the stream.
- *
+ *
*/
#ifdef HAVE_CONFIG_H
GstBuffer * store;
guint64 stream_length;
gboolean stream_length_available;
-
+
GList * possibilities;
};
#if !GLIB_CHECK_VERSION (2, 6, 0)
/**
- * g_mkdir:
+ * g_mkdir:
* @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
* @mode: permissions to use for the newly created directory
*
- * A wrapper for the POSIX mkdir() function. The mkdir() function
+ * A wrapper for the POSIX mkdir() function. The mkdir() function
* attempts to create a directory with the given name and permissions.
- *
+ *
* See the C library manual for more details about mkdir().
*
- * Returns: 0 if the directory was successfully created, -1 if an error
+ * Returns: 0 if the directory was successfully created, -1 if an error
* occurred
- *
+ *
* Since: 2.6
*/
int
#if !GLIB_CHECK_VERSION (2, 6, 0)
/**
- * g_stat:
+ * g_stat:
* @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
* @buf: a pointer to a <structname>stat</structname> struct, which
* will be filled with the file information
*
- * A wrapper for the POSIX stat() function. The stat() function
+ * A wrapper for the POSIX stat() function. The stat() function
* returns information about a file.
- *
+ *
* See the C library manual for more details about stat().
*
- * Returns: 0 if the information was successfully retrieved, -1 if an error
+ * Returns: 0 if the information was successfully retrieved, -1 if an error
* occurred
- *
+ *
* Since: 2.6
*/
int
* a powerful negotiation framework. Plugins are heavily used to provide for
* all elements, allowing one to construct plugins outside of the GST
* library, even released binary-only if license require (please don't).
- *
+ *
* GStreamer borrows heavily from both the <ulink
* url="http://www.cse.ogi.edu/sysl/">OGI media pipeline</ulink> and
* Microsoft's DirectShow, hopefully taking the best of both and leaving the
- * cruft behind. Its interface is still very fluid and thus can be changed
+ * cruft behind. Its interface is still very fluid and thus can be changed
* to increase the sanity/noise ratio.
*
* The <application>GStreamer</application> library should be initialized with
* <example>
* <title>Initializing the gstreamer library</title>
* <programlisting language="c">
- * int
+ * int
* main (int argc, char *argv[])
* {
* // initialize the GStreamer library
* }
* </programlisting>
* </example>
- *
+ *
* It's allowed to pass two NULL pointers to gst_init() in case you don't want to
* pass the command line args to GStreamer.
*
* <programlisting>
* static gboolean stats = FALSE;
* ...
- *
- * int
+ *
+ * int
* main (int argc, char *argv[])
* {
* struct poptOption options[] = {
* "Show pad stats", NULL},
* POPT_TABLEEND
* };
- *
+ *
* // initialize the GStreamer library
* gst_init_with_popt_table (&argc, &argv, options);
- *
+ *
* ...
* }
* </programlisting>
* A new GstBin is created with gst_bin_new(). Use a #GstPipeline instead if you
* want to create a toplevel bin because a normal bin doesn't have a bus or
* handle clock distribution of its own.
- *
+ *
* After the bin has been created you will typically add elements to it with
* gst_bin_add(). You can remove elements with gst_bin_remove().
*
* elements name. gst_bin_get_by_name_recurse_up() is mainly used for internal
* purposes and will query the parent bins when the element is not found in the
* current bin.
- *
- * An iterator of elements in a bin can be retrieved with
+ *
+ * An iterator of elements in a bin can be retrieved with
* gst_bin_iterate_elements(). Various other iterators exist to retrieve the
* elements in a bin.
- *
+ *
* The "element_added" signal is fired whenever a new element is added to the
* bin. Likewise the "element_removed" signal is fired whenever an element is
* removed from the bin.
*
- * gst_object_unref() is used to destroy the bin.
+ * gst_object_unref() is used to destroy the bin.
*/
#include "gst_private.h"
}
/***********************************************
- * Topologically sorted iterator
+ * Topologically sorted iterator
* see http://en.wikipedia.org/wiki/Topological_sorting
*
* For each element in the graph, an entry is kept in a HashTable
- * with its number of srcpad connections (degree).
- * We then change state of all elements without dependencies
+ * with its number of srcpad connections (degree).
+ * We then change state of all elements without dependencies
* (degree 0) and decrement the degree of all elements connected
* on the sinkpads. When an element reaches degree 0, its state is
* changed next.
* sorted order. This means that the elements are returned from
* the most downstream elements (sinks) to the sources.
*
- * This function is used internally to perform the state changes
+ * This function is used internally to perform the state changes
* of the bin elements.
*
* Each element will have its refcount increased, so unref
* after use.
*
- * MT safe.
+ * MT safe.
*
* Returns: a #GstIterator of #GstElements. gst_iterator_free after use.
*/
gst_object_unref (src);
/* we can lock, either the state change is sync and we can
- * recursively lock or the state change is async and we
+ * recursively lock or the state change is async and we
* lock when the bin has done its state change. We can check which
* case it is by looking at the CHANGING_STATE flag. */
GST_STATE_LOCK (bin);
* provides all the state necessary to define a region of memory as part of a
* stream. Sub-buffers are also supported, allowing a smaller region of a
* buffer to become its own buffer, with mechanisms in place to ensure that
- * neither memory space goes away.
- *
- * Buffers are usually created with gst_buffer_new(). After a buffer has been
- * created one will typically allocate memory for it and set the size of the
+ * neither memory space goes away.
+ *
+ * Buffers are usually created with gst_buffer_new(). After a buffer has been
+ * created one will typically allocate memory for it and set the size of the
* buffer data. The following example creates a buffer that can hold a given
* video frame with a given width, height and bits per plane.
* <example>
* <programlisting>
* GstBuffer *buffer;
* gint size, width, height, bpp;
- *
+ *
* ...
- *
+ *
* size = width * height * bpp;
- *
+ *
* buffer = gst_buffer_new ();
* GST_BUFFER_SIZE (buffer) = size;
* GST_BUFFER_MALLOCDATA (buffer) = g_alloc (size);
* ...
* </programlisting>
* </example>
- *
- * Alternatively, use gst_buffer_new_and_alloc()
+ *
+ * Alternatively, use gst_buffer_new_and_alloc()
* to create a buffer with preallocated data of a given size.
- *
+ *
* If an element knows what pad you will push the buffer out on, it should use
* gst_pad_alloc_buffer() instead to create a buffer. This allows downstream
* elements to provide special buffers to write in, like hardware buffers.
* in the buffer. Attach caps to the buffer with gst_buffer_set_caps(); this
* is typically done before pushing out a buffer using gst_pad_push() so that
* the downstream element knows the type of the buffer.
- *
+ *
* gst_buffer_ref() is used to increase the refcount of a buffer. This must be
* done when you want to keep a handle to the buffer after pushing it to the
* next element.
- *
+ *
* To efficiently create a smaller buffer out of an existing one, you can
* use gst_buffer_create_sub().
- *
+ *
* If the plug-in wants to modify the buffer in-place, it should first obtain
* a buffer that is safe to modify by using gst_buffer_make_writable(). This
* function is optimized so that a copy will only be made when it is necessary.
- *
+ *
* Several flags of the buffer can be set and unset with the GST_BUFFER_FLAG_SET()
* and GST_BUFFER_FLAG_UNSET() macros. Use GST_BUFFER_FLAG_IS_SET() to test it
* a certain #GstBufferFlag is set.
- *
+ *
* Buffers can be efficiently merged into a larger buffer with gst_buffer_merge()
* and gst_buffer_span() if the gst_buffer_is_span_fast() function returns TRUE.
- *
+ *
* An element should either unref the buffer or push it out on a src pad
* using gst_pad_push() (see #GstPad).
- *
+ *
* Buffers usually are freed by unreffing them with gst_buffer_unref(). When
* the refcount drops to 0, the buffer memory will be freed again.
*
*
* The #GstBus is an object responsible for delivering #GstMessages in
* a first-in first-out way from the streaming threads to the application.
- *
+ *
* Since the application typically only wants to deal with delivery of these
* messages from one thread, the GstBus will marshall the messages between
* different threads. This is important since the actual streaming of media
* is done in another thread than the application.
- *
+ *
* The GstBus provides support for #GSource based notifications. This makes it
* possible to handle the delivery in the glib mainloop.
*
* The #GSource callback function gst_bus_async_signal_func() can be used to
* convert all bus messages into signal emissions.
- *
+ *
* A message is posted on the bus with the gst_bus_post() method. With the
* gst_bus_peek() and _pop() methods one can look at or retrieve a previously
* posted message.
- *
+ *
* The bus can be polled with the gst_bus_poll() method. This methods blocks
* up to the specified timeout value until one of the specified messages types
* is posted on the bus. The application can then _pop() the messages from the
* Alternatively the application can register an asynchronous bus function using
* gst_bus_add_watch_full() or gst_bus_add_watch(). This function will receive
* messages a short while after they have been posted.
- *
- * It is also possible to get messages from the bus without any thread
+ *
+ * It is also possible to get messages from the bus without any thread
* marshalling with the gst_bus_set_sync_handler() method. This makes it
* possible to react to a message in the same thread that posted the
* message on the bus. This should only be used if the application is able
* gst_bus_peek:
* @bus: a #GstBus
*
- * Peek the message on the top of the bus' queue. The message will remain
+ * Peek the message on the top of the bus' queue. The message will remain
* on the bus' message queue. A reference is returned, and needs to be unreffed
* by the caller.
*
* @bus: a #GstBus to create the watch for
*
* Create watch for this bus. The GSource will be dispatched whenever
- * a message is on the bus. After the GSource is dispatched, the
+ * a message is on the bus. After the GSource is dispatched, the
* message is popped off the bus and unreffed.
*
* Returns: A #GSource that can be added to a mainloop.
* @user_data: user data passed to @func.
* @notify: the function to call when the source is removed.
*
- * Adds a bus watch to the default main context with the given priority.
- * If the func returns FALSE, the source will be removed.
+ * Adds a bus watch to the default main context with the given priority.
+ * If the func returns FALSE, the source will be removed.
*
- * When the func is called, the message belongs to the caller; if you want to
+ * When the func is called, the message belongs to the caller; if you want to
* keep a copy of it, call gst_message_ref() before leaving the func.
*
* The watch can be removed using #g_source_remove().
*
* This function will enter the default mainloop while polling.
*
- * Returns: The message that was received, or NULL if the poll timed out.
+ * Returns: The message that was received, or NULL if the poll timed out.
* The message is taken from the bus and needs to be unreffed after usage.
*/
GstMessage *
* @message: the message received
* @data: user data
*
- * A helper GstBusFunc that can be used to convert all asynchronous messages
+ * A helper GstBusFunc that can be used to convert all asynchronous messages
* into signals.
*
* Returns: TRUE
* @message: the #GstMessage
* @data: user data that has been given, when registering the handler
*
- * Specifies the type of function passed to #gst_bus_add_watch() or
+ * Specifies the type of function passed to #gst_bus_add_watch() or
* #gst_bus_add_watch_full(), which is called from the mainloop when a message
* is available on the bus.
*
* The message passed to the function will be unreffed after execution of this
- * function so it should not be freed in the function.
+ * function so it should not be freed in the function.
*
- * Returns: %FALSE if the event source should be removed.
+ * Returns: %FALSE if the event source should be removed.
*/
typedef gboolean (*GstBusFunc) (GstBus * bus, GstMessage * message, gpointer data);
GSource * gst_bus_create_watch (GstBus * bus);
guint gst_bus_add_watch_full (GstBus * bus,
gint priority,
- GstBusFunc func,
- gpointer user_data,
+ GstBusFunc func,
+ gpointer user_data,
GDestroyNotify notify);
guint gst_bus_add_watch (GstBus * bus,
- GstBusFunc func,
+ GstBusFunc func,
gpointer user_data);
/* polling the bus */
* gst_caps_unref:
* @caps: the #GstCaps to unref
*
- * Unref a #GstCaps and and free all its structures and the
+ * Unref a #GstCaps and and free all its structures and the
* structures' values when the refcount reaches 0.
*/
void
* Converts a #GstStaticCaps to a #GstCaps.
*
* Returns: A pointer to the #GstCaps. Unref after usage. Since the
- * core holds an additional ref to the returned caps,
+ * core holds an additional ref to the returned caps,
* use gst_caps_make_writable() on the returned caps to modify it.
*/
GstCaps *
* @caps: the #GstCaps to remove from
* @idx: Index of the structure to remove
*
- * removes the stucture with the given index from the list of structures
+ * removes the stucture with the given index from the list of structures
* contained in @caps.
*/
void
* @caps: a #GstCaps
* @index: the index of the structure
*
- * Finds the structure in @caps that has the index @index, and
+ * Finds the structure in @caps that has the index @index, and
* returns it.
*
* WARNING: This function takes a const GstCaps *, but returns a
return g_ptr_array_index (caps->structs, index);
}
-/**
- * gst_caps_copy_nth:
- * @caps: the @GstCaps to copy
+/**
+ * gst_caps_copy_nth:
+ * @caps: the @GstCaps to copy
* @nth: the nth structure to copy
- *
- * Creates a new @GstCaps and appends a copy of the nth structure
- * contained in @caps.
- *
- * Returns: the new @GstCaps
+ *
+ * Creates a new @GstCaps and appends a copy of the nth structure
+ * contained in @caps.
+ *
+ * Returns: the new @GstCaps
*/
GstCaps *
gst_caps_copy_nth (const GstCaps * caps, guint nth)
return newcaps;
}
-/**
- * gst_caps_truncate:
+/**
+ * gst_caps_truncate:
* @caps: the @GstCaps to truncate
- *
+ *
* Destructively discard all but the first structure from @caps. Useful when
* fixating. @caps must be writable.
*/
dest = gst_caps_new_empty ();
/* run zigzag on top line then right line, this preserves the caps order
- * much better than a simple loop.
- *
+ * much better than a simple loop.
+ *
* This algorithm zigzags over the caps structures as demonstrated in
* the folowing matrix:
*
* | 1 2 4 7
* caps2 | 3 5 8 10
* | 6 9 11 12
- *
+ *
* First we iterate over the caps1 structures (top line) intersecting
* the structures diagonally down, then we iterate over the caps2
- * structures.
+ * structures.
*/
for (i = 0; i < caps1->structs->len + caps2->structs->len - 1; i++) {
/* caps1 index goes from 0 to caps1->structs->len-1 */
const GstStructure *struct1 = *((const GstStructure **) one);
const GstStructure *struct2 = *((const GstStructure **) two);
- /* FIXME: this orders aphabetically, but ordering the quarks might be faster
+ /* FIXME: this orders aphabetically, but ordering the quarks might be faster
So what's the best way? */
ret = strcmp (gst_structure_get_name (struct1),
gst_structure_get_name (struct2));
* gst_caps_do_simplify:
* @caps: a #GstCaps to simplify
*
- * Modifies the given @caps inplace into a representation that represents the
- * same set of formats, but in a simpler form. Component structures that are
- * identical are merged. Component structures that have values that can be
+ * Modifies the given @caps inplace into a representation that represents the
+ * same set of formats, but in a simpler form. Component structures that are
+ * identical are merged. Component structures that have values that can be
* merged are also merged.
*
* Returns: TRUE, if the caps could be simplified
*
* Looks up a child element by the given name.
*
- * Implementors can use #GstObject together with gst_object_get_name()
+ * Implementors can use #GstObject together with gst_object_get_name()
*
* Returns: the child object or %NULL if not found. Unref after usage.
*
*
* Looks up which object and #GParamSpec would be effected by the given @name.
*
- * Returns: TRUE if @target and @pspec could be found. FALSE otherwise. In that
+ * Returns: TRUE if @target and @pspec could be found. FALSE otherwise. In that
* case the values for @pspec and @target are not modified. Unref @target after
* usage.
*
* gst_child_proxy_get_property:
* @object: object to query
* @name: name of the property
- * @value: an uninitialized #GValue that should take the result.
+ * @value: an uninitialized #GValue that should take the result.
*
* Gets a single property using the GstChildProxy mechanism.
* You are responsible for for freeing it by calling g_value_unset()
* gst_child_proxy_child_added:
* @object: the parent object
* @child: the newly added child
- *
+ *
* Emits the "child-added" signal.
*/
void
* gst_child_proxy_child_removed:
* @object: the parent object
* @child: the newly added child
- *
+ *
* Emits the "child-removed" signal.
*/
void
/**
* gst_clock_id_wait_async:
* @id: a #GstClockID to wait on
- * @func: The callback function
+ * @func: The callback function
* @user_data: User data passed in the calback
*
* Register a callback on the given clockid with the given
*
* Adjusts the current time of the clock with the adjust value.
* A positive value moves the clock forwards and a backwards value
- * moves it backwards. Note that _get_time() always returns
+ * moves it backwards. Note that _get_time() always returns
* increasing values so when you move the clock backwards, _get_time()
* will report the previous value until the clock catches up.
*
* GstElement is the base class needed to construct an element that can be
* used in a GStreamer pipeline. As such, it is not a functional entity, and
* cannot do anything when placed in a pipeline.
- *
+ *
* The name of a GstElement can be get with gst_element_get_name() and set with
- * gst_element_set_name(). For speed, GST_ELEMENT_NAME() can be used in the
- * core when using the appropriate locking. Do not use this in plug-ins or
+ * gst_element_set_name(). For speed, GST_ELEMENT_NAME() can be used in the
+ * core when using the appropriate locking. Do not use this in plug-ins or
* applications in order to retain ABI compatibility.
- *
+ *
* All elements have pads (of the type #GstPad). These pads link to pads on
* other elements. Buffers flow between these linked pads.
* A GstElement has a GList of #GstPad structures for all their input (or sink)
- * and output (or source) pads.
+ * and output (or source) pads.
* Core and plug-in writers can add and remove pads with gst_element_add_pad()
* and gst_element_remove_pad().
*
* A pad of an element can be retrieved by name with gst_element_get_pad().
* An iterator of all pads can be retrieved with gst_element_iterate_pads().
- *
+ *
* Elements can be linked through their pads.
- * If the link is straightforward, use the gst_element_link()
- * convenience function to link two elements, or gst_element_link_many()
+ * If the link is straightforward, use the gst_element_link()
+ * convenience function to link two elements, or gst_element_link_many()
* for more elements in a row.
* Use gst_element_link_filtered() to link two elements constrained by
* a specified set of #GstCaps.
- * For finer control, use gst_element_link_pads() and
- * gst_element_link_pads_filtered() to specify the pads to link on
+ * For finer control, use gst_element_link_pads() and
+ * gst_element_link_pads_filtered() to specify the pads to link on
* each element by name.
- *
+ *
* Each element has a state (see #GstState). You can get and set the state
- * of an element with gst_element_get_state() and gst_element_set_state().
- * To get a string representation of a #GstState, use
+ * of an element with gst_element_get_state() and gst_element_set_state().
+ * To get a string representation of a #GstState, use
* gst_element_state_get_name().
- *
+ *
* You can get and set a #GstClock on an element using gst_element_get_clock()
- * and gst_element_set_clock().
- * Some elements can provide a clock for the pipeline if
+ * and gst_element_set_clock().
+ * Some elements can provide a clock for the pipeline if
* gst_element_provides_clock() returns TRUE. With the gst_element_provide_clock()
* method one can retrieve the clock provided by such an element.
- * Not all elements require a clock to operate correctly. If
+ * Not all elements require a clock to operate correctly. If
* gst_element_requires_clock() returns TRUE, a clock should be set on the element
- * with gst_element_set_clock().
+ * with gst_element_set_clock().
*
- * Note that clock slection and distribution is normally handled by the toplevel
+ * Note that clock slection and distribution is normally handled by the toplevel
* #GstPipeline so the clock functions are only to be used in very specific situations.
*/
*
* Pads are not automatically activated so elements should perform the needed
* steps to activate the pad in case this pad is added in the PAUSED or PLAYING
- * state.
+ * state.
*
* The pad and the element should be unlocked when calling this function.
*
* gst_element_iterate_src_pads:
* @element: a #GstElement.
*
- * Retrieves an iterator of @element's source pads.
+ * Retrieves an iterator of @element's source pads.
*
* Returns: the #GstIterator of #GstPad. Unref each pad after use.
*
* gst_element_iterate_sink_pads:
* @element: a #GstElement.
*
- * Retrieves an iterator of @element's sink pads.
+ * Retrieves an iterator of @element's sink pads.
*
* Returns: the #GstIterator of #GstPad. Unref each pad after use.
*
* @timeout: a #GstClockTime to specify the timeout for an async
* state change or GST_CLOCK_TIME_NONE for infinite timeout.
*
- * Gets the state of the element.
+ * Gets the state of the element.
*
- * For elements that performed an ASYNC state change, as reported by
- * #gst_element_set_state(), this function will block up to the
- * specified timeout value for the state change to complete.
+ * For elements that performed an ASYNC state change, as reported by
+ * #gst_element_set_state(), this function will block up to the
+ * specified timeout value for the state change to complete.
* If the element completes the state change or goes into
* an error, this function returns immediatly with a return value of
- * GST_STATE_CHANGE_SUCCESS or GST_STATE_CHANGE_FAILURE respectively.
+ * GST_STATE_CHANGE_SUCCESS or GST_STATE_CHANGE_FAILURE respectively.
*
- * For elements that did not return ASYNC, this function returns the
+ * For elements that did not return ASYNC, this function returns the
* current and pending state immediatly.
*
* Returns: GST_STATE_CHANGE_SUCCESS if the element has no more pending state and
* the last state change succeeded, GST_STATE_CHANGE_ASYNC
- * if the element is still performing a state change or
+ * if the element is still performing a state change or
* GST_STATE_CHANGE_FAILURE if the last state change failed.
*
* MT safe.
*
* Commit the state change of the element. This function is used
* by elements that do asynchronous state changes.
- * The core will normally call this method automatically when an
+ * The core will normally call this method automatically when an
* element returned SUCCESS from the state change function.
* Elements that return ASYNC from the change_state function should
* eventually call this method from the streaming thread to signal
case GST_STATE_CHANGE_SUCCESS:
GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
"element changed state SUCCESS");
- /* we can commit the state now which will proceeed to
+ /* we can commit the state now which will proceeed to
* the next state */
ret = gst_element_commit_state (element);
break;
case GST_STATE_CHANGE_NO_PREROLL:
GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
"element changed state NO_PREROLL");
- /* we can commit the state now which will proceeed to
+ /* we can commit the state now which will proceeed to
* the next state */
gst_element_commit_state (element);
ret = GST_STATE_CHANGE_NO_PREROLL;
*
* Retrieves the factory that was used to create this element.
*
- * Returns: the #GstElementFactory used for creating this element.
+ * Returns: the #GstElementFactory used for creating this element.
* no refcounting is needed.
*/
GstElementFactory *
*
* GstElementFactory is used to create instances of elements. A GstElementfactory
* can be added to a #GstPlugin as it is also a #GstPluginFeature.
- *
+ *
* Use gst_element_factory_new() to create a new factory which can be added to a
* plugin with gst_plugin_add_feature().
- *
+ *
* gst_element_factory_add_pad_template() is used to add a padtemplate to the factory.
* This function will enable the application to query for elementfactories that handle
* a specific media type.
- *
+ *
* Use the gst_element_factory_find() and gst_element_factory_create() functions
- * to create element instances or use gst_element_factory_make() as a convenient
+ * to create element instances or use gst_element_factory_make() as a convenient
* shortcut.
- *
+ *
* The following code example shows you how to create a GstFileSrc element.
*
* <example>
* <title>Using an element factory</title>
* <programlisting language="c">
* #include <gst/gst.h>
- *
+ *
* GstElement *src;
* GstElementFactory *srcfactory;
- *
+ *
* gst_init(&argc,&argv);
- *
+ *
* srcfactory = gst_element_factory_find("filesrc");
* g_return_if_fail(srcfactory != NULL);
- *
+ *
* src = gst_element_factory_create(srcfactory,"src");
* g_return_if_fail(src != NULL);
* ...
* </programlisting>
* </example>
- *
- * An elementfactory can be assigned a rank with gst_element_factory_set_rank()
+ *
+ * An elementfactory can be assigned a rank with gst_element_factory_set_rank()
* so that the autopluggers can select a plugin more appropriatly
*/
/**
* gst_element_factory_get_element_type:
* @factory: factory to get managed #GType from
- *
+ *
* Get the #GType for elements managed by this factory
*
* Returns: the #GType for elements managed by this factory
/**
* gst_element_factory_get_longname:
* @factory: a #GstElementFactory
- *
+ *
* Gets the longname for this factory
*
* Returns: the longname
/**
* gst_element_factory_get_klass:
* @factory: a #GstElementFactory
- *
+ *
* Gets the class for this factory.
*
* Returns: the class
/**
* gst_element_factory_get_description:
* @factory: a #GstElementFactory
- *
+ *
* Gets the description for this factory.
*
* Returns: the description
/**
* gst_element_factory_get_author:
* @factory: a #GstElementFactory
- *
+ *
* Gets the author for this factory.
*
* Returns: the author
/**
* gst_element_factory_get_num_pad_templates:
* @factory: a #GstElementFactory
- *
+ *
* Gets the number of pad_templates in this factory.
*
* Returns: the number of pad_templates
/**
* gst_element_factory_get_static_pad_templates:
* @factory: a #GstElementFactory
- *
+ *
* Gets the #GList of padtemplates for this factory.
*
* Returns: the padtemplates
/**
* gst_element_factory_get_uri_type:
* @factory: a #GstElementFactory
- *
+ *
* Gets the type of URIs the element supports or GST_URI_UNKNOWN if none.
*
* Returns: type of URIs this element supports
/**
* gst_element_factory_get_uri_protocols:
* @factory: a #GstElementFactory
- *
+ *
* Gets a NULL-terminated array of protocols this element supports or NULL, if
* no protocols are supported. You may not change the contents of the returned
* array as it is still ownt by the element factory. Use g_strdupv() if you want to.
/* URI interface stuff */
guint uri_type;
gchar ** uri_protocols;
-
+
GList * interfaces; /* interfaces this element implements */
gpointer _gst_reserved[GST_PADDING];
G_CONST_RETURN gchar * gst_element_factory_get_author (GstElementFactory *factory);
guint gst_element_factory_get_num_pad_templates (GstElementFactory *factory);
G_CONST_RETURN GList * gst_element_factory_get_static_pad_templates (GstElementFactory *factory);
-gint gst_element_factory_get_uri_type (GstElementFactory *factory);
-gchar ** gst_element_factory_get_uri_protocols (GstElementFactory *factory);
+gint gst_element_factory_get_uri_type (GstElementFactory *factory);
+gchar ** gst_element_factory_get_uri_protocols (GstElementFactory *factory);
GstElement* gst_element_factory_create (GstElementFactory *factory,
const gchar *name);
*
* Get a printable name for the given event type. Do not modify or free.
*
- * Returns: a reference to the static name of the event.
+ * Returns: a reference to the static name of the event.
*/
const gchar *
gst_event_type_get_name (GstEventType type)
GstEvent* gst_event_new_newsegment (gboolean update, gdouble rate, GstFormat format,
gint64 start_value, gint64 stop_value,
gint64 stream_time);
-void gst_event_parse_newsegment (GstEvent *event, gboolean *update, gdouble *rate,
- GstFormat *format, gint64 *start_value, gint64 *stop_value,
+void gst_event_parse_newsegment (GstEvent *event, gboolean *update, gdouble *rate,
+ GstFormat *format, gint64 *start_value, gint64 *stop_value,
gint64 *stream_time);
/* tag event */
GstEvent* gst_event_new_tag (GstTagList *taglist);
GstEvent * gst_event_new_filler (void);
/* buffer */
-GstEvent * gst_event_new_buffersize (GstFormat format, gint64 minsize, gint64 maxsize,
+GstEvent * gst_event_new_buffersize (GstFormat format, gint64 minsize, gint64 maxsize,
gboolean async);
-void gst_event_parse_buffersize (GstEvent *event, GstFormat *format, gint64 *minsize,
+void gst_event_parse_buffersize (GstEvent *event, GstFormat *format, gint64 *minsize,
gint64 *maxsize, gboolean *async);
/* QOS events */
* gst_format_get_by_nick:
* @nick: The nick of the format
*
- * Return the format registered with the given nick.
+ * Return the format registered with the given nick.
*
* Returns: The format with @nick or GST_FORMAT_UNDEFINED
* if the format was not registered.
/**
* gst_format_iterate_definitions:
*
- * Iterate all the registered formats. The format definition is read
+ * Iterate all the registered formats. The format definition is read
* only.
*
* Returns: A GstIterator of #GstFormatDefinition.
*
* A format definition
*/
-struct _GstFormatDefinition
+struct _GstFormatDefinition
{
GstFormat value;
gchar *nick;
void _gst_format_initialize (void);
/* register a new format */
-GstFormat gst_format_register (const gchar *nick,
+GstFormat gst_format_register (const gchar *nick,
const gchar *description);
GstFormat gst_format_get_by_nick (const gchar *nick);
gboolean gst_formats_contains (const GstFormat *formats, GstFormat format);
/* query for format details */
-G_CONST_RETURN GstFormatDefinition*
+G_CONST_RETURN GstFormatDefinition*
gst_format_get_details (GstFormat format);
GstIterator* gst_format_iterate_definitions (void);
* @dir: the direction of the ghostpad
*
* Create a new ghostpad without a target with the given direction.
- * A target can be set on the ghostpad later with the
+ * A target can be set on the ghostpad later with the
* #gst_ghost_pad_set_target() function.
*
* The created ghostpad will not have a padtemplate.
*
* Before entries can be added to the index, a writer
* should obtain a unique id. The methods to add new entries
- * to the index require this id as an argument.
+ * to the index require this id as an argument.
*
- * The application can implement a custom function to map the writer object
+ * The application can implement a custom function to map the writer object
* to a string. That string will be used to register or look up an id
* in the index.
*
* @id: the id of the index writer
* @flags: optinal flags for this entry
* @format: the format of the value
- * @value: the value
+ * @value: the value
* @...: other format/value pairs or 0 to end the list
*
* Associate given format/value pairs with each other.
* @object: a pointer to the object to add
*
* Add the given object to the index with the given key.
- *
+ *
* Returns: a pointer to the newly added entry in the index.
*/
GstIndexEntry *
*
* Gets alternative formats associated with the indexentry.
*
- * Returns: TRUE if there was a value associated with the given
+ * Returns: TRUE if there was a value associated with the given
* format.
*/
gboolean
* @GST_INDEX_UNKNOWN: accuracy is not known
* @GST_INDEX_CERTAIN: accuracy is perfect
* @GST_INDEX_FUZZY: accuracy is fuzzy
- *
+ *
* The certainty of a group in the index.
*/
typedef enum {
* @GST_INDEX_ENTRY_ASSOCIATION: This entry is an association between formats
* @GST_INDEX_ENTRY_OBJECT: An object
* @GST_INDEX_ENTRY_FORMAT: A format definition
- *
+ *
* The different types of entries in the index.
*/
typedef enum {
* @GST_INDEX_LOOKUP_EXACT: There has to be an exact indexentry with the given format/value
* @GST_INDEX_LOOKUP_BEFORE: The exact entry or the one before it
* @GST_INDEX_LOOKUP_AFTER: The exact entry or the one after it
- *
+ *
* Specify the method to find an index entry in the index.
*/
typedef enum {
} id;
struct {
gint nassocs;
- GstIndexAssociation
+ GstIndexAssociation
*assocs;
GstAssocFlags flags;
} assoc;
* to the index, %FALSE otherwise.
*
*/
-typedef gboolean (*GstIndexFilter) (GstIndex *index,
+typedef gboolean (*GstIndexFilter) (GstIndex *index,
GstIndexEntry *entry);
/**
* GstIndexResolverMethod:
*
* Returns: %TRUE if an id could be assigned to the writer.
*/
-typedef gboolean (*GstIndexResolver) (GstIndex *index,
- GstObject *writer,
+typedef gboolean (*GstIndexResolver) (GstIndex *index,
+ GstObject *writer,
gchar **writer_string,
gpointer user_data);
* Flags for this index
*/
typedef enum {
- GST_INDEX_WRITABLE = (GST_OBJECT_FLAG_LAST << 0),
- GST_INDEX_READABLE = (GST_OBJECT_FLAG_LAST << 1),
+ GST_INDEX_WRITABLE = (GST_OBJECT_FLAG_LAST << 0),
+ GST_INDEX_READABLE = (GST_OBJECT_FLAG_LAST << 1),
GST_INDEX_FLAG_LAST = (GST_OBJECT_FLAG_LAST << 8)
} GstIndexFlags;
/* abstract methods */
void (*add_entry) (GstIndex *index, GstIndexEntry *entry);
- GstIndexEntry* (*get_assoc_entry) (GstIndex *index, gint id,
+ GstIndexEntry* (*get_assoc_entry) (GstIndex *index, gint id,
GstIndexLookupMethod method, GstAssocFlags flags,
GstFormat format, gint64 value,
GCompareDataFunc func,
- gpointer user_data);
+ gpointer user_data);
/* signals */
void (*entry_added) (GstIndex *index, GstIndexEntry *entry);
gint gst_index_new_group (GstIndex *index);
gboolean gst_index_set_group (GstIndex *index, gint groupnum);
-void gst_index_set_certainty (GstIndex *index,
+void gst_index_set_certainty (GstIndex *index,
GstIndexCertainty certainty);
GstIndexCertainty gst_index_get_certainty (GstIndex *index);
-void gst_index_set_filter (GstIndex *index,
+void gst_index_set_filter (GstIndex *index,
GstIndexFilter filter, gpointer user_data);
-void gst_index_set_resolver (GstIndex *index,
+void gst_index_set_resolver (GstIndex *index,
GstIndexResolver resolver, gpointer user_data);
gboolean gst_index_get_writer_id (GstIndex *index, GstObject *writer, gint *id);
-GstIndexEntry* gst_index_add_format (GstIndex *index, gint id, GstFormat format);
+GstIndexEntry* gst_index_add_format (GstIndex *index, gint id, GstFormat format);
GstIndexEntry* gst_index_add_association (GstIndex *index, gint id, GstAssocFlags flags,
GstFormat format, gint64 value, ...);
GstIndexEntry* gst_index_add_object (GstIndex *index, gint id, gchar *key,
GType type, gpointer object);
GstIndexEntry* gst_index_add_id (GstIndex *index, gint id,
- gchar *description);
+ gchar *description);
-GstIndexEntry* gst_index_get_assoc_entry (GstIndex *index, gint id,
+GstIndexEntry* gst_index_get_assoc_entry (GstIndex *index, gint id,
GstIndexLookupMethod method, GstAssocFlags flags,
GstFormat format, gint64 value);
-GstIndexEntry* gst_index_get_assoc_entry_full (GstIndex *index, gint id,
+GstIndexEntry* gst_index_get_assoc_entry_full (GstIndex *index, gint id,
GstIndexLookupMethod method, GstAssocFlags flags,
GstFormat format, gint64 value,
GCompareDataFunc func,
* gst_index_factory_create:
* @factory: the factory used to create the instance
*
- * Create a new #GstIndex instance from the
+ * Create a new #GstIndex instance from the
* given indexfactory.
*
* Returns: A new #GstIndex instance.
* gst_index_factory_make:
* @name: the name of the factory used to create the instance
*
- * Create a new #GstIndex instance from the
+ * Create a new #GstIndex instance from the
* indexfactory with the given name.
*
* Returns: A new #GstIndex instance.
*/
struct _GstIndexFactory {
GstPluginFeature feature;
-
+
gchar *longdesc; /* long description of the index (well, don't overdo it..) */
GType type; /* unique GType of the index */
};
struct _GstIndexFactoryClass {
- GstPluginFeatureClass parent;
+ GstPluginFeatureClass parent;
gpointer _gst_reserved[GST_PADDING];
};
GType gst_index_factory_get_type (void);
-GstIndexFactory* gst_index_factory_new (const gchar *name,
+GstIndexFactory* gst_index_factory_new (const gchar *name,
const gchar *longdesc, GType type);
void gst_index_factory_destroy (GstIndexFactory *factory);
*
* GStreamer's debugging subsystem is an easy way to get information about what
* the application is doing.
- * It is not meant for programming errors. Use GLib methods (g_warning and
+ * It is not meant for programming errors. Use GLib methods (g_warning and
* friends) for that.
*
* The debugging subsystem works only after GStreamer has been initialized
* - for example by calling gst_init().
*
* The debugging subsystem is used to log informational messages while the
- * application runs.
+ * application runs.
* Each messages has some properties attached to it. Among these properties
* are the debugging category, the severity (called "level" here) and an
* optional
* debugging handlers, which then handle the messages. GStreamer attaches a
* default handler on startup, which outputs requested messages to stderr.
*
- * Messages are output by using shortcut macros like #GST_DEBUG,
+ * Messages are output by using shortcut macros like #GST_DEBUG,
* #GST_CAT_ERROR_OBJECT or similar. These all expand to calling gst_debug_log()
* with the right parameters.
- * The only thing a developer will probably want to do is define his own
+ * The only thing a developer will probably want to do is define his own
* categories. This is easily done with 3 lines. At the top of your code,
* declare
* the variables and set the default category.
* </programlisting>
* </informalexample>
* Initialization must be done before the category is used first.
- * Plugins do this
+ * Plugins do this
* in their plugin_init function, libraries and applications should do that
* during their initialization.
*
* subsystem was compiled out, #GST_DISABLE_GST_DEBUG is defined in
* <gst/gst.h>,
* so you can check that before doing your trick.
- * Disabling the debugging subsystem will give you a slight (read: unnoticable)
- * speed increase and will reduce the size of your compiled code. The GStreamer
+ * Disabling the debugging subsystem will give you a slight (read: unnoticable)
+ * speed increase and will reduce the size of your compiled code. The GStreamer
* library itself becomes around 10% smaller.
*
- * Please note that there are naming conventions for the names of debugging
+ * Please note that there are naming conventions for the names of debugging
* categories. These are explained at GST_DEBUG_CATEGORY_INIT().
*/
/**
* _gst_debug_init:
- *
+ *
* Initializes the debugging system.
* Normally you don't want to call this, because gst_init does it for you.
*/
* @object: the object this message relates to or NULL if none
* @format: a printf style format string
* @...: optional arguments for the format
- *
+ *
* Logs the given message using the currently registered debugging handlers.
*/
void
* @object: the object this message relates to or NULL if none
* @format: a printf style format string
* @args: optional arguments for the format
- *
+ *
* Logs the given message using the currently registered debugging handlers.
*/
void
/**
* gst_debug_construct_term_color:
* @colorinfo: the color info
- *
+ *
* Constructs a string that can be used for getting the desired color in color
* terminals.
* You need to free the string after use.
- *
+ *
* Returns: a string containing the color definition
*/
gchar *
* @message: the actual message
* @object: the object this message relates to or NULL if none
* @unused: an unused variable, reserved for some user_data.
- *
+ *
* The default logging handler used by GStreamer. Logging functions get called
* whenever a macro like GST_DEBUG or similar is used. This function outputs the
* message and additional info using the glib error handler.
- * You can add other handlers by using #gst_debug_add_log_function.
+ * You can add other handlers by using #gst_debug_add_log_function.
* And you can remove this handler by calling
* gst_debug_remove_log_function (gst_debug_log_default);
*/
/**
* gst_debug_level_get_name:
* @level: the level to get the name for
- *
+ *
* Get the string trepresentation of a debugging level
- *
+ *
* Returns: the name
*/
const gchar *
* gst_debug_add_log_function:
* @func: the function to use
* @data: user data
- *
+ *
* Adds the logging function to the list of logging functions.
* Be sure to use G_GNUC_NO_INSTRUMENT on that function, it is needed.
*/
/* FIXME: we leak the old list here - other threads might access it right now
* in gst_debug_logv. Another solution is to lock the mutex in gst_debug_logv,
* but that is waaay costly.
- * It'd probably be clever to use some kind of RCU here, but I don't know
+ * It'd probably be clever to use some kind of RCU here, but I don't know
* anything about that.
*/
g_static_mutex_lock (&__log_func_mutex);
/**
* gst_debug_remove_log_function:
* @func: the log function to remove
- *
+ *
* Removes all registrered instances of the given logging functions.
- *
+ *
* Returns: How many instances of the function were removed
*/
guint
/**
* gst_debug_remove_log_function_by_data:
* @data: user data of the log function to remove
- *
+ *
* Removes all registrered instances of log functions with the given user data.
- *
+ *
* Returns: How many instances of the function were removed
*/
guint
/**
* gst_debug_set_colored:
* @colored: Whether to use colored output or not
- *
+ *
* Sets or unsets the use of coloured debugging output.
*/
void
/**
* gst_debug_is_colored:
- *
+ *
* Checks if the debugging output should be colored.
- *
+ *
* Returns: TRUE, if the debug output should be colored.
*/
gboolean
/**
* gst_debug_set_active:
* @active: Whether to use debugging output or not
- *
+ *
* If activated, debugging messages are sent to the debugging
* handlers.
* It makes sense to deactivate it for speed issues.
/**
* gst_debug_is_active:
- *
+ *
* Checks if debugging output is activated.
- *
+ *
* Returns: TRUE, if debugging is activated
*/
gboolean
/**
* gst_debug_set_default_threshold:
* @level: level to set
- *
+ *
* Sets the default threshold to the given level and updates all categories to
* use this threshold.
*/
/**
* gst_debug_get_default_threshold:
- *
+ *
* Returns the default threshold that is used for new categories.
- *
+ *
* Returns: the default threshold level
*/
GstDebugLevel
* gst_debug_print_stack_trace:
*
* If GST_ENABLE_FUNC_INSTRUMENTATION is defined a stacktracke is available for
- * gstreamer code, which can be printed with this function.
+ * gstreamer code, which can be printed with this function.
*/
void
gst_debug_print_stack_trace (void)
* GstDebugLevel:
* @GST_LEVEL_NONE: No debugging level specified or desired. Used to deactivate
* debugging output.
- * @GST_LEVEL_ERROR: Error messages are to be used only when an error occured
+ * @GST_LEVEL_ERROR: Error messages are to be used only when an error occured
* that stops the application from keeping working correctly.
* An examples is gst_element_error, which outputs a message with this priority.
* It does not mean that the application is terminating as with g_errror.
* @GST_LEVEL_WARNING: Warning messages are to inform about abnormal behaviour
- * that could lead to problems or weird behaviour later on. An example of this
+ * that could lead to problems or weird behaviour later on. An example of this
* would be clocking issues ("your computer is pretty slow") or broken input
* data ("Can't synchronize to stream.")
* @GST_LEVEL_INFO: Informational messages should be used to keep the developer
* updated about what is happening.
- * Examples where this should be used are when a typefind function has
+ * Examples where this should be used are when a typefind function has
* successfully determined the type of the stream or when an mp3 plugin detects
* the format to be used. ("This file has mono sound.")
* @GST_LEVEL_DEBUG: Debugging messages should be used when something common
- * happens that is not the expected default behavior.
+ * happens that is not the expected default behavior.
* An example would be notifications about state changes or receiving/sending of
* events.
- * @GST_LEVEL_LOG: Log messages are messages that are very common but might be
+ * @GST_LEVEL_LOG: Log messages are messages that are very common but might be
* useful to know. As a rule of thumb a pipeline that is iterating as expected
* should never output anzthing else but LOG messages.
* Examples for this are referencing/dereferencing of objects or cothread switches.
* @GST_LEVEL_COUNT: The number of defined debugging levels.
- *
- * The level defines the importance of a debugging message. The more important a
+ *
+ * The level defines the importance of a debugging message. The more important a
* message is, the greater the probability that the debugging system outputs it.
*/
typedef enum {
* @GST_DEBUG_BG_WHITE: Use white as background color.
* @GST_DEBUG_BOLD: Make the output bold.
* @GST_DEBUG_UNDERLINE: Underline the output.
- *
+ *
* These are some terminal style flags you can use when creating your
* debugging categories to make them stand out in debugging output.
*/
* @obj: the #GObject the message belongs to
* @...: printf-style message to output
*
- * Output an informational message belonging to the given object in the default
+ * Output an informational message belonging to the given object in the default
* category.
*/
/**
* @obj: the #GObject the message belongs to
* @...: printf-style message to output
*
- * Output a debugging message belonging to the given object in the default
+ * Output a debugging message belonging to the given object in the default
* category.
*/
/**
* Output a logging message belonging to the given object in the default category.
*/
-
+
/**
* GST_ERROR:
* @...: printf-style message to output
/* GStreamer
- *
+ *
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* @elem: pointer to hold next element
*
* Get the next item from the iterator.
- *
+ *
* Returns: The result of the iteration.
*
* MT safe.
*
* Resync the iterator. this function is mostly called
* after #gst_iterator_next() returned #GST_ITERATOR_RESYNC.
- *
+ *
* MT safe.
*/
void
*
* This function is mainly used by objects implementing the iterator
* next function to recurse into substructures.
- *
+ *
* MT safe.
*/
void
* When this iterator is freed, @it will also be freed.
*
* Returns: a new #GstIterator.
- *
+ *
* MT safe.
*/
GstIterator *
* The iterator will not be freed.
*
* Returns: A #GstIteratorResult, as described above.
- *
+ *
* MT safe.
*/
GstIteratorResult
# define GST_INLINE_FUNC extern __inline
# define GST_CAN_INLINE 1
#else
-# define GST_INLINE_FUNC extern
+# define GST_INLINE_FUNC extern
# undef GST_CAN_INLINE
#endif
* @type: the allocation strategy to use
*
* Creates a new memchunk that will allocate atom_sized memchunks.
- * The initial area is set to area_size and will grow automatically
+ * The initial area is set to area_size and will grow automatically
* when it is too small (with a small overhead when that happens)
*
* Returns: a new #GstMemChunk
* @short_description: Lightweight objects to signal the application of pipeline events
* @see_also: #GstBus,#GstMiniObject
*
- * Messages are implemented as a subclass of #GstMiniObject with a generic
+ * Messages are implemented as a subclass of #GstMiniObject with a generic
* #GstStructure as the content. This allows for writing custom messages without
* requiring an API change while allowing a wide range of different types
* of messages.
*
- * Messages are posted by objects in the pipeline and are passed to the
- * application using the #GstBus.
+ * Messages are posted by objects in the pipeline and are passed to the
+ * application using the #GstBus.
*/
#include <string.h> /* memcpy */
*
* Get a printable name for the given message type. Do not modify or free.
*
- * Returns: a reference to the static name of the message.
+ * Returns: a reference to the static name of the message.
*/
const gchar *
gst_message_type_get_name (GstMessageType type)
*
* Create a new error message. The message will copy @error and
* @debug. This message is posted by element when a fatal event
- * occured. The pipeline will probably (partially) stop.
+ * occured. The pipeline will probably (partially) stop.
*
* Returns: The new error message.
*
* @clock: The clock it provides
* @ready: TRUE if the sender can provide a clock
*
- * Create a clock provide message. This message is posted whenever an
+ * Create a clock provide message. This message is posted whenever an
* element is ready to provide a clock or lost its ability to provide
* a clock (maybe because it paused or became EOS).
*
- * This message is mainly used internally to manage the clock
+ * This message is mainly used internally to manage the clock
* selection.
*
* Returns: The new provide clock message.
* Access the structure of the message.
*
* Returns: The structure of the message. The structure is still
- * owned by the message, which means that you should not free it and
+ * owned by the message, which means that you should not free it and
* that the pointer becomes invalid when you free the message.
*
* MT safe.
GstObject *src;
GstStructure *structure;
-
+
/*< private > */
gpointer _gst_reserved[GST_PADDING];
};
* if the reference count is one and the GST_MINI_OBJECT_FLAG_READONLY
* flag is not set. Modification of a mini-object should only be
* done after verifying that it is writable.
- *
+ *
* MT safe
*
* Returns: TRUE if the object is writable.
{
g_return_val_if_fail (mini_object != NULL, NULL);
/* we cannot assert that the refcount > 0 since a bufferalloc
- * function might resurect an object
+ * function might resurect an object
g_return_val_if_fail (mini_object->refcount > 0, NULL);
*/
* reference can be removed by anyone at any time, by calling gst_object_sink().
* gst_object_sink() does nothing if an object is already sunk (has no floating
* reference).
- *
+ *
* When you add a GstElement to its parent container, the parent container will do
* this:
* <informalexample>
* Another effect of this is, that calling gst_object_unref() on a bin object, will
* also destoy all the GstElement objects in it. The same is true for calling
* gst_bin_remove().
- *
+ *
* In contrast to GObject instances GstObject add a name property. The functions
* gst_object_set_name() and gst_object_get_name() are used to set/get the name
* of the object.
* signals being emitted by the object itself, as well as in each parent
* object. This is so that an application can connect a listener to the
* top-level bin to catch property-change notifications for all contained
- * elements.
+ * elements.
*
- * This function is not MT safe in glib so we need to lock it with a
+ * This function is not MT safe in glib so we need to lock it with a
* classwide mutex.
*
* MT safe.
GST_CLASS_UNLOCK (klass);
}
-/**
+/**
* gst_object_default_deep_notify:
* @object: the #GObject that signalled the notify.
* @orig: a #GstObject that initiated the notify.
* @excluded_props: a set of user-specified properties to exclude or
* NULL to show all changes.
*
- * A default deep_notify signal callback for an element. The user data
- * should contain a pointer to an array of strings that should be excluded
- * from the notify. The default handler will print the new value of the property
+ * A default deep_notify signal callback for an element. The user data
+ * should contain a pointer to an array of strings that should be excluded
+ * from the notify. The default handler will print the new value of the property
* using g_print.
*
* MT safe. This function grabs and releases the object's LOCK or getting the
* the object hierarchy. Only useful (or used) for debugging.
*
* Returns: a string describing the path of the object. You must
- * g_free() the string after usage.
+ * g_free() the string after usage.
*
* MT safe. Grabs and releases the object's LOCK for all objects
* in the hierarchy.
* GST_OBJECT_REFCOUNT:
* @obj: Object get the refcount for.
*
- * Get access to the reference count field of the object.
+ * Get access to the reference count field of the object.
*/
#define GST_OBJECT_REFCOUNT(obj) (((GObject*)(obj))->ref_count)
/**
* GST_OBJECT_REFCOUNT_VALUE:
* @obj: Object get the refcount value for.
*
- * Get the reference count value of the object.
+ * Get the reference count value of the object.
*/
#define GST_OBJECT_REFCOUNT_VALUE(obj) GST_OBJECT_REFCOUNT(obj)
#else
/* we do a GST_OBJECT_CAST to avoid type checking, better call these
* function with a valid object! */
-
+
/**
* GST_LOCK:
* @obj: Object to lock.
void gst_object_unparent (GstObject *object);
gboolean gst_object_has_ancestor (GstObject *object, GstObject *ancestor);
-void gst_object_default_deep_notify (GObject *object, GstObject *orig,
+void gst_object_default_deep_notify (GObject *object, GstObject *orig,
GParamSpec *pspec, gchar **excluded_props);
/* refcounting + life cycle */
* @short_description: Object contained by elements that allows links to other elements
* @see_also: #GstPadTemplate, #GstElement, #GstEvent
*
- * A #GstElement is linked to other elements via "pads", which are extremely
- * light-weight generic link points.
- * After two pads are retrieved from an element with gst_element_get_pad(),
+ * A #GstElement is linked to other elements via "pads", which are extremely
+ * light-weight generic link points.
+ * After two pads are retrieved from an element with gst_element_get_pad(),
* the pads can be link with gst_pad_link(). (For quick links,
* you can also use gst_element_link(), which will make the obvious
* link for you if it's straightforward.)
*
- * Pads are typically created from a #GstPadTemplate with
+ * Pads are typically created from a #GstPadTemplate with
* gst_pad_new_from_template().
*
* Pads have #GstCaps attached to it to describe the media type they are capable
- * of dealing with.
+ * of dealing with.
* gst_pad_get_caps() and gst_pad_try_set_caps() are used to manipulate the caps
- * of the pads.
- * Pads created from a pad template cannot set capabilities that are
+ * of the pads.
+ * Pads created from a pad template cannot set capabilities that are
* incompatible with the pad template capabilities.
*
* Pads without pad templates can be created with gst_pad_new(),
*
* gst_pad_get_parent() will retrieve the #GstElement that owns the pad.
*
- * A #GstElement creating a pad will typically use the various
- * gst_pad_set_*_function() calls to register callbacks for various events
+ * A #GstElement creating a pad will typically use the various
+ * gst_pad_set_*_function() calls to register callbacks for various events
* on the pads.
*
- * GstElements will use gst_pad_push() and gst_pad_pull() to push out
+ * GstElements will use gst_pad_push() and gst_pad_pull() to push out
* or pull in a buffer.
* gst_pad_select() and gst_pad_selectv() are used by plugins to wait for the
* first incoming buffer or event on any of the given set of pads.
* @direction: the #GstPadDirection of the pad.
*
* Creates a new pad with the given name in the given direction.
- * If name is NULL, a guaranteed unique name (across all pads)
+ * If name is NULL, a guaranteed unique name (across all pads)
* will be assigned.
* This function makes a copy of the name so you can safely free the name.
*
* @name: the name of the element
*
* Creates a new pad with the given name from the given template.
- * If name is NULL, a guaranteed unique name (across all pads)
+ * If name is NULL, a guaranteed unique name (across all pads)
* will be assigned.
* This function makes a copy of the name so you can safely free the name.
*
* @pad: a #GstPad to get the direction of.
*
* Gets the direction of the pad. The direction of the pad is
- * decided at construction time so this function does not take
+ * decided at construction time so this function does not take
* the LOCK.
*
* Returns: the #GstPadDirection of the pad.
* callback.
*
* Returns: TRUE if the pad could be blocked. This function can fail
- * wrong parameters were passed or the pad was already in the
+ * wrong parameters were passed or the pad was already in the
* requested state.
*
* MT safe.
/**
* gst_pad_is_blocked:
- * @pad: the #GstPad to query
+ * @pad: the #GstPad to query
*
* Checks if the pad is blocked or not. This function returns the
* last requested state of the pad. It is not certain that the pad
* gst_pad_set_link_function:
* @pad: a #GstPad.
* @link: the #GstPadLinkFunction to set.
- *
+ *
* Sets the given link function for the pad. It will be called when the pad is
* linked or relinked with caps. The caps passed to the link function is
* the caps for the connnection. It can contain a non fixed caps.
- *
+ *
* The return value GST_PAD_LINK_OK should be used when the connection can be
* made.
- *
+ *
* The return value GST_PAD_LINK_REFUSED should be used when the connection
* cannot be made for some reason.
*/
* gst_pad_set_getcaps_function:
* @pad: a #GstPad.
* @getcaps: the #GstPadGetCapsFunction to set.
- *
+ *
* Sets the given getcaps function for the pad. @getcaps should return the
* allowable caps for a pad in the context of the element's state, its link to
* other elements, and the devices or files it has opened. These caps must be a
* but this is discouraged.
*
* You do not need to call this function if @pad's allowed caps are always the
- * same as the pad template caps. This can only be true if the padtemplate
+ * same as the pad template caps. This can only be true if the padtemplate
* has fixed simple caps.
*
* For most filters, the caps returned by @getcaps is directly affected by the
* allowed caps on other pads. For demuxers and decoders, the caps returned by
* the srcpad's getcaps function is directly related to the stream data. Again,
* @getcaps should return the most specific caps it reasonably can, since this
- * helps with autoplugging.
+ * helps with autoplugging.
*
* Note that the return value from @getcaps is owned by the caller, so the caller
* should unref the caps after usage.
GST_UNLOCK (sinkpad);
GST_UNLOCK (srcpad);
- /* fire off a signal to each of the pads telling them
+ /* fire off a signal to each of the pads telling them
* that they've been unlinked */
g_signal_emit (G_OBJECT (srcpad), gst_pad_signals[PAD_UNLINKED], 0, sinkpad);
g_signal_emit (G_OBJECT (sinkpad), gst_pad_signals[PAD_UNLINKED], 0, srcpad);
*
* Gets the capabilities of the peer connected to this pad.
*
- * Returns: the #GstCaps of the peer pad. This function returns a new caps, so use
+ * Returns: the #GstCaps of the peer pad. This function returns a new caps, so use
* gst_caps_unref to get rid of it. this function returns NULL if there is no
* peer pad or when this function is called recursively from a getcaps function.
*/
* @dispatch: the #GstDispatcherFunction to call.
* @data: gpointer user data passed to the dispatcher function.
*
- * Invokes the given dispatcher function on all pads that are
- * internally linked to the given pad.
- * The GstPadDispatcherFunction should return TRUE when no further pads
+ * Invokes the given dispatcher function on all pads that are
+ * internally linked to the given pad.
+ * The GstPadDispatcherFunction should return TRUE when no further pads
* need to be processed.
*
* Returns: TRUE if one of the dispatcher functions returned TRUE.
#endif /* 0 */
#endif /* GST_DISABLE_LOADSAVE */
-/*
- * should be called with pad lock held
+/*
+ * should be called with pad lock held
*
* MT safe.
*/
*
* Checks if a #gst_pad_pull_range() can be performed on the peer
* source pad. This function is used by plugins that want to check
- * if they can use random access on the peer source pad.
+ * if they can use random access on the peer source pad.
*
* The peer sourcepad can implement a custom #GstPadCheckGetRangeFunction
* if it needs to perform some logic to determine if pull_range is
* @size: The length of the buffer
* @buffer: a pointer to hold the #GstBuffer.
*
- * Calls the getrange function of @pad.
+ * Calls the getrange function of @pad.
*
* Returns: a #GstFlowReturn from the pad.
*
* @pad: the #GstPad to set the private data of.
* @priv: The private data to attach to the pad.
*
- * Set the given private data gpointer on the pad.
+ * Set the given private data gpointer on the pad.
* This function can only be used by the element that owns the pad.
*/
void
* dataflow. This function will automatically acauire the STREAM_LOCK of
* the pad before calling @func.
*
- * Returns: a TRUE if the task could be started.
+ * Returns: a TRUE if the task could be started.
*/
gboolean
gst_pad_start_task (GstPad * pad, GstTaskFunction func, gpointer data)
* gst_pad_pause_task:
* @pad: the #GstPad to pause the task of
*
- * Pause the task of @pad. This function will also make sure that the
+ * Pause the task of @pad. This function will also make sure that the
* function executed by the task will effectively stop.
*
* Returns: a TRUE if the task could be paused or FALSE when the pad
* gst_pad_stop_task:
* @pad: the #GstPad to stop the task of
*
- * Stop the task of @pad. This function will also make sure that the
+ * Stop the task of @pad. This function will also make sure that the
* function executed by the task will effectively stop if not called
* from the GstTaskFunction.
*
* GstPadChainFunction:
* @pad: the #GstPad that performed the chain.
* @buffer: the #GstBuffer that is chained.
- *
+ *
* A function that will be called when chaining buffers.
*
* Returns: GST_FLOW_OK for success
* @query: the #GstQuery object to execute
*
* The signature of the query function.
- *
+ *
* Returns: TRUE if the query could be performed.
*/
typedef gboolean (*GstPadQueryFunction) (GstPad *pad, GstQuery *query);
* @pad: the #GstPad that is dispatched.
* @data: the gpointer to optional user data.
*
- * A dispatcher function is called for all internally linked pads, see
+ * A dispatcher function is called for all internally linked pads, see
* gst_pad_dispatcher().
*
* Returns: TRUE if the dispatching procedure has to be stopped.
* @see_also: #GstPad, #GstElementFactory
*
* Padtemplates describe the possible media types a pad or an elementfactory can
- * handle.
- *
+ * handle.
+ *
* Pad and PadTemplates have #GstCaps attached to it to describe the media type they
* are capable of dealing with. gst_pad_template_get_caps() is used to get the
* caps of a padtemplate. It's not possible to modify the caps of a padtemplate after
- * creation.
- *
+ * creation.
+ *
* Padtemplates can be created with gst_pad_template_new() or with the convenient
- * GST_PAD_TEMPLATE_FACTORY() macro. A padtemplate can be used to create a pad or
+ * GST_PAD_TEMPLATE_FACTORY() macro. A padtemplate can be used to create a pad or
* to add to an elementfactory.
- *
+ *
* The following code example shows the code to create a pad from a padtemplate.
* <example>
* <title>Create a pad from a padtemplate</title>
* "channels = (int) [ 1, 6 ]"
* )
* )
- *
+ *
* void
- * my_method (void)
+ * my_method (void)
* {
* GstPad *pad;
- *
+ *
* pad = gst_pad_new_from_template (GST_PAD_TEMPLATE_GET (my_template_factory), "sink");
* ...
* }
* </programlisting>
* </example>
- *
+ *
* The following example shows you how to add the padtemplate to an elementfactory:
* <informalexample>
* <programlisting>
* my_factory_init (GstPlugin *plugin)
* {
* GstElementFactory *factory;
- *
+ *
* factory = gst_element_factory_new ("my_factory", GST_TYPE_MYFACTORY, &gst_myfactory_details);
* g_return_val_if_fail (factory != NULL, FALSE);
- *
+ *
* gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (my_template_factory));
- *
+ *
* gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
- *
+ *
* return TRUE;
* }
* </programlisting>
*
* Gets the capabilities of the static pad template.
*
- * Returns: the #GstCaps of the static pad template. If you need to keep a
+ * Returns: the #GstCaps of the static pad template. If you need to keep a
* reference to the caps, take a ref (see gst_caps_ref ()).
*/
GstCaps *
* GstPadPresence:
* @GST_PAD_ALWAYS: the pad is always available
* @GST_PAD_SOMETIMES: the pad will become available depending on the media stream
- * @GST_PAD_REQUEST: the pad is only available on request with
+ * @GST_PAD_REQUEST: the pad is only available on request with
* gst_element_request_pad_by_name() or gst_element_request_compatible_pad().
*
* Indicates when this pad will become available.
* pipeline is properly PAUSED and resumed as well as update the new stream time
* after the seek.
*
- * gst_pipeline_new() is used to create a pipeline. when you are done with
+ * gst_pipeline_new() is used to create a pipeline. when you are done with
* the pipeline, use gst_object_unref() to free its resources including all
* added #GstElement objects (if not otherwiese referenced).
*/
*
* Use gst_plugin_find_feature() and gst_plugin_get_feature_list() to find features in a plugin.
*
- * Usually plugins are always automaticlly loaded so you don't need to call gst_plugin_load() explicitly
+ * Usually plugins are always automaticlly loaded so you don't need to call gst_plugin_load() explicitly
* to bring it into memory. There are options to statically link plugins to an app or even
- * use GStreamer without a plugin repository in which case gst_plugin_load() can be needed
+ * use GStreamer without a plugin repository in which case gst_plugin_load() can be needed
* to bring the plugin into memory.
*/
#endif
/* list of valid licenses.
- * One of these must be specified or the plugin won't be loaded
- * Contact gstreamer-devel@lists.sourceforge.net if your license should be
+ * One of these must be specified or the plugin won't be loaded
+ * Contact gstreamer-devel@lists.sourceforge.net if your license should be
* added.
*
* GPL: http://www.gnu.org/copyleft/gpl.html
}
/* this function can be called in the GCC constructor extension, before
- * the _gst_plugin_initialize() was called. In that case, we store the
+ * the _gst_plugin_initialize() was called. In that case, we store the
* plugin description in a list to initialize it when we open the main
* module later on.
* When the main module is known, we can register the plugin right away.
NULL);
}
-/* this function could be extended to check if the plugin license matches the
+/* this function could be extended to check if the plugin license matches the
* applications license (would require the app to register its license somehow).
* We'll wait for someone who's interested in it to code it :)
*/
* gst_plugin_get_module:
* @plugin: plugin to query
*
- * Gets the #GModule of the plugin. If the plugin isn't loaded yet, NULL is
+ * Gets the #GModule of the plugin. If the plugin isn't loaded yet, NULL is
* returned.
*
- * Returns: module belonging to the plugin or NULL if the plugin isn't
+ * Returns: module belonging to the plugin or NULL if the plugin isn't
* loaded yet.
*/
GModule *
*
* Loads @plugin. Note that the *return value* is the loaded plugin; @plugin is
* untouched. The normal use pattern of this function goes like this:
- *
+ *
* <programlisting>
* GstPlugin *loaded_plugin;
* loaded_plugin = gst_plugin_load (plugin);
- *
+ *
* // presumably, we're no longer interested in the potentially-unloaded plugin
* gst_object_unref (plugin);
* plugin = loaded_plugin;
* plugin_desc struct.
* This function will be called by the loader at startup.
*
- * Returns: %TRUE if plugin initialised successfully
+ * Returns: %TRUE if plugin initialised successfully
*/
typedef gboolean (*GstPluginInitFunc) (GstPlugin *plugin);
* @package: shipped package plugin belongs to
* @origin: URL to provider of plugin
* @_gst_reserved: private, for later expansion
- *
+ *
*
* A plugins should export a variable of this type called plugin_desc. This plugin
* loaded will use this variable to initialize the plugin.
* @name: the name to set
*
* Sets the name of a plugin feature. The name uniquely identifies a feature
- * within all features of the same type. Renaming a plugin feature is not
+ * within all features of the same type. Renaming a plugin feature is not
* allowed. A copy is made of the name so you should free the supplied @name
* after calling this function.
*/
* @see_also: #GstPad, #GstElement
*
* GstQuery functions are used to register a new query types to the gstreamer
- * core.
+ * core.
* Query types can be used to perform queries on pads and elements.
*
* Query answer can be parsed using gst_query_parse_xxx() helpers.
* gst_query_type_get_by_nick:
* @nick: The nick of the query
*
- * Return the query registered with the given nick.
+ * Return the query registered with the given nick.
*
* Returns: The query with @nick or GST_QUERY_NONE
* if the query was not registered.
GstQueryType type;
GstStructure *structure;
-
+
/*< private > */
gpointer _gst_reserved[GST_PADDING];
};
struct _GstQueryClass {
GstMiniObjectClass mini_object_class;
-
+
/*< private > */
gpointer _gst_reserved[GST_PADDING];
};
GType gst_query_get_type (void);
/* register a new query */
-GstQueryType gst_query_type_register (const gchar *nick,
+GstQueryType gst_query_type_register (const gchar *nick,
const gchar *description);
GstQueryType gst_query_type_get_by_nick (const gchar *nick);
/* query for query details */
-G_CONST_RETURN GstQueryTypeDefinition*
+G_CONST_RETURN GstQueryTypeDefinition*
gst_query_type_get_details (GstQueryType type);
GstIterator* gst_query_type_iterate_definitions (void);
* Data is queued till max_level buffers have been stored. Any subsequent
* buffers sent to this filter will block until free space becomes available in
* the buffer. The queue is typically used in conjunction with a thread.
- *
+ *
* You can query how many buffers are queued with the level argument.
- *
+ *
* The default queue length is set to 100.
- *
+ *
* The queue blocks by default.
*/
g_thread_self ());
g_cond_wait (queue->item_add, queue->qlock);
- /* we released the lock in the g_cond above so we might be
+ /* we released the lock in the g_cond above so we might be
* flushing now */
if (queue->srcresult != GST_FLOW_OK)
goto out_flushing;
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
- * gstqueue.h:
+ * gstqueue.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
void gst_registry_remove_feature (GstRegistry * registry, GstPluginFeature * feature);
GList* gst_registry_get_plugin_list (GstRegistry *registry);
-GList* gst_registry_plugin_filter (GstRegistry *registry,
- GstPluginFilter filter,
- gboolean first,
+GList* gst_registry_plugin_filter (GstRegistry *registry,
+ GstPluginFilter filter,
+ gboolean first,
gpointer user_data);
-GList* gst_registry_feature_filter (GstRegistry *registry,
- GstPluginFeatureFilter filter,
+GList* gst_registry_feature_filter (GstRegistry *registry,
+ GstPluginFeatureFilter filter,
gboolean first,
gpointer user_data);
GList * gst_registry_get_feature_list (GstRegistry *registry,
/* if the dir does not exist, make it. if that can't be done, flags = 0x0.
if the file can be appended to, it's writable. if it can then be read,
- it's readable.
+ it's readable.
After that check if it exists. */
if (make_dir (registry->location) != TRUE) {
static gboolean
gst_registry_xml_save_caps (GstRegistry * registry, const GstCaps * caps)
{
- /* we copy the caps here so we can simplify them before saving. This is a lot
+ /* we copy the caps here so we can simplify them before saving. This is a lot
* faster when loading them later on */
char *s;
GstCaps *copy = gst_caps_copy (caps);
}
/**
- * gst_structure_free:
+ * gst_structure_free:
* @structure: the #GstStructure to free
*
* Frees a #GstStructure and all its fields and values. The structure must not
*
* Accessor function.
*
- * Returns: the #GValue corresponding to the field with the given name
+ * Returns: the #GValue corresponding to the field with the given name
* identifier.
*/
const GValue *
* gst_structure_remove_all_fields:
* @structure: a #GstStructure
*
- * Removes all fields in a GstStructure.
+ * Removes all fields in a GstStructure.
*/
void
gst_structure_remove_all_fields (GstStructure * structure)
* @structure: a #GstStructure
*
* Converts @structure to a human-readable representation.
- *
+ *
* Returns: a pointer to string allocated by g_malloc()
*/
gchar *
}
/*
- * r will still point to the string. if end == next, the string will not be
+ * r will still point to the string. if end == next, the string will not be
* null-terminated. In all other cases it will be.
* end = pointer to char behind end of string, next = pointer to start of
* unread data.
- * THIS FUNCTION MODIFIES THE STRING AND DETECTS INSIDE A NONTERMINATED STRING
+ * THIS FUNCTION MODIFIES THE STRING AND DETECTS INSIDE A NONTERMINATED STRING
*/
static gboolean
gst_structure_parse_string (gchar * s, gchar ** end, gchar ** next)
const gchar *fieldname);
void gst_structure_remove_field (GstStructure *structure,
const gchar *fieldname);
-void gst_structure_remove_fields (GstStructure *structure,
+void gst_structure_remove_fields (GstStructure *structure,
const gchar *fieldname,
...);
-void gst_structure_remove_fields_valist (GstStructure *structure,
+void gst_structure_remove_fields_valist (GstStructure *structure,
const gchar *fieldname,
va_list varargs);
void gst_structure_remove_all_fields (GstStructure *structure);
return clock;
}
-/* this thread reads the sorted clock entries from the queue.
+/* this thread reads the sorted clock entries from the queue.
*
* It waits on each of them and fires the callback when the timeout occurs.
*
* When an entry in the queue was canceled, it is simply skipped.
*
- * When waiting for an entry, it can become canceled, in that case we don't
+ * When waiting for an entry, it can become canceled, in that case we don't
* call the callback but move to the next item in the queue.
*
* MT safe.
}
case GST_CLOCK_BUSY:
/* somebody unlocked the entry but is was not canceled, This means that
- * either a new entry was added in front of the queue or some other entry
+ * either a new entry was added in front of the queue or some other entry
* was canceled. Whatever it is, pick the head entry of the list and
* continue waiting. */
GST_CAT_DEBUG (GST_CAT_CLOCK, "async entry %p needs restart", entry);
/* Add an entry to the list of pending async waits. The entry is inserted
* in sorted order. If we inserted the entry at the head of the list, we
* need to signal the thread as it might either be waiting on it or waiting
- * for a new entry.
+ * for a new entry.
*
* MT safe.
*/
}
/* unschedule an entry. This will set the state of the entry to GST_CLOCK_UNSCHEDULED
- * and will signal any thread waiting for entries to recheck their entry.
+ * and will signal any thread waiting for entries to recheck their entry.
* We cannot really decide if the signal is needed or not because the entry
* could be waited on in async or sync mode.
*
* @list1: first list to merge
* @list2: second list to merge
* @mode: the mode to use
- *
+ *
* Merges the two given lists into a new list. If one of the lists is NULL, a
* copy of the other is returned. If both lists are NULL, NULL is returned.
*
* @tag: tag to set
* @...: more tag / value pairs to set
*
- * Adds the given tag / value pairs on the setter using the given merge mode.
+ * Adds the given tag / value pairs on the setter using the given merge mode.
* The list must be terminated with NULL.
*/
void
* @tag: tag to set
* @...: more tag / GValue pairs to set
*
- * Adds the given tag / GValue pairs on the setter using the given merge mode.
+ * Adds the given tag / GValue pairs on the setter using the given merge mode.
* The list must be terminated with NULL.
*/
void
* @tag: tag to set
* @var_args: tag / value pairs to set
*
- * Adds the given tag / value pairs on the setter using the given merge mode.
+ * Adds the given tag / value pairs on the setter using the given merge mode.
* The list must be terminated with NULL.
*/
void
* @tag: tag to set
* @var_args: tag / GValue pairs to set
*
- * Adds the given tag / GValue pairs on the setter using the given merge mode.
+ * Adds the given tag / GValue pairs on the setter using the given merge mode.
* The list must be terminated with NULL.
*/
void
* gst_tag_setter_get_merge_mode:
* @setter: a #GstTagSetter
*
- * Queries the mode by which tags inside the setter are overwritten by tags
+ * Queries the mode by which tags inside the setter are overwritten by tags
* from events
*
* Returns: the merge mode used inside the element.
/**
* gst_alloc_trace_set_flags:
- * @trace: the GstAllocTrace
- * @flags: flags to set
+ * @trace: the GstAllocTrace
+ * @flags: flags to set
*
* Enable the given features on the given GstAllocTrace object.
*/
#define gst_trace_get_remaining(trace) ((trace)->bufsize - (trace)->bufoffset)
void gst_trace_set_default (GstTrace *trace);
-void _gst_trace_add_entry (GstTrace *trace, guint32 seq,
+void _gst_trace_add_entry (GstTrace *trace, guint32 seq,
guint32 data, gchar *msg);
void gst_trace_read_tsc (gint64 *dst);
#else /* GST_DISABLE_TRACE */
#if defined _GNUC_ && _GNUC_ >= 3
-#pragma GCC poison gst_trace_new
+#pragma GCC poison gst_trace_new
#pragma GCC poison gst_trace_destroy
#pragma GCC poison gst_trace_flush
#pragma GCC poison gst_trace_text_flush
#endif
#define gst_alloc_trace_register(name)
-#define gst_alloc_trace_new(trace, mem)
+#define gst_alloc_trace_new(trace, mem)
#define gst_alloc_trace_free(trace, mem)
#define gst_alloc_trace_available() (FALSE)
#define gst_alloc_trace_list() (NULL)
#define _gst_alloc_trace_register(name) (NULL)
-
-#define gst_alloc_trace_print_all()
+
+#define gst_alloc_trace_print_all()
#define gst_alloc_trace_set_flags_all(flags)
-
+
#define gst_alloc_trace_get(name) (NULL)
#define gst_alloc_trace_print(trace)
#define gst_alloc_trace_set_flags(trace,flags)
* @func: the function to use for typefinding
* @extensions: optional extensions that could belong to this type
* @possible_caps: optionally the caps that could be returned when typefinding succeeds
- * @data: optional user data. This user data must be available until the plugin
+ * @data: optional user data. This user data must be available until the plugin
* is unloaded.
*
- * Registers a new typefind function to be used for typefinding. After
+ * Registers a new typefind function to be used for typefinding. After
* registering this function will be available for typefinding.
* This function is typically called during an element's plugin initialization.
*
* @offset: the offset
* @size: the number of bytes to return
*
- * Returns size bytes of the stream to identify beginning at offset. If offset
+ * Returns size bytes of the stream to identify beginning at offset. If offset
* is a positive number, the offset is relative to the beginning of the stream,
- * if offset is a negative number the offset is relative to the end of the
+ * if offset is a negative number the offset is relative to the end of the
* stream. The returned memory is valid until the typefinding function returns
* and must not be freed.
* If NULL is returned, that data is not available.
* @find: the find object the function was called with
*
* Get the length of the data stream.
- *
+ *
* Returns: the length of the data stream or 0 if it is not available.
*/
guint64
void (* suggest) (gpointer data,
guint probability,
const GstCaps * caps);
-
+
gpointer data;
-
+
/* optional */
guint64 (* get_length) (gpointer data);
/* registration interface */
gboolean gst_type_find_register (GstPlugin * plugin,
- const gchar * name,
+ const gchar * name,
guint rank,
GstTypeFindFunction func,
gchar ** extensions,
const GstCaps * possible_caps,
- gpointer data);
+ gpointer data);
G_END_DECLS
* SECTION:gsttypefindfactory
* @short_description: Information about registered typefind functions
*
- * These functions allow querying informations about registered typefind
+ * These functions allow querying informations about registered typefind
* functions. How to create and register these functions is described in
* the section <link linkend="gstreamer-Writing-typefind-functions">
* "Writing typefind functions"</link>.
* GList *walk, *type_list;
* MyTypeFind find = {data, size, 0, NULL};
* GstTypeFind gst_find = {my_peek, my_suggest, &find, };
- *
+ *
* walk = type_list = gst_type_find_factory_get_list ();
* while (walk) {
* GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (walk->data);
*
* Gets the list of all registered typefind factories. You must free the
* list using g_list_free.
- *
+ *
* Returns: the list of all registered typefind factories
*/
GList *
/**
* gst_type_find_factory_get_caps:
* @factory: a factory
- *
+ *
* Gets the caps associated with a typefind factory.
*
* Returns: the #GstCaps associated with this factory
/**
* gst_type_find_factory_get_extensions:
* @factory: a factory
- *
+ *
* Gets the extensions associated with a typefind factory. The returned
* array should not be changed. If you need to change stuff in it, you should
* copy it using g_stdupv(). This function may return NULL to indicate
* @factory: a factory
* @find: a properly setup #GstTypeFind entry. The get_data and suggest_type
* members must be set.
- *
+ *
* Calls the typefinding function associated with this factory.
*/
void
GstTypeFindFunction function;
gchar ** extensions;
GstCaps * caps; /* FIXME: not yet saved in registry */
-
+
gpointer user_data;
-
+
gpointer _gst_reserved[GST_PADDING];
};
-
+
struct _GstTypeFindFactoryClass {
GstPluginFeatureClass parent;
/* <private> */
-
+
gpointer _gst_reserved[GST_PADDING];
};
/* typefinding interface */
GType gst_type_find_factory_get_type (void);
-
+
GList * gst_type_find_factory_get_list (void);
gchar ** gst_type_find_factory_get_extensions (GstTypeFindFactory *factory);
* escape_string:
* @string: string to be escaped
*
- * Escapes @string, replacing any and all special characters
+ * Escapes @string, replacing any and all special characters
* with equivalent escape sequences.
*
* Return value: a newly allocated string equivalent to @string
* considered "illegal", '\0' is automatically in this list.
*
* Decodes escaped characters (i.e. PERCENTxx sequences) in @escaped_string.
- * Characters are encoded in PERCENTxy form, where xy is the ASCII hex code
+ * Characters are encoded in PERCENTxy form, where xy is the ASCII hex code
* for character 16x+y.
- *
- * Return value: a newly allocated string with the unescaped equivalents,
- * or %NULL if @escaped_string contained one of the characters
+ *
+ * Return value: a newly allocated string with the unescaped equivalents,
+ * or %NULL if @escaped_string contained one of the characters
* in @illegal_characters.
**/
static char *
* @uri: URI to get the location from
*
* Extracts the location out of a given valid URI. So the protocol and "://"
- * are stripped from the URI. The returned string must be freed using
+ * are stripped from the URI. The returned string must be freed using
* g_free().
*
* Returns: The location for this URI.
* @uri: URI to create element for
* @elementname: optional name of created element
*
- * Creates an element for handling the given URI.
- *
+ * Creates an element for handling the given URI.
+ *
* Returns: a new element or NULL if none could be created
*/
GstElement *
* gst_pad_use_fixed_caps:
* @pad: the pad to use
*
- * A helper function you can use that sets the
+ * A helper function you can use that sets the
* @gst_pad_get_fixed_caps_func as the gstcaps function for the
* pad. This way the function will always return the negotiated caps
* or in case the pad is not negotiated, the padtemplate caps.
* @pad: a #GstPad to invoke the convert query on.
* @src_format: a #GstFormat to convert from.
* @src_val: a value to convert.
- * @dest_format: a pointer to the #GstFormat to convert to.
+ * @dest_format: a pointer to the #GstFormat to convert to.
* @dest_val: a pointer to the result.
*
* Queries a pad to convert @src_val in @src_format to @dest_format.
* @type_as_function: the prefix for the functions
* @parent_type: the parent type struct name
* @parent_type_macro: the parent type macro
- * @additional_initializations: function pointer in the form of
+ * @additional_initializations: function pointer in the form of
* void additional_initializations (GType type) that can be used for
* initializing interfaces and the like
*
return d;
}
-/*
+/*
* This function takes a string delimited with double quotes (")
* and unescapes any \xxx octal numbers.
*
return FALSE;
}
-/* creates a new int range based on input values.
+/* creates a new int range based on input values.
*/
static gboolean
gst_value_create_new_range (GValue * dest, int min1, int max1, int min2,
* @subtrahend_type: type of the subtrahend
* @func: function to use
*
- * Registers @func as a function capable of subtracting the values of
+ * Registers @func as a function capable of subtracting the values of
* @subtrahend_type from values of @minuend_type.
*/
void
/* Not using G_TYPE_DATE here on purpose, even if we could
* if GLIB_CHECK_VERSION(2,8,0) was true: we don't want the
* serialised strings to have different type strings depending
- * on what version is used, so FIXME in 0.11 when we
+ * on what version is used, so FIXME in 0.11 when we
* require GLib-2.8 */
gst_type_date = g_boxed_type_register_static ("GstDate",
(GBoxedCopyFunc) gst_date_copy, (GBoxedFreeFunc) g_date_free);
/**
* GstValueCompareFunc:
* @value1: first value for comparission
- * @value2: second value for comparission
+ * @value2: second value for comparission
*
* Used together with gst_value_compare() to compare #GValues.
*
*/
typedef int (* GstValueCompareFunc) (const GValue *value1,
const GValue *value2);
-
+
typedef char * (* GstValueSerializeFunc) (const GValue *value1);
typedef gboolean (* GstValueDeserializeFunc) (GValue *dest,
const char *s);
-
+
typedef int (* GstValueUnionFunc) (GValue *dest,
const GValue *value1,
const GValue *value2);
-
+
typedef int (* GstValueIntersectFunc) (GValue *dest,
const GValue *value1,
const GValue *value2);
-
+
typedef int (* GstValueSubtractFunc) (GValue *dest,
const GValue *minuend,
const GValue *subtrahend);
* Object model:
*
* We build an index to each entry for each id.
- *
+ *
*
* fileindex
* -----------------------------...
- * ! !
- * id1 id2
+ * ! !
+ * id1 id2
* !
* GArray
*
{
switch (entry->type) {
case GST_INDEX_ENTRY_ID:
- g_print ("id %d describes writer %s\n", entry->id,
+ g_print ("id %d describes writer %s\n", entry->id,
GST_INDEX_ID_DESCRIPTION (entry));
break;
case GST_INDEX_ENTRY_FORMAT:
- g_print ("%d: registered format %d for %s\n", entry->id,
+ g_print ("%d: registered format %d for %s\n", entry->id,
GST_INDEX_FORMAT_FORMAT (entry),
GST_INDEX_FORMAT_KEY (entry));
break;
g_print ("%d: %08x ", entry->id, GST_INDEX_ASSOC_FLAGS (entry));
for (i = 0; i < GST_INDEX_NASSOCS (entry); i++) {
- g_print ("%d %lld ", GST_INDEX_ASSOC_FORMAT (entry, i),
+ g_print ("%d %lld ", GST_INDEX_ASSOC_FORMAT (entry, i),
GST_INDEX_ASSOC_VALUE (entry, i));
}
g_print ("\n");
*
* All entries are simply added to a GList first. Then we build
* an index to each entry for each id/format
- *
+ *
*
* memindex
* -----------------------------...
- * ! !
- * id1 id2
+ * ! !
+ * id1 id2
* ------------
* ! !
* format1 format2
* The MemIndexId keeps a MemIndexFormatIndex for each format the
* specific writer wants indexed.
*
- * The MemIndexFormatIndex keeps all the values of the particular
- * format in a GTree, The values of the GTree point back to the entry.
+ * The MemIndexFormatIndex keeps all the values of the particular
+ * format in a GTree, The values of the GTree point back to the entry.
*
* Finding a value for an id/format requires locating the correct GTree,
* then do a lookup in the Tree to get the required value.
data.index = format_index;
data.exact = (method == GST_INDEX_LOOKUP_EXACT);
- /* setup data for low/high checks if we are not looking
+ /* setup data for low/high checks if we are not looking
* for an exact match */
if (!data.exact) {
data.low_diff = G_MININT64;
};
-/*
- * Memory checking. Should probably be done with gsttrace stuff, but that
+/*
+ * Memory checking. Should probably be done with gsttrace stuff, but that
* doesn't really work.
* This is not safe from reentrance issues, but that doesn't matter as long as
* we lock a mutex before parsing anyway.
gst_parse_unescape (gchar *str)
{
gchar *walk;
-
+
g_return_if_fail (str != NULL);
-
+
walk = str;
-
+
while (*walk) {
if (*walk == '\\')
walk++;
* @short_description: object to splice and merge buffers to desired size
* @see_also: #GstBytestream, #GstFilePad
*
- * This class is for elements that receive buffers in an undesired size.
- * While for example raw video contains one image per buffer, the same is not
- * true for a lot of other formats, especially those that come directly from
- * a file. So if you have undefined buffer sizes and require a specific size,
+ * This class is for elements that receive buffers in an undesired size.
+ * While for example raw video contains one image per buffer, the same is not
+ * true for a lot of other formats, especially those that come directly from
+ * a file. So if you have undefined buffer sizes and require a specific size,
* this object is for you.
*
* The theory of operation is like this: All buffers received are put
- * into the adapter using gst_adapter_push() and the data is then read back
+ * into the adapter using gst_adapter_push() and the data is then read back
* in chunks of the desired size using gst_adapter_peek(). After the data is
* processed, it is freed using gst_adapter_flush(). An example function that
* needs to process data in 10 byte chunks could look like this:
* For another example, a simple element inside GStreamer that uses GstAdapter
* is the libvisual element.
*
- * A last thing to note is that while GstAdapter is pretty optimized,
- * merging buffers still might be an operation that requires a memcpy()
- * operation, and this operation is not the fastest. Because of this, some
- * functions like gst_adapter_available_fast() are provided to help speed up
+ * A last thing to note is that while GstAdapter is pretty optimized,
+ * merging buffers still might be an operation that requires a memcpy()
+ * operation, and this operation is not the fastest. Because of this, some
+ * functions like gst_adapter_available_fast() are provided to help speed up
* such cases should you want to.
*/
* @adapter: a #GstAdapter
* @buf: the #GstBuffer to queue into the adapter
*
- * Adds the data from @buf to the data stored inside @adapter and takes
+ * Adds the data from @buf to the data stored inside @adapter and takes
* ownership of the buffer.
*/
void
* gst_adapter_available:
* @adapter: a #GstAdapter
*
- * Gets the maximum amount of bytes available, that is it returns the maximum
- * value that can be supplied to gst_adapter_peek() without that function
+ * Gets the maximum amount of bytes available, that is it returns the maximum
+ * value that can be supplied to gst_adapter_peek() without that function
* returning NULL.
*
* Returns: amount of bytes available in @adapter
}
/* perform synchronisation on a buffer
- *
+ *
* 1) check if we have a clock, if not, do nothing
* 2) calculate the start and end time of the buffer
* 3) create a single shot notification to wait on
* interested in modifying the buffers.
* </para></listitem>
* <listitem><para>
- * Elements which are always in passthrough mode whenever the same caps has
- * been negotiated on both pads can set the class variable
+ * Elements which are always in passthrough mode whenever the same caps has
+ * been negotiated on both pads can set the class variable
* passthrough_on_same_caps to have this behaviour automatically.
* </para></listitem>
* </itemizedlist>
return ret;
}
- /* If the output buffer metadata is modifiable, copy timestamps and
+ /* If the output buffer metadata is modifiable, copy timestamps and
* buffer flags */
if (*buf != input && GST_MINI_OBJECT_REFCOUNT_VALUE (*buf) == 1) {
*outbuf = NULL;
if (want_in_place) {
- /* If want_in_place is TRUE, we may need to prepare a new output buffer
+ /* If want_in_place is TRUE, we may need to prepare a new output buffer
* Sub-classes can implement a prepare_output_buffer function as they
* wish. */
GST_LOG_OBJECT (trans, "doing inplace transform");
* @passthrough: boolean indicating passthrough mode.
*
* Set passthrough mode for this filter by default. This is mostly
- * useful for filters that do not care about negotiation.
- *
- * Always TRUE for filters which don't implement either a transform
+ * useful for filters that do not care about negotiation.
+ *
+ * Always TRUE for filters which don't implement either a transform
* or transform_ip method.
*
* MT safe.
* @in_place: Boolean value indicating that we would like to operate
* on in_place buffers.
*
- * Determines whether a non-writable buffer will be copied before passing
+ * Determines whether a non-writable buffer will be copied before passing
* to the transform_ip function.
* <itemizedlist>
* <listitem>Always TRUE if no transform function is implemented.</listitem>
gboolean passthrough_on_same_caps;
/* Subclasses can override this to do their own allocation of output buffers.
- * Elements that only do analysis can return a subbuffer or even just
+ * Elements that only do analysis can return a subbuffer or even just
* increment the reference to the input buffer (if in passthrough mode)
*/
- GstFlowReturn (*prepare_output_buffer) (GstBaseTransform * trans,
+ GstFlowReturn (*prepare_output_buffer) (GstBaseTransform * trans,
GstBuffer *input, gint size, GstCaps *caps, GstBuffer **buf);
/*< private >*/
gpointer _gst_reserved[GST_PADDING - 2];
};
-void gst_base_transform_set_passthrough (GstBaseTransform *trans,
+void gst_base_transform_set_passthrough (GstBaseTransform *trans,
gboolean passthrough);
gboolean gst_base_transform_is_passthrough (GstBaseTransform *trans);
-void gst_base_transform_set_in_place (GstBaseTransform *trans,
+void gst_base_transform_set_in_place (GstBaseTransform *trans,
gboolean in_place);
gboolean gst_base_transform_is_in_place (GstBaseTransform *trans);
/* GStreamer
* Copyright (C) 2005 Wim Taymans <wim@fluendo.com>
*
- * gstcollectpads.c:
+ * gstcollectpads.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
/**
* SECTION:gstcollectpads
* @short_description: manages a set of pads that operate in collect mode
- * @see_also:
+ * @see_also:
*
* Manages a set of pads that operate in collect mode. This means that control
* is given to the manager of this object when all pads have data.
* When data is queued on all pads, a callback function is called.
* </para></listitem>
* <listitem><para>
- * Data can be dequeued from the pad with the _pop() method.
+ * Data can be dequeued from the pad with the _pop() method.
* One can _peek() at the data with the peek function.
* </para></listitem>
* <listitem><para>
* gst_collectpads_new:
*
* Create a new instance of #GstCollectsPads.
- *
+ *
* Returns: a new #GstCollectPads, or NULL in case of an error.
*
* MT safe.
* This function should be called with @pads LOCK held, such as
* in the callback.
*
- * Returns: The maximum number of bytes queued on all pad. This function
+ * Returns: The maximum number of bytes queued on all pad. This function
* returns 0 if a pad has no queued buffer.
*
* MT safe.
* gst_collectpads_read:
* @pads: the collectspads to query
* @data: the data to use
- * @bytes: a pointer to a byte array
+ * @bytes: a pointer to a byte array
* @size: the number of bytes to read
*
* Get a pointer in @bytes where @size bytes can be read from the
* @data: the data to use
* @size: the number of bytes to flush
*
- * Flush @size bytes from the pad @data.
+ * Flush @size bytes from the pad @data.
*
* This function should be called with @pads LOCK held, such as
* in the callback.
/* GStreamer
* Copyright (C) 2005 Wim Taymans <wim@fluendo.com>
*
- * gstcollectpads.h:
+ * gstcollectpads.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
/* get collected bytes */
guint gst_collectpads_available (GstCollectPads *pads);
-guint gst_collectpads_read (GstCollectPads *pads, GstCollectData *data,
+guint gst_collectpads_read (GstCollectPads *pads, GstCollectData *data,
guint8 **bytes, guint size);
-guint gst_collectpads_flush (GstCollectPads *pads, GstCollectData *data,
+guint gst_collectpads_flush (GstCollectPads *pads, GstCollectData *data,
guint size);
G_END_DECLS
* 2000 Wim Taymans <wtay@chello.be>
* 2005 Wim Taymans <wim@fluendo.com>
*
- * gstpushsrc.h:
+ * gstpushsrc.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000,2005 Wim Taymans <wim@fluendo.com>
*
- * gsttypefindhelper.c:
+ * gsttypefindhelper.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000,2005 Wim Taymans <wim@fluendo.com>
*
- * gsttypefindhelper.h:
+ * gsttypefindhelper.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* @store: a bufferstore
* @buffer: the buffer to add
*
- * Adds a buffer to the buffer store.
+ * Adds a buffer to the buffer store.
*
* Returns: TRUE, if the buffer was added, FALSE if an error occured.
*/
* data is not available inside the store, NULL is returned. You have to unref
* the buffer after use.
*
- * Returns: a buffer with the requested data or NULL if the data was not
+ * Returns: a buffer with the requested data or NULL if the data was not
* available.
*/
GstBuffer *
/* Output buffer preparation... if the buffer has no caps, and
* our allowed output caps is fixed, then give the caps to the
* buffer.
- * This ensures that outgoing buffers have caps if we can, so
+ * This ensures that outgoing buffers have caps if we can, so
* that pipelines like:
- * gst-launch filesrc location=rawsamples.raw !
+ * gst-launch filesrc location=rawsamples.raw !
* audio/x-raw-int,width=16,depth=16,rate=48000,channels=2,
* endianness=4321,signed='(boolean)'true ! alsasink
* will work.
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2005 Wim Taymans <wim@fluendo.com>
*
- * gstfakesink.c:
+ * gstfakesink.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
- * gstfdsink.c:
+ * gstfdsink.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
- * gstfdsink.h:
+ * gstfdsink.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* 2000 Wim Taymans <wtay@chello.be>
* 2005 Philippe Khalaf <burger@speedy.org>
*
- * gstfdsrc.c:
+ * gstfdsrc.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* 2000 Wim Taymans <wtay@chello.be>
* 2005 Philippe Khalaf <burger@speedy.org>
*
- * gstfdsrc.h:
+ * gstfdsrc.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
} else
#endif
{
- /* If not in mmap mode, we need to check if the underlying file is
+ /* If not in mmap mode, we need to check if the underlying file is
* seekable. */
off_t res = lseek (src->fd, 0, SEEK_CUR);
* 2000 Wim Taymans <wtay@chello.be>
* 2005 Wim Taymans <wim@fluendo.com>
*
- * gstidentity.c:
+ * gstidentity.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
- * gstidentity.h:
+ * gstidentity.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Data is queued till max_level buffers have been stored. Any subsequent
* buffers sent to this filter will block until free space becomes available in
* the buffer. The queue is typically used in conjunction with a thread.
- *
+ *
* You can query how many buffers are queued with the level argument.
- *
+ *
* The default queue length is set to 100.
- *
+ *
* The queue blocks by default.
*/
g_thread_self ());
g_cond_wait (queue->item_add, queue->qlock);
- /* we released the lock in the g_cond above so we might be
+ /* we released the lock in the g_cond above so we might be
* flushing now */
if (queue->srcresult != GST_FLOW_OK)
goto out_flushing;
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
- * gstqueue.h:
+ * gstqueue.h:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000,2001,2002,2003,2004,2005 Wim Taymans <wim@fluendo.com>
- *
+ *
*
* gsttee.c: Tee element, one in N out
*
gint pad_counter;
guint64 offset;
GstActivateMode sink_mode;
-
+
gchar *last_message;
};
* 4) if a function returns a value >= ARG_MAXIMUM goto 8
* 5) all functions with a result > ARG_MINIMUM or functions that did not get
* all requested data (where peek returned NULL) stay in list
- * 6) seek to requested offset of best function that still has open data
+ * 6) seek to requested offset of best function that still has open data
* requests
* 7) goto 2
* 8) take best available result and use its caps
* 1) chain based, it will collect buffers and run the typefind function on
* the buffer until something is found.
* 2) getrange based, it will proxy the getrange function to the sinkpad. It
- * is assumed that the peer element is happy with whatever format we
+ * is assumed that the peer element is happy with whatever format we
* eventually read.
*
* When the element has no connected srcpad, and the sinkpad can operate in
- * getrange based mode, the element starts its own task to figure out the
+ * getrange based mode, the element starts its own task to figure out the
* type of the stream.
- *
+ *
*/
#ifdef HAVE_CONFIG_H
GstBuffer * store;
guint64 stream_length;
gboolean stream_length_available;
-
+
GList * possibilities;
};
* Object model:
*
* We build an index to each entry for each id.
- *
+ *
*
* fileindex
* -----------------------------...
- * ! !
- * id1 id2
+ * ! !
+ * id1 id2
* !
* GArray
*
{
switch (entry->type) {
case GST_INDEX_ENTRY_ID:
- g_print ("id %d describes writer %s\n", entry->id,
+ g_print ("id %d describes writer %s\n", entry->id,
GST_INDEX_ID_DESCRIPTION (entry));
break;
case GST_INDEX_ENTRY_FORMAT:
- g_print ("%d: registered format %d for %s\n", entry->id,
+ g_print ("%d: registered format %d for %s\n", entry->id,
GST_INDEX_FORMAT_FORMAT (entry),
GST_INDEX_FORMAT_KEY (entry));
break;
g_print ("%d: %08x ", entry->id, GST_INDEX_ASSOC_FLAGS (entry));
for (i = 0; i < GST_INDEX_NASSOCS (entry); i++) {
- g_print ("%d %lld ", GST_INDEX_ASSOC_FORMAT (entry, i),
+ g_print ("%d %lld ", GST_INDEX_ASSOC_FORMAT (entry, i),
GST_INDEX_ASSOC_VALUE (entry, i));
}
g_print ("\n");
*
* All entries are simply added to a GList first. Then we build
* an index to each entry for each id/format
- *
+ *
*
* memindex
* -----------------------------...
- * ! !
- * id1 id2
+ * ! !
+ * id1 id2
* ------------
* ! !
* format1 format2
* The MemIndexId keeps a MemIndexFormatIndex for each format the
* specific writer wants indexed.
*
- * The MemIndexFormatIndex keeps all the values of the particular
- * format in a GTree, The values of the GTree point back to the entry.
+ * The MemIndexFormatIndex keeps all the values of the particular
+ * format in a GTree, The values of the GTree point back to the entry.
*
* Finding a value for an id/format requires locating the correct GTree,
* then do a lookup in the Tree to get the required value.
data.index = format_index;
data.exact = (method == GST_INDEX_LOOKUP_EXACT);
- /* setup data for low/high checks if we are not looking
+ /* setup data for low/high checks if we are not looking
* for an exact match */
if (!data.exact) {
data.low_diff = G_MININT64;
projects / platform / upstream / gstreamer.git / commitdiff