mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-23 02:01:12 +00:00
Code Issues 1 Projects Releases Wiki Activity

fix doc build for glib2 remove template files from cvs, they are generated with gtkdoc-mktmpl new, cleaner interface ...

Browse source 
Original commit message from CVS:
* fix doc build for glib2
* remove template files from cvs, they are generated with gtkdoc-mktmpl
* new, cleaner interface to the parser facilities
* cleanups in gstparse.c
This commit is contained in:
Andy Wingo 2002-01-14 04:09:56 +00:00
parent dcfb86bb73
commit f38969ff25
64 changed files with 294 additions and 12897 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
configure.ac
View file

@ -271,8 +271,11 @@ else
if $HAVE_GTK_DOC; then
AC_CHECK_PROG(HAVE_GTK_DOC, gtkdoc-scangobj, true, false)
if $HAVE_GTK_DOC; then
GTK_DOC_SCANOBJ=gtkdoc-scangobj
fi;
# don't you love undocumented command line options?
GTK_DOC_SCANOBJ="gtkdoc-scangobj --nogtkinit"
else
GTK_DOC_SCANOBJ=false
fi
fi
dnl FIXME: check for gnome2 - this conditional is currently

4
docs/gst/Makefile.am
View file

@ -48,8 +48,8 @@ extra_files =
# CFLAGS and LDFLAGS for compiling scan program. Only needed if your app/lib
# contains GtkObjects/GObjects and you want to document signals and properties.
GTKDOC_CFLAGS = $(GST_CFLAGS) $(GLIB_CFLAGS) $(XML_CFLAGS)
GTKDOC_LIBS = $(GST_LIBS) $(GLIB_LIBS) $(XML_LIBS) $(SCANOBJ_DEPS)
GTKDOC_CFLAGS = $(GST_CFLAGS)
GTKDOC_LIBS = $(GST_LIBS) $(SCANOBJ_DEPS)
# $(shell echo $(top_builddir)/gst/autoplug/*.la) \
# $(top_builddir)/gst/types/libgsttypes.la \

53
docs/gst/gstreamer.hierarchy
View file

@ -1,53 +0,0 @@
GtkObject
GtkWidget
GtkRange
GtkScrollbar
GtkVScrollbar
GtkHScrollbar
GtkScale
GtkHScale
GtkVScale
GtkContainer
GtkBin
GtkScrolledWindow
GtkButton
GtkToggleButton
GtkCheckButton
GtkRadioButton
GtkPaned
GtkVPaned
GtkHPaned
GtkBox
GtkHBox
GtkCombo
GtkCList
GtkEditable
GtkEntry
GtkSpinButton
GtkData
GtkAdjustment
GObject
GstObject
GstXml
GstElement
GstBin
GstPipeline
GstThread
GstTee
GstAggregator
GstFakeSrc
GstFakeSink
GstFileSrc
GstFdSrc
GstFdSink
GstPipefilter
GstIdentity
GstQueue
GstStatistics
GstTypeFind
GstPad
GstPluginFeature
GstAutoplugFactory
GstTypeFactory
GstElementFactory
GstSchedulerFactory

1
docs/gst/gstreamer.types.in
View file

@ -1,4 +1,3 @@
#include <gtk/gtk.h>
#include <gst/gst.h>
gst_object_get_type

208
docs/gst/tmpl/cothreads.sgml
View file

@ -1,208 +0,0 @@
<!-- ##### SECTION Title ##### -->
cothreads
<!-- ##### SECTION Short_Description ##### -->
userspace threads
<!-- ##### SECTION Long_Description ##### -->
<para>
Cothreads are a simple user-space method for switching between
subtasks. They're based on setjmp()/longjmp() in their current form.
</para>
<para>
Cothreads are used for loop-based elements that pull data instead
of being fed with data. They can also be used to pull a specific region
of data out of their src element.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### MACRO CURRENT_STACK_FRAME ##### -->
<para>
Get the current stack frame.
</para>
<!-- ##### STRUCT cothread_state ##### -->
<para>
</para>
@ctx:
@threadnum:
@func:
@argc:
@argv:
@flags:
@sp:
@jmp:
@top_sp:
@pc:
<!-- ##### STRUCT cothread_context ##### -->
<para>
</para>
<!-- ##### USER_FUNCTION cothread_func ##### -->
<para>
the function that will be called when the cothread starts. The function
prototype is like a main() function, so you can do whatever you want with
it.
</para>
@argc: a main-like argument count
@argv: a main-like array of arguments
@Returns: a return code
<!-- ##### MACRO COTHREAD_STARTED ##### -->
<para>
Indicates the cothread is started.
</para>
<!-- ##### MACRO COTHREAD_DESTROYED ##### -->
<para>
Indicates the cothread is destroyed.
</para>
<!-- ##### FUNCTION cothread_context_init ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION cothread_context_free ##### -->
<para>
</para>
@ctx:
<!-- ##### FUNCTION cothread_create ##### -->
<para>
</para>
@ctx:
@Returns:
<!-- ##### FUNCTION cothread_free ##### -->
<para>
</para>
@thread:
<!-- ##### FUNCTION cothread_setfunc ##### -->
<para>
</para>
@thread:
@func:
@argc:
@argv:
<!-- ##### FUNCTION cothread_stop ##### -->
<para>
</para>
@thread:
<!-- ##### FUNCTION cothread_switch ##### -->
<para>
</para>
@thread:
<!-- ##### FUNCTION cothread_set_data ##### -->
<para>
</para>
@thread:
@key:
@data:
<!-- ##### FUNCTION cothread_get_data ##### -->
<para>
</para>
@thread:
@key:
@Returns:
<!-- ##### FUNCTION cothread_lock ##### -->
<para>
</para>
@thread:
<!-- ##### FUNCTION cothread_trylock ##### -->
<para>
</para>
@thread:
@Returns:
<!-- ##### FUNCTION cothread_unlock ##### -->
<para>
</para>
@thread:
<!-- ##### FUNCTION cothread_main ##### -->
<para>
</para>
@ctx:
@Returns:
<!-- ##### FUNCTION cothread_current_main ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION cothread_current ##### -->
<para>
</para>
@Returns:

16
docs/gst/tmpl/gobject2gtk.sgml
View file

@ -1,16 +0,0 @@
<!-- ##### SECTION Title ##### -->
GObject
<!-- ##### SECTION Short_Description ##### -->
<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>

109
docs/gst/tmpl/gst.sgml
View file

@ -1,109 +0,0 @@
<!-- ##### SECTION Title ##### -->
Gstreamer
<!-- ##### SECTION Short_Description ##### -->
Media library supporting arbitrary formats and filter graphs.
<!-- ##### SECTION Long_Description ##### -->
<para>
GStreamer is a framework for constructing graphs of various filters
(termed elements here) that will handle streaming media. Any discreet
(packetizable) media type is supported, with provisions for automatically
determining source type. Metadata can be passed with all data to provide
formatting/framing information. 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).
</para>
<para>
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 (I've redesigned the
metadata handling twice already), and thus can be changed to increase the
sanity/noise ratio.
</para>
<para>
The <application>GStreamer</application> library should be initialized with gst_init() before
it can be used. You should pass a pointer to the main argc and argv variables so that GStreamer can
process its own command line options, as shown in the following example.
<programlisting>
int
main (int argc, char *argv[])
{
// initialize the GStreamer library
gst_init (&amp;argc, &amp;argv);
...
}
</programlisting>
</para>
<para>
Use gst_version() to query the library version at runtime or use the GST_VERSION_* macros
to find the version at compile time.
</para>
<para>
gst_main() and gst_main_quit() enter and exit the main loop.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
Check out both <ulink url="http://www.cse.ogi.edu/sysl/">OGI's
pipeline</ulink> and Microsoft's DirectShow for some background.
</para>
<!-- ##### FUNCTION gst_init ##### -->
<para>
</para>
@argc:
@argv:
<!-- ##### FUNCTION gst_version ##### -->
<para>
</para>
@major:
@minor:
@micro:
<!-- ##### FUNCTION gst_main ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_main_quit ##### -->
<para>
</para>
<!-- ##### MACRO GST_VERSION_MAJOR ##### -->
<para>
The major version of GStreamer at compile time
</para>
<!-- ##### MACRO GST_VERSION_MINOR ##### -->
<para>
The minor version of GStreamer at compile time
</para>
<!-- ##### MACRO GST_VERSION_MICRO ##### -->
<para>
The micro version of GStreamer at compile time
</para>

42
docs/gst/tmpl/gstaggregator.sgml
View file

@ -1,42 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstAggregator
<!-- ##### SECTION Short_Description ##### -->
Combine buffers.
<!-- ##### SECTION Long_Description ##### -->
<para>
The aggregator is mainly used for testing purposes. It has several
methods to request buffers from its pads.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ENUM GstAggregatorSchedType ##### -->
<para>
</para>
@AGGREGATOR_LOOP:
@AGGREGATOR_LOOP_PEEK:
@AGGREGATOR_LOOP_SELECT:
@AGGREGATOR_CHAIN:
<!-- ##### ARG GstAggregator:num-pads ##### -->
<para>
</para>
<!-- ##### ARG GstAggregator:silent ##### -->
<para>
</para>
<!-- ##### ARG GstAggregator:sched ##### -->
<para>
</para>

51
docs/gst/tmpl/gstarch.sgml
View file

@ -1,51 +0,0 @@
<!-- ##### SECTION Title ##### -->
gstarch
<!-- ##### SECTION Short_Description ##### -->
Architecural specific macros and functions.
<!-- ##### SECTION Long_Description ##### -->
<para>
This file contains various macros and function for performing common
GStreamer tasks that requires some knowledge of the underlaying architecture.
Porting to other CPU architectures will typically require adding appropriate
implementations in this file.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### MACRO GST_ARCH_CALL ##### -->
<para>
Jumps to a specific location in memory.
</para>
@target: the memory to jump to.
<!-- ##### MACRO GST_ARCH_SET_SP ##### -->
<para>
Sets the stackpointer.
</para>
@stackpointer: the stackpointer to set.
<!-- ##### MACRO GST_ARCH_SETUP_STACK ##### -->
<para>
Make toom on the stack?
</para>
@sp: the stackpointer to modify.
<!-- ##### MACRO GST_ARCH_PRESETJMP ##### -->
<para>
Do something funny, which is required on some archs..
</para>

144
docs/gst/tmpl/gstautoplug.sgml
View file

@ -1,144 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstAutoplug
<!-- ##### SECTION Short_Description ##### -->
Automatically create and connect elements
<!-- ##### SECTION Long_Description ##### -->
<para>
GstAutoplug is an abstract class that is used for constructing and
connecting elements. Two types of autopluggers exist: renderer ones and non
renderer ones. the renderer autopluggers will not have any src pads while the
non renderer ones do.
</para>
<para>
You first need to create a suitable autoplugger with gst_autoplugfactory_make()
(see #GstAutoplugFactory).
The name of the autoplugger must be one of the registered autopluggers
(see #GstStaticAutoplug and #GstStaticAutoplugRender).
</para>
<para>
If the autoplugger supports the RENDERER API, use gst_autoplug_to_renderers() call to
create a bin that connectes the src caps to the specified rendrer elements. You can
then add the bin to a pipeline and run it.
<programlisting>
GstAutoplug *autoplug;
GstElement *element;
GstElement *sink;
/* create a static autoplugger */
autoplug = gst_autoplugfactory_make ("staticrender");
/* create an osssink */
sink = gst_elementfactory_make ("osssink", "our_sink");
/* create an element that can play audio/mp3 through osssink */
element = gst_autoplug_to_renderers (autoplug,
gst_caps_new (
"sink_audio_caps",
"audio/mp3",
NULL
),
sink,
NULL);
/* add the element to a bin and connect the sink pad */
...
</programlisting>
</para>
<para>
If the autoplugger supports the CAPS API, use gst_autoplug_to_caps() call to
connect the src caps to the destination caps. The created bin will have src pads
compatible with the provided sink caps.
<programlisting>
GstAutoplug *autoplug;
GstElement *element;
/* create a static autoplugger */
autoplug = gst_autoplugfactory_make ("static");
/* create an element that converts audio/mp3 to audio/raw */
element = gst_autoplug_to_caps (autoplug,
gst_caps_new (
"sink_audio_caps",
"audio/mp3",
NULL
),
gst_caps_new (
"src_audio_caps",
"audio/raw",
NULL
),
NULL);
/* add the element to a bin and connect the src/sink pads */
...
</programlisting>
</para>
<para>
Optionally you can get a notification when a new object is added to the created
pipeline with a g_signal_connect to the "new_object" signal.
</para>
<para>
Use the regular gst_object_destroy() call to destroy the autoplugger.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstStaticAutoplug, #GstStaticAutoplugRender
</para>
<!-- ##### STRUCT GstAutoplug ##### -->
<para>
</para>
@object:
<!-- ##### ENUM GstAutoplugFlags ##### -->
<para>
The type of the autoplugger.
</para>
@GST_AUTOPLUG_TO_CAPS:
@GST_AUTOPLUG_TO_RENDERER:
@GST_AUTOPLUG_FLAG_LAST:
<!-- ##### FUNCTION gst_autoplug_signal_new_object ##### -->
<para>
</para>
@autoplug:
@object:
<!-- ##### FUNCTION gst_autoplug_to_caps ##### -->
<para>
</para>
@autoplug:
@srccaps:
@sinkcaps:
@Varargs:
@Returns:
<!-- ##### FUNCTION gst_autoplug_to_renderers ##### -->
<para>
</para>
@autoplug:
@srccaps:
@target:
@Varargs:
@Returns:

93
docs/gst/tmpl/gstautoplugfactory.sgml
View file

@ -1,93 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstAutoplugFactory
<!-- ##### SECTION Short_Description ##### -->
Create autopluggers from a factory.
<!-- ##### SECTION Long_Description ##### -->
<para>
An autoplugfactory is used to create instances of an autoplugger. It
can be added to a #GstPlugin as it extends #GstPluginFeature.
</para>
<para>
Use gst_autoplugfactory_new() to create a new autoplugger which can be registered
to a plugin with gst_plugin_add_feature().
</para>
<para>
Use gst_autoplugfactory_find() to find the named autoplugfactory.
or use gst_autoplugfactory_get_list() to get a list of all available autopluggers.
</para>
<para>
Once an autoplugfactory has been obtained use gst_autoplugfactory_create() to
instantiate a real autoplugger. Optionally gst_autoplugfactory_make() to create
a autoplugger from the named factory.
</para>
<para>
Use gst_autoplugfactory_destroy() to remove the factory from the global list.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstAutoplug, #GstPlugin, #GstPluginFeature.
</para>
<!-- ##### STRUCT GstAutoplugFactory ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_autoplugfactory_new ##### -->
<para>
</para>
@name:
@longdesc:
@type:
@Returns:
<!-- ##### FUNCTION gst_autoplugfactory_destroy ##### -->
<para>
</para>
@factory:
<!-- ##### FUNCTION gst_autoplugfactory_find ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_autoplugfactory_get_list ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_autoplugfactory_create ##### -->
<para>
</para>
@factory:
@Returns:
<!-- ##### FUNCTION gst_autoplugfactory_make ##### -->
<para>
</para>
@name:
@Returns:

176
docs/gst/tmpl/gstbin.sgml
View file

@ -1,176 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstBin
<!-- ##### SECTION Short_Description ##### -->
Base container element
<!-- ##### SECTION Long_Description ##### -->
<para>
GstBin is the simplest of the container elements, allowing elements to
become children of itself. Pads from the child elements can be ghosted to
the bin, making the bin itself look transparently like any other element,
allowing for deep nesting of predefined sub-pipelines.
</para>
<para>
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 scheduler of its
own.
</para>
<para>
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().
</para>
<para>
An element can be retrieved from a bin with gst_bin_get_by_name(), using the
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.
</para>
<para>
The list of elements in a bin can be retrieved with gst_bin_get_list().
</para>
<para>
After the bin has been set to the PLAYING state (with gst_element_set_state()),
gst_bin_iterate() is used to process the elements in the bin.
</para>
<para>
The "object_added" signal is fired whenever a new object is added to the bin.
</para>
<para>
gst_bin_destroy() is used to destroy the bin.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ENUM GstBinFlags ##### -->
<para>
Flags for a bin.
</para>
@GST_BIN_FLAG_MANAGER:
@GST_BIN_SELF_SCHEDULABLE:
@GST_BIN_FLAG_PREFER_COTHREADS:
@GST_BIN_FLAG_LAST:
<!-- ##### STRUCT GstBin ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_bin_new ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### MACRO gst_bin_destroy ##### -->
<para>
Free the memory allocated by this bin
</para>
@bin: the bin to free
<!-- ##### FUNCTION gst_bin_add ##### -->
<para>
</para>
@bin:
@element:
<!-- ##### FUNCTION gst_bin_remove ##### -->
<para>
</para>
@bin:
@element:
<!-- ##### FUNCTION gst_bin_get_by_name ##### -->
<para>
</para>
@bin:
@name:
@Returns:
<!-- ##### FUNCTION gst_bin_get_by_name_recurse_up ##### -->
<para>
</para>
@bin:
@name:
@Returns:
<!-- ##### FUNCTION gst_bin_get_list ##### -->
<para>
</para>
@bin:
@Returns:
<!-- ##### FUNCTION gst_bin_set_state_type ##### -->
<para>
</para>
@bin:
@state:
@type:
@Returns:
<!-- ##### FUNCTION gst_bin_iterate ##### -->
<para>
</para>
@bin:
@Returns:
<!-- ##### FUNCTION gst_bin_child_state_change ##### -->
<para>
</para>
@bin:
@oldstate:
@newstate:
@child:
<!-- ##### FUNCTION gst_bin_child_error ##### -->
<para>
</para>
@bin:
@child:
<!-- ##### SIGNAL GstBin::object-added ##### -->
<para>
is signaled whenever a new <classname>GstElement</classname> is added to the <classname>GstBin</classname>
</para>
@gstbin: the object which received the signal.
@arg1: the element that was added

401
docs/gst/tmpl/gstbuffer.sgml
View file

@ -1,401 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstBuffer
<!-- ##### SECTION Short_Description ##### -->
Data-passing buffer type, supporting sub-buffers and metadata
<!-- ##### SECTION Long_Description ##### -->
<para>
Buffers are the basic unit of data transfer in GST. The GstBuffer type
provides all the state necessary to define a region of memory as part of a
stream. Sub-buffer 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. Metadata is supported as a list of
pointers to arbitrary metadata.
</para>
<para>
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.
<programlisting>
GstBuffer *buffer;
gint size, widht, height, bpp;
size = width * height * bpp;
buffer = gst_buffer_new ();
GST_BUFFER_SIZE (buffer) = size;
GST_BUFFER_DATA (buffer) = g_alloc (size);
...
</programlisting>
</para>
<para>
GstBuffers can also be created from a GstBufferPool with
gst_buffer_new_from_pool(). The bufferpool can be obtained from a
peer element with gst_pad_get_bufferpool().
</para>
<para>
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.
</para>
<para>
To efficiently create a smaller buffer out of an existing one, you can
use gst_buffer_create_sub().
</para>
<para>
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 flag is set.
</para>
<para>
Buffers usually are freed by unreffing them with gst_buffer_unref().
gst_buffer_destroy() can also be used to effectively destroy the buffer
regardless of the refcount (dangerous).
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstBufferPool, #GstPad, #GstData
</para>
<!-- ##### MACRO GST_IS_BUFFER ##### -->
<para>
Check if the object is a buffer.
</para>
@buf: The object to check
<!-- ##### MACRO GST_BUFFER ##### -->
<para>
Cast an object to a GstBuffer
</para>
@buf: The object to cast.
<!-- ##### MACRO GST_BUFFER_FLAGS ##### -->
<para>
Get the flags from this buffer.
</para>
@buf: GstBuffer to retrieve the flags from
<!-- ##### MACRO GST_BUFFER_FLAG_IS_SET ##### -->
<para>
Gives the status of a given flag.
</para>
@buf: GstBuffer to query
@flag: the flag to check
<!-- ##### MACRO GST_BUFFER_FLAG_SET ##### -->
<para>
Set a flag in a buffer.
</para>
@buf: GstBuffer to query
@flag: the flag to set
<!-- ##### MACRO GST_BUFFER_FLAG_UNSET ##### -->
<para>
Clear a flag in a buffer.
</para>
@buf: GstBuffer to modify
@flag: the flag to clear
<!-- ##### MACRO GST_BUFFER_DATA ##### -->
<para>
Retrieves a pointer to the data element of this buffer
</para>
@buf: GstBuffer
<!-- ##### MACRO GST_BUFFER_SIZE ##### -->
<para>
Get the size of the data in this buffer.
</para>
@buf: GstBuffer
<!-- ##### MACRO GST_BUFFER_OFFSET ##### -->
<para>
Get the offset in the source file of this buffer.
</para>
@buf: GstBuffer
<!-- ##### MACRO GST_BUFFER_MAXSIZE ##### -->
<para>
Gets the maximun size of this buffer.
</para>
@buf: GstBuffer
<!-- ##### MACRO GST_BUFFER_TIMESTAMP ##### -->
<para>
Get the timestamp for this buffer.
</para>
@buf: GstBuffer
<!-- ##### MACRO GST_BUFFER_BUFFERPOOL ##### -->
<para>
Get the bufferpool for this buffer.
</para>
@buf: GstBuffer
<!-- ##### MACRO GST_BUFFER_POOL_PRIVATE ##### -->
<para>
Get the bufferpool private data.
</para>
@buf: GstBuffer
<!-- ##### MACRO GST_BUFFER_LOCK ##### -->
<para>
This macro will obtain a lock on the object, making serialization
possible.
</para>
@buf: GstBuffer to lock
<!-- ##### MACRO GST_BUFFER_TRYLOCK ##### -->
<para>
This macro will try to obtain a lock on the object, but will return with
FALSE if it can't get it immediately.
</para>
@buf: GstBuffer to try to lock
<!-- ##### MACRO GST_BUFFER_UNLOCK ##### -->
<para>
This macro releases a lock on the object.
</para>
@buf: GstBuffer to unlock.
<!-- ##### MACRO GST_BUFFER_PARENT ##### -->
<para>
Get the parent of this buffer. The parent is set on subbuffers.
</para>
@buf: GstBuffer to get the parent of.
<!-- ##### MACRO GST_BUFFER_MAXAGE ##### -->
<para>
Get the maximun age of a buffer.
</para>
@buf: GstBuffer to get the maxage of.
<!-- ##### MACRO GST_BUFFER_COPY_FUNC ##### -->
<para>
Call the buffer specific copy function on the given buffer.
</para>
@buf: the buffer to copy.
<!-- ##### MACRO GST_BUFFER_FREE_FUNC ##### -->
<para>
Call the buffer specific free function on the given buffer.
</para>
@buf: the buffer to free.
<!-- ##### USER_FUNCTION GstBufferCopyFunc ##### -->
<para>
This function is used to copy the buffer contents.
</para>
@srcbuf: the src buffer
@Returns: The copied buffer
<!-- ##### USER_FUNCTION GstBufferFreeFunc ##### -->
<para>
The function called when the buffer data has to be freed
</para>
@buf: the buffer to clear the buffer data of.
<!-- ##### ENUM GstBufferFlags ##### -->
<para>
</para>
@GST_BUFFER_READONLY: the buffer is read only
@GST_BUFFER_ORIGINAL: this buffer not a copy
@GST_BUFFER_DONTFREE: do not try to free the data when this buffer is unref-ed
<!-- ##### STRUCT GstBuffer ##### -->
<para>
</para>
@data_type:
@lock:
@data:
@size:
@maxsize:
@offset:
@timestamp:
@maxage:
@parent:
@pool:
@pool_private:
@free:
@copy:
<!-- ##### FUNCTION gst_buffer_new ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_buffer_new_from_pool ##### -->
<para>
</para>
@pool:
@offset:
@size:
@Returns:
<!-- # Unused Parameters # -->
@location:
<!-- ##### FUNCTION gst_buffer_copy ##### -->
<para>
</para>
@buffer:
@Returns:
<!-- ##### FUNCTION gst_buffer_create_sub ##### -->
<para>
</para>
@parent:
@offset:
@size:
@Returns:
<!-- ##### FUNCTION gst_buffer_append ##### -->
<para>
</para>
@buffer:
@append:
@Returns:
<!-- # Unused Parameters # -->
@buf:
@buf2:
<!-- ##### FUNCTION gst_buffer_ref ##### -->
<para>
</para>
@buffer:
<!-- ##### FUNCTION gst_buffer_ref_by_count ##### -->
<para>
</para>
@buffer:
@count:
<!-- ##### FUNCTION gst_buffer_unref ##### -->
<para>
</para>
@buffer:
<!-- ##### FUNCTION gst_buffer_destroy ##### -->
<para>
</para>
@buffer:
<!-- ##### FUNCTION gst_buffer_is_span_fast ##### -->
<para>
</para>
@buf1:
@buf2:
@Returns:
<!-- ##### FUNCTION gst_buffer_merge ##### -->
<para>
</para>
@buf1:
@buf2:
@Returns:
<!-- ##### FUNCTION gst_buffer_span ##### -->
<para>
</para>
@buf1:
@offset:
@buf2:
@len:
@Returns:
<!-- ##### FUNCTION gst_buffer_print_stats ##### -->
<para>
</para>

226
docs/gst/tmpl/gstbufferpool.sgml
View file

@ -1,226 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstBufferPool
<!-- ##### SECTION Short_Description ##### -->
Create buffers from a pool
<!-- ##### SECTION Long_Description ##### -->
<para>
A bufferpool is used to create buffers in an efficient way. En element
can maintain a bufferpool with a fixed number of buffers. This will reduce
the g_malloc and g_free overhead.
</para>
<para>
A bufferpool can also be used to implement direct access. A bufferpool can be
sent from one element to another so that the latter can directly write into
the memory of the element that maintains the bufferpool. This can greatly reduce
the number of memcpy operations.
</para>
<para>
A bufferpool is created with gst_buffer_pool_new(). You'll have to set the
buffer new and free function afterwards with gst_buffer_pool_set_buffer_new_function() and
gst_buffer_pool_set_buffer_free_function() so that all buffers created
from this pool will be allocated/freed with these functions.
</para>
<para>
Optionally the default buffer copy function of the buffers allocated from this pool
can be overridden with gst_buffer_pool_set_buffer_copy_function().
</para>
<para>
To create a buffer from the bufferpool use gst_buffer_new_from_pool().
</para>
<para>
When the buffer is unreffed and has reached a refcount of 0, the bufferpools free
function is called with the buffer as an argument.
</para>
<para>
A bufferpool can store private data in the buffer it creates with the GST_BUFFER_POOL_PRIVATE()
macro. To check it a buffer was made by a specific bufferpool, use the GST_BUFFER_BUFFERPOOL()
macro to get its bufferpool.
</para>
<para>
Destroy the bufferpool with gst_buffer_pool_destroy(), optional cleanup of the bufferpool can
be triggered in the GstBufferPoolDestroyHook which you can install with
gst_buffer_pool_set_destroy_hook().
</para>
<para>
The owner of the bufferpool can add user data to the pool with
gst_buffer_pool_set_user_data() and gst_buffer_pool_get_user_data().
</para>
<para>
If your plugin is going to need a lot of equally sized memory areas you can use
gst_buffer_pool_get_default() to request a pool that will create buffers of that size.
These bufferpools will be shared with all plugins needing the same size of buffers so it's
quite efficient since it reduces the number of memory allocations.
</para>
<para>
A bufferpool can be requested from a pad with the gst_pad_get_bufferpool() function. This function
is typically used when a plugin wants to write into a memory area provided by another plugin.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstBuffer, #GstPad
</para>
<!-- ##### STRUCT GstBufferPool ##### -->
<para>
</para>
@lock:
@buffer_free:
@buffer_copy:
@destroy_hook:
@user_data:
<!-- ##### USER_FUNCTION GstBufferPoolBufferNewFunction ##### -->
<para>
The function will be called when a buffer must be allocated from the pool.
</para>
@pool: The pool allocating the buffer
@location: the location (offset) of the buffer to allocate
@size: The size of the allocated buffer
@user_data: user data as set on the bufferpool
@Returns: A new buffer with the given parameters.
<!-- ##### USER_FUNCTION GstBufferPoolDestroyHook ##### -->
<para>
Will be called when the bufferpool is destroyed so that the owner of the pool
can perform necessary cleanup.
</para>
@pool: The pool that is being destroyed
@user_data: user data as set on th bufferpool
<!-- ##### MACRO GST_BUFFER_POOL_UNLOCK ##### -->
<para>
Lock the given bufferpool.
</para>
@pool: The pool to lock.
<!-- ##### MACRO GST_BUFFER_POOL_LOCK ##### -->
<para>
Unlock the given bufferpool.
</para>
@pool: the bufferpool to unlock.
<!-- ##### FUNCTION gst_buffer_pool_new ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_buffer_pool_ref ##### -->
<para>
</para>
@pool:
<!-- ##### FUNCTION gst_buffer_pool_ref_by_count ##### -->
<para>
</para>
@pool:
@count:
<!-- ##### FUNCTION gst_buffer_pool_unref ##### -->
<para>
</para>
@pool:
<!-- # Unused Parameters # -->
@buffer:
<!-- ##### FUNCTION gst_buffer_pool_destroy ##### -->
<para>
</para>
@pool:
<!-- ##### FUNCTION gst_buffer_pool_get_default ##### -->
<para>
</para>
@buffer_size:
@pool_size:
@Returns:
<!-- # Unused Parameters # -->
@oldpool:
<!-- ##### FUNCTION gst_buffer_pool_set_user_data ##### -->
<para>
</para>
@pool:
@user_data:
<!-- ##### FUNCTION gst_buffer_pool_get_user_data ##### -->
<para>
</para>
@pool:
@Returns:
<!-- # Unused Parameters # -->
@user_data:
<!-- ##### FUNCTION gst_buffer_pool_set_buffer_copy_function ##### -->
<para>
</para>
@pool:
@copy:
<!-- ##### FUNCTION gst_buffer_pool_set_buffer_free_function ##### -->
<para>
</para>
@pool:
@destroy:
<!-- ##### FUNCTION gst_buffer_pool_set_buffer_new_function ##### -->
<para>
</para>
@pool:
@create:
<!-- ##### FUNCTION gst_buffer_pool_set_destroy_hook ##### -->
<para>
</para>
@pool:
@destroy:

424
docs/gst/tmpl/gstcaps.sgml
View file

@ -1,424 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstCaps
<!-- ##### SECTION Short_Description ##### -->
Capabilities of pads
<!-- ##### SECTION Long_Description ##### -->
<para>
GstCaps is used to attach capabilities to a pad. Capabilities are made of
a mime-type and a set of properties. GstCaps can be named and chained into
a list, which is then a GstCaps on its own.
</para>
<para>
GstCaps are created with gst_caps_new(), which takes a name, a mime type and
a pointer to a #GstProps. A convenience macro with a cleaner syntax is
available to create a caps with GST_CAPS_NEW(). The following example shows how
to create a GstCaps.
<programlisting>
GstCaps *caps;
caps = gst_caps_new (
"my_caps", /* capability name */
"audio/raw", /* mime type */
gst_props_new ( /* properties */
"format", GST_PROPS_STRING ("float"),
"layout", GST_PROPS_INT (5),
NULL));
</programlisting>
The following code example is equivalent to the above example:
<programlisting>
GstCaps *caps;
caps = GST_CAPS_NEW (
"my_caps", /* capability name */
"audio/raw", /* mime type */
"format", GST_PROPS_STRING ("float"),
"channels", GST_PROPS_INT (5)
);
</programlisting>
</para>
<para>
GstCaps are refcounted with gst_caps_ref() and gst_caps_unref().
</para>
<para>
GstCaps can be chained with the gst_caps_append(), gst_caps_prepend() and
gst_caps_chain() functions. Use gst_caps_get_by_name() to get a named caps
structure from a chained list.
</para>
<para>
To get the properties of a caps structure the functions
gst_caps_get_boolean(), gst_caps_get_fourcc_int(), gst_caps_get_int(),
gst_caps_get_string(), gst_caps_get_float(), which all take a property name as an argument.
</para>
<para>
The properties of the caps structure can be modified with gst_caps_set, which
takes a list of key value pairs in the #GstProps syntax as shown by this example:
<programlisting>
GstCaps *caps;
....
gst_caps_set (caps, "format", GST_PROPS_STRING ("int"), NULL);
gst_caps_set (caps, "channels", GST_PROPS_INT (20), NULL);
</programlisting>
</para>
<para>
before modifying a GstCaps, it is a good idea to make a copy if it first with
gst_caps_copy_on_write(). This will copy the GstCaps if the refcount is &gt;1.
</para>
<para>
If you need a unique instance of a GstCaps you can use the convenient
GST_CAPS_FACTORY() macro as shown below.
<programlisting>
GST_CAPS_FACTORY (my_caps,
GST_CAPS_NEW (
"caps1",
"audio/raw",
"format", GST_PROPS_STRING ("float"),
"channels", GST_PROPS_INT (5)
),
GST_CAPS_NEW (
"caps2",
"audio/raw",
"format", GST_PROPS_STRING ("int"),
"channels", GST_PROPS_INT (5)
)
)
void
some_function (void)
{
GstCaps *caps = GST_CAPS_GET (my_caps);
...
}
</programlisting>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstProps, #GstPad
</para>
<!-- ##### MACRO GST_CAPS_LOCK ##### -->
<para>
Lock the caps structure
</para>
@caps: The caps structure to lock
<!-- ##### MACRO GST_CAPS_TRYLOCK ##### -->
<para>
Try to lock the caps structure
</para>
@caps: The caps structure to try to lock
<!-- ##### MACRO GST_CAPS_UNLOCK ##### -->
<para>
Unlock the caps structure
</para>
@caps: The caps structure to unlock
<!-- ##### MACRO GST_CAPS_NEW ##### -->
<para>
A convenience macro to create a new GstCaps structure.
</para>
@name: the name of the caps structure
@type: the mime type of the caps structure
@a...: the properties of this caps stucture.
<!-- ##### MACRO GST_CAPS_FACTORY ##### -->
<para>
A convenience macro to create a GstCaps factory.
</para>
@factoryname: the name of the factory
@a...: the caps to create with this factory, usualy specified
with GST_CAPS_NEW()
<!-- ##### MACRO GST_CAPS_GET ##### -->
<para>
A convenience macro to get a GstCaps from the given capsfactory.
</para>
@fact: the factory to use.
<!-- ##### STRUCT GstCaps ##### -->
<para>
</para>
@name: the name of the capability, for the application
@id: the typeid of the capability
@refcount: a refcounter for this caps structure
@lock: the lock for this caps structure
@properties: the properties of the capability
@next: a pointer to the next caps.
<!-- ##### FUNCTION gst_caps_new ##### -->
<para>
</para>
@name:
@mime:
@props:
@Returns:
<!-- ##### FUNCTION gst_caps_destroy ##### -->
<para>
</para>
@caps:
<!-- ##### FUNCTION gst_caps_ref ##### -->
<para>
</para>
@caps:
@Returns:
<!-- ##### FUNCTION gst_caps_unref ##### -->
<para>
</para>
@caps:
@Returns:
<!-- ##### FUNCTION gst_caps_copy ##### -->
<para>
</para>
@caps:
@Returns:
<!-- ##### FUNCTION gst_caps_copy_on_write ##### -->
<para>
</para>
@caps:
@Returns:
<!-- ##### FUNCTION gst_caps_chain ##### -->
<para>
</para>
@caps:
@Varargs:
@Returns:
<!-- ##### FUNCTION gst_caps_append ##### -->
<para>
</para>
@caps:
@capstoadd:
@Returns:
<!-- ##### FUNCTION gst_caps_prepend ##### -->
<para>
</para>
@caps:
@capstoadd:
@Returns:
<!-- ##### FUNCTION gst_caps_set_name ##### -->
<para>
</para>
@caps:
@name:
<!-- ##### FUNCTION gst_caps_get_name ##### -->
<para>
</para>
@caps:
@Returns:
<!-- ##### FUNCTION gst_caps_set_type_id ##### -->
<para>
</para>
@caps:
@type_id:
<!-- # Unused Parameters # -->
@Param2:
@typeid:
<!-- ##### FUNCTION gst_caps_get_type_id ##### -->
<para>
</para>
@caps:
@Returns:
<!-- ##### FUNCTION gst_caps_set_mime ##### -->
<para>
</para>
@caps:
@mime:
<!-- ##### FUNCTION gst_caps_get_mime ##### -->
<para>
</para>
@caps:
@Returns:
<!-- ##### FUNCTION gst_caps_set_props ##### -->
<para>
</para>
@caps:
@props:
@Returns:
<!-- ##### FUNCTION gst_caps_get_props ##### -->
<para>
</para>
@caps:
@Returns:
<!-- ##### FUNCTION gst_caps_check_compatibility ##### -->
<para>
</para>
@fromcaps:
@tocaps:
@Returns:
<!-- ##### MACRO gst_caps_set ##### -->
<para>
Set a property of a caps structure.
</para>
@caps: the caps structure to modify
@name: the name of the property to change
@args...: the new value of the property
<!-- ##### MACRO gst_caps_get_boolean ##### -->
<para>
Get the value of the named property as a boolean.
</para>
@caps: the caps to query
@name: the name of the property to get
<!-- ##### FUNCTION gst_caps_get_by_name ##### -->
<para>
</para>
@caps:
@name:
@Returns:
<!-- ##### MACRO gst_caps_get_fourcc_int ##### -->
<para>
Get the value of the named property as a fourcc.
</para>
@caps: the caps to query
@name: the name of the property to get
<!-- ##### MACRO gst_caps_get_int ##### -->
<para>
Get the value of the named property as an int.
</para>
@caps: the caps to query
@name: the name of the property to get
<!-- ##### MACRO gst_caps_get_string ##### -->
<para>
Get the value of the named property as a string.
</para>
@caps: the caps to query
@name: the name of the property to get
<!-- ##### MACRO gst_caps_get_float ##### -->
<para>
Get the value of the named property as a float.
</para>
@caps: the caps to query
@name: the name of the property to get
<!-- ##### FUNCTION gst_caps_save_thyself ##### -->
<para>
</para>
@caps:
@parent:
@Returns:
<!-- ##### FUNCTION gst_caps_load_thyself ##### -->
<para>
</para>
@parent:
@Returns:

118
docs/gst/tmpl/gstclock.sgml
View file

@ -1,118 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstClock
<!-- ##### SECTION Short_Description ##### -->
Clocking and synchronisation.
<!-- ##### SECTION Long_Description ##### -->
<para>
GstClock provides an easy way to synchonize against a global clock.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### TYPEDEF GstClockTime ##### -->
<para>
</para>
<!-- ##### TYPEDEF GstClockTimeDiff ##### -->
<para>
</para>
<!-- ##### MACRO GST_CLOCK_DIFF ##### -->
<para>
Calculate the difference between to timestamps. This does not create
and absolute difference so the result might be negative if the first
timestamp is less than the second timestamp.
</para>
@s: first timestamp
@e: second timestamp
<!-- ##### STRUCT GstClock ##### -->
<para>
</para>
@name:
@start_time:
@current_time:
@adjust:
@locking:
@sinkobjects:
@num:
@num_locked:
@sinkmutex:
@lock:
<!-- ##### FUNCTION gst_clock_new ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_clock_get_system ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_clock_register ##### -->
<para>
</para>
@clock:
@obj:
<!-- ##### FUNCTION gst_clock_set ##### -->
<para>
</para>
@clock:
@time:
<!-- ##### FUNCTION gst_clock_reset ##### -->
<para>
</para>
@clock:
<!-- ##### FUNCTION gst_clock_wait ##### -->
<para>
</para>
@clock:
@time:
@obj:
<!-- ##### FUNCTION gst_clock_current_diff ##### -->
<para>
</para>
@clock:
@time:
@Returns:

40
docs/gst/tmpl/gstcpu.sgml
View file

@ -1,40 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstCpu
<!-- ##### SECTION Short_Description ##### -->
Request the features of the CPU.
<!-- ##### SECTION Long_Description ##### -->
<para>
This module can be used when developing plugins. It is
typically used to enable special optimisations based on the
features of the CPU.
</para>
<para>
You'll get a bitmask of flags with gst_cpu_get_flags().
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ENUM GstCPUFlags ##### -->
<para>
</para>
@GST_CPU_FLAG_MMX:
@GST_CPU_FLAG_SSE:
@GST_CPU_FLAG_MMXEXT:
@GST_CPU_FLAG_3DNOW:
<!-- ##### FUNCTION gst_cpu_get_flags ##### -->
<para>
Request a set of bits specifiying the features of the CPU.
</para>
@Returns: the features of the CPU

24
docs/gst/tmpl/gstdata.sgml
View file

@ -1,24 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstData
<!-- ##### SECTION Short_Description ##### -->
Common structure for GstBuffer and GstEvent
<!-- ##### SECTION Long_Description ##### -->
<para>
This structure provides a common base for #GstBuffer and #GstEvent. It is the
main data type that is passed along in a pipeline.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstBuffer, #GstEvent
</para>
<!-- ##### STRUCT GstData ##### -->
<para>
The base structure
</para>
@type: The type of this data.

24
docs/gst/tmpl/gstdisksink.sgml
View file

@ -1,24 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstDiskSink
<!-- ##### SECTION Short_Description ##### -->
Write to a file
<!-- ##### SECTION Long_Description ##### -->
<para>
The disksink write to a file. The filename can be given as an argument.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstFdSink
</para>
<!-- ##### ENUM GstDiskSinkFlags ##### -->
<para>
</para>
@GST_DISKSINK_OPEN:
@GST_DISKSINK_FLAG_LAST:

54
docs/gst/tmpl/gstdisksrc.sgml
View file

@ -1,54 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstDiskSrc
<!-- ##### SECTION Short_Description ##### -->
Asynchronous read from a file (disksrc)
<!-- ##### SECTION Long_Description ##### -->
<para>
Asynchonously read buffers from a file.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ENUM GstDiskSrcFlags ##### -->
<para>
<informaltable pgwide=1 frame="none" role="enum">
<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
<tbody>
<row>
<entry>GST_DISKSRC_OPEN</entry>
<entry>the disksrc is open for reading</entry>
</row>
</tbody></tgroup></informaltable>
</para>
@GST_DISKSRC_OPEN:
@GST_DISKSRC_FLAG_LAST:
<!-- ##### ARG GstDiskSrc:location ##### -->
<para>
Specify the location of the file to read.
</para>
<!-- ##### ARG GstDiskSrc:bytesperread ##### -->
<para>
Specify how many bytes to read at a time.
</para>
<!-- ##### ARG GstDiskSrc:offset ##### -->
<para>
Get/set the current offset in the file.
</para>
<!-- ##### ARG GstDiskSrc:filesize ##### -->
<para>
</para>

602
docs/gst/tmpl/gstelement.sgml
View file

@ -1,602 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstElement
<!-- ##### SECTION Short_Description ##### -->
Base class for all pipeline elements
<!-- ##### SECTION Long_Description ##### -->
<para>
GstElement is the base class needed to construct an element that can be
used in a GST pipeline. As such, it is not a functional entity, and
cannot do anything when placed in a pipeline.
</para>
<para>
All GstElements have a list containing the #GstPad structure for all their
inputs and outputs. These can be added with gst_element_add_pad() or
gst_element_add_ghost_pad(), and retrieved by name with
gst_element_get_pad(), or in a list form by gst_element_get_pad_list().
</para>
<para>
gst_element_connect() is a convenience function provided to make it
simpler to connect pads of two elements together.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstElementFactory
</para>
<!-- ##### ENUM GstElementState ##### -->
<para>
This enum defines the standard states an element may be in. You will normally
use gst_element_set_state() to change the state of an element.
</para>
@GST_STATE_VOID_PENDING:
@GST_STATE_NULL: Reset the state of an element.
@GST_STATE_READY: will make the element ready to start processing data. some
elements might have a non trivial way to initialize themselves.
@GST_STATE_PAUSED: means there really is data flowing temporary stops the data flow.
@GST_STATE_PLAYING: means there really is data flowing through the graph.
<!-- ##### ENUM GstElementStateReturn ##### -->
<para>
This enum defines the standard return values that an element
can return after a state change.
</para>
@GST_STATE_FAILURE: the element could not perform the state change
@GST_STATE_SUCCESS: the element successfully changed its state
@GST_STATE_ASYNC: the element will asynchronously change its state as soon as possible
<!-- ##### MACRO GST_NUM_STATES ##### -->
<para>
The maximun number of states.
</para>
<!-- ##### MACRO GST_STATE ##### -->
<para>
This macro returns the current state of the element.
</para>
@obj: Element to return state for.
<!-- ##### MACRO GST_STATE_PENDING ##### -->
<para>
This macro returns the currently pending state of the element.
</para>
@obj: Element to return the pending state for.
<!-- ##### MACRO GST_STATE_TRANSITION ##### -->
<para>
Returns the state transition this object is going through.
</para>
@obj: the Element to return the state transition for
<!-- ##### MACRO GST_STATE_NULL_TO_READY ##### -->
<para>
The Element is going from the NULL state to the READY state.
</para>
<!-- ##### MACRO GST_STATE_READY_TO_PAUSED ##### -->
<para>
The Element is going from the READY state to the PAUSED state.
</para>
<!-- ##### MACRO GST_STATE_PAUSED_TO_READY ##### -->
<para>
The Element is going from the PAUSED state to the READY state.
</para>
<!-- ##### MACRO GST_STATE_PLAYING_TO_PAUSED ##### -->
<para>
The Element is going from the PLAYING state to the PAUSED state.
</para>
<!-- ##### MACRO GST_STATE_PAUSED_TO_PLAYING ##### -->
<para>
The Element is going from the PAUSED state to the PLAYING state.
</para>
<!-- ##### MACRO GST_STATE_READY_TO_NULL ##### -->
<para>
The Element is going from the READY state to the NULL state.
</para>
<!-- ##### ENUM GstElementFlags ##### -->
<para>
This enum defines the standard flags that an element may have.
</para>
@GST_ELEMENT_COMPLEX:
@GST_ELEMENT_DECOUPLED:
@GST_ELEMENT_THREAD_SUGGESTED:
@GST_ELEMENT_NO_SEEK:
@GST_ELEMENT_INFINITE_LOOP:
@GST_ELEMENT_SCHEDULER_PRIVATE1:
@GST_ELEMENT_SCHEDULER_PRIVATE2:
@GST_ELEMENT_NEW_LOOPFUNC:
@GST_ELEMENT_EVENT_AWARE:
@GST_ELEMENT_FLAG_LAST:
<!-- ##### MACRO GST_ELEMENT_IS_THREAD_SUGGESTED ##### -->
<para>
Queries whether the Element should be placed in a thread.
</para>
@obj: The element to query
<!-- ##### MACRO GST_ELEMENT_IS_DECOUPLED ##### -->
<para>
Queries if the Element is decoupled.
</para>
@obj: The element to query
<!-- ##### MACRO GST_ELEMENT_IS_EOS ##### -->
<para>
Query wether this element is in the End Of Stream state.
</para>
@obj: The element to query
<!-- ##### MACRO GST_ELEMENT_IS_EVENT_AWARE ##### -->
<para>
Query wether this element can handle events.
</para>
@obj: The element to query
<!-- ##### MACRO GST_ELEMENT_PARENT ##### -->
<para>
Get the parent object of this element.
</para>
@obj: The element to query
<!-- ##### MACRO GST_ELEMENT_NAME ##### -->
<para>
Get the name of this element.
</para>
@obj: The element to query
<!-- ##### MACRO GST_ELEMENT_PADS ##### -->
<para>
Get the pads of this elements.
</para>
@obj: The element to query
<!-- ##### MACRO GST_ELEMENT_SCHED ##### -->
<para>
Get the scheduler of this element.
</para>
@obj: The element to query
<!-- ##### MACRO GST_ELEMENT_MANAGER ##### -->
<para>
Get the manager of this element.
</para>
@obj: The element to query
<!-- ##### STRUCT GstElement ##### -->
<para>
</para>
<!-- ##### USER_FUNCTION GstElementLoopFunction ##### -->
<para>
This function type is used to specify a loop function for the element. It
is passed the element in question, and is expect to return only in error
circumstances.
</para>
@element: The element in question.
<!-- ##### FUNCTION gst_element_class_add_padtemplate ##### -->
<para>
</para>
@klass:
@templ:
<!-- # Unused Parameters # -->
@element:
<!-- ##### MACRO gst_element_destroy ##### -->
<para>
Destroy the element. This is potentially dangerous, use gst_object_unref
instead.
</para>
@element: the element to destroy
<!-- ##### FUNCTION gst_element_set_loop_function ##### -->
<para>
</para>
@element:
@loop:
<!-- ##### FUNCTION gst_element_set_name ##### -->
<para>
</para>
@element:
@name:
<!-- ##### FUNCTION gst_element_get_name ##### -->
<para>
</para>
@element:
@Returns:
<!-- ##### FUNCTION gst_element_get_sched ##### -->
<para>
</para>
@element:
@Returns:
<!-- ##### FUNCTION gst_element_set_sched ##### -->
<para>
</para>
@element:
@sched:
<!-- ##### FUNCTION gst_element_set_parent ##### -->
<para>
</para>
@element:
@parent:
<!-- ##### FUNCTION gst_element_get_parent ##### -->
<para>
</para>
@element:
@Returns:
<!-- ##### FUNCTION gst_element_add_pad ##### -->
<para>
</para>
@element:
@pad:
<!-- ##### FUNCTION gst_element_remove_pad ##### -->
<para>
</para>
@element:
@pad:
<!-- ##### FUNCTION gst_element_get_pad ##### -->
<para>
</para>
@element:
@name:
@Returns: GList of pads
<!-- ##### FUNCTION gst_element_get_pad_list ##### -->
<para>
</para>
@element:
@Returns:
<!-- ##### FUNCTION gst_element_get_padtemplate_list ##### -->
<para>
</para>
@element:
@Returns:
<!-- ##### FUNCTION gst_element_get_padtemplate_by_name ##### -->
<para>
</para>
@element:
@name:
@Returns:
<!-- ##### FUNCTION gst_element_add_ghost_pad ##### -->
<para>
</para>
@element:
@pad:
@name:
<!-- ##### FUNCTION gst_element_remove_ghost_pad ##### -->
<para>
</para>
@element:
@pad:
<!-- ##### FUNCTION gst_element_request_compatible_pad ##### -->
<para>
</para>
@element:
@templ:
@Returns:
<!-- ##### FUNCTION gst_element_request_pad_by_name ##### -->
<para>
</para>
@element:
@name:
@Returns:
<!-- ##### FUNCTION gst_element_connect ##### -->
<para>
</para>
@src:
@srcpadname:
@dest:
@destpadname:
<!-- ##### FUNCTION gst_element_disconnect ##### -->
<para>
</para>
@src:
@srcpadname:
@dest:
@destpadname:
<!-- ##### FUNCTION gst_element_set_state ##### -->
<para>
</para>
@element:
@state:
@Returns:
<!-- ##### FUNCTION gst_element_get_state ##### -->
<para>
</para>
@element:
@Returns:
<!-- # Unused Parameters # -->
@elem:
<!-- ##### FUNCTION gst_element_wait_state_change ##### -->
<para>
</para>
@element:
<!-- ##### FUNCTION gst_element_statename ##### -->
<para>
</para>
@state:
@Returns:
<!-- ##### FUNCTION gst_element_info ##### -->
<para>
</para>
@element:
@info:
@Varargs:
<!-- ##### FUNCTION gst_element_error ##### -->
<para>
</para>
@element:
@error:
@Varargs:
<!-- ##### FUNCTION gst_element_get_factory ##### -->
<para>
</para>
@element:
@Returns:
<!-- ##### FUNCTION gst_element_set_eos ##### -->
<para>
</para>
@element:
<!-- ##### FUNCTION gst_element_restore_thyself ##### -->
<para>
</para>
@self:
@parent:
@Returns:
<!-- ##### FUNCTION gst_element_install_std_props ##### -->
<para>
</para>
@klass:
@first_name:
@Varargs:
<!-- ##### FUNCTION gst_element_send_event ##### -->
<para>
</para>
@element:
@event:
<!-- ##### FUNCTION gst_element_interrupt ##### -->
<para>
</para>
@element:
@Returns:
<!-- ##### FUNCTION gst_element_yield ##### -->
<para>
</para>
@element:
<!-- ##### SIGNAL GstElement::state-change ##### -->
<para>
Is trigered whenever the state of an element changes
</para>
@gstelement: the object which received the signal.
@arg1: the new state of the object
@arg2:
<!-- ##### SIGNAL GstElement::new-pad ##### -->
<para>
Is trigered whenever a new pad is added to an element
</para>
@gstelement: the object which received the signal.
@arg1: the new pad that was added
<!-- ##### SIGNAL GstElement::pad-removed ##### -->
<para>
</para>
@gstelement: the object which received the signal.
@arg1: The pad that was removed.
<!-- ##### SIGNAL GstElement::error ##### -->
<para>
Is trigered whenever an error occured
</para>
@gstelement: the object which received the signal.
@arg1: the error message
<!-- ##### SIGNAL GstElement::event ##### -->
<para>
</para>
@gstelement: the object which received the signal.
@arg1:
<!-- ##### SIGNAL GstElement::eos ##### -->
<para>
</para>
@gstelement: the object which received the signal.

149
docs/gst/tmpl/gstelementfactory.sgml
View file

@ -1,149 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstElementFactory
<!-- ##### SECTION Short_Description ##### -->
Create GstElements from a factory
<!-- ##### SECTION Long_Description ##### -->
<para>
GstElementFactory is used to create instances of elements. A GstElementfactory
can be added to a #GstPlugin as it is also a #GstPluginFeature.
</para>
<para>
Use gst_elementfactory_new() to create a new factory which can be added to a plugin
with gst_plugin_add_feature().
</para>
<para>
gst_elementfactory_get_list() is used to get a list of all available factories in
the plugin repository.
</para>
<para>
gst_elementfactory_add_padtemplate() 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.
</para>
<para>
Use the gst_elementfactory_find() and gst_elementfactory_create() functions
to create element instances or use gst_elementfactory_make() as a convenient
shortcut.
</para>
<para>
The following code example shows you how to create a GstDiskSrc element.
</para>
<para>
<programlisting role="C">
#include &lt;gst/gst.h&gt;
GstElement *src;
GstElementFactory *srcfactory;
gst_init(&amp;argc,&amp;argv);
srcfactory = gst_elementfactory_find("filesrc");
g_return_if_fail(srcfactory != NULL);
src = gst_elementfactory_create(srcfactory,"src");
g_return_if_fail(src != NULL);
...
</programlisting>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstElement, #GstPlugin, #GstPluginFeature, #GstPadTemplate.
</para>
<!-- ##### STRUCT GstElementDetails ##### -->
<para>
This struct is used to define public information about the element. It
describes the element, mostly for the benefit of editors.
</para>
@longname:
@klass:
@description:
@version:
@author:
@copyright:
<!-- ##### FUNCTION gst_elementfactory_new ##### -->
<para>
</para>
@name:
@type:
@details:
@Returns:
<!-- ##### FUNCTION gst_elementfactory_find ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_elementfactory_get_list ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_elementfactory_add_padtemplate ##### -->
<para>
</para>
@elementfactory:
@templ:
<!-- # Unused Parameters # -->
@temp:
@pad:
<!-- ##### FUNCTION gst_elementfactory_can_src_caps ##### -->
<para>
</para>
@factory:
@caps:
@Returns:
<!-- ##### FUNCTION gst_elementfactory_can_sink_caps ##### -->
<para>
</para>
@factory:
@caps:
@Returns:
<!-- ##### FUNCTION gst_elementfactory_create ##### -->
<para>
</para>
@factory:
@name:
@Returns:
<!-- ##### FUNCTION gst_elementfactory_make ##### -->
<para>
</para>
@factoryname:
@name:
@Returns:

163
docs/gst/tmpl/gstevent.sgml
View file

@ -1,163 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstEvent
<!-- ##### SECTION Short_Description ##### -->
Event definitions.
<!-- ##### SECTION Long_Description ##### -->
<para>
The event classes are used to construct and query events.
</para>
<para>
Events are usually created with gst_event_new() which takes the event type as an argument.
properties specific to the event can be set afterwards with the provided macros.
The event is freed with gst_event_free().
</para>
<para>
gst_event_new_seek() is a usually used to create a seek event and it takes the
needed parameters for a seek event.
</para>
<para>
gst_event_new_flush() creates a new flush event.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstPad
</para>
<!-- ##### ENUM GstEventType ##### -->
<para>
The different major types of events.
</para>
@GST_EVENT_UNKNOWN: unknown event.
@GST_EVENT_EOS: an end-of-stream event.
@GST_EVENT_FLUSH: a flush event.
@GST_EVENT_EMPTY: an empty event.
@GST_EVENT_SEEK: a seek event.
@GST_EVENT_DISCONTINUOUS: a discontinuous event to indicate the stream has a discontinuity.
@GST_EVENT_INFO: an informational event
@GST_EVENT_ERROR: an error event
<!-- ##### MACRO GST_EVENT_TYPE ##### -->
<para>
Get the event type.
</para>
@event: The event to query.
<!-- ##### MACRO GST_EVENT_SRC ##### -->
<para>
The source object that generated this event
</para>
@event: The event to query
<!-- ##### MACRO GST_EVENT_TIMESTAMP ##### -->
<para>
Get the timestamp of the event.
</para>
@event: The event to query.
<!-- ##### ENUM GstSeekType ##### -->
<para>
The different types of seek events.
</para>
@GST_SEEK_ANY: the seek is performed anyway.
@GST_SEEK_TIMEOFFSET: this is a seek to specific timeoffset
@GST_SEEK_BYTEOFFSET: this is a seek to specific byteoffset
<!-- ##### MACRO GST_EVENT_SEEK_TYPE ##### -->
<para>
Get the seektype of the GST_EVENT_SEEK.
</para>
@event: The event to query.
<!-- ##### MACRO GST_EVENT_SEEK_OFFSET ##### -->
<para>
Get the offset of the seek event.
</para>
@event: The event to query.
<!-- ##### MACRO GST_EVENT_SEEK_FLUSH ##### -->
<para>
Qeury wether the seek event also needs a flush.
</para>
@event: The event to query.
<!-- ##### MACRO GST_EVENT_INFO_PROPS ##### -->
<para>
The properties of the info event
</para>
@event: The event to query
<!-- ##### STRUCT GstEvent ##### -->
<para>
The event data structure.
</para>
@data: The parent data type.
@type: The event type.
@timestamp: The event timestamp.
@src:
<!-- ##### FUNCTION gst_event_new ##### -->
<para>
</para>
@type:
@Returns:
<!-- ##### FUNCTION gst_event_free ##### -->
<para>
</para>
@event:
<!-- ##### FUNCTION gst_event_new_seek ##### -->
<para>
</para>
@type:
@offset:
@flush:
@Returns:
<!-- ##### MACRO gst_event_new_flush ##### -->
<para>
Create a new flush event.
</para>
<!-- ##### FUNCTION gst_event_new_info ##### -->
<para>
</para>
@firstname:
@Varargs:
@Returns:

23
docs/gst/tmpl/gstextratypes.sgml
View file

@ -1,23 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstExtraTypes
<!-- ##### SECTION Short_Description ##### -->
<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### MACRO GST_TYPE_FILENAME ##### -->
<para>
A type that can be used to indicate a filename.
</para>

41
docs/gst/tmpl/gstfakesink.sgml
View file

@ -1,41 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstFakeSink
<!-- ##### SECTION Short_Description ##### -->
Sources a buffer without doing anything with it. (fakesink)
<!-- ##### SECTION Long_Description ##### -->
<para>
Take a buffer and gst_buffer_unref() it. This element does nothing
with the buffer. (fakesink)
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SIGNAL GstFakeSink::handoff ##### -->
<para>
</para>
@gstfakesink: the object which received the signal.
@arg1:
<!-- ##### ARG GstFakeSink:num-sinks ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSink:silent ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSink:dump ##### -->
<para>
</para>

94
docs/gst/tmpl/gstfakesrc.sgml
View file

@ -1,94 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstFakeSrc
<!-- ##### SECTION Short_Description ##### -->
Generate empty buffers. (fakesrc)
<!-- ##### SECTION Long_Description ##### -->
<para>
The <classname>GstFakeSrc</classname> generates empty buffers. (fakesrc)
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SIGNAL GstFakeSrc::handoff ##### -->
<para>
</para>
@gstfakesrc: the object which received the signal.
@arg1:
<!-- ##### ARG GstFakeSrc:num-sources ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:loop-based ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:output ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:data ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:sizetype ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:sizemin ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:sizemax ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:parentsize ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:filltype ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:pattern ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:num-buffers ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:eos ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:silent ##### -->
<para>
</para>
<!-- ##### ARG GstFakeSrc:dump ##### -->
<para>
</para>

21
docs/gst/tmpl/gstfdsink.sgml
View file

@ -1,21 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstFdSink
<!-- ##### SECTION Short_Description ##### -->
Write data to a file descriptor. (fdsink)
<!-- ##### SECTION Long_Description ##### -->
<para>
Write data to a file descriptor.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ARG GstFdSink:fd ##### -->
<para>
The filedescriptor to write to.
</para>

31
docs/gst/tmpl/gstfdsrc.sgml
View file

@ -1,31 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstFdSrc
<!-- ##### SECTION Short_Description ##### -->
Read buffers from a file descriptor. (fdsrc)
<!-- ##### SECTION Long_Description ##### -->
<para>
Read buffers from a file descriptor.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ARG GstFdSrc:location ##### -->
<para>
The filedescriptor to read from. Pass the argument as a char* (???)
</para>
<!-- ##### ARG GstFdSrc:bytesperread ##### -->
<para>
The number of bytes per read.
</para>
<!-- ##### ARG GstFdSrc:offset ##### -->
<para>
Get the current offset in the file.
</para>

51
docs/gst/tmpl/gstfilesrc.sgml
View file

@ -1,51 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstFileSrc
<!-- ##### SECTION Short_Description ##### -->
<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ARG GstFileSrc:fd ##### -->
<para>
</para>
<!-- ##### ARG GstFileSrc:offset ##### -->
<para>
</para>
<!-- ##### ARG GstFileSrc:filesize ##### -->
<para>
</para>
<!-- ##### ARG GstFileSrc:location ##### -->
<para>
</para>
<!-- ##### ARG GstFileSrc:blocksize ##### -->
<para>
</para>
<!-- ##### ARG GstFileSrc:mmapsize ##### -->
<para>
</para>
<!-- ##### ARG GstFileSrc:touch ##### -->
<para>
</para>

16
docs/gst/tmpl/gsthttpsrc.sgml
View file

@ -1,16 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstHttpSrc
<!-- ##### SECTION Short_Description ##### -->
Reads data from a URL. (httpsrc)
<!-- ##### SECTION Long_Description ##### -->
<para>
Reads data from a URL.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>

54
docs/gst/tmpl/gstidentity.sgml
View file

@ -1,54 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstIdentity
<!-- ##### SECTION Short_Description ##### -->
Pass data without modification. (identity)
<!-- ##### SECTION Long_Description ##### -->
<para>
Pass data without modification.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SIGNAL GstIdentity::handoff ##### -->
<para>
</para>
@gstidentity: the object which received the signal.
@arg1:
<!-- ##### ARG GstIdentity:loop-based ##### -->
<para>
</para>
<!-- ##### ARG GstIdentity:sleep-time ##### -->
<para>
</para>
<!-- ##### ARG GstIdentity:duplicate ##### -->
<para>
</para>
<!-- ##### ARG GstIdentity:error-after ##### -->
<para>
</para>
<!-- ##### ARG GstIdentity:drop-probability ##### -->
<para>
</para>
<!-- ##### ARG GstIdentity:silent ##### -->
<para>
</para>

324
docs/gst/tmpl/gstinfo.sgml
View file

@ -1,324 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstInfo
<!-- ##### SECTION Short_Description ##### -->
info/debugging/error handling
<!-- ##### SECTION Long_Description ##### -->
<para>
gstinfo.c contains a number of debuggins subsystems.
</para>
<para>The INFO subsystem is used to provide informative printouts to
application and plugin developers. These messages can be enabled and
disabled via a category system, which is a bitmask enabling you to turn
on and off any subset of categories.</para>
<para>The DEBUG subsystem is similar, but is intended for core developers
and those writing more complex pipelines or filters. It uses the same
category system, but must be enabled at configure time else it's not
compiled into the library. autogen.sh automatically enables the DEBUG
subsystem.
</para>
<para>The ERROR subsystem doesn't use categories, but will print out a
more verbose message, and attempt to print out a stack trace of the error
before aborting the application.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_get_category_name ##### -->
<para>
</para>
@category:
@Returns:
<!-- ##### FUNCTION gst_info_get_categories ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_info_set_categories ##### -->
<para>
</para>
@categories:
<!-- ##### FUNCTION gst_info_enable_category ##### -->
<para>
</para>
@category:
<!-- ##### FUNCTION gst_info_disable_category ##### -->
<para>
</para>
@category:
<!-- ##### FUNCTION gst_default_info_handler ##### -->
<para>
</para>
@category:
@incore:
@file:
@function:
@line:
@debug_string:
@element:
@string:
<!-- ##### MACRO GST_INFO_ENABLED ##### -->
<para>
When defined, INFO printouts are compiled into the library.
</para>
<!-- ##### MACRO GST_INFO ##### -->
<para>
Print out any information usable at run-time by application developers.
</para>
@cat: the GST_CAT_... category for the information
@format: printf-style format string
@args...: printf arguments
<!-- ##### MACRO GST_INFO_ELEMENT ##### -->
<para>
Print out information like #GST_INFO, but with an element pointer to clarify things.
</para>
@cat: the GST_CAT_... category for the information
@element: pointer to the #GstElement in question
@format: printf-style format string
@args...: printf arguments
<!-- ##### FUNCTION gst_debug_get_categories ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_debug_set_categories ##### -->
<para>
</para>
@categories:
<!-- ##### FUNCTION gst_debug_enable_category ##### -->
<para>
</para>
@category:
<!-- ##### FUNCTION gst_debug_disable_category ##### -->
<para>
</para>
@category:
<!-- ##### MACRO GST_DEBUG_ENTER ##### -->
<para>
Called at the beginning of a function, it simply prints out a DEBUG string of "entering"
in addition to the given string.
</para>
@format: printf-style format string
@args...: printf arguments
<!-- ##### MACRO GST_DEBUG_LEAVE ##### -->
<para>
Called at the end of a function, it simply prints out a DEBUG string of "leaving"
in addition to the given string.
</para>
@format: printf-stype format string
@args...: printf arguments
<!-- ##### MACRO GST_DEBUG ##### -->
<para>
Print out debugging information.
</para>
@cat: the GST_CAT_... the debug falls within
@format: printf-style format string
@args...: printf arguments
<!-- ##### MACRO GST_DEBUG_FUNCPTR ##### -->
<para>
Add a function to the global function pointer table used for debugging.
</para>
@ptr: The pointer to add to the function table.
<!-- ##### MACRO GST_DEBUG_FUNCPTR_NAME ##### -->
<para>
Get the name of the given function pointer by looking up its name in the global
function table.
</para>
@ptr: The pointer to look up.
<!-- ##### MACRO GST_DEBUG_PAD_NAME ##### -->
<para>
Print out debugging statements for a pad.
</para>
@pad: The pad to debug.
<!-- ##### MACRO GST_DEBUG_THREAD_ARGS ##### -->
<para>
Part of the colorized debug functions for threads
</para>
@id: The thread id.
<!-- ##### MACRO GST_DEBUG_THREAD_FORMAT ##### -->
<para>
Part of the colorized debug functions for threads
</para>
<!-- ##### MACRO GST_DEBUG_ELEMENT ##### -->
<para>
Print out usefull debugging info of an element.
</para>
@cat: The category of this debugging statement.
@element: The element to debug.
@format: A printf-like string.
@args...: The argument for the printf-like string.
<!-- ##### MACRO GST_ERROR ##### -->
<para>
Print out an error condition and abort the application.
</para>
@element: the #GstElement in question
@format: printf-style format string
@args...: printf arguments
<!-- ##### MACRO GST_ERROR_OBJECT ##### -->
<para>
Print out an error condition and abort the application.
</para>
@element: the #GstElement in question
@object: pointer to a 'contributing' object
@format: printf-style format string
@args...: printf arguments
<!-- ##### USER_FUNCTION GstDebugHandler ##### -->
<para>
</para>
@category:
@core:
@file:
@function:
@line:
@debug_string:
@element:
@string:
<!-- ##### FUNCTION gst_default_debug_handler ##### -->
<para>
</para>
@category:
@incore:
@file:
@function:
@line:
@debug_string:
@element:
@string:
<!-- ##### FUNCTION gst_default_error_handler ##### -->
<para>
</para>
@file:
@function:
@line:
@debug_string:
@element:
@object:
@string:
<!-- ##### USER_FUNCTION GstInfoHandler ##### -->
<para>
</para>
@category:
@incore:
@file:
@function:
@line:
@debug_string:
@element:
@string:
<!-- ##### USER_FUNCTION GstErrorHandler ##### -->
<para>
</para>
@file:
@function:
@line:
@debug_string:
@element:
@object:
@string:

16
docs/gst/tmpl/gstlog.sgml
View file

@ -1,16 +0,0 @@
<!-- ##### SECTION Title ##### -->
gstlog
<!-- ##### SECTION Short_Description ##### -->
<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>

24
docs/gst/tmpl/gstmultidisksrc.sgml
View file

@ -1,24 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstMultiDiskSrc
<!-- ##### SECTION Short_Description ##### -->
<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ENUM GstMultiDiskSrcFlags ##### -->
<para>
</para>
@GST_MULTIDISKSRC_OPEN:
@GST_MULTIDISKSRC_FLAG_LAST:

303
docs/gst/tmpl/gstobject.sgml
View file

@ -1,303 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstObject
<!-- ##### SECTION Short_Description ##### -->
Basis for the GST object hierarchy.
<!-- ##### SECTION Long_Description ##### -->
<para>
GstObject provides a root for the object hierarchy tree filed in by the
GST library. It is currently a thin wrapper on top of
<classname>GObject</classname> but it can be compiled against GTK+ with
a shim provided by the GStreamer library. It is an abstract class that is not
very usable on its own.
</para>
<para>
GstObject gives us basic refcounting, parenting functionality and locking.
</para>
<para>
gst_object_set_name() and gst_object_get_name() are used to set/get the name of the
object.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ENUM GstObjectFlags ##### -->
<para>
</para>
@GST_DESTROYED:
@GST_FLOATING:
@GST_OBJECT_FLAG_LAST:
<!-- ##### STRUCT GstObject ##### -->
<para>
</para>
<!-- ##### MACRO GST_FLAGS ##### -->
<para>
This macro returns the entire set of flags for the object.
</para>
@obj: Object to return flags for.
<!-- ##### MACRO GST_FLAG_IS_SET ##### -->
<para>
This macro checks to see if the given flag is set.
</para>
@obj: GstSrc to check for flag in.
@flag: Flag to check for, must be a single bit in guint32.
<!-- ##### MACRO GST_FLAG_SET ##### -->
<para>
This macro sets the given bits.
</para>
@obj: Object to set flag in.
@flag: Flag to set, can by any number of bits in guint32.
<!-- ##### MACRO GST_FLAG_UNSET ##### -->
<para>
This macro usets the given bits.
</para>
@obj: Object to unset flag in.
@flag: Flag to set, must be a single bit in guint32.
<!-- ##### MACRO GST_LOCK ##### -->
<para>
This macro will obtain a lock on the object, making serialization
possible.
</para>
@obj: Object to lock.
<!-- ##### MACRO GST_TRYLOCK ##### -->
<para>
This macro will try to obtain a lock on the object, but will return with
FALSE if it can't get it immediately.
</para>
@obj: Object to try to get a lock on.
<!-- ##### MACRO GST_UNLOCK ##### -->
<para>
This macro releases a lock on the object.
</para>
@obj: Object to unlock.
<!-- ##### MACRO GST_GET_LOCK ##### -->
<para>
Acquire a reference to the mutex of this object.
</para>
@obj: Object to get the mutex of.
<!-- ##### MACRO GST_OBJECT_PARENT ##### -->
<para>
Get the parent of this object
</para>
@obj: Object to get the parent of.
<!-- ##### MACRO GST_OBJECT_NAME ##### -->
<para>
Get the name of this object
</para>
@obj: Object to get the name of.
<!-- ##### MACRO GST_OBJECT_FLOATING ##### -->
<para>
Check if the object is floating.
</para>
@obj: The Object to check
<!-- ##### MACRO GST_OBJECT_DESTROYED ##### -->
<para>
Check if the object has been destroyed.
</para>
@obj: The Object to check
<!-- ##### FUNCTION gst_object_check_uniqueness ##### -->
<para>
</para>
@list:
@name:
@Returns:
<!-- ##### FUNCTION gst_object_set_parent ##### -->
<para>
</para>
@object:
@parent:
<!-- ##### FUNCTION gst_object_get_parent ##### -->
<para>
</para>
@object:
@Returns:
<!-- ##### FUNCTION gst_object_set_name ##### -->
<para>
</para>
@object:
@name:
<!-- ##### FUNCTION gst_object_get_name ##### -->
<para>
</para>
@object:
@Returns:
<!-- ##### FUNCTION gst_object_unparent ##### -->
<para>
</para>
@object:
<!-- ##### FUNCTION gst_object_ref ##### -->
<para>
</para>
@object: the object
@Returns:
<!-- ##### FUNCTION gst_object_unref ##### -->
<para>
</para>
@object: the object
<!-- ##### FUNCTION gst_object_sink ##### -->
<para>
</para>
@object: the object
<!-- ##### FUNCTION gst_object_destroy ##### -->
<para>
</para>
@object: the object
<!-- ##### FUNCTION gst_object_save_thyself ##### -->
<para>
</para>
@object:
@parent:
@Returns:
<!-- ##### FUNCTION gst_object_restore_thyself ##### -->
<para>
</para>
@object:
@parent:
<!-- ##### FUNCTION gst_object_get_path_string ##### -->
<para>
</para>
@object:
@Returns:
<!-- ##### FUNCTION gst_class_signal_emit_by_name ##### -->
<para>
</para>
@object:
@name:
@self:
<!-- ##### FUNCTION gst_class_signal_connect ##### -->
<para>
</para>
@klass:
@name:
@func:
@func_data:
@Returns:
<!-- ##### SIGNAL GstObject::parent-set ##### -->
<para>
</para>
@gstobject: the object which received the signal.
@arg1: the new parent
<!-- ##### SIGNAL GstObject::object-saved ##### -->
<para>
Is trigered whenever a new object is saved to XML. You can connect to
this signal to insert custom XML tags into the core XML.
</para>
@gstobject: the object which received the signal.
@arg1: the xmlNodePtr of the parent node
<!-- ##### ARG GstObject:name ##### -->
<para>
</para>

896
docs/gst/tmpl/gstpad.sgml
View file

@ -1,896 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstPad
<!-- ##### SECTION Short_Description ##### -->
The connection between Elements
<!-- ##### SECTION Long_Description ##### -->
<para>
#GstElement are connected to each other via "pads", which are extremely light-weight generic
connections. After two pad are retrieved from an element with gst_element_get_pad(), the pads
can be connected with gst_pad_connect().
</para>
<para>
Pads are typically created from a #GstPadTemplate with gst_pad_new_from_template().
</para>
<para>
Pad have #GstCaps attached to it to describe the media type they
are capable of dealing with. gst_pad_get_caps() and gst_pad_set_caps() are used to
manipulate the caps of the pads.
Pads created from a padtemplate cannot set capabilities that are incompatible with
the padtemplates capabilities.
</para>
<para>
Pads without padtemplates can be created with gst_pad_new() which takes a direction and
a name as an argument.
</para>
<para>
gst_pad_get_parent() will retrieve the #GstElement that owns the pad.
</para>
<para>
GstElements creating a pad will typicilally use the various gst_pad_set_*_function() calls
to register callbacks for various events on the pads.
</para>
<para>
GstElements will use gst_pad_push() and gst_pad_pull() to push out or pull a buffer in. The
gst_pad_pullregion() function can be used to request for a buffer with a specific offset (in
time or in bytes). gst_pad_select() and gst_pad_selectv() are use by plugins to wait on a set
of pads for a new #GstBuffer or #GstEvent.
</para>
<para>
To send an event on a pad, use gst_pad_send_event().
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstPadTemplate, #GstElement, #GstEvent
</para>
<!-- ##### MACRO GST_PAD_NAME ##### -->
<para>
Get the name of the pad.
</para>
@pad: the pad to query
<!-- ##### MACRO GST_PAD_ELEMENT_PRIVATE ##### -->
<para>
Get the private data set by the element that owns the pad.
</para>
@pad: the pad to query
<!-- ##### MACRO GST_PAD_PARENT ##### -->
<para>
Get the parent element of this pad.
</para>
@pad: the pad to query
<!-- ##### MACRO GST_PAD_PADTEMPLATE ##### -->
<para>
Get the padtemplate that was used to create this pad. NULL if no padtemplate
was used.
</para>
@pad: the pad to query
<!-- ##### MACRO GST_PAD_REALIZE ##### -->
<para>
Return the real pad of this pad.
</para>
@pad: the pad to query
<!-- ##### MACRO GST_PAD_DIRECTION ##### -->
<para>
Get the pad direction.
</para>
@pad: the pad to query
<!-- ##### MACRO GST_PAD_CAPS ##### -->
<para>
Get the capabilities of a pad.
</para>
@pad: the pad to query
<!-- ##### MACRO GST_PAD_PEER ##### -->
<para>
Get the peerpad of this pad.
</para>
@pad: the pad to query
<!-- ##### MACRO GST_PAD_CONNECTED ##### -->
<para>
Is this pad connected.
</para>
@pad: the pad to check
<!-- ##### MACRO GST_PAD_CAN_PULL ##### -->
<para>
Can this pad be used to pull a buffer.
</para>
@pad: the pad to check
<!-- ##### STRUCT GstPad ##### -->
<para>
</para>
<!-- ##### USER_FUNCTION GstPadChainFunction ##### -->
<para>
The function that will be called when chaining buffers.
</para>
@pad: the pad that performed the chain
@buf: the buffer that is chained
<!-- ##### USER_FUNCTION GstPadGetFunction ##### -->
<para>
The function that will be called when pulling a buffer.
</para>
@pad: the pad to get a buffer from
@Returns: a #GstBuffer
<!-- ##### USER_FUNCTION GstPadGetRegionFunction ##### -->
<para>
The function that will be called when pulling a region buffer.
You can specify which buffer to get using an offset/length pair or
a start/stop timecode pair.
</para>
@pad: the pad to get a buffer from
@type: the type of region to get (time or offset based)
@offset: the offset of the region to get
@len: the length of the region to get
@Returns: a #GstBuffer
<!-- ##### USER_FUNCTION GstPadNewCapsFunction ##### -->
<para>
The function that will be called when the caps of the pad has
changed.
</para>
@pad: The pad that has its caps changed
@caps: the new caps of the pad
<!-- ##### USER_FUNCTION GstPadBufferPoolFunction ##### -->
<para>
The function that will be called when a bufferpool is requested
from this pad.
</para>
@pad: the pad with the bufferpool
@Returns: the GstBufferPool associated with this pad.
<!-- ##### ENUM GstPadNegotiateReturn ##### -->
<para>
The possible results from padnegotiation.
</para>
@GST_PAD_NEGOTIATE_FAIL: The pads could not agree about the media type.
@GST_PAD_NEGOTIATE_AGREE: The pads agreed about the media type.
@GST_PAD_NEGOTIATE_TRY: The pad did not agree and suggests another media type.
<!-- ##### USER_FUNCTION GstPadNegotiateFunction ##### -->
<para>
The function that will be called when negotiating.
</para>
@pad: The pad that is being negotiated
@caps: The current caps that are being negotiated
@data: A generic gpointer that can be used to store user_data
@Returns: The result of the negotiation process
<!-- ##### ENUM GstRegionType ##### -->
<para>
the region types for #gst_pad_pullregion.
</para>
@GST_REGION_VOID:
@GST_REGION_OFFSET_LEN: an offet/length pair
@GST_REGION_TIME_LEN: a time start/length pair
<!-- ##### USER_FUNCTION GstPadPullRegionFunction ##### -->
<para>
The function that will be called when pulling a region buffer.
You can specify which buffer to get using an offset/length pair or
a start/stop timecode pair.
</para>
@pad: the pad to get a buffer from
@type: the type of region to get (time or offset based)
@offset: the offset of the region to get
@len: the length of the region to get
@Returns: a #GstBuffer
<!-- ##### USER_FUNCTION GstPadEventFunction ##### -->
<para>
</para>
@pad:
@event:
@Returns:
<!-- ##### ENUM GstPadDirection ##### -->
<para>
The direction this pad is.
</para>
@GST_PAD_UNKNOWN: direction is unknown
@GST_PAD_SRC: this is a source pad
@GST_PAD_SINK: this is a sink pad
<!-- ##### ENUM GstPadFlags ##### -->
<para>
Flags for the pad.
</para>
@GST_PAD_DISABLED: the pad is disabled
@GST_PAD_EOS: the pad is in end of stream state
@GST_PAD_FLAG_LAST: subclasses can use this number to enumerate their flags
<!-- ##### FUNCTION gst_pad_new ##### -->
<para>
</para>
@name:
@direction:
@Returns:
<!-- ##### MACRO gst_pad_destroy ##### -->
<para>
Destroy the pad.
</para>
@pad: the pad to destroy
<!-- ##### FUNCTION gst_pad_new_from_template ##### -->
<para>
</para>
@templ:
@name:
@Returns:
<!-- # Unused Parameters # -->
@temp:
<!-- ##### FUNCTION gst_pad_get_direction ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_set_chain_function ##### -->
<para>
</para>
@pad:
@chain:
<!-- ##### FUNCTION gst_pad_set_get_function ##### -->
<para>
</para>
@pad:
@get:
<!-- ##### FUNCTION gst_pad_set_getregion_function ##### -->
<para>
</para>
@pad:
@getregion:
<!-- ##### FUNCTION gst_pad_set_negotiate_function ##### -->
<para>
</para>
@pad:
@nego:
<!-- ##### FUNCTION gst_pad_set_newcaps_function ##### -->
<para>
</para>
@pad:
@newcaps:
<!-- ##### FUNCTION gst_pad_set_bufferpool_function ##### -->
<para>
</para>
@pad:
@bufpool:
<!-- ##### FUNCTION gst_pad_set_caps ##### -->
<para>
</para>
@pad:
@caps:
@Returns:
<!-- ##### FUNCTION gst_pad_get_caps ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_check_compatibility ##### -->
<para>
</para>
@srcpad:
@sinkpad:
@Returns:
<!-- ##### FUNCTION gst_pad_set_name ##### -->
<para>
</para>
@pad:
@name:
<!-- ##### FUNCTION gst_pad_get_name ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_set_element_private ##### -->
<para>
</para>
@pad:
@priv:
<!-- ##### FUNCTION gst_pad_get_element_private ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_set_parent ##### -->
<para>
</para>
@pad:
@parent:
<!-- ##### FUNCTION gst_pad_get_parent ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_get_sched ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_set_sched ##### -->
<para>
</para>
@pad:
@sched:
<!-- ##### FUNCTION gst_pad_get_real_parent ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_add_ghost_pad ##### -->
<para>
</para>
@pad:
@ghostpad:
<!-- ##### FUNCTION gst_pad_remove_ghost_pad ##### -->
<para>
</para>
@pad:
@ghostpad:
<!-- ##### FUNCTION gst_pad_get_ghost_pad_list ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_get_peer ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_connect ##### -->
<para>
</para>
@srcpad:
@sinkpad:
<!-- # Unused Parameters # -->
@Returns:
<!-- ##### FUNCTION gst_pad_try_connect ##### -->
<para>
</para>
@srcpad:
@sinkpad:
@Returns:
<!-- ##### FUNCTION gst_pad_disconnect ##### -->
<para>
</para>
@srcpad:
@sinkpad:
<!-- ##### FUNCTION gst_pad_push ##### -->
<para>
</para>
@pad:
@buf:
<!-- # Unused Parameters # -->
@buffer:
<!-- ##### FUNCTION gst_pad_pull ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_pullregion ##### -->
<para>
</para>
@pad:
@type:
@offset:
@len:
@Returns:
<!-- # Unused Parameters # -->
@size:
<!-- ##### FUNCTION gst_pad_get_bufferpool ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_load_and_connect ##### -->
<para>
</para>
@self:
@parent:
<!-- # Unused Parameters # -->
@element:
@elements:
<!-- ##### FUNCTION gst_pad_negotiate_proxy ##### -->
<para>
</para>
@srcpad:
@destpad:
@caps:
@Returns:
<!-- # Unused Parameters # -->
@counter:
@count:
<!-- ##### FUNCTION gst_pad_renegotiate ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_get_padtemplate ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_get_padtemplate_caps ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_ghost_save_thyself ##### -->
<para>
</para>
@pad:
@bin:
@parent:
@Returns:
<!-- ##### FUNCTION gst_pad_peek ##### -->
<para>
</para>
@pad:
@Returns:
<!-- ##### FUNCTION gst_pad_select ##### -->
<para>
</para>
@padlist:
@Returns:
<!-- ##### FUNCTION gst_pad_selectv ##### -->
<para>
</para>
@pad:
@Varargs:
@Returns:
<!-- ##### FUNCTION gst_pad_send_event ##### -->
<para>
</para>
@pad:
@event:
@Returns:
<!-- ##### FUNCTION gst_pad_event_default ##### -->
<para>
</para>
@pad:
@event:
<!-- ##### FUNCTION gst_pad_set_event_function ##### -->
<para>
</para>
@pad:
@event:
<!-- ##### STRUCT GstRealPad ##### -->
<para>
</para>
@pad:
@caps:
@direction:
@sched:
@sched_private:
@peer:
@bufpen:
@regiontype:
@offset:
@len:
@chainfunc:
@chainhandler:
@getfunc:
@gethandler:
@eventfunc:
@eventhandler:
@getregionfunc:
@pullregionfunc:
@negotiatefunc:
@newcapsfunc:
@bufferpoolfunc:
@ghostpads:
<!-- ##### MACRO GST_RPAD_LEN ##### -->
<para>
Get the length of the region that is being pulled.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_OFFSET ##### -->
<para>
Get the offset of the region that is being pulled.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_SCHED ##### -->
<para>
Get the scheduler of this real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_REGIONTYPE ##### -->
<para>
Get the type of the region that is being pulled.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_DIRECTION ##### -->
<para>
Get the direction of the real pad.
</para>
@pad: the realpad to query.
<!-- ##### MACRO GST_RPAD_CAPS ##### -->
<para>
Get the caps of the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_PEER ##### -->
<para>
Get the peer element of the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_BUFPEN ##### -->
<para>
Get the bufpen of the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_CHAINFUNC ##### -->
<para>
Get the chain function of the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_GETFUNC ##### -->
<para>
Get get getfunction of the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_GETREGIONFUNC ##### -->
<para>
Get the getregion function of the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_PULLREGIONFUNC ##### -->
<para>
Get the pullregion function of the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_NEGOTIATEFUNC ##### -->
<para>
Get the negotiate function from the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_NEWCAPSFUNC ##### -->
<para>
Get the newcaps function from the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_BUFFERPOOLFUNC ##### -->
<para>
Get the bufferpoolfunction from the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_CHAINHANDLER ##### -->
<para>
Get the eventhandler function from the real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_EVENTFUNC ##### -->
<para>
Get the event function of this real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_EVENTHANDLER ##### -->
<para>
Get the eventhandler function of this real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_RPAD_GETHANDLER ##### -->
<para>
Get the gethandler function of this real pad.
</para>
@pad: the real pad to query.
<!-- ##### MACRO GST_GPAD_REALPAD ##### -->
<para>
Get the real pad of this ghost pad.
</para>
@pad: the real pad to query.
<!-- ##### STRUCT GstGhostPad ##### -->
<para>
</para>
@pad:
@realpad:
<!-- ##### FUNCTION gst_ghost_pad_new ##### -->
<para>
</para>
@name:
@pad:
@Returns:

209
docs/gst/tmpl/gstpadtemplate.sgml
View file

@ -1,209 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstPadTemplate
<!-- ##### SECTION Short_Description ##### -->
Describe the media type of a pad.
<!-- ##### SECTION Long_Description ##### -->
<para>
Padtemplates describe the possible media types a pad or an elementfactory can
handle.
</para>
<para>
Pad and PadTemplates have #GstCaps attached to it to describe the media type they
are capable of dealing with. gst_padtemplate_get_caps() is used to get the
caps of a padtemplate. It's not possible to modify the caps of a padtemplate after
creation.
</para>
<para>
Padtemplates can be created with gst_padtemplate_new() or with the convenient
GST_PADTEMPLATE_FACTORY() macro. A padtemplate can be used to create a pad or
to add to an elementfactory.
</para>
<para>
The following code example shows the code to create a pad from a padtemplate.
<programlisting>
GST_PADTEMPLATE_FACTORY (my_template_factory,
"sink", /* the name of the pad */
GST_PAD_SINK, /* the direction of the pad */
GST_PAD_ALWAYS, /* when this pad will be present */
GST_CAPS_NEW ( /* the capabilities of the padtemplate */
"my_caps",
"audio/raw",
"format", GST_PROPS_STRING ("int"),
"channels", GST_PROPS_INT_RANGE (1, 6)
)
)
void
my_method (void)
{
GstPad *pad;
pad = gst_pad_new_from_template (GST_PADTEMPLATE_GET (my_template_factory), "sink");
...
}
</programlisting>
</para>
<para>
The following example shows you how to add the padtemplate to an elementfactory:
<programlisting>
gboolean
my_factory_init (GstPlugin *plugin)
{
GstElementFactory *factory;
factory = gst_elementfactory_new ("my_factory", GST_TYPE_MYFACTORY, &amp;gst_myfactory_details);
g_return_val_if_fail (factory != NULL, FALSE);
gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (my_template_factory));
gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
return TRUE;
}
</programlisting>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstPad, #GstElementFactory
</para>
<!-- ##### ENUM GstPadPresence ##### -->
<para>
Indicates when this pad will become available.
</para>
@GST_PAD_ALWAYS: the pad is always available
@GST_PAD_SOMETIMES: the pad will become available depending on the media stream
@GST_PAD_REQUEST: th pad is only available on request with
gst_element_request_pad_by_name() or gst_element_request_compatible_pad().
<!-- ##### STRUCT GstPadTemplate ##### -->
<para>
</para>
@object:
@name_template:
@direction:
@presence:
@caps:
<!-- ##### MACRO GST_PADTEMPLATE_CAPS ##### -->
<para>
Get a handle to the padtemplate #GstCaps
</para>
@templ: the template to query
<!-- ##### MACRO GST_PADTEMPLATE_DIRECTION ##### -->
<para>
Get the direction of the padtemplate.
</para>
@templ: the template to query
<!-- ##### MACRO GST_PADTEMPLATE_NAME_TEMPLATE ##### -->
<para>
Get the nametemplate of the padtemplate.
</para>
@templ: the template to query
<!-- ##### MACRO GST_PADTEMPLATE_PRESENCE ##### -->
<para>
Get the presence of the padtemplate.
</para>
@templ: the template to query
<!-- ##### MACRO GST_PADTEMPLATE_NEW ##### -->
<para>
Create a new padtemplate.
</para>
@padname: the nametemplate for the pads that will be created with this template
@dir: the direction of the pads.
@pres: the presence of the pads.
@a...: the capabilities of this padtemplate usually created with GST_CAPS_NEW()
<!-- ##### MACRO GST_PADTEMPLATE_FACTORY ##### -->
<para>
Create a factory for a padtemplate. This can be used if you only want one instance
of the padtemplate. Use GST_PADTEMPLATE_GET() to get the unique padtemplate.
</para>
@name: th name of the factory
@padname: the nametemplate of the pads
@dir: the direction of the pads.
@pres: the presence of the pads.
@a...: the capabilities of this padtemplate, usually created with GST_CAPS_NEW()
<!-- ##### MACRO GST_PADTEMPLATE_GET ##### -->
<para>
Get the padtemplate of the factory created with GST_PADTEMPLATE_FACTORY()
</para>
@fact: the factory name to get the padtemplate from.
<!-- ##### FUNCTION gst_padtemplate_new ##### -->
<para>
</para>
@name_template:
@direction:
@presence:
@caps:
@Varargs:
@Returns:
<!-- ##### FUNCTION gst_padtemplate_load_thyself ##### -->
<para>
</para>
@parent:
@Returns:
<!-- ##### FUNCTION gst_padtemplate_save_thyself ##### -->
<para>
</para>
@templ:
@parent:
@Returns:
<!-- ##### FUNCTION gst_padtemplate_get_caps ##### -->
<para>
</para>
@templ:
@Returns:
<!-- ##### FUNCTION gst_padtemplate_get_caps_by_name ##### -->
<para>
</para>
@templ:
@name:
@Returns:

65
docs/gst/tmpl/gstparse.sgml
View file

@ -1,65 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstParse
<!-- ##### SECTION Short_Description ##### -->
Parses commandline syntax into a pipeline.
<!-- ##### SECTION Long_Description ##### -->
<para>
This method allows you to create a pipeline from a command
line syntax description. The following example creates a simple
mp3 player.
<programlisting>
GstElement *pipeline;
/* create a pipeline to hold our elements */
pipeline = gst_pipeline_new ("launch");
/* build a pipeline in the pipeline */
gst_parse_launch ("filesrc location=some.mp3 ! mad ! osssink", GST_BIN (pipeline));
/* play the thing */
gst_element_set_state (pipeline, GST_STATE_PLAYING);
while (gst_bin_iterate (GST_BIN (pipeline)));
gst_element_set_state (pipeline, GST_STATE_NULL);
</programlisting>
</para>
<para>
Elements are separated with a <option>!</option>, properties are set with
<replaceable>property</replaceable>=<replaceable>value</replaceable>, specific pads
of an element are selected by replacing the <option>!</option> with
<replaceable>padname</replaceable><option>!</option>.
</para>
<para>
Elements can be added to a bin by embracing them with <option>()</option>. Threads
can be made with <option>{}</option>.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ENUM GstParseErrors ##### -->
<para>
</para>
@GST_PARSE_ERROR_SYNTAX:
@GST_PARSE_ERROR_CREATING_ELEMENT:
@GST_PARSE_ERROR_NOSUCH_ELEMENT:
<!-- ##### FUNCTION gst_parse_launch ##### -->
<para>
</para>
@cmdline:
@parent:
@Returns:

22
docs/gst/tmpl/gstpipefilter.sgml
View file

@ -1,22 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstPipefilter
<!-- ##### SECTION Short_Description ##### -->
A wrapper around every stdin/stdout capable program
<!-- ##### SECTION Long_Description ##### -->
<para>
A GstPipefilter pipes data to an external program and creates
buffers from its output.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ARG GstPipefilter:command ##### -->
<para>
Sets the command to be executed.
</para>

46
docs/gst/tmpl/gstpipeline.sgml
View file

@ -1,46 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstPipeline
<!-- ##### SECTION Short_Description ##### -->
Top-level bin with scheduling and pipeline management functionality.
<!-- ##### SECTION Long_Description ##### -->
<para>
In almost all cases, you'll want to use a GstPipeline when creating a
filter graph. The GstPipeline will manage all the scheduling issues,
including threading, as well as provide simple interfaces to common
functions, like 'Play'.
</para>
<para>
gst_pipeline_new() is used to create a pipeline. when you are done with
the pipeline, use gst_element_unref() to free its resources.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstBin
</para>
<!-- ##### STRUCT GstPipeline ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_pipeline_new ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### MACRO gst_pipeline_destroy ##### -->
<para>
Destroys the pipeline.
</para>
@pipeline: #GstPipeline to destroy

269
docs/gst/tmpl/gstplugin.sgml
View file

@ -1,269 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstPlugin
<!-- ##### SECTION Short_Description ##### -->
Dynamically loadable Elements
<!-- ##### SECTION Long_Description ##### -->
<para>
GStreamer is extensible so <classname>GstElements</classname> can be loaded at runtime. A plugin
system can provide one or more of the basic <application>GStreamer</application>
#GstPluginFeature subclasses.
</para>
<para>
A plugin should export a symbol plugin_desc that is a struct of type #GstPluginDesc.
the plugin loader will check the version of the core library the plugin was linked against
and will create a new #GstPlugin. It will then call the #GstPluginInitFunc function
that was provided in the plugin_desc.
</para>
<para>
Once you have a handle to a #GstPlugin, you can add any object that subclasses #GstPluginFeature.
</para>
<para>
use gst_plugin_find(), gst_plugin_get_list() and gst_plugin_get_feature_list()
to query the plugin repository.
</para>
<para>
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
to bring the plugin into memory.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstPluginFeature, #GstType, #GstAutoplug, #GstElementFactory
</para>
<!-- ##### STRUCT GstPlugin ##### -->
<para>
</para>
@name:
@longname:
@filename:
@features:
@numfeatures:
@module:
<!-- ##### USER_FUNCTION GstPluginInitFunc ##### -->
<para>
A plugin should provide a pointer to a function of this type in the plugin_desc struct.
It will be called by the loader at statup.
</para>
@module: The <classname>GModule</classname> it was loaded from
@plugin: The plugin object that can be used to register stuff for this plugin.
@Returns: A boolean indicating success or failure.
<!-- ##### STRUCT GstPluginDesc ##### -->
<para>
A plugins should export a variable of this type called plugin_desc. This plugin
loaded will use this variable to initialize the plugin.
</para>
@major_version: The minor version of the gstreamer library this plugin was created with
@minor_version: The minor version of the gstreamer library this plugin was created with
@name: The name of the plugin
@plugin_init: The init function of this plugin.
<!-- ##### MACRO GST_PLUGIN_DESC ##### -->
<para>
A handy macro to define a plugin description. This macro handles with all the issues
involved with the different linking methods for this plugin.
</para>
@major: The major version of GStreamer this plugin was compiled against.
@minor: The minor version of GStreamer this plugin was compiled against.
@name: The name of the plugin.
@init: The init function of this plugin.
<!-- ##### MACRO GST_PLUGIN_DESC_DYNAMIC ##### -->
<para>
The macro used to define dynamically loaded plugins.
</para>
@major: The major version of GStreamer this plugin was compiled against.
@minor: The minor version of GStreamer this plugin was compiled against.
@name: The name of the plugin.
@init: The init function of this plugin.
<!-- ##### MACRO GST_PLUGIN_DESC_STATIC ##### -->
<para>
A macro used to define a statically linked plugin.
</para>
@major: The major version of GStreamer this plugin was compiled against.
@minor: The minor version of GStreamer this plugin was compiled against.
@name: The name of the plugin.
@init: The init function of this plugin.
<!-- ##### FUNCTION gst_plugin_set_name ##### -->
<para>
</para>
@plugin:
@name:
<!-- ##### FUNCTION gst_plugin_get_name ##### -->
<para>
</para>
@plugin:
@Returns:
<!-- ##### FUNCTION gst_plugin_get_longname ##### -->
<para>
</para>
@plugin:
@Returns:
<!-- ##### FUNCTION gst_plugin_set_longname ##### -->
<para>
</para>
@plugin:
@longname:
<!-- ##### FUNCTION gst_plugin_get_filename ##### -->
<para>
</para>
@plugin:
@Returns:
<!-- ##### FUNCTION gst_plugin_is_loaded ##### -->
<para>
</para>
@plugin:
@Returns:
<!-- ##### FUNCTION gst_plugin_load_all ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_plugin_load ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_plugin_load_absolute ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_plugin_add_path ##### -->
<para>
</para>
@path:
<!-- ##### FUNCTION gst_library_load ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_plugin_find ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_plugin_get_list ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_plugin_load_thyself ##### -->
<para>
</para>
@parent:
<!-- ##### FUNCTION gst_plugin_save_thyself ##### -->
<para>
</para>
@parent:
@Returns:
<!-- ##### FUNCTION gst_plugin_add_feature ##### -->
<para>
</para>
@plugin:
@feature:
<!-- ##### FUNCTION gst_plugin_get_feature_list ##### -->
<para>
</para>
@plugin:
@Returns:
<!-- ##### FUNCTION gst_plugin_load_plugin ##### -->
<para>
</para>
@plugin:
@Returns:
<!-- ##### FUNCTION gst_plugin_unload_all ##### -->
<para>
</para>

33
docs/gst/tmpl/gstpluginfeature.sgml
View file

@ -1,33 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstPluginFeature
<!-- ##### SECTION Short_Description ##### -->
The base class for plugable objects.
<!-- ##### SECTION Long_Description ##### -->
<para>
This is a base class for anything that can be added to a #GstPlugin.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstPlugin
</para>
<!-- ##### FUNCTION gst_plugin_feature_ensure_loaded ##### -->
<para>
</para>
@feature:
@Returns:
<!-- ##### FUNCTION gst_plugin_feature_unload_thyself ##### -->
<para>
</para>
@feature:

290
docs/gst/tmpl/gstprops.sgml
View file

@ -1,290 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstProps
<!-- ##### SECTION Short_Description ##### -->
Properties
<!-- ##### SECTION Long_Description ##### -->
<para>
GstProps is used to attach certain properties to a pad. Properties
are usually used in conjunction with GstCaps.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstCaps
</para>
<!-- ##### STRUCT GstProps ##### -->
<para>
</para>
@refcount:
@lock:
@properties: the properties
<!-- ##### MACRO GST_MAKE_FOURCC ##### -->
<para>
Create a FOURCC value that can easily be used to construct
a fourcc property.
<programlisting>
...
"format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y','U','Y','2')),
...
</programlisting>
</para>
@a: first fourcc byte
@b: second fourcc byte
@c: third fourcc byte
@d: fourth fourcc byte
<!-- ##### MACRO GST_STR_FOURCC ##### -->
<para>
Create a FOURCC value from a string. example:
<programlisting>
...
"format", GST_PROPS_FOURCC (GST_STR_FOURCC ("YUY2")),
...
</programlisting>
</para>
@f: the string describing the fourcc value.
<!-- ##### MACRO GST_PROPS_LIST ##### -->
<para>
Create a list of properties.
</para>
@a...: the list of GstProps
<!-- ##### MACRO GST_PROPS_INT ##### -->
<para>
Create an integer property.
</para>
@a: the integer property
<!-- ##### MACRO GST_PROPS_INT_RANGE ##### -->
<para>
Create an integer range property.
</para>
@a: the min value for the range
@b: the max value for the range
<!-- ##### MACRO GST_PROPS_FOURCC ##### -->
<para>
Construct a fourcc property out of four bytes.
</para>
@a: a fourcc value usualy created with GST_FOURCC_MAKE ()
<!-- ##### MACRO GST_PROPS_BOOLEAN ##### -->
<para>
Create a boolean property.
</para>
@a: the boolean property
<!-- ##### MACRO GST_PROPS_STRING ##### -->
<para>
Create a string value.
</para>
@a: the string value.
<!-- ##### MACRO GST_PROPS_FLOAT ##### -->
<para>
Create a floating point value.
</para>
@a: the float value
<!-- ##### MACRO GST_PROPS_FLOAT_RANGE ##### -->
<para>
Create a float range value.
</para>
@a: lower float bounds
@b: upper float bounds
<!-- ##### FUNCTION gst_props_new ##### -->
<para>
</para>
@firstname:
@Varargs:
@Returns:
<!-- ##### FUNCTION gst_props_newv ##### -->
<para>
</para>
@firstname:
@var_args:
@Returns:
<!-- ##### FUNCTION gst_props_merge ##### -->
<para>
</para>
@props:
@tomerge:
@Returns:
<!-- ##### FUNCTION gst_props_copy ##### -->
<para>
</para>
@props:
@Returns:
<!-- ##### FUNCTION gst_props_copy_on_write ##### -->
<para>
</para>
@props:
@Returns:
<!-- ##### FUNCTION gst_props_destroy ##### -->
<para>
</para>
@props:
<!-- ##### FUNCTION gst_props_ref ##### -->
<para>
</para>
@props:
<!-- ##### FUNCTION gst_props_unref ##### -->
<para>
</para>
@props:
<!-- ##### FUNCTION gst_props_check_compatibility ##### -->
<para>
</para>
@fromprops:
@toprops:
@Returns:
<!-- # Unused Parameters # -->
@props1:
@props2:
<!-- ##### FUNCTION gst_props_set ##### -->
<para>
</para>
@props:
@name:
@Varargs:
@Returns:
<!-- # Unused Parameters # -->
@entry:
@value:
<!-- ##### FUNCTION gst_props_get_boolean ##### -->
<para>
</para>
@props:
@name:
@Returns:
<!-- ##### FUNCTION gst_props_get_fourcc_int ##### -->
<para>
</para>
@props:
@name:
@Returns:
<!-- ##### FUNCTION gst_props_get_int ##### -->
<para>
</para>
@props:
@name:
@Returns:
<!-- ##### FUNCTION gst_props_get_string ##### -->
<para>
</para>
@props:
@name:
@Returns:
<!-- ##### FUNCTION gst_props_get_float ##### -->
<para>
</para>
@props:
@name:
@Returns:
<!-- ##### FUNCTION gst_props_save_thyself ##### -->
<para>
</para>
@props:
@parent:
@Returns:
<!-- ##### FUNCTION gst_props_load_thyself ##### -->
<para>
</para>
@parent:
@Returns:

48
docs/gst/tmpl/gstqueue.sgml
View file

@ -1,48 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstQueue
<!-- ##### SECTION Short_Description ##### -->
Simple asynchronous data queue.
<!-- ##### SECTION Long_Description ##### -->
<para>
Simple data queue. Data is queued till max_level buffers 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.
</para>
<para>
You can query how many buffers are queued with the level argument.
</para>
<para>
The default queue length is set to 10.
</para>
<para>
The queue blocks by default.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ARG GstQueue:leaky ##### -->
<para>
</para>
<!-- ##### ARG GstQueue:level ##### -->
<para>
Get the number of buffers in the queue.
</para>
<!-- ##### ARG GstQueue:max-level ##### -->
<para>
Specify the maximum number of buffers in the queue before the queue
blocks.
</para>
<!-- ##### ARG GstQueue:may-deadlock ##### -->
<para>
</para>

5479
docs/gst/tmpl/gstreamer-unused.sgml
View file

File diff suppressed because it is too large Load diff

188
docs/gst/tmpl/gstscheduler.sgml
View file

@ -1,188 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstScheduler
<!-- ##### SECTION Short_Description ##### -->
An abstract class for plugable schedulers.
<!-- ##### SECTION Long_Description ##### -->
<para>
This is a base class for custom schedulers.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### MACRO GST_SCHEDULER_PARENT ##### -->
<para>
Get the parent object of this scheduler.
</para>
@sched: the scheduler to get the parent of.
<!-- ##### MACRO GST_SCHEDULER_STATE ##### -->
<para>
Get the state of the scheduler.
</para>
@sched: the scheduler to get the state of.
<!-- ##### ENUM GstSchedulerState ##### -->
<para>
</para>
@GST_SCHEDULER_STATE_NONE:
@GST_SCHEDULER_STATE_RUNNING:
@GST_SCHEDULER_STATE_STOPPED:
@GST_SCHEDULER_STATE_ERROR:
<!-- ##### MACRO gst_scheduler_destroy ##### -->
<para>
Destroy the scheduler
</para>
@sched: The scheduler to destroy.
<!-- ##### FUNCTION gst_scheduler_setup ##### -->
<para>
</para>
@sched:
<!-- ##### FUNCTION gst_scheduler_reset ##### -->
<para>
</para>
@sched:
<!-- ##### FUNCTION gst_scheduler_add_element ##### -->
<para>
</para>
@sched:
@element:
<!-- ##### FUNCTION gst_scheduler_remove_element ##### -->
<para>
</para>
@sched:
@element:
<!-- ##### FUNCTION gst_scheduler_state_transition ##### -->
<para>
</para>
@sched:
@element:
@transition:
@Returns:
<!-- ##### FUNCTION gst_scheduler_lock_element ##### -->
<para>
</para>
@sched:
@element:
<!-- ##### FUNCTION gst_scheduler_unlock_element ##### -->
<para>
</para>
@sched:
@element:
<!-- ##### FUNCTION gst_scheduler_yield ##### -->
<para>
</para>
@sched:
@element:
<!-- ##### FUNCTION gst_scheduler_interrupt ##### -->
<para>
</para>
@sched:
@element:
@Returns:
<!-- ##### FUNCTION gst_scheduler_error ##### -->
<para>
</para>
@sched:
@element:
<!-- ##### FUNCTION gst_scheduler_pad_connect ##### -->
<para>
</para>
@sched:
@srcpad:
@sinkpad:
<!-- ##### FUNCTION gst_scheduler_pad_disconnect ##### -->
<para>
</para>
@sched:
@srcpad:
@sinkpad:
<!-- ##### FUNCTION gst_scheduler_pad_select ##### -->
<para>
</para>
@sched:
@padlist:
@Returns:
<!-- ##### FUNCTION gst_scheduler_iterate ##### -->
<para>
</para>
@sched:
@Returns:
<!-- ##### FUNCTION gst_scheduler_show ##### -->
<para>
</para>
@sched:

105
docs/gst/tmpl/gstschedulerfactory.sgml
View file

@ -1,105 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstSchedulerFactory
<!-- ##### SECTION Short_Description ##### -->
Create schedulers from a factory
<!-- ##### SECTION Long_Description ##### -->
<para>
A schedulerfactory is used to create instances of a scheduler. It
can be added to a #GstPlugin as it extends #GstPluginFeature.
</para>
<para>
Use gst_schedulerfactory_new() to create a new scheduler which can be registered
to a plugin with gst_plugin_add_feature().
</para>
<para>
Use gst_schedulerfactory_find() to find the named schedulerfactory.
or use gst_schedulerfactory_get_list() to get a list of all available schedulers.
</para>
<para>
Once an schedulerfactory has been obtained use gst_schedulerfactory_create() to
instantiate a real scheduler. Optionally gst_schedulerfactory_make() to create
a scheduler from the named factory.
</para>
<para>
Use gst_schedulerfactory_destroy() to remove the factory from the global list.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_schedulerfactory_create ##### -->
<para>
</para>
@factory:
@parent:
@Returns:
<!-- ##### FUNCTION gst_schedulerfactory_destroy ##### -->
<para>
</para>
@factory:
<!-- ##### FUNCTION gst_schedulerfactory_find ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_schedulerfactory_get_list ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_schedulerfactory_make ##### -->
<para>
</para>
@name:
@parent:
@Returns:
<!-- ##### FUNCTION gst_schedulerfactory_new ##### -->
<para>
</para>
@name:
@longdesc:
@type:
@Returns:
<!-- ##### FUNCTION gst_schedulerfactory_get_default_name ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_schedulerfactory_set_default_name ##### -->
<para>
</para>
@name:

17
docs/gst/tmpl/gststaticautoplug.sgml
View file

@ -1,17 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstStaticAutoplug
<!-- ##### SECTION Short_Description ##### -->
A static autoplugger.
<!-- ##### SECTION Long_Description ##### -->
<para>
This autoplugger will create a non threaded element before running the
pipeline.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>

17
docs/gst/tmpl/gststaticautoplugrender.sgml
View file

@ -1,17 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstStaticAutoplugRender
<!-- ##### SECTION Short_Description ##### -->
An autoplugger made for media playback
<!-- ##### SECTION Long_Description ##### -->
<para>
this autoplugger will create a threaded element that can be used
in media players.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>

69
docs/gst/tmpl/gststatistics.sgml
View file

@ -1,69 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstStatistics
<!-- ##### SECTION Short_Description ##### -->
Provide statistics about data that passes this plugin
<!-- ##### SECTION Long_Description ##### -->
<para>
The plugin doesn't alter the data but provides statistics about
the data stream, such as buffers/bytes/events etc.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SIGNAL GstStatistics::update ##### -->
<para>
</para>
@gststatistics: the object which received the signal.
<!-- ##### ARG GstStatistics:buffers ##### -->
<para>
</para>
<!-- ##### ARG GstStatistics:bytes ##### -->
<para>
</para>
<!-- ##### ARG GstStatistics:events ##### -->
<para>
</para>
<!-- ##### ARG GstStatistics:buffer-update-freq ##### -->
<para>
</para>
<!-- ##### ARG GstStatistics:bytes-update-freq ##### -->
<para>
</para>
<!-- ##### ARG GstStatistics:event-update-freq ##### -->
<para>
</para>
<!-- ##### ARG GstStatistics:update-on-eos ##### -->
<para>
</para>
<!-- ##### ARG GstStatistics:update ##### -->
<para>
</para>
<!-- ##### ARG GstStatistics:silent ##### -->
<para>
</para>

26
docs/gst/tmpl/gsttee.sgml
View file

@ -1,26 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstTee
<!-- ##### SECTION Short_Description ##### -->
1-to-N pipe fitting
<!-- ##### SECTION Long_Description ##### -->
<para>
A tee can be used to split out the filter graph.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ARG GstTee:num-pads ##### -->
<para>
</para>
<!-- ##### ARG GstTee:silent ##### -->
<para>
</para>

45
docs/gst/tmpl/gstthread.sgml
View file

@ -1,45 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstThread
<!-- ##### SECTION Short_Description ##### -->
A bin that will become a thread
<!-- ##### SECTION Long_Description ##### -->
<para>
A bin that will become a thread if possible when the pipeline is started
up. Can contain any set of GstObjects except another GstThread. All
starting points and/or clocked events must be registered with this object,
to be dealt with in the separate thread.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### ENUM GstThreadState ##### -->
<para>
Thread flags:
</para>
@GST_THREAD_STATE_STARTED:
@GST_THREAD_STATE_SPINNING: The thread is runnning
@GST_THREAD_STATE_REAPING: The thread is ending.
@GST_THREAD_FLAG_LAST: subclass use this to start their enumeration
<!-- ##### STRUCT GstThread ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_thread_new ##### -->
<para>
</para>
@name:
@Returns:

136
docs/gst/tmpl/gsttimecache.sgml
View file

@ -1,136 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstTimeCache
<!-- ##### SECTION Short_Description ##### -->
Cache time and byteoffsets.
<!-- ##### SECTION Long_Description ##### -->
<para>
This clas is used by plugins to manage time vs byte offsets. It is mainly
used for efficient seeking.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### STRUCT GstTimeCacheEntry ##### -->
<para>
</para>
@location:
@timestamp:
<!-- ##### STRUCT GstTimeCacheGroup ##### -->
<para>
</para>
@groupnum:
@entries:
@certainty:
@peergroup:
@mintimestamp:
@maxtimestamp:
@minlocation:
@maxlocation:
<!-- ##### ENUM GstTimeCacheCertainty ##### -->
<para>
</para>
@GST_TIMECACHE_UNKNOWN:
@GST_TIMECACHE_CERTAIN:
@GST_TIMECACHE_FUZZY_LOCATION:
@GST_TIMECACHE_FUZZY_TIMESTAMP:
@GST_TIMECACHE_FUZZY:
<!-- ##### FUNCTION gst_timecache_new ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_timecache_get_group ##### -->
<para>
</para>
@tc:
@Returns:
<!-- ##### FUNCTION gst_timecache_new_group ##### -->
<para>
</para>
@tc:
@Returns:
<!-- ##### FUNCTION gst_timecache_set_group ##### -->
<para>
</para>
@tc:
@groupnum:
@Returns:
<!-- ##### FUNCTION gst_timecache_set_certainty ##### -->
<para>
</para>
@tc:
@certainty:
<!-- ##### FUNCTION gst_timecache_get_certainty ##### -->
<para>
</para>
@tc:
@Returns:
<!-- ##### FUNCTION gst_timecache_add_entry ##### -->
<para>
</para>
@tc:
@location:
@timestamp:
<!-- ##### FUNCTION gst_timecache_find_location ##### -->
<para>
</para>
@tc:
@location:
@timestamp:
@Returns:
<!-- ##### FUNCTION gst_timecache_find_timestamp ##### -->
<para>
</para>
@tc:
@timestamp:
@location:
@Returns:

16
docs/gst/tmpl/gsttrace.sgml
View file

@ -1,16 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstTrace
<!-- ##### SECTION Short_Description ##### -->
Tracing functionality
<!-- ##### SECTION Long_Description ##### -->
<para>
Tracing functionality
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>

108
docs/gst/tmpl/gsttype.sgml
View file

@ -1,108 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstType
<!-- ##### SECTION Short_Description ##### -->
Identifies the data
<!-- ##### SECTION Long_Description ##### -->
<para>
GstTypes exist to try to make sure data eveyrone is talking about the
right kind of data. They aid quite a bit in autoplugging, in fact make it
possible. Each well-formed type includes a function (typefind) that will
take one or more buffers and determine whether or not it is indeed a
stream of that type, and possible a metadata to go with it. It may
provide related metadata structure IDs (and must if it provides metadata
from the typefind function).
</para>
<para>
Because multiple elements and plugins are very likely to be using the same
types, the process of creating/finding types is designed to be done with a
single function call. All operations on GstTypes occur via their guint16
ID numbers, with the GstType structure "private" to the GST library. A
plugin wishing to use a give type would contain a static struct of type
GstTypeFactory, which lists the MIME type, possible extensions (which may
overlap the mime-types file), a typefind function, and any other cruft I
decide to add.
</para>
<para>
A plugin init function would take this typefactory and hand it to the
gst_type_new() (FIXME: badly named) function, which would first search for
that same MIME type in the current list. If it found one, it would
compare the two to see if the new one is "better". Better is defined as
having more extentions (to be merged) or a typefind function verses none.
</para>
<para>
The point of returning an existing MIME type is a result of the goal of
unifying types enough to guarantee that, for instance, all MP3 decoders
will work interchangably. If MP3 decoder A says "MIME type 'audio/mpeg'
with extensions 'mpeg3'" and decoder B says "MIME type 'audio/mpeg' with
extensions 'mp3'", we don't want to have two types defined, possibly with
two typefind functions. If we did, it's not obvious which of the two would
be tried first (luck) and if both would really identify streams as mp3
correctly in all cases. And whichever wins, we're stuck using the
associated decoder to play that stream. We lose the choice between any
valid mp3 decoder, and thus the whole point of the type system.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstTypeFactory
</para>
<!-- ##### STRUCT GstType ##### -->
<para>
A type.
</para>
@id:
@mime:
@exts:
@factories:
<!-- ##### FUNCTION gst_type_register ##### -->
<para>
</para>
@factory:
@Returns:
<!-- ##### FUNCTION gst_type_find_by_mime ##### -->
<para>
</para>
@mime:
@Returns:
<!-- ##### FUNCTION gst_type_find_by_ext ##### -->
<para>
</para>
@ext:
@Returns:
<!-- ##### FUNCTION gst_type_find_by_id ##### -->
<para>
</para>
@id:
@Returns:
<!-- ##### FUNCTION gst_type_get_list ##### -->
<para>
</para>
@Returns:

107
docs/gst/tmpl/gsttypefactory.sgml
View file

@ -1,107 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstTypeFactory
<!-- ##### SECTION Short_Description ##### -->
Add types to plugins.
<!-- ##### SECTION Long_Description ##### -->
<para>
A GstTypeFactory is used to add a new type and a typedetection function
to a plugin. Typefactories are named so they can be found with
gst_typefactory_find().
</para>
<para>
gst_typefactory_new() is used to create a new typefactory from the given
#GstTypeDefinition. A typefactory is added to a #GstPlugin with
gst_plugin_add_feature() as shown in the example:
<programlisting>
static GstCaps*
avi_typefind (GstBuffer *buf, gpointer private)
{
gchar *data = GST_BUFFER_DATA (buf);
if (strncmp (&amp;data[0], "RIFF", 4)) return NULL;
if (strncmp (&amp;data[8], "AVI ", 4)) return NULL;
return gst_caps_new ("avi_typefind","video/avi", NULL);
}
/* typedefinition for 'avi' */
static GstTypeDefinition avidefinition = {
"avidecoder_video/avi", /* the name of this definition */
"video/avi", /* the mime type */
".avi", /* the file extensions */
avi_typefind, /* a pointer to a GstTypeFindFunc function */
};
static gboolean
plugin_init (GModule *module, GstPlugin *plugin)
{
GstTypeFactory *type;
...
type = gst_typefactory_new (&amp;avidefinition);
gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
...
}
</programlisting>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GstPluginFeature, #GstPlugin
</para>
<!-- ##### STRUCT GstTypeFactory ##### -->
<para>
The struct with the typefactory information.
</para>
<!-- ##### STRUCT GstTypeDefinition ##### -->
<para>
</para>
@name: The name of this factory
@mime: The mime type of the new type.
@exts: The extensions of this type.
@typefindfunc: An optional typefind function.
<!-- ##### USER_FUNCTION GstTypeFindFunc ##### -->
<para>
This is the function that will be called when a typefind has to be
performed by a plugin.
</para>
@buf: the buffer with media on which to perform the typefind
@priv: private; don't touch
@Returns: A #GstCaps structure describing the type or NULL if the
type was not recognized by this function;
<!-- ##### FUNCTION gst_typefactory_new ##### -->
<para>
</para>
@definition:
@Returns:
<!-- ##### FUNCTION gst_typefactory_find ##### -->
<para>
</para>
@name:
@Returns:
<!-- ##### FUNCTION gst_typefactory_get_list ##### -->
<para>
</para>
@Returns:

30
docs/gst/tmpl/gsttypefind.sgml
View file

@ -1,30 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstTypeFind
<!-- ##### SECTION Short_Description ##### -->
Detect the mime type of a media stream
<!-- ##### SECTION Long_Description ##### -->
<para>
This element can be added to the pipeline and will notify the listener of
the detected mime type of the stream. It is used in autoplugging.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SIGNAL GstTypeFind::have-type ##### -->
<para>
The signal to indicate the mime type was detected.
</para>
@gsttypefind: the object which received the signal.
@arg1: The mime type that was detected
<!-- ##### ARG GstTypeFind:caps ##### -->
<para>
</para>

146
docs/gst/tmpl/gstutils.sgml
View file

@ -1,146 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstUtils
<!-- ##### SECTION Short_Description ##### -->
Utility functions
<!-- ##### SECTION Long_Description ##### -->
<para>
Some convenience functions
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_util_set_object_arg ##### -->
<para>
</para>
@object:
@name:
@value:
<!-- ##### FUNCTION gst_util_get_int_arg ##### -->
<para>
</para>
@object:
@argname:
@Returns:
<!-- ##### FUNCTION gst_util_get_bool_arg ##### -->
<para>
</para>
@object:
@argname:
@Returns:
<!-- ##### FUNCTION gst_util_get_long_arg ##### -->
<para>
</para>
@object:
@argname:
@Returns:
<!-- ##### FUNCTION gst_util_get_float_arg ##### -->
<para>
</para>
@object:
@argname:
@Returns:
<!-- ##### FUNCTION gst_util_get_double_arg ##### -->
<para>
</para>
@object:
@argname:
@Returns:
<!-- ##### FUNCTION gst_util_get_string_arg ##### -->
<para>
</para>
@object:
@argname:
@Returns:
<!-- ##### FUNCTION gst_util_get_pointer_arg ##### -->
<para>
</para>
@object:
@argname:
@Returns:
<!-- ##### FUNCTION gst_util_get_int64_arg ##### -->
<para>
</para>
@object:
@argname:
@Returns:
<!-- ##### FUNCTION gst_util_dump_mem ##### -->
<para>
</para>
@mem:
@size:
<!-- ##### FUNCTION gst_util_has_arg ##### -->
<para>
</para>
@object:
@argname:
@arg_type:
@Returns:
<!-- ##### FUNCTION gst_print_element_args ##### -->
<para>
</para>
@buf:
@indent:
@element:
<!-- ##### FUNCTION gst_print_pad_caps ##### -->
<para>
</para>
@buf:
@indent:
@pad:

114
docs/gst/tmpl/gstxml.sgml
View file

@ -1,114 +0,0 @@
<!-- ##### SECTION Title ##### -->
GstXml
<!-- ##### SECTION Short_Description ##### -->
Convert Elements into an XML presentation.
<!-- ##### SECTION Long_Description ##### -->
<para>
All GstElements can be serialized to an XML presentation and subsequently loaded back.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### STRUCT GstXML ##### -->
<para>
</para>
@object:
@topelements:
@ns:
<!-- ##### FUNCTION gst_xml_new ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_xml_parse_doc ##### -->
<para>
</para>
@xml:
@doc:
@root:
@Returns:
<!-- ##### FUNCTION gst_xml_parse_memory ##### -->
<para>
</para>
@xml:
@buffer:
@size:
@root:
@Returns:
<!-- ##### FUNCTION gst_xml_parse_file ##### -->
<para>
</para>
@xml:
@fname:
@root:
@Returns:
<!-- ##### FUNCTION gst_xml_write ##### -->
<para>
</para>
@element:
@Returns:
<!-- ##### FUNCTION gst_xml_get_element ##### -->
<para>
</para>
@xml:
@name:
@Returns:
<!-- ##### FUNCTION gst_xml_get_topelements ##### -->
<para>
</para>
@xml:
@Returns:
<!-- ##### SIGNAL GstXml::object-loaded ##### -->
<para>
</para>
@gstxml: the object which received the signal.
@arg1:
@arg2:
<!-- ##### SIGNAL GstXml::object-loaded ##### -->
<para>
</para>
@gstxml: the object which received the signal.
@arg1:
@arg2:

3
examples/launch/mp3parselaunch.c
View file

@ -12,9 +12,8 @@ main (int argc, char *argv[])
g_print ("usage: %s <filename>\n", argv[0]);
return -1;
}
pipeline = gst_pipeline_new ("my_pipeline");
gst_parse_launch ("filesrc[my_filesrc] ! mp3parse ! mpg123 ! osssink", GST_BIN (pipeline));
pipeline = (GstElement*) gst_parse_launch ("filesrc [ my_filesrc ] ! mad ! osssink");
filesrc = gst_bin_get_by_name (GST_BIN (pipeline), "my_filesrc");
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);

535
gst/gstparse.c
View file

@ -20,6 +20,7 @@
* Boston, MA 02111-1307, USA.
*/
/* #define DEBUG(format,args...) g_print (format, ##args) */
#define DEBUG(format,args...)
#define DEBUG_NOPREFIX(format,args...)
#define VERBOSE(format,args...)
@ -73,7 +74,7 @@ dynamic_connect (GstElement * element, GstPad * newpad, gpointer data)
}
static gchar *
gst_parse_unique_name (gchar * type, gst_parse_priv * priv)
gst_parse_unique_name (const gchar * type, gst_parse_priv * priv)
{
gpointer tmp;
gint count;
@ -81,21 +82,20 @@ gst_parse_unique_name (gchar * type, gst_parse_priv * priv)
tmp = g_hash_table_lookup (priv->elementcounts, type);
count = GPOINTER_TO_INT (tmp);
count++;
g_hash_table_insert (priv->elementcounts, type, GINT_TO_POINTER (count));
g_hash_table_insert (priv->elementcounts, g_strdup (type), GINT_TO_POINTER (count));
return g_strdup_printf ("%s%d", type, count - 1);
}
static gint
gst_parse_launch_cmdline (int argc, char *argv[], GstBin * parent, gst_parse_priv * priv)
gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv * priv)
{
gint i = 0, j = 0;
gchar *arg;
gint i = -1, j = 0;
const gchar *arg;
GstElement *element = NULL, *previous = NULL, *prevelement = NULL;
gchar closingchar = '\0';
gint len;
const gchar *cptr;
gchar *ptr;
gchar *sinkpadname = NULL, *srcpadname = NULL, *tempname;
GstPad *temppad;
@ -106,50 +106,40 @@ gst_parse_launch_cmdline (int argc, char *argv[], GstBin * parent, gst_parse_pri
gint retval = 0;
gboolean backref = FALSE;
if (!priv) {
priv = g_new0 (gst_parse_priv, 1);
priv->elementcounts = g_hash_table_new (g_str_hash, g_str_equal);
}
priv->binlevel++;
if (GST_IS_PIPELINE (parent)) {
closingchar = '\0';
DEBUG ("in pipeline ");
}
else if (GST_IS_THREAD (parent)) {
} else if (GST_IS_THREAD (parent)) {
closingchar = '}';
DEBUG ("in thread ");
}
else {
} else {
closingchar = ')';
DEBUG ("in bin ");
}
DEBUG_NOPREFIX ("%s\n", GST_ELEMENT_NAME (GST_ELEMENT (parent)));
while (i < argc) {
arg = argv[i];
/* FIXME this is a lame solution for problems with the first parser */
if (arg == NULL) {
i++;
continue;
}
while ((arg = argv[++i])) {
len = strlen (arg);
element = NULL;
DEBUG ("** ARGUMENT is '%s'\n", arg);
/* a null that slipped through the reconstruction */
if (len == 0) {
DEBUG ("random arg, FIXME\n");
i++;
continue;
/* end of the container */
}
else if (arg[0] == closingchar) {
/* time to finish off this bin */
continue;
} else if (arg[0] == closingchar) {
DEBUG ("exiting container %s\n", GST_ELEMENT_NAME (GST_ELEMENT (parent)));
retval = i + 1;
break;
/* a pad connection */
}
else if ((ptr = strchr (arg, '!'))) {
} else if ((cptr = strchr (arg, '!'))) {
DEBUG ("attempting to connect pads together....\n");
/* if it starts with the ! */
@ -157,35 +147,35 @@ gst_parse_launch_cmdline (int argc, char *argv[], GstBin * parent, gst_parse_pri
srcpadname = NULL;
/* if there's a sinkpad... */
if (len > 1)
sinkpadname = &arg[1];
sinkpadname = g_strdup (&arg[1]);
else
sinkpadname = NULL;
}
else {
srcpadname = g_strndup (arg, (ptr - arg));
} else {
srcpadname = g_strndup (arg, (cptr - arg));
/* if there's a sinkpad */
if (len > (ptr - arg) + 1)
sinkpadname = &ptr[1];
if (len > (cptr - arg) + 1)
sinkpadname = g_strdup(&cptr[1]);
else
sinkpadname = NULL;
}
if (srcpadname && (ptr = strchr (srcpadname, '.'))) {
gchar *element_name = g_strndup (arg, (ptr - srcpadname));
gchar *element_name = srcpadname;
GstElement *new;
*ptr = '\0'; /* it was a '.' before */
GST_DEBUG (0, "have pad for element %s\n", element_name);
new = gst_bin_get_by_name_recurse_up (parent, element_name);
if (!new) {
GST_DEBUG (0, "element %s does not exist! trying to continue\n", element_name);
}
else {
previous = new;
GST_DEBUG (0, "element %s does not exist! trying to continue\n", element_name);
} else {
previous = new;
srcpadname = ptr + 1;
backref = TRUE;
}
}
GST_DEBUG (0, "have srcpad %s, sinkpad %s\n", srcpadname, sinkpadname);
g_slist_free (srcpads);
@ -198,10 +188,10 @@ gst_parse_launch_cmdline (int argc, char *argv[], GstBin * parent, gst_parse_pri
while (1) {
/* split name at commas */
if ((ptr = strchr (srcpadname, ','))) {
tempname = g_strndup (srcpadname, (ptr - srcpadname));
tempname = srcpadname;
srcpadname = &ptr[1];
}
else {
*ptr = '\0';
} else {
tempname = srcpadname;
}
@ -218,8 +208,7 @@ gst_parse_launch_cmdline (int argc, char *argv[], GstBin * parent, gst_parse_pri
}
if (!temppad) {
GST_DEBUG (0, "NO SUCH pad %s in element %s\n", tempname, GST_ELEMENT_NAME (previous));
}
else {
} else {
GST_DEBUG (0, "have src pad %s:%s\n", GST_DEBUG_PAD_NAME (temppad));
}
@ -228,10 +217,9 @@ gst_parse_launch_cmdline (int argc, char *argv[], GstBin * parent, gst_parse_pri
break;
g_free (tempname);
}
}
else {
/* check through the list to find the first sink pad */
GST_DEBUG (0, "CHECKING through element %s for pad named %s\n", GST_ELEMENT_NAME (previous),
} else {
/* check through the list to find the first src pad */
GST_DEBUG (0, "CHECKING element %s for pad named %s\n", GST_ELEMENT_NAME (previous),
srcpadname);
pads = gst_element_get_pad_list (previous);
while (pads) {
@ -251,227 +239,226 @@ gst_parse_launch_cmdline (int argc, char *argv[], GstBin * parent, gst_parse_pri
else
GST_DEBUG (0, "have src pad %s:%s\n", GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (srcpads)));
}
/* argument with = in it */
}
else if (strstr (arg, "=")) {
gchar *argname;
gchar *argval;
gchar *pos = strstr (arg, "=");
/* we have an argument */
argname = arg;
pos[0] = '\0';
argval = pos + 1;
GST_DEBUG (0, "attempting to set argument '%s' to '%s' on element '%s'\n",
argname, argval, GST_ELEMENT_NAME (previous));
gst_util_set_object_arg (G_OBJECT (previous), argname, argval);
g_free (argname);
/* element or argument, or beginning of bin or thread */
}
else if (arg[0] == '[') {
/* we have the start of a name of the preceding element. */
/* rename previous element to next arg. */
} else if (strchr (arg, '=')) {
gchar *propname;
gchar *propval;
gchar *pos;
DEBUG ("have a property\n");
/* we have a property */
propname = g_strdup (arg);
pos = strchr (propname, '=');
*pos = '\0';
propval = pos + 1;
/* use g_object_set in the future when gst_util_{set|get} go away */
GST_DEBUG (0, "attempting to set property '%s' to '%s' on element '%s'\n",
propname, propval, GST_ELEMENT_NAME (previous));
gst_util_set_object_arg (G_OBJECT (previous), propname, propval);
g_free (propname);
} else if (arg[0] == '[') {
DEBUG ("have element name\n");
if (arg[1] != '\0') {
fprintf (stderr, "error, unexpected junk after [\n");
return GST_PARSE_ERROR_SYNTAX;
fprintf (stderr, "error, unexpected junk after [\n");
return GST_PARSE_ERROR_SYNTAX;
}
i++;
if (i < argc) {
gst_element_set_name (previous, argv[i]);
if ((arg = argv[++i])) {
if (!previous) {
g_critical("parser error, please report");
return GST_PARSE_ERROR_INTERNAL;
}
gst_element_set_name (previous, arg);
} else {
fprintf (stderr, "error, expected element name, found end of arguments\n");
return GST_PARSE_ERROR_SYNTAX;
}
else {
fprintf (stderr, "error, expected element name, found end of arguments\n");
return GST_PARSE_ERROR_SYNTAX;
if ((arg = argv[++i])) {
if (strcmp (arg, "]") != 0) {
fprintf (stderr, "error, expected ], found '%s'\n", arg);
return GST_PARSE_ERROR_SYNTAX;
}
} else {
fprintf (stderr, "error, expected ], found end of arguments\n");
return GST_PARSE_ERROR_SYNTAX;
}
i++;
if (i >= argc) {
fprintf (stderr, "error, expected ], found end of arguments\n");
return GST_PARSE_ERROR_SYNTAX;
}
else if (strcmp (argv[i], "]") != 0) {
fprintf (stderr, "error, expected ], found '%s'\n", argv[i]);
return GST_PARSE_ERROR_SYNTAX;
}
}
else {
DEBUG ("have element or bin/thread\n");
/* if we have a bin or thread starting */
} else {
/* we have an element, a bin, or a thread. we treat these together because
* once we rech them we have to resolve any dangling connections from
* previous array arguments. */
if (strchr ("({", arg[0])) {
if (arg[0] == '(') {
/* create a bin and add it to the current parent */
element = gst_bin_new (g_strdup_printf ("bin%d", priv->bincount++));
if (!element) {
fprintf (stderr, "Couldn't create a bin!\n");
return GST_PARSE_ERROR_CREATING_ELEMENT;
}
GST_DEBUG (0, "CREATED bin %s\n", GST_ELEMENT_NAME (element));
}
else if (arg[0] == '{') {
/* create a thread and add it to the current parent */
element = gst_thread_new (g_strdup_printf ("thread%d", priv->threadcount++));
if (!element) {
fprintf (stderr, "Couldn't create a thread!\n");
return GST_PARSE_ERROR_CREATING_ELEMENT;
}
GST_DEBUG (0, "CREATED thread %s\n", GST_ELEMENT_NAME (element));
}
else {
DEBUG ("error in parser, unexpected symbol, FIXME\n");
i++;
continue;
}
DEBUG ("have bin or thread\n");
if (arg[0] == '(') {
/* create a bin and add it to the current parent */
element = gst_bin_new (g_strdup_printf ("bin%d", priv->bincount++));
if (!element) {
fprintf (stderr, "Couldn't create a bin!\n");
return GST_PARSE_ERROR_CREATING_ELEMENT;
}
GST_DEBUG (0, "CREATED bin %s\n", GST_ELEMENT_NAME (element));
} else if (arg[0] == '{') {
/* create a thread and add it to the current parent */
element = gst_thread_new (g_strdup_printf ("thread%d", priv->threadcount++));
if (!element) {
fprintf (stderr, "Couldn't create a thread!\n");
return GST_PARSE_ERROR_CREATING_ELEMENT;
}
GST_DEBUG (0, "CREATED thread %s\n", GST_ELEMENT_NAME (element));
} else {
fprintf (stderr, "Illegal argument: %s\n", arg);
return GST_PARSE_ERROR_CREATING_ELEMENT;
}
gst_bin_add (GST_BIN (parent), element);
j = gst_parse_launch_cmdline (argc - i, argv + i + 1, GST_BIN (element), priv);
/* check for parse error */
if (j < 0)
return j;
i += j;
}
else {
/* we have an element */
DEBUG ("attempting to create element '%s'\n", arg);
ptr = gst_parse_unique_name (arg, priv);
element = gst_elementfactory_make (arg, ptr);
g_free (ptr);
if (!element) {
j = gst_parse_launchv_recurse (argv + i + 1, GST_BIN (element), priv);
/* check for parse error */
if (j < 0)
return j;
/* we will get autoincremented at the while */
i += j;
} else {
/* we have an element */
DEBUG ("attempting to create element '%s'\n", arg);
ptr = gst_parse_unique_name (arg, priv);
element = gst_elementfactory_make (arg, ptr);
g_free (ptr);
if (!element) {
#ifndef GST_DISABLE_REGISTRY
fprintf (stderr,
"Couldn't create a '%s', no such element or need to run gst-register?\n",
arg);
fprintf (stderr,
"Couldn't create a '%s', no such element or need to run gst-register?\n", arg);
#else
fprintf (stderr, "Couldn't create a '%s', no such element or need to load pluginn?\n",
arg);
fprintf (stderr, "Couldn't create a '%s', no such element or need to load plugin?\n",
arg);
#endif
return GST_PARSE_ERROR_NOSUCH_ELEMENT;
}
GST_DEBUG (0, "CREATED element %s\n", GST_ELEMENT_NAME (element));
return GST_PARSE_ERROR_NOSUCH_ELEMENT;
}
GST_DEBUG (0, "CREATED element %s\n", GST_ELEMENT_NAME (element));
gst_bin_add (GST_BIN (parent), element);
}
elementcount++;
g_slist_free (sinkpads);
sinkpads = NULL;
numsinkpads = 0;
tempname = NULL;
/* find sink pads */
if (sinkpadname != NULL) {
while (1) {
/* split name at commas */
if ((ptr = strchr (sinkpadname, ','))) {
tempname = g_strndup (sinkpadname, (ptr - sinkpadname));
sinkpadname = &ptr[1];
}
else {
tempname = sinkpadname;
}
/* look for pad with that name */
if ((temppad = gst_element_get_pad (element, tempname))) {
sinkpads = g_slist_append (sinkpads, temppad);
numsinkpads++;
}
/* try to create a pad using that padtemplate name */
else if ((temppad = gst_element_request_pad_by_name (element, tempname))) {
sinkpads = g_slist_append (sinkpads, temppad);
numsinkpads++;
}
if (!temppad) {
GST_DEBUG (0, "NO SUCH pad %s in element %s\n", tempname, GST_ELEMENT_NAME (element));
}
else {
GST_DEBUG (0, "have sink pad %s:%s\n", GST_DEBUG_PAD_NAME (temppad));
}
/* if there is no more commas in sinkpadname then we're done */
if (tempname == sinkpadname)
break;
g_free (tempname);
}
}
else {
/* check through the list to find the first sink pad */
pads = gst_element_get_pad_list (element);
while (pads) {
temppad = GST_PAD (pads->data);
pads = g_list_next (pads);
if (gst_pad_get_direction (temppad) == GST_PAD_SINK) {
while (1) {
/* split name at commas */
if ((ptr = strchr (sinkpadname, ','))) {
tempname = g_strndup (sinkpadname, (ptr - sinkpadname));
sinkpadname = &ptr[1];
} else {
tempname = sinkpadname;
}
/* look for pad with that name */
if ((temppad = gst_element_get_pad (element, tempname))) {
sinkpads = g_slist_append (sinkpads, temppad);
numsinkpads++;
}
/* try to create a pad using that padtemplate name */
else if ((temppad = gst_element_request_pad_by_name (element, tempname))) {
sinkpads = g_slist_append (sinkpads, temppad);
numsinkpads++;
}
if (!temppad) {
GST_DEBUG (0, "NO SUCH pad %s in element %s\n", tempname, GST_ELEMENT_NAME (element));
} else {
GST_DEBUG (0, "have sink pad %s:%s\n", GST_DEBUG_PAD_NAME (temppad));
}
/* if there is no more commas in sinkpadname then we're done */
if (tempname == sinkpadname)
break;
g_free (tempname);
}
} else {
/* check through the list to find the first sink pad */
pads = gst_element_get_pad_list (element);
while (pads) {
temppad = GST_PAD (pads->data);
pads = g_list_next (pads);
if (gst_pad_get_direction (temppad) == GST_PAD_SINK) {
sinkpads = g_slist_append (sinkpads, temppad);
numsinkpads++;
break;
}
}
}
}
}
if (!sinkpads)
GST_DEBUG (0, "can't find a sink pad for element\n");
GST_DEBUG (0, "can't find a sink pad for element\n");
else
GST_DEBUG (0, "have sink pad %s:%s\n", GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (sinkpads)));
GST_DEBUG (0, "have sink pad %s:%s\n", GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (sinkpads)));
if (!srcpads && sinkpads && previous && srcpadname) {
dyn_connect *connect = g_malloc (sizeof (dyn_connect));
connect->srcpadname = srcpadname;
connect->target = GST_PARSE_LISTPAD (sinkpads);
connect->pipeline = GST_ELEMENT (parent);
GST_DEBUG (0, "SETTING UP dynamic connection %s:%s and %s:%s\n",
gst_element_get_name (previous),
srcpadname, GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (sinkpads)));
g_signal_connect (G_OBJECT (previous), "new_pad", G_CALLBACK (dynamic_connect), connect);
dyn_connect *connect = g_malloc (sizeof (dyn_connect));
connect->srcpadname = srcpadname;
connect->target = GST_PARSE_LISTPAD (sinkpads);
connect->pipeline = GST_ELEMENT (parent);
GST_DEBUG (0, "SETTING UP dynamic connection %s:%s and %s:%s\n",
gst_element_get_name (previous),
srcpadname, GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (sinkpads)));
g_signal_connect (G_OBJECT (previous), "new_pad", G_CALLBACK (dynamic_connect), connect);
} else {
for (j = 0; (j < numsrcpads) && (j < numsinkpads); j++) {
GST_DEBUG (0, "CONNECTING %s:%s and %s:%s\n",
GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (g_slist_nth (srcpads, j))),
GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (g_slist_nth (sinkpads, j))));
gst_pad_connect (GST_PARSE_LISTPAD (g_slist_nth (srcpads, j)),
GST_PARSE_LISTPAD (g_slist_nth (sinkpads, j)));
}
}
else {
for (j = 0; (j < numsrcpads) && (j < numsinkpads); j++) {
GST_DEBUG (0, "CONNECTING %s:%s and %s:%s\n",
GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (g_slist_nth (srcpads, j))),
GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (g_slist_nth (sinkpads, j))));
gst_pad_connect (GST_PARSE_LISTPAD (g_slist_nth (srcpads, j)),
GST_PARSE_LISTPAD (g_slist_nth (sinkpads, j)));
}
}
g_slist_free (srcpads);
srcpads = NULL;
g_slist_free (sinkpads);
sinkpads = NULL;
/* if we're the first element, ghost all the sinkpads */
if (elementcount == 1 && !backref) {
DEBUG ("first element, ghosting all of %s's sink pads to parent %s\n",
GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (GST_ELEMENT (parent)));
pads = gst_element_get_pad_list (element);
while (pads) {
temppad = GST_PAD (pads->data);
pads = g_list_next (pads);
if (!temppad)
DEBUG ("much oddness, pad doesn't seem to exist\n");
else if (gst_pad_get_direction (temppad) == GST_PAD_SINK) {
gst_element_add_ghost_pad (GST_ELEMENT (parent), temppad,
g_strdup_printf ("%s-ghost", GST_PAD_NAME (temppad)));
GST_DEBUG (0, "GHOSTED %s:%s to %s as %s-ghost\n",
GST_DEBUG_PAD_NAME (temppad), GST_ELEMENT_NAME (GST_ELEMENT (parent)),
GST_PAD_NAME (temppad));
}
}
DEBUG ("first element, ghosting all of %s's sink pads to parent %s\n",
GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (GST_ELEMENT (parent)));
pads = gst_element_get_pad_list (element);
while (pads) {
temppad = GST_PAD (pads->data);
pads = g_list_next (pads);
if (!temppad)
DEBUG ("much oddness, pad doesn't seem to exist\n");
else if (gst_pad_get_direction (temppad) == GST_PAD_SINK) {
gst_element_add_ghost_pad (GST_ELEMENT (parent), temppad,
g_strdup_printf ("%s-ghost", GST_PAD_NAME (temppad)));
GST_DEBUG (0, "GHOSTED %s:%s to %s as %s-ghost\n",
GST_DEBUG_PAD_NAME (temppad), GST_ELEMENT_NAME (GST_ELEMENT (parent)),
GST_PAD_NAME (temppad));
}
}
}
previous = element;
if (!GST_IS_BIN (element))
prevelement = element;
prevelement = element;
}
i++;
}
/* ghost all the src pads of the bin */
if (prevelement != NULL) {
DEBUG ("last element, ghosting all of %s's src pads to parent %s\n",
@ -490,51 +477,73 @@ gst_parse_launch_cmdline (int argc, char *argv[], GstBin * parent, gst_parse_pri
}
}
}
priv->binlevel--;
if (retval)
return retval;
DEBUG (closingchar != '\0' ? "returning IN THE WRONG PLACE\n" : "ending pipeline\n");
return i + 1;
}
/**
* gst_parse_launchv:
* @argv: null-terminated array of arguments
*
* Create a new pipeline based on command line syntax.
*
* Returns: a new pipeline on success, NULL on failure
*/
GstPipeline *
gst_parse_launchv (const gchar **argv)
{
GstPipeline *pipeline;
gint ret;
/* defer error detection to the _recurse function */
pipeline = (GstPipeline*) gst_pipeline_new ("launch");
ret = gst_parse_launchv_recurse (argv, GST_BIN (pipeline), NULL);
if (ret <= 0) {
// print an error
gst_object_unref (GST_OBJECT (pipeline));
return NULL;
} else {
return pipeline;
}
}
/**
* gst_parse_launch:
* @cmdline: the command line describing the pipeline
* @parent: the parent bin for the resulting pipeline
* @pipeline_description: the command line describing the pipeline
*
* Create a new pipeline based on command line syntax.
*
* Returns: ?
* Returns: a new GstPipeline (cast to a Bin) on success, NULL on failure
*/
gint
gst_parse_launch (const gchar * cmdline, GstBin * parent)
GstPipeline *
gst_parse_launch (const gchar * pipeline_description)
{
gst_parse_priv priv;
gchar **argvn;
gint newargc;
gint i;
const gchar *cp, *start, *end;
gchar *temp;
GSList *string_list = NULL, *slist;
GstPipeline *pipeline;
priv.bincount = 0;
priv.threadcount = 0;
priv.binlevel = 0;
priv.elementcounts = NULL;
priv.verbose = FALSE;
priv.debug = FALSE;
end = cmdline + strlen (cmdline);
end = pipeline_description + strlen (pipeline_description);
newargc = 0;
temp = "";
/* Extract the arguments to a gslist in reverse order */
for (cp = cmdline; cp < end;) {
for (cp = pipeline_description; cp < end;) {
i = strcspn (cp, "([{}]) \"\\");
if (i > 0) {
@ -546,8 +555,7 @@ gst_parse_launch (const gchar * cmdline, GstBin * parent)
string_list = g_slist_prepend (string_list, temp);
newargc++;
temp = "";
}
else {
} else {
temp = g_strconcat (temp, g_strndup (&cp[++i], 1), NULL);
}
cp += i;
@ -587,8 +595,8 @@ gst_parse_launch (const gchar * cmdline, GstBin * parent)
}
}
/* now allocate the new argv array */
argvn = g_new0 (char *, newargc);
/* now allocate the new argv array, with room for NULL termination */
argvn = g_new0 (char *, newargc + 1);
GST_DEBUG (0, "got %d args\n", newargc);
@ -601,18 +609,15 @@ gst_parse_launch (const gchar * cmdline, GstBin * parent)
g_slist_free (string_list);
/* print them out */
for (i = 0; i < newargc; i++) {
GST_DEBUG (0, "arg %d is: %s\n", i, argvn[i]);
while (argvn[i]) {
GST_DEBUG (0, "arg %d is: %s\n", i, argvn[i++]);
}
/* set up the elementcounts hash */
priv.elementcounts = g_hash_table_new (g_str_hash, g_str_equal);
/* do it! */
i = gst_parse_launch_cmdline (newargc, argvn, parent, &priv);
pipeline = gst_parse_launchv (argvn);
/* GST_DEBUG(0, "Finished - freeing temporary argument array"); */
/* g_strfreev(argvn); */
GST_DEBUG(0, "Finished - freeing temporary argument array");
g_strfreev(argvn);
return i;
return pipeline;
}

6
gst/gstparse.h
View file

@ -23,7 +23,7 @@
#ifndef __GST_PARSE_H__
#define __GST_PARSE_H__
#include <gst/gstbin.h>
#include <gst/gstpipeline.h>
#ifdef __cplusplus
extern "C" {
@ -35,9 +35,11 @@ typedef enum {
GST_PARSE_ERROR_SYNTAX = -1,
GST_PARSE_ERROR_CREATING_ELEMENT = -2,
GST_PARSE_ERROR_NOSUCH_ELEMENT = -3,
GST_PARSE_ERROR_INTERNAL = -4
} GstParseErrors;
gint gst_parse_launch (const gchar *cmdline, GstBin *parent);
GstPipeline* gst_parse_launch (const gchar *pipeline_description);
GstPipeline* gst_parse_launchv (const gchar **argv);
#else /* GST_DISABLE_PARSE */

3
tests/old/examples/launch/mp3parselaunch.c
View file

@ -12,9 +12,8 @@ main (int argc, char *argv[])
g_print ("usage: %s <filename>\n", argv[0]);
return -1;
}
pipeline = gst_pipeline_new ("my_pipeline");
gst_parse_launch ("filesrc[my_filesrc] ! mp3parse ! mpg123 ! osssink", GST_BIN (pipeline));
pipeline = (GstElement*) gst_parse_launch ("filesrc [ my_filesrc ] ! mad ! osssink");
filesrc = gst_bin_get_by_name (GST_BIN (pipeline), "my_filesrc");
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);

36
tools/gst-launch.c
View file

@ -94,7 +94,7 @@ main(int argc, char *argv[])
free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
if (argc >= 3 && !strcmp(argv[1], "-o")) {
save_pipeline = TRUE;
run_pipeline = FALSE;
@ -107,43 +107,29 @@ main(int argc, char *argv[])
launch_argc = argc;
launch_argv = argv;
pipeline = gst_pipeline_new ("launch");
g_signal_connect (G_OBJECT (pipeline), "event", G_CALLBACK (event_func), NULL);
/* make a null-terminated version of argv */
argvn = g_new0 (char *,argc);
memcpy (argvn, argv+1, sizeof (char*) * (argc-1));
/* escape spaces */
for (i=0; i<argc-1; i++) {
gchar **split;
split = g_strsplit (argvn[i], " ", 0);
argvn[i] = g_strjoinv ("\\ ", split);
g_strfreev (split);
if (strstr (argv[0], "gst-xmllaunch")) {
// pipeline = gst_xmllaunch_parse_cmdline (argc, argv);
} else {
pipeline = (GstElement*) gst_parse_launchv (argvn);
}
/* join the argvs together */
cmdline = g_strjoinv (" ", argvn);
/* free the null-terminated argv */
g_free (argvn);
/* fail if there are no pipes in it (needs pipes for a pipeline */
if (!strchr(cmdline,'!')) {
fprintf(stderr,"ERROR: no pipeline description found on commandline\n");
if (!pipeline) {
fprintf(stderr, "ERROR: pipeline could not be constructed\n");
exit(1);
}
if (gst_parse_launch (cmdline, GST_BIN (pipeline)) < 0){
fprintf(stderr,"ERROR: pipeline description could not be parsed\n");
exit(1);
}
g_signal_connect (G_OBJECT (pipeline), "event", G_CALLBACK (event_func), NULL);
#ifndef GST_DISABLE_LOADSAVE
if (save_pipeline) {
gst_xml_write_file (GST_ELEMENT (pipeline), fopen (savefile, "w"));
}
#endif
if (run_pipeline) {
gst_buffer_print_stats();
fprintf(stderr,"RUNNING pipeline\n");