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

cleanup of unused and forgoten sections fixed links from the manual and the pwg to the API docs added more notes to R...

Browse source 
Original commit message from CVS:
cleanup of unused and forgoten sections
fixed links from the manual and the pwg to the API docs
added more notes to README
This commit is contained in:
Stefan Kost 2004-07-27 15:01:10 +00:00
parent 1a1c19bb74
commit 626cbdc8b2
37 changed files with 1222 additions and 982 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
docs/README
View file

@ -143,7 +143,8 @@ GTK-DOC NOTES
$(MODULE)-sections.txt is created if it doesn't exist yet (it should),
as well as $(MODULE)-decl.txt and $(MODULE)-decl-list.txt
and .args, .hierarchy and .signals files are created
gtkdoc-scan is called
gtkdoc-scan is called
- if it not works, try e.g. 'rm docs/gst/*.stamp'
* Possible errors and how to fix them
- Warning: multiple "IDs" for constraint linkend: gst-tag-register.

43
docs/gst/gstreamer-docs.sgml
View file

@ -9,21 +9,24 @@
<!ENTITY GstBuffer SYSTEM "xml/gstbuffer.xml">
<!ENTITY GstCaps SYSTEM "xml/gstcaps.xml">
<!ENTITY GstClock SYSTEM "xml/gstclock.xml">
<!ENTITY GstCompat SYSTEM "xml/gstcompat.xml">
<!ENTITY GstConfig SYSTEM "xml/gstconfig.xml">
<!ENTITY GstCpu SYSTEM "xml/gstcpu.xml">
<!ENTITY GstData SYSTEM "xml/gstdata.xml">
<!ENTITY GstElement SYSTEM "xml/gstelement.xml">
<!ENTITY GstElementDetails SYSTEM "xml/gstelementdetails.xml">
<!ENTITY GstElementFactory SYSTEM "xml/gstelementfactory.xml">
<!ENTITY GstEnumTypes SYSTEM "xml/gstenumtypes.xml">
<!ENTITY GstError SYSTEM "xml/gsterror.xml">
<!ENTITY GstEvent SYSTEM "xml/gstevent.xml">
<!ENTITY GstFilter SYSTEM "xml/gstfilter.xml">
<!ENTITY GstFormat SYSTEM "xml/gstformat.xml">
<!ENTITY GstGhostPad SYSTEM "xml/gstghostpad.xml">
<!ENTITY GstImplementsInterface SYSTEM "xml/gstimplementsinterface.xml">
<!ENTITY GstIndex SYSTEM "xml/gstindex.xml">
<!ENTITY GstIndexFactory SYSTEM "xml/gstindexfactory.xml">
<!ENTITY GstImplementsInterface SYSTEM "xml/gstimplementsinterface.xml">
<!ENTITY GstInfo SYSTEM "xml/gstinfo.xml">
<!ENTITY GstLog SYSTEM "xml/gstlog.xml">
<!ENTITY GstMacros SYSTEM "xml/gstmacros.xml">
<!ENTITY GstMemChunk SYSTEM "xml/gstmemchunk.xml">
<!ENTITY GstObject SYSTEM "xml/gstobject.xml">
<!ENTITY GstPad SYSTEM "xml/gstpad.xml">
@ -34,6 +37,7 @@
<!ENTITY GstPluginFeature SYSTEM "xml/gstpluginfeature.xml">
<!ENTITY GstProbe SYSTEM "xml/gstprobe.xml">
<!ENTITY GstQuery SYSTEM "xml/gstquery.xml">
<!ENTITY GstQueue SYSTEM "xml/gstqueue.xml">
<!ENTITY GstRealPad SYSTEM "xml/gstrealpad.xml">
<!ENTITY GstRegistry SYSTEM "xml/gstregistry.xml">
<!ENTITY GstRegistryPool SYSTEM "xml/gstregistrypool.xml">
@ -45,14 +49,18 @@
<!ENTITY GstTagSetter SYSTEM "xml/gsttagsetter.xml">
<!ENTITY GstThread SYSTEM "xml/gstthread.xml">
<!ENTITY GstTrace SYSTEM "xml/gsttrace.xml">
<!ENTITY GstTrashStack SYSTEM "xml/gsttrashstack.xml">
<!ENTITY GstTypeFind SYSTEM "xml/gsttypefind.xml">
<!ENTITY GstTypeFindFactory SYSTEM "xml/gsttypefindfactory.xml">
<!ENTITY GstUtils SYSTEM "xml/gstutils.xml">
<!ENTITY GstTypes SYSTEM "xml/gsttypes.xml">
<!ENTITY GstUriHandler SYSTEM "xml/gsturihandler.xml">
<!ENTITY GstUriType SYSTEM "xml/gsturitype.xml">
<!ENTITY GstUtils SYSTEM "xml/gstutils.xml">
<!ENTITY GstValue SYSTEM "xml/gstvalue.xml">
<!ENTITY GstVersion SYSTEM "xml/gstversion.xml">
<!ENTITY GstXML SYSTEM "xml/gstxml.xml">
<!ENTITY GstQueue SYSTEM "xml/gstqueue.xml">
<!--
<!ENTITY GstAggregator SYSTEM "xml/gstaggregator.xml">
<!ENTITY GstFakeSrc SYSTEM "xml/gstfakesrc.xml">
<!ENTITY GstFakeSink SYSTEM "xml/gstfakesink.xml">
@ -65,7 +73,7 @@
<!ENTITY GstStatistics SYSTEM "xml/gststatistics.xml">
<!ENTITY GstMD5Sink SYSTEM "xml/gstmd5sink.xml">
<!ENTITY GstTee SYSTEM "xml/gsttee.xml">
-->
<!ENTITY gstreamer-tree-index SYSTEM "xml/tree_index.sgml">
<!ENTITY hash "#">
@ -89,22 +97,24 @@
&Gst;
&GstBin;
&GstBuffer;
&GstConfig;
&GstCaps;
&GstClock;
&GstConfig;
&GstCpu;
&GstData;
&GstElement;
&GstElementDetails;
&GstElementFactory;
&GstEnumTypes;
&GstError;
&GstEvent;
&GstFilter;
&GstFormat;
&GstGhostPad;
&GstImplementsInterface;
&GstIndex;
&GstIndexFactory;
&GstInfo;
&GstImplementsInterface;
&GstObject;
&GstPad;
&GstPadTemplate;
@ -127,9 +137,12 @@
&GstThread;
&GstTypeFind;
&GstTypeFindFactory;
&GstTypes;
&GstUriHandler;
&GstUriType;
&GstUtils;
&GstValue;
&GstVersion;
&GstXML;
</chapter>
@ -141,12 +154,24 @@
</para>
&GstAtomic;
&GstMacros;
&GstMemChunk;
</chapter>
<!--
FIXME: why is this commented out
<chapter id="gstreamer-compat">
<title>GStreamer Core Compatibility</title>
<para>
Theses elements are defined for compatibillity with older code.
The must not be use in new code!
</para>
&GstCompat;
</chapter>
<!--
FIXME: why is this commented out (reason #1: no public API)
<chapter id="element-types">
<title>GStreamer Standard Elements</title>

6
docs/gst/gstreamer-sections.txt
View file

@ -1438,6 +1438,8 @@ gst_scheduler_factory_get_type
<SECTION>
<FILE>gststructure</FILE>
<TITLE>GstStructure</TITLE>
GST_TYPE_STRUCTURE
GstStructure
GstStructureForeachFunc
gst_structure_empty_new
@ -1474,7 +1476,6 @@ gst_structure_from_string
<SUBSECTION Standard>
GST_STRUCTURE
GST_IS_STRUCTURE
GST_TYPE_STRUCTURE
<SUBSECTION Private>
gst_structure_get_type
</SECTION>
@ -1483,12 +1484,12 @@ gst_structure_get_type
<FILE>gstsystemclock</FILE>
<TITLE>GstSystemClock</TITLE>
GstSystemClock
GST_TYPE_SYSTEM_CLOCK
gst_system_clock_obtain
<SUBSECTION Standard>
GstSystemClockClass
GST_SYSTEM_CLOCK
GST_IS_SYSTEM_CLOCK
GST_TYPE_SYSTEM_CLOCK
gst_system_clock_get_type
GST_SYSTEM_CLOCK_CLASS
GST_IS_SYSTEM_CLOCK_CLASS
@ -1873,6 +1874,7 @@ gst_value_register_intersect_func
<SECTION>
<FILE>gstversion</FILE>
<TITLE>GstVersion</TITLE>
GST_VERSION_MAJOR
GST_VERSION_MINOR
GST_VERSION_MICRO

4
docs/gst/tmpl/gstcompat.sgml
View file

@ -1,8 +1,8 @@
<!-- ##### SECTION Title ##### -->
gstcompat
GstCompat
<!-- ##### SECTION Short_Description ##### -->
Deprecated API entries
<!-- ##### SECTION Long_Description ##### -->
<para>

4
docs/gst/tmpl/gstmacros.sgml
View file

@ -1,8 +1,8 @@
<!-- ##### SECTION Title ##### -->
gstmacros
GstMacros
<!-- ##### SECTION Short_Description ##### -->
various portabillity helper macros
<!-- ##### SECTION Long_Description ##### -->
<para>

7
docs/gst/tmpl/gststructure.sgml
View file

@ -14,6 +14,13 @@ Generic structure containing fields of names and values
</para>
<!-- ##### MACRO GST_TYPE_STRUCTURE ##### -->
<para>
</para>
<!-- ##### STRUCT GstStructure ##### -->
<para>

7
docs/gst/tmpl/gstsystemclock.sgml
View file

@ -25,6 +25,13 @@ system time.
@cond:
@_gst_reserved:
<!-- ##### MACRO GST_TYPE_SYSTEM_CLOCK ##### -->
<para>
</para>
<!-- ##### FUNCTION gst_system_clock_obtain ##### -->
<para>

863
docs/gst/tmpl/gsttaglist.sgml Normal file
View file

@ -0,0 +1,863 @@
<!-- ##### SECTION Title ##### -->
GstTagList
<!-- ##### SECTION Short_Description ##### -->
List of tags and values used to describe media metadata
<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### TYPEDEF GstTagList ##### -->
<para>
</para>
<!-- ##### MACRO GST_TYPE_TAG_LIST ##### -->
<para>
</para>
<!-- ##### ENUM GstTagMergeMode ##### -->
<para>
</para>
@GST_TAG_MERGE_UNDEFINED:
@GST_TAG_MERGE_REPLACE_ALL:
@GST_TAG_MERGE_REPLACE:
@GST_TAG_MERGE_APPEND:
@GST_TAG_MERGE_PREPEND:
@GST_TAG_MERGE_KEEP:
@GST_TAG_MERGE_KEEP_ALL:
@GST_TAG_MERGE_COUNT:
<!-- ##### ENUM GstTagFlag ##### -->
<para>
</para>
@GST_TAG_FLAG_UNDEFINED:
@GST_TAG_FLAG_META:
@GST_TAG_FLAG_ENCODED:
@GST_TAG_FLAG_DECODED:
@GST_TAG_FLAG_COUNT:
<!-- ##### USER_FUNCTION GstTagForeachFunc ##### -->
<para>
</para>
@list:
@tag:
@user_data:
<!-- ##### USER_FUNCTION GstTagMergeFunc ##### -->
<para>
</para>
@dest:
@src:
<!-- ##### FUNCTION gst_tag_register ##### -->
<para>
</para>
@name:
@flag:
@type:
@nick:
@blurb:
@func:
<!-- ##### FUNCTION gst_tag_merge_use_first ##### -->
<para>
</para>
@dest:
@src:
<!-- ##### FUNCTION gst_tag_merge_strings_with_comma ##### -->
<para>
</para>
@dest:
@src:
<!-- ##### FUNCTION gst_tag_exists ##### -->
<para>
</para>
@tag:
@Returns:
<!-- ##### FUNCTION gst_tag_get_type ##### -->
<para>
</para>
@tag:
@Returns:
<!-- ##### FUNCTION gst_tag_get_nick ##### -->
<para>
</para>
@tag:
@Returns:
<!-- ##### FUNCTION gst_tag_get_description ##### -->
<para>
</para>
@tag:
@Returns:
<!-- ##### FUNCTION gst_tag_get_flag ##### -->
<para>
</para>
@tag:
@Returns:
<!-- ##### FUNCTION gst_tag_is_fixed ##### -->
<para>
</para>
@tag:
@Returns:
<!-- ##### FUNCTION gst_tag_list_new ##### -->
<para>
</para>
@Returns:
<!-- ##### FUNCTION gst_is_tag_list ##### -->
<para>
</para>
@p:
@Returns:
<!-- ##### FUNCTION gst_tag_list_copy ##### -->
<para>
</para>
@list:
@Returns:
<!-- ##### FUNCTION gst_tag_list_insert ##### -->
<para>
</para>
@into:
@from:
@mode:
<!-- ##### FUNCTION gst_tag_list_merge ##### -->
<para>
</para>
@list1:
@list2:
@mode:
@Returns:
<!-- ##### FUNCTION gst_tag_list_free ##### -->
<para>
</para>
@list:
<!-- ##### FUNCTION gst_tag_list_get_tag_size ##### -->
<para>
</para>
@list:
@tag:
@Returns:
<!-- ##### FUNCTION gst_tag_list_add ##### -->
<para>
</para>
@list:
@mode:
@tag:
@Varargs:
<!-- ##### FUNCTION gst_tag_list_add_values ##### -->
<para>
</para>
@list:
@mode:
@tag:
@Varargs:
<!-- ##### FUNCTION gst_tag_list_add_valist ##### -->
<para>
</para>
@list:
@mode:
@tag:
@var_args:
<!-- ##### FUNCTION gst_tag_list_add_valist_values ##### -->
<para>
</para>
@list:
@mode:
@tag:
@var_args:
<!-- ##### FUNCTION gst_tag_list_remove_tag ##### -->
<para>
</para>
@list:
@tag:
<!-- ##### FUNCTION gst_tag_list_foreach ##### -->
<para>
</para>
@list:
@func:
@user_data:
<!-- ##### FUNCTION gst_tag_list_get_value_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@Returns:
<!-- ##### FUNCTION gst_tag_list_copy_value ##### -->
<para>
</para>
@dest:
@list:
@tag:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_char ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_char_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_uchar ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_uchar_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_boolean ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_boolean_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_int ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_int_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_uint ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_uint_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_long ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_long_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_ulong ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_ulong_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_int64 ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_int64_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_uint64 ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_uint64_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_float ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_float_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_double ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_double_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_string ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_string_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_pointer ##### -->
<para>
</para>
@list:
@tag:
@value:
@Returns:
<!-- ##### FUNCTION gst_tag_list_get_pointer_index ##### -->
<para>
</para>
@list:
@tag:
@index:
@value:
@Returns:
<!-- ##### FUNCTION gst_event_new_tag ##### -->
<para>
</para>
@list:
@Returns:
<!-- ##### FUNCTION gst_event_tag_get_list ##### -->
<para>
</para>
@tag_event:
@Returns:
<!-- ##### MACRO GST_TAG_TITLE ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ARTIST ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ALBUM ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_DATE ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_GENRE ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_COMMENT ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_TRACK_NUMBER ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_TRACK_COUNT ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ALBUM_VOLUME_NUMBER ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ALBUM_VOLUME_COUNT ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_LOCATION ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_DESCRIPTION ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_VERSION ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ISRC ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ORGANIZATION ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_COPYRIGHT ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_CONTACT ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_LICENSE ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_PERFORMER ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_DURATION ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_CODEC ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_VIDEO_CODEC ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_AUDIO_CODEC ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_BITRATE ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_NOMINAL_BITRATE ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_MINIMUM_BITRATE ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_MAXIMUM_BITRATE ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_SERIAL ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ENCODER ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ENCODER_VERSION ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_TRACK_GAIN ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_TRACK_PEAK ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ALBUM_GAIN ##### -->
<para>
</para>
<!-- ##### MACRO GST_TAG_ALBUM_PEAK ##### -->
<para>
</para>

4
docs/gst/tmpl/gsttypes.sgml
View file

@ -1,8 +1,8 @@
<!-- ##### SECTION Title ##### -->
gsttypes
GstTypes
<!-- ##### SECTION Short_Description ##### -->
various global enums and constants
<!-- ##### SECTION Long_Description ##### -->
<para>

141
docs/gst/tmpl/gsturihandler.sgml Normal file
View file

@ -0,0 +1,141 @@
<!-- ##### SECTION Title ##### -->
GstUriHandler
<!-- ##### SECTION Short_Description ##### -->
Plugin feature that handles URI types
<!-- ##### SECTION Long_Description ##### -->
<para>
The URIHandler is a pluginfeature that can be used to locate element
and the element property that can handle a given URI.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### STRUCT GstURIHandler ##### -->
<para>
</para>
<!-- ##### MACRO GST_TYPE_URI_HANDLER ##### -->
<para>
</para>
<!-- ##### MACRO GST_URI_TYPE_IS_VALID ##### -->
<para>
</para>
@type:
<!-- ##### FUNCTION gst_uri_protocol_is_valid ##### -->
<para>
</para>
@protocol:
@Returns:
<!-- ##### FUNCTION gst_uri_is_valid ##### -->
<para>
</para>
@uri:
@Returns:
<!-- ##### FUNCTION gst_uri_get_protocol ##### -->
<para>
</para>
@uri:
@Returns:
<!-- ##### FUNCTION gst_uri_get_location ##### -->
<para>
</para>
@uri:
@Returns:
<!-- ##### FUNCTION gst_uri_construct ##### -->
<para>
</para>
@protocol:
@location:
@Returns:
<!-- ##### FUNCTION gst_element_make_from_uri ##### -->
<para>
</para>
@type:
@uri:
@elementname:
@Returns:
<!-- ##### FUNCTION gst_uri_handler_get_uri_type ##### -->
<para>
</para>
@handler:
@Returns:
<!-- ##### FUNCTION gst_uri_handler_get_protocols ##### -->
<para>
</para>
@handler:
@Returns:
<!-- ##### FUNCTION gst_uri_handler_get_uri ##### -->
<para>
</para>
@handler:
@Returns:
<!-- ##### FUNCTION gst_uri_handler_set_uri ##### -->
<para>
</para>
@handler:
@uri:
@Returns:
<!-- ##### FUNCTION gst_uri_handler_new_uri ##### -->
<para>
</para>
@handler:
@uri:

2
docs/gst/tmpl/gsturitype.sgml
View file

@ -2,7 +2,7 @@
GstURIType
<!-- ##### SECTION Short_Description ##### -->
describes URI types
<!-- ##### SECTION Long_Description ##### -->
<para>

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

@ -1,5 +1,5 @@
<!-- ##### SECTION Title ##### -->
gstutils
GstUtils
<!-- ##### SECTION Short_Description ##### -->
various utility functions

2
docs/gst/tmpl/gstversion.sgml
View file

@ -2,7 +2,7 @@
gstversion
<!-- ##### SECTION Short_Description ##### -->
GStreamer version macros
<!-- ##### SECTION Long_Description ##### -->
<para>

166
docs/manual/advanced-threads.xml
View file

@ -1,166 +0,0 @@
<chapter id="chapter-threads">
<title>Threads</title>
<para>
GStreamer has support for multithreading through the use of
the <classname>GstThread</classname> object. This object is in fact
a special <classname>GstBin</classname> that will become a thread when started.
</para>
<para>
To construct a new thread you will perform something like:
</para>
<para>
<programlisting>
GstElement *my_thread;
/* create the thread object */
my_thread = gst_thread_new ("my_thread");
/* you could have used gst_element_factory_make ("thread", "my_thread"); */
g_return_if_fail (my_thread != NULL);
/* add some plugins */
gst_bin_add (GST_BIN (my_thread), GST_ELEMENT (funky_src));
gst_bin_add (GST_BIN (my_thread), GST_ELEMENT (cool_effect));
/* link the elements here... */
...
/* start playing */
gst_element_set_state (GST_ELEMENT (my_thread), GST_STATE_PLAYING);
</programlisting>
</para>
<para>
The above program will create a thread with two elements in it. As soon
as it is set to the PLAYING state, the thread will start to iterate
itself. You never need to explicitly iterate a thread.
</para>
<sect1 id="section-threads-constraints">
<title>Constraints placed on the pipeline by the GstThread</title>
<para>
Within the pipeline, everything is the same as in any other bin. The
difference lies at the thread boundary, at the link between the
thread and the outside world (containing bin). Since GStreamer is
fundamentally buffer-oriented rather than byte-oriented, the natural
solution to this problem is an element that can "buffer" the buffers
between the threads, in a thread-safe fashion. This element is the
queue, described more fully in <xref linkend="chapter-queues"/>. It doesn't
matter if the queue is placed in the containing bin or in the thread
itself, but it needs to be present on one side or the other to enable
inter-thread communication.
</para>
</sect1>
<sect1 id="section-threads-when">
<title>When would you want to use a thread?</title>
<para>
If you are writing a GUI application, making the top-level bin a thread will make your GUI
more responsive. If it were a pipeline instead, it would have to be iterated by your
application's event loop, which increases the latency between events (say, keyboard presses)
and responses from the GUI. In addition, any slight hang in the GUI would delay iteration of
the pipeline, which (for example) could cause pops in the output of the sound card, if it is
an audio pipeline.
</para>
<para>
<xref linkend="section-threads-img"/> shows how a thread can be visualised.
</para>
<figure float="1" id="section-threads-img">
<title>A thread</title>
<mediaobject>
<imageobject>
<imagedata fileref="images/thread.&image;" format="&IMAGE;" />
</imageobject>
</mediaobject>
</figure>
<para>
As an example we show the helloworld program using a thread.
</para>
<para>
<programlisting>
/* example-begin threads.c */
#include &lt;gst/gst.h&gt;
/* we set this to TRUE right before gst_main (), but there could still
be a race condition between setting it and entering the function */
gboolean can_quit = FALSE;
/* eos will be called when the src element has an end of stream */
void
eos (GstElement *src, gpointer data)
{
GstThread *thread = GST_THREAD (data);
g_print ("have eos, quitting\n");
/* stop the bin */
gst_element_set_state (GST_ELEMENT (thread), GST_STATE_NULL);
while (!can_quit) /* waste cycles */ ;
gst_main_quit ();
}
int
main (int argc, char *argv[])
{
GstElement *filesrc, *demuxer, *decoder, *converter, *audiosink;
GstElement *thread;
if (argc &lt; 2) {
g_print ("usage: %s &lt;Ogg/Vorbis filename&gt;\n", argv[0]);
exit (-1);
}
gst_init (&amp;argc, &amp;argv);
/* create a new thread to hold the elements */
thread = gst_thread_new ("thread");
g_assert (thread != NULL);
/* create a disk reader */
filesrc = gst_element_factory_make ("filesrc", "disk_source");
g_assert (filesrc != NULL);
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);
g_signal_connect (G_OBJECT (filesrc), "eos",
G_CALLBACK (eos), thread);
/* create an ogg demuxer */
demuxer = gst_element_factory_make ("oggdemux", "demuxer");
g_assert (demuxer != NULL);
/* create a vorbis decoder */
decoder = gst_element_factory_make ("vorbisdec", "decoder");
g_assert (decoder != NULL);
/* create an audio converter */
converter = gst_element_factory_make ("audioconvert", "converter");
g_assert (decoder != NULL);
/* and an audio sink */
audiosink = gst_element_factory_make ("osssink", "play_audio");
g_assert (audiosink != NULL);
/* add objects to the thread */
gst_bin_add_many (GST_BIN (thread), filesrc, demuxer, decoder, converter, audiosink, NULL);
/* link them in the logical order */
gst_element_link_many (filesrc, demuxer, decoder, converter, audiosink, NULL);
/* start playing */
gst_element_set_state (thread, GST_STATE_PLAYING);
/* do whatever you want here, the thread will be playing */
g_print ("thread is playing\n");
can_quit = TRUE;
gst_main ();
gst_object_unref (GST_OBJECT (thread));
exit (0);
}
/* example-end threads.c */
</programlisting>
</para>
</sect1>
</chapter>

1
docs/manual/autoplugging.xml
View file

@ -92,6 +92,7 @@
</para>
</sect1>
<sect1 id="section-autoplug-cache">
<!-- FIXME: this is outdated, there is no GstAutoplugCache in gst-0.8.X -->
<title>Using the <classname>GstAutoplugCache</classname> element</title>
<para>
The <classname>GstAutoplugCache</classname> element is used to cache the

65
docs/manual/basics-data.xml
View file

@ -1,65 +0,0 @@
<chapter id="chapter-buffers">
<title>Buffers</title>
<para>
Buffers contain the data that will flow through the pipeline you have
created. A source element will typically create a new buffer and pass
it through a pad to the next element in the chain. When using the
GStreamer infrastructure to create a media pipeline you will not have
to deal with buffers yourself; the elements will do that for you.
</para>
<para>
A buffer consists of:
<itemizedlist>
<listitem>
<para>
a pointer to a piece of memory.
</para>
</listitem>
<listitem>
<para>
the size of the memory.
</para>
</listitem>
<listitem>
<para>
a timestamp for the buffer.
</para>
</listitem>
<listitem>
<para>
A refcount that indicates how many elements are using this
buffer. This refcount will be used to destroy the buffer when no
element has a reference to it.
</para>
</listitem>
</itemizedlist>
</para>
<para>
GStreamer provides functions to create custom buffer create/destroy algorithms, called
a <classname>GstBufferPool</classname>. This makes it possible to efficiently
allocate and destroy buffer memory. It also makes it possible to exchange memory between
elements by passing the <classname>GstBufferPool</classname>. A video element can,
for example, create a custom buffer allocation algorithm that creates buffers with XSHM
as the buffer memory. An element can use this algorithm to create and fill the buffer
with data.
</para>
<para>
The simple case is that a buffer is created, memory allocated, data put
in it, and passed to the next element. That element reads the data, does
something (like creating a new buffer and decoding into it), and
unreferences the buffer. This causes the data to be freed and the buffer
to be destroyed. A typical MPEG audio decoder works like this.
</para>
<para>
A more complex case is when the filter modifies the data in place. It
does so and simply passes on the buffer to the next element. This is just
as easy to deal with. An element that works in place has to be careful when
the buffer is used in more than one element; a copy on write has to made in this
situation.
</para>
</chapter>

118
docs/manual/basics-elements.xml
View file

@ -1,118 +0,0 @@
<chapter id="chapter-elements">
<title>Elements</title>
<para>
The most important object in <application>GStreamer</application> for the
application programmer is the <classname>GstElement</classname> object.
</para>
<sect1 id="section-elements-design">
<title>What is an element ?</title>
<para>
An element is the basic building block for the media pipeline.
All the different high-level components you are going to use are
derived from <classname>GstElement</classname>. This means that a
lot of functions you are going to use operate on objects of this class.
</para>
<para>
Elements, from the perspective of GStreamer, are viewed as "black boxes"
with a number of different aspects. One of these aspects is the presence
of "pads" (see <xref linkend="chapter-pads"/>), or link points. This terminology arises from soldering;
pads are where wires can be attached.
</para>
</sect1>
<sect1 id="section-elements-types">
<title>Types of elements</title>
<sect2 id="section-elements-src">
<title>Source elements</title>
<para>
Source elements generate data for use by a pipeline, for example
reading from disk or from a sound card.
</para>
<para>
<xref linkend="section-element-srcimg"/> shows how we will visualise
a source element.
We always draw a source pad to the right of the element.
</para>
<figure float="1" id="section-element-srcimg">
<title>Visualisation of a source element</title>
<mediaobject>
<imageobject>
<imagedata fileref="images/src-element.&image;" format="&IMAGE;" />
</imageobject>
</mediaobject>
</figure>
<para>
Source elements do not accept data, they only generate data. You can
see this in the figure because it only has a source pad. A source
pad can only generate data.
</para>
</sect2>
<sect2 id="section-elements-filter">
<title>Filters and codecs</title>
<para>
Filter elements have both input and output pads. They operate on
data they receive in their sink pads and produce data on their source
pads. For example, MPEG decoders and volume filters would fall into
this category.
</para>
<para>
Elements are not constrained as to the number of pads they might have;
for example, a video mixer might have two input pads (the images of
the two different video streams) and one output pad.
</para>
<figure float="1" id="section-element-filterimg">
<title>Visualisation of a filter element</title>
<mediaobject>
<imageobject>
<imagedata fileref="images/filter-element.&image;" format="&IMAGE;" />
</imageobject>
</mediaobject>
</figure>
<para>
<xref linkend="section-element-filterimg"/> shows how we will visualise
a filter element.
This element has one sink (input) pad and one source (output) pad.
Sink pads are drawn on the left of the element.
</para>
<figure float="1" id="section-element-multifilterimg">
<title>Visualisation of a filter element with
more than one output pad</title>
<mediaobject>
<imageobject>
<imagedata fileref="images/filter-element-multi.&image;"
format="&IMAGE;" />
</imageobject>
</mediaobject>
</figure>
<para>
<xref linkend="section-element-multifilterimg"/> shows the visualisation of a filter element with
more than one output pad. An example of such a filter is the AVI
demultiplexer. This element will parse the input data and
extract the audio and video data. Most of these filters dynamically
send out a signal when a new pad is created so that the application
programmer can link an arbitrary element to the newly created pad.
</para>
</sect2>
<sect2 id="section-elements-sink">
<title>Sink elements</title>
<para>
Sink elements are end points in a media pipeline. They accept
data but do not produce anything. Disk writing, soundcard playback,
and video output would all be implemented by sink elements.
<xref linkend="section-element-sinkimg"/> shows a sink element.
</para>
<figure float="1" id="section-element-sinkimg">
<title>Visualisation of a sink element</title>
<mediaobject>
<imageobject>
<imagedata fileref="images/sink-element.&image;" format="&IMAGE;" />
</imageobject>
</mediaobject>
</figure>
</sect2>
</sect1>
</chapter>

279
docs/manual/basics-helloworld.xml
View file

@ -1,279 +0,0 @@
<chapter id="chapter-hello-world">
<title>Your first application</title>
<para>
This chapter describes the most rudimentary aspects of a
<application>GStreamer</application> application, including initializing
the libraries, creating elements, packing them into a pipeline and playing,
pausing and stopping the pipeline.
</para>
<sect1 id="section-hello-world">
<title>Hello world</title>
<para>
We will create a simple first application, a complete MP3 player, using
standard <application>GStreamer</application> components. The player
will read from a file that is given as the first argument to the program.
</para>
<programlisting>
/* example-begin helloworld.c */
#include &lt;gst/gst.h&gt;
int
main (int argc, char *argv[])
{
GstElement *pipeline, *filesrc, *decoder, *audiosink;
gst_init(&amp;argc, &amp;argv);
if (argc != 2) {
g_print ("usage: %s &lt;mp3 filename&gt;\n", argv[0]);
exit (-1);
}
/* create a new pipeline to hold the elements */
pipeline = gst_pipeline_new ("pipeline");
/* create a disk reader */
filesrc = gst_element_factory_make ("filesrc", "disk_source");
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);
/* now it's time to get the decoder */
decoder = gst_element_factory_make ("mad", "decoder");
/* and an audio sink */
audiosink = gst_element_factory_make ("osssink", "play_audio");
/* add objects to the main pipeline */
gst_bin_add_many (GST_BIN (pipeline), filesrc, decoder, audiosink, NULL);
/* link src to sink */
gst_element_link_many (filesrc, decoder, audiosink, NULL);
/* start playing */
gst_element_set_state (pipeline, GST_STATE_PLAYING);
while (gst_bin_iterate (GST_BIN (pipeline)));
/* stop the pipeline */
gst_element_set_state (pipeline, GST_STATE_NULL);
/* we don't need a reference to these objects anymore */
gst_object_unref (GST_OBJECT (pipeline));
/* unreffing the pipeline unrefs the contained elements as well */
exit (0);
}
/* example-end helloworld.c */
</programlisting>
<para>
Let's go through this example step by step.
</para>
<para>
The first thing you have to do is to include the standard
<application>GStreamer</application> headers and
initialize the framework.
</para>
<programlisting>
#include &lt;gst/gst.h&gt;
...
int
main (int argc, char *argv[])
{
...
gst_init(&amp;argc, &amp;argv);
...
</programlisting>
<para>
We are going to create three elements and one pipeline. Since all
elements share the same base type, <classname>GstElement</classname>,
we can define them as:
</para>
<programlisting>
...
GstElement *pipeline, *filesrc, *decoder, *audiosink;
...
</programlisting>
<para>
Next, we are going to create an empty pipeline. As you have seen in
the basic introduction, this pipeline will hold and manage all the
elements we are going to pack into it.
</para>
<programlisting>
/* create a new pipeline to hold the elements */
pipeline = gst_pipeline_new ("pipeline");
</programlisting>
<para>
We use the standard constructor for a pipeline: gst_pipeline_new ().
</para>
<para>
We then create a disk source element. The disk source element is able to
read from a file. We use the standard GObject property mechanism to set
a property of the element: the file to read from.
</para>
<programlisting>
/* create a disk reader */
filesrc = gst_element_factory_make ("filesrc", "disk_source");
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);
</programlisting>
<note>
<para>
You can check if the filesrc != NULL to verify the creation of the
disk source element.
</para>
</note>
<para>
We now create the MP3 decoder element. This assumes that the 'mad' plugin
is installed on the system where this application is executed.
</para>
<programlisting>
/* now it's time to get the decoder */
decoder = gst_element_factory_make ("mad", "decoder");
</programlisting>
<para>
gst_element_factory_make() takes two arguments: a string that will
identify the element you need and a second argument: how you want
to name the element. The name of the element is something you can
choose yourself and might be used to retrieve the element from a
bin/pipeline.
</para>
<para>
Finally we create our audio sink element. This element will be able
to play back the audio using OSS.
</para>
<programlisting>
/* and an audio sink */
audiosink = gst_element_factory_make ("osssink", "play_audio");
</programlisting>
<para>
We then add the elements to the pipeline.
</para>
<programlisting>
/* add objects to the main pipeline */
gst_bin_add_many (GST_BIN (pipeline), filesrc, decoder, audiosink, NULL);
</programlisting>
<para>
We link the different pads of the elements together like this:
</para>
<programlisting>
/* link src to sink */
gst_element_link_many (filesrc, decoder, audiosink, NULL);
</programlisting>
<para>
We now have created a complete pipeline. We can visualise the
pipeline as follows:
</para>
<figure float="1" id="section-hello-img">
<title>The "hello world" pipeline</title>
<mediaobject>
<imageobject>
<imagedata fileref="images/hello-world.&image;" format="&IMAGE;" />
</imageobject>
</mediaobject>
</figure>
<para>
Everything is now set up to start streaming. We use the following
statements to change the state of the pipeline:
</para>
<programlisting>
/* start playing */
gst_element_set_state (pipeline, GST_STATE_PLAYING);
</programlisting>
<note>
<para>
<application>GStreamer</application> will take care of the READY and PAUSED state for
you when going from NULL to PLAYING.
</para>
</note>
<para>
Since we do not use threads, nothing will happen yet. We have to
call gst_bin_iterate() to execute one iteration of the pipeline.
</para>
<programlisting>
while (gst_bin_iterate (GST_BIN (pipeline)));
</programlisting>
<para>
The gst_bin_iterate() function will return TRUE as long as something
interesting happened inside the pipeline. When the end-of-file has been
reached the _iterate function will return FALSE and we can end the loop.
</para>
<programlisting>
/* stop the pipeline */
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (GST_OBJECT (pipeline));
exit (0);
</programlisting>
<note>
<para>
Don't forget to set the state of the pipeline to NULL. This will free
all of the resources held by the elements.
</para>
</note>
</sect1>
<sect1 id="section-hello-world-compile">
<title>Compiling helloworld.c</title>
<para>
To compile the helloworld example, use:
</para>
<programlisting>
gcc -Wall `pkg-config gstreamer-&GST_MAJORMINOR; --cflags --libs` helloworld.c \
-o helloworld
</programlisting>
<para>
We use pkg-config to get the compiler flags needed to compile
this application. Make sure to have your PKG_CONFIG_PATH environment
variable set to the correct location if you are building this
application against the uninstalled location.
</para>
<para>
You can run the example with
(substitute helloworld.mp3 with you favorite MP3 file):
</para>
<programlisting>
./helloworld helloworld.mp3
</programlisting>
</sect1>
<sect1 id="section-hello-world-conclusion">
<title>Conclusion</title>
<para>
This concludes our first example. As you see, setting up a pipeline
is very low-level but powerful. You will see later in this manual how
you can create a custom MP3 element with a higher-level API.
</para>
<para>
It should be clear from the example that we can very easily replace the
filesrc element with the gnomevfssrc element, giving you instant streaming
from any gnomevfs URL.
</para>
<para>
We can also choose to use another type of sink instead of the audiosink.
We could use a filesink to write the raw samples to a file, for example.
It should also be clear that inserting filters, like a stereo effect,
into the pipeline is not that hard to do. The most important thing is
that you can reuse already existing elements.
</para>
</sect1>
</chapter>

243
docs/manual/basics-pads.xml
View file

@ -1,243 +0,0 @@
<chapter id="chapter-pads">
<title>Pads</title>
<para>
As we have seen in <xref linkend="chapter-elements"/>, the pads are the element's
interface to the outside world.
</para>
<para>
The specific type of media that the element can handle will be exposed by the pads.
The description of this media type is done with capabilities(see
<xref linkend="section-caps"/>)
</para>
<para>
Pads are either source or sink pads. The terminology is defined from the
view of the element itself: elements accept data on their sink pads, and
send data out on their source pads. Sink pads are drawn on the left,
while source pads are drawn on the right of an element. In general,
data flows from left to right in the graph.<footnote>
<para>
In reality, there is no objection to data flowing from a
source pad to the sink pad of an element upstream. Data will, however,
always flow from a source pad of one element to the sink pad of
another.
</para></footnote>
</para>
<sect1 id="section-pads-type">
<title>Types of pad</title>
<sect2 id="section-pads-dynamic">
<title>Dynamic pads</title>
<para>
Some elements might not have all of their pads when the element is
created. This
can happen, for example, with an MPEG system demultiplexer. The
demultiplexer will create its pads at runtime when it detects the
different elementary streams in the MPEG system stream.
</para>
<para>
Running <application>gst-inspect mpegdemux</application> will show that
the element has only one pad: a sink pad called 'sink'. The other pads are
"dormant". You can see this in the pad template because there is
an 'Exists: Sometimes'
property. Depending on the type of MPEG file you play, the pads will
be created. We
will see that this is very important when you are going to create dynamic
pipelines later on in this manual.
</para>
</sect2>
<sect2 id="section-pads-request">
<title>Request pads</title>
<para>
An element can also have request pads. These pads are not created
automatically but are only created on demand. This is very useful
for multiplexers, aggregators and tee elements.
</para>
<para>
The tee element, for example, has one input pad and a request padtemplate for the
output pads. Whenever an element wants to get an output pad from the tee element, it
has to request the pad.
</para>
</sect2>
</sect1>
<sect1 id="section-caps">
<title>Capabilities of a pad</title>
<para>
Since the pads play a very important role in how the element is viewed by the
outside world, a mechanism is implemented to describe the data that can
flow through the pad by using capabilities.
</para>
<para>
We will briefly describe what capabilities are, enough for you to get a basic understanding
of the concepts. You will find more information on how to create capabilities in the
Plugin Writer's Guide.
</para>
<sect2 id="section-pads-caps">
<title>Capabilities</title>
<para>
Capabilities are attached to a pad in order to describe
what type of media the pad can handle.
</para>
<para>
Capabilities is shorthand for "capability chain". A capability chain
is a chain of one capability or more.
</para>
<para>
The basic entity is a capability, and is defined by a name, a MIME
type and a set of properties. A capability can be chained to
another capability, which is why we commonly refer to a chain of
capability entities as "capabilities".
<footnote>
<para>
It is important to understand that the term "capabilities" refers
to a chain of one capability or more. This will be clearer when
you see the structure definition of a <classname>GstCaps</classname>
element.
</para>
</footnote>
</para>
<para>
Below is a dump of the capabilities of the element mad, as shown by
<command>gst-inspect</command>.
You can see two pads: sink and src. Both pads have capability information attached to them.
</para>
<para>
The sink pad (input pad) is called 'sink' and takes data of MIME type 'audio/mp3'. It also has
three properties: layer, bitrate and framed.
</para>
<para>
The source pad (output pad) is called 'src' and outputs data of
MIME type 'audio/raw'. It also has four properties: format, depth,
rate and channels.
</para>
<programlisting>
Pads:
SINK template: 'sink'
Availability: Always
Capabilities:
'mad_sink':
MIME type: 'audio/mp3':
SRC template: 'src'
Availability: Always
Capabilities:
'mad_src':
MIME type: 'audio/raw':
format: String: int
endianness: Integer: 1234
width: Integer: 16
depth: Integer: 16
channels: Integer range: 1 - 2
law: Integer: 0
signed: Boolean: TRUE
rate: Integer range: 11025 - 48000
</programlisting>
</sect2>
<sect2 id="section-pads-props">
<title>What are properties ?</title>
<para>
Properties are used to describe extra information for
capabilities. A property consists of a key (a string) and
a value. There are different possible value types that can be used:
</para>
<itemizedlist>
<listitem>
<para>
basic types:
</para>
<itemizedlist>
<listitem>
<para>
an integer value: the property has this exact value.
</para>
</listitem>
<listitem>
<para>
a boolean value: the property is either TRUE or FALSE.
</para>
</listitem>
<listitem>
<para>
a fourcc value: this is a value that is commonly used to
describe an encoding for video,
as used for example by the AVI specification.
<footnote><para>
fourcc values consist of four bytes.
<ulink url="http://www.fourcc.org" type="http">The FOURCC
Definition List</ulink> is the most complete resource
on the allowed fourcc values.
</para></footnote>
</para>
</listitem>
<listitem>
<para>
a float value: the property has this exact floating point value.
</para>
</listitem>
<listitem>
<para>
a string value.
</para>
</listitem>
</itemizedlist>
</listitem>
<listitem>
<para>
range types:
</para>
<itemizedlist>
<listitem>
<para>
an integer range value: the property denotes a range of
possible integers. For example, the wavparse element has
a source pad where the "rate" property can go from 8000 to
48000.
</para>
</listitem>
<listitem>
<para>
a float range value: the property denotes a range of possible
floating point values.
</para>
</listitem>
</itemizedlist>
</listitem>
<listitem>
<para>
a list value: the property can take any value from a list of
basic value types or range types.
</para>
</listitem>
</itemizedlist>
</sect2>
<sect2 id="section-pads-caps-use">
<title>What capabilities are used for</title>
<para>
Capabilities describe in great detail the type of media that is handled by the pads.
They are mostly used for:
</para>
<itemizedlist>
<listitem>
<para>
Autoplugging: automatically finding plugins for a set of capabilities
</para>
</listitem>
<listitem>
<para>
Compatibility detection: when two pads are linked, <application>GStreamer</application>
can verify if the two pads are talking about the same media types.
The process of linking two pads and checking if they are compatible
is called "caps negotiation".
</para>
</listitem>
</itemizedlist>
</sect2>
</sect1>
</chapter>

14
docs/manual/bins-api.xml
View file

@ -119,7 +119,8 @@
</programlisting>
<para>
Note that the above code assumes that the mp3player bin derives itself
from a <classname>GstThread</classname>, which begins to play as soon
from a <ulink type="http"
url="../../gstreamer/html/GstThread.html"><classname>GstThread</classname></ulink>, which begins to play as soon
as its state is set to PLAYING. Other bin types may need explicit
iteration. For more information, see <xref linkend="chapter-threads"/>.
</para>
@ -137,7 +138,8 @@
This is where "ghost pads" come into play.
</para>
<figure float="1" id="section-bin-noghost-img">
<title>Visualisation of a <classname>GstBin</classname> element without ghost pads</title>
<title>Visualisation of a <ulink type="http"
url="../../gstreamer/html/GstBin.html"><classname>GstBin</classname></ulink> element without ghost pads</title>
<mediaobject>
<imageobject>
<imagedata fileref="images/bin-element-noghost.&image;" format="&IMAGE;" />
@ -152,7 +154,8 @@
</para>
<figure float="1" id="section-bin-ghost-img">
<title>Visualisation of a <classname>GstBin</classname> element with a ghost pad</title>
<title>Visualisation of a <ulink type="http"
url="../../gstreamer/html/GstBin.html"><classname>GstBin</classname></ulink> element with a ghost pad</title>
<mediaobject>
<imageobject>
<imagedata fileref="images/bin-element-ghost.&image;" format="&IMAGE;" />
@ -165,8 +168,9 @@
of the bin.
</para>
<para>
Ghost pads can actually be added to all <classname>GstElement</classname>s and not just
<classname>GstBin</classname>s. Use the following code example to add a ghost pad to a bin:
Ghost pads can actually be added to all <ulink type="http"
url="../../gstreamer/html/GstElement.html"><classname>GstElement</classname></ulink>s and not just
<ulink type="http" url="../../gstreamer/html/GstBin.html"><classname>GstBin</classname></ulink>s. Use the following code example to add a ghost pad to a bin:
</para>
<programlisting>
GstElement *bin;

3
docs/manual/buffers.xml
View file

@ -36,7 +36,8 @@
</itemizedlist>
</para>
<para>
<para>
<!-- FIXME: this is outdated, there is no GstBufferPool in gst-0.8.X -->
GStreamer provides functions to create custom buffer create/destroy algorithms, called
a <classname>GstBufferPool</classname>. This makes it possible to efficiently
allocate and destroy buffer memory. It also makes it possible to exchange memory between

11
docs/manual/cothreads.xml
View file

@ -6,7 +6,9 @@
from other user-space threading libraries in that they are scheduled explictly by GStreamer.
</para>
<para>
A cothread is created by a <classname>GstBin</classname> whenever an element is found
A cothread is created by a <ulink type="http"
url="../../gstreamer/html/GstBin.html"><classname>GstBin</classname></ulink>
whenever an element is found
inside the bin that has one or more of the following properties:
<itemizedlist>
<listitem>
@ -25,7 +27,8 @@
</para>
</listitem>
</itemizedlist>
The <classname>GstBin</classname> will create a cothread context for all the elements
The <ulink type="http" url="../../gstreamer/html/GstBin.html"><classname>GstBin
</classname></ulink> will create a cothread context for all the elements
in the bin so that the elements will interact in cooperative
multithreading.
</para>
@ -117,7 +120,9 @@ chain_function (GstPad *pad, GstBuffer *buffer)
bytestream library will need to be loop-based.
</para>
<para>
There is no problem in putting cothreaded elements into a <classname>GstThread</classname> to
There is no problem in putting cothreaded elements into a <ulink
type="http" url="../../gstreamer/html/GstThread.html"><classname>GstThread
</classname></ulink> to
create even more complex pipelines with both user and kernel space threads.
</para>

18
docs/manual/elements-api.xml
View file

@ -3,9 +3,12 @@
<sect1 id="section-elements-create">
<title>Creating a GstElement</title>
<para>
A <classname>GstElement</classname> object is created from
a factory. To create an element, you have to get access to a
<classname>GstElementFactory</classname> object using a unique
A <ulink type="http"
url="../../gstreamer/html/GstElement.html"><classname>GstElement</classname></ulink>
object is created from a factory.
To create an element, you have to get access to a
<ulink type="http" url="../../gstreamer/html/GstElementFactory.html">
<classname>GstElementFactory</classname></ulink> object using a unique
factory name.
</para>
<para>
@ -58,14 +61,16 @@
<sect1 id="section-elements-properties">
<title>GstElement properties</title>
<para>
A <classname>GstElement</classname> can have several properties
A <ulink type="http" url="../../gstreamer/html/GstElement.html">
<classname>GstElement</classname></ulink> can have several properties
which are implemented using standard <classname>GObject</classname>
properties. The usual <classname>GObject</classname> methods to query,
set and get property values and <classname>GParamSpecs</classname>
are therefore supported.
</para>
<para>
Every <classname>GstElement</classname> inherits at least
Every <ulink type="http" url="../../gstreamer/html/GstElementFactory.html">
<classname>GstElement</classname></ulink> inherits at least
one property of its parent <classname>GstObject</classname>:
the "name" property. This is the name you provide to the
functions <function>gst_element_factory_make</function> or
@ -108,7 +113,8 @@
<sect1 id="section-elements-signals">
<title>GstElement signals</title>
<para>
A <classname>GstElement</classname> also provides various
A <ulink type="http" url="../../gstreamer/html/GstElementFactory.html">
<classname>GstElement</classname></ulink> also provides various
<classname>GObject</classname> signals that can be used as a flexible
callback mechanism.
</para>

12
docs/manual/elements.xml
View file

@ -2,7 +2,9 @@
<title>Elements</title>
<para>
The most important object in <application>GStreamer</application> for the
application programmer is the <classname>GstElement</classname> object.
application programmer is the <ulink type="http"
url="../../gstreamer/html/GstElement.html"><classname>GstElement</classname>
</ulink>object.
</para>
<sect1 id="section-elements-design">
@ -10,14 +12,16 @@
<para>
An element is the basic building block for the media pipeline.
All the different high-level components you are going to use are
derived from <classname>GstElement</classname>. This means that a
derived from <ulink type="http" url="../../gstreamer/html/GstElement.html">
<classname>GstElement</classname></ulink>. This means that a
lot of functions you are going to use operate on objects of this class.
</para>
<para>
Elements, from the perspective of GStreamer, are viewed as "black boxes"
with a number of different aspects. One of these aspects is the presence
of "pads" (see <xref linkend="chapter-pads"/>), or link points. This terminology arises from soldering;
pads are where wires can be attached.
of "pads" (see <xref linkend="chapter-pads"/>), or link points.
This terminology arises from soldering; pads are where wires can be
attached.
</para>
</sect1>

3
docs/manual/helloworld.xml
View file

@ -93,7 +93,8 @@ main (int argc, char *argv[])
<para>
We are going to create three elements and one pipeline. Since all
elements share the same base type, <classname>GstElement</classname>,
elements share the same base type, <ulink type="http"
url="../../gstreamer/html/GstElement.html"><classname>GstElement</classname></ulink>,
we can define them as:
</para>
<programlisting>

13
docs/manual/links-api.xml
View file

@ -59,19 +59,22 @@
</programlisting>
<para>
You can query if a pad is linked with GST_PAD_IS_LINKED (pad).
You can query if a pad is linked with
<function>GST_PAD_IS_LINKED (pad)</function>.
</para>
<para>
To query for the <classname>GstPad</classname> a pad is linked to, use
gst_pad_get_peer (pad).
To query for the <ulink type="http"
url="../../gstreamer/html/GstPad.html"><classname>GstPad</classname></ulink>
a pad is linked to, use <function>gst_pad_get_peer (pad)</function>.
</para>
</sect1>
<sect1 id="section-link-filtered">
<title>Making filtered links</title>
<para>
You can also force a specific media type on the link by using gst_pad_link_filtered ()
and gst_element_link_filtered () with capabilities.
You can also force a specific media type on the link by using
<function>gst_pad_link_filtered ()</function>
and <function>gst_element_link_filtered ()</function> with capabilities.
See <xref linkend="section-caps"/> for
an explanation of capabilities.
</para>

8
docs/manual/manual.xml
View file

@ -123,9 +123,11 @@
For a gentle introduction to this system, you may wish to read the
<emphasis><ulink url="http://www.gtk.org/tutorial/" type="http">GTK+
Tutorial</ulink></emphasis> or Eric Harlow's book <emphasis>Developing
Linux Applications with GTK+ and GDK</emphasis>.
Tutorial</ulink></emphasis>, Eric Harlow's book <emphasis>Developing
Linux Applications with GTK+ and GDK</emphasis> and the <emphasis>
<ulink type="http"
url="http://www.le-hacker.org/papers/gobject/index.html">Glib Object
system</ulink></emphasis>.
</para>
</partintro>

5
docs/manual/pads-api.xml
View file

@ -190,8 +190,9 @@ struct _GstCaps {
<para>
As we said, a capability has a name, a mime-type and some
properties. The signature of the function to create a new
<classname>GstCaps</classname> structure is:
<ulink type="http" url="../../gstreamer/html/gstreamer-GstCaps.html">
<classname>GstCaps</classname></ulink> structure is:
<!-- FIXME: GstProbs are deprecated, in gst-0.8.X -->
<programlisting>
GstCaps* gst_caps_new (const gchar *name, const gchar *mime, GstProps *props);
</programlisting>

5
docs/manual/pads.xml
View file

@ -95,8 +95,9 @@
<para>
It is important to understand that the term "capabilities" refers
to a chain of one capability or more. This will be clearer when
you see the structure definition of a <classname>GstCaps</classname>
element.
you see the structure definition of a <ulink type="http"
url="../../gstreamer/html/gstreamer-GstCaps.html"><classname>GstCaps
</classname></ulink>element.
</para>
</footnote>
</para>

6
docs/manual/threads.xml
View file

@ -2,8 +2,10 @@
<title>Threads</title>
<para>
GStreamer has support for multithreading through the use of
the <classname>GstThread</classname> object. This object is in fact
a special <classname>GstBin</classname> that will become a thread when started.
the <ulink type="http" url="../../gstreamer/html/GstThread.html"><classname>
GstThread</classname></ulink> object. This object is in fact
a special <ulink type="http" url="../../gstreamer/html/GstBin.html"><classname>
GstBin</classname></ulink> that will become a thread when started.
</para>
<para>

16
docs/pwg/advanced-events.xml
View file

@ -158,9 +158,13 @@ gst_my_filter_handle_src_event (GstPad *pad,
<para>
In this chapter follows a list of all defined events that are currently
being used, plus how they should be used/interpreted. Events are stored
in a <classname>GstEvent</classname> structure, which is simply a big
C union with the types for each event in it. For the next development
cycle, we intend to switch events over to <classname>GstStructure</classname>,
in a <ulink type="http"
url="../../gstreamer/html/gstreamer-GstEvent.html"><classname>GstEvent
</classname></ulink> structure, which is simply a big C union with the
types for each event in it. For the next development cycle, we intend to
switch events over to <ulink type="http"
url="../../gstreamer/html/gstreamer-GstStructure.html"><classname>GstStructure
</classname></ulink>,
but you don't need to worry about that too much for now.
</para>
<para>
@ -194,7 +198,7 @@ gst_my_filter_handle_src_event (GstPad *pad,
<xref linkend="section-loopfn-multiinput"/>.
</para>
<para>
The EOS event (<classname>GST_EVENT_EOS</classname>) has no properties,
The EOS event (<symbol>GST_EVENT_EOS</symbol>) has no properties,
and that makes it one of the simplest events in &GStreamer;. It is
created using <function>gst_event_new (GST_EVENT_EOS);</function>.
</para>
@ -246,12 +250,12 @@ gst_my_filter_handle_src_event (GstPad *pad,
and a modified event should be sent on. The last is true for demuxers,
which generally have a byte-to-time conversion concept. Their input
is usually byte-based, so the incoming event will have an offset in
byte units (<classname>GST_FORMAT_BYTES</classname>), too. Elements
byte units (<symbol>GST_FORMAT_BYTES</symbol>), too. Elements
downstream, however, expect discontinuity events in time units, so that
it can be used to update the pipeline clock. Therefore, demuxers and
similar elements should not forward the event, but parse it, free it
and send a new discontinuity event (in time units,
<classname>GST_FORMAT_TIME</classname>) further downstream.
<symbol>GST_FORMAT_TIME</symbol>) further downstream.
</para>
<para>
The discontinuity event is created using the function

35
docs/pwg/advanced-interfaces.xml
View file

@ -37,7 +37,9 @@
at their own will. We've also created a small extension to
<classname>GTypeInterface</classname> (which is static itself, too) which
allows us to query for interface availability based on runtime properties.
This extension is called <classname>GstImplementsInterface</classname>.
This extension is called <ulink type="http"
url="../../gstreamer/html/GstImplementsInterface.html"><classname>
GstImplementsInterface</classname></ulink>.
</para>
<para>
One important note: interfaces do <emphasis>not</emphasis> replace
@ -57,13 +59,16 @@
will be notified of doing that wrongly when using the element: it will
quit with failed assertions, which will explain what went wrong. In the
case of GStreamer, the only dependency that <emphasis>some</emphasis>
interfaces have is <classname>GstImplementsInterface</classname>. Per
interfaces have is <ulink type="http"
url="../../gstreamer/html/GstImplementsInterface.html"><classname>
GstImplementsInterface</classname></ulink>. Per
interface, we will indicate clearly when it depends on this extension.
If it does, you need to register support for <emphasis>that</emphasis>
interface before registering support for the interface that you're
wanting to support. The example below explains how to add support for a
simple interface with no further dependencies. For a small explanation
on <classname>GstImplementsInterface</classname>, see the next section
on <ulink type="http" url="../../gstreamer/html/GstImplementsInterface.html">
<classname>GstImplementsInterface</classname></ulink>, see the next section
about the mixer interface: <xref linkend="section-iface-mixer"/>.
</para>
<programlisting>
@ -127,13 +132,16 @@ gst_my_filter_some_interface_init (GstSomeInterface *iface)
and input/output settings.
</para>
<para>
The mixer interface requires the <classname>GstImplementsInterface</classname>
The mixer interface requires the <ulink type="http"
url="../../gstreamer/html/GstImplementsInterface.html"><classname>
GstImplementsInterface</classname></ulink>
interface to be implemented by the element. The example below will
feature both, so it serves as an example for the
<classname>GstImplementsInterface</classname>, too. In the
<classname>GstImplementsInterface</classname>, it is required to set a
function pointer for the <function>supported ()</function> function. If
you don't, this function will always return FALSE (default
feature both, so it serves as an example for the <ulink type="http"
url="../../gstreamer/html/GstImplementsInterface.html"><classname>
GstImplementsInterface</classname></ulink>, too. In this
interface, it is required to set a function pointer for the <function>
supported ()</function> function.
If you don't, this function will always return FALSE (default
implementation) and the mixer interface implementation will not work. For
the mixer interface, the only required function is
<function>list_tracks ()</function>. All other function pointers in the
@ -307,7 +315,9 @@ gst_my_filter_mixer_interface_init (GstMixerClass *iface)
highly analog-video-centric.
</para>
<para>
This interface requires the <classname>GstImplemensInterface</classname>
This interface requires the <ulink type="http"
url="../../gstreamer/html/GstImplementsInterface.html"><classname>
GstImplemensInterface</classname></ulink>
interface to work correctly.
</para>
<para>
@ -454,7 +464,7 @@ gst_my_filter_tuner_interface_init (GstTunerClass *iface)
<para>
Property probing stores the list of allowed (or recommended) values in a
<classname>GValueArray</classname> and returns that to the user.
<classname>NULL</classname> is a valid return value, too. The process of
<symbol>NULL</symbol> is a valid return value, too. The process of
property probing is separated over two virtual functions: one for probing
the property to create a <classname>GValueArray</classname>, and one to
retrieve the current <classname>GValueArray</classname>. Those two are
@ -462,12 +472,13 @@ gst_my_filter_tuner_interface_init (GstTunerClass *iface)
this simpliies interface implementation in elements. For the application,
there are functions that wrap those two. For more information on this,
have a look at the API reference for the
<!-- FIXME: add link, but this is in ./gst-plugins/gst-libs/gst/propertyprobe/propertyprobe.c-->
<classname>GstPropertyProbe</classname> interface.
</para>
<para>
Below is a example of property probing for the audio filter element; it
will probe for allowed values for the <quote>silent</quote> property.
Indeed, this value is a <classname>gboolean</classname> so it doesn't
Indeed, this value is a <type>gboolean</type> so it doesn't
make much sense. Then again, it's only an example.
</para>
<programlisting>

31
docs/pwg/advanced-tagging.xml
View file

@ -32,21 +32,32 @@
once as streaminfo.
</para>
<para>
<!-- FIXME: (Company knows about this)
when people are interested in tags, they should connect to the pipeline's 'found-tag' signal and use that
the code example on that page is bogus, too btw
there are no string => something else g_value_transforms
either use gst_value_deserialize or a custom deserialization (which is a better idea most of the time)
-->
A tag reading element is called <classname>TagGetter</classname> in
&GStreamer;. A tag writer is called <classname>TagSetter</classname>. An
element supporting both can be used in a tag editor for quick tag changing.
&GStreamer;.
A tag writer is called <ulink type="http"
url="../../gstreamer/html/GstTagSetter.html"><classname>TagSetter</classname></ulink>.
An element supporting both can be used in a tag editor for quick tag
changing.
</para>
<sect1 id="section-tagging-read" xreflabel="Reading Tags from Streams">
<title>Reading Tags from Streams</title>
<para>
The basic object for tags is a <classname>GstTagList</classname>. An
element that is reading tags from a stream should create an empty taglist
and fill this with individual tags. Empty tag lists can be created with
<function>gst_tag_list_new ()</function>. Then, the element can fill the
list using <function>gst_tag_list_add_values ()</function>. Note that
an element probably reads metadata as strings, but values might not
necessarily be strings. Be sure to use <function>gst_value_transform ()</function>
The basic object for tags is a <ulink type="http"
url="../../gstreamer/html/gstreamer-GstTagList.html"><classname>GstTagList
</classname></ulink>. An element that is reading tags from a stream should
create an empty taglist and fill this with individual tags. Empty tag
lists can be created with <function>gst_tag_list_new ()</function>. Then,
the element can fill the list using <function>gst_tag_list_add_values ()
</function>. Note that an element probably reads metadata as strings, but
values might not necessarily be strings. Be sure to use
<function>gst_value_transform ()</function>
to make sure that your data is of the right type. After data reading, the
application can be notified of the new taglist by calling
<function>gst_element_found_tags ()</function>. The tags should also be
@ -160,7 +171,7 @@ gst_my_filter_class_init (GstMyFilterClass *klass)
reader, too. Application tags are tags provided to the element via the
TagSetter interface (which is just a layer). Pipeline tags are tags
provided to the element from within the pipeline. The element receives
such tags via the <classname>GST_EVENT_TAG</classname> event, which means
such tags via the <symbol>GST_EVENT_TAG</symbol> event, which means
that tags writers should automatically be event aware. The tag writer is
responsible for combining all these three into one list and writing them
to the output stream.

18
docs/pwg/building-pads.xml
View file

@ -63,11 +63,12 @@ gst_my_filter_init (GstMyFilter *filter)
is the process where the linked pads decide on the streamtype that will
transfer between them. A full list of type-definitions can be found in
<xref linkend="chapter-building-types"/>. A <function>_link ()</function>
receives a pointer to a <classname>GstCaps</classname> struct that
defines the proposed streamtype, and can respond with either
<quote>yes</quote> (<classname>GST_PAD_LINK_OK</classname>),
<quote>no</quote> (<classname>GST_PAD_LINK_REFUSED</classname>) or
<quote>don't know yet</quote> (<classname>GST_PAD_LINK_DELAYED</classname>).
receives a pointer to a <ulink type="http"
url="../../gstreamer/html/gstreamer-GstCaps.html"><classname>GstCaps</classname>
</ulink> struct that defines the proposed streamtype, and can respond with
either <quote>yes</quote> (<symbol>GST_PAD_LINK_OK</symbol>),
<quote>no</quote> (<symbol>GST_PAD_LINK_REFUSED</symbol>) or
<quote>don't know yet</quote> (<symbol>GST_PAD_LINK_DELAYED</symbol>).
If the element responds positively towards the streamtype, that type
will be used on the pad. An example:
</para>
@ -115,8 +116,11 @@ gst_my_filter_link (GstPad *pad,
In here, we check the mimetype of the provided caps. Normally, you don't
need to do that in your own plugin/element, because the core does that
for you. We simply use it to show how to retrieve the mimetype from a
provided set of caps. Types are stored in <classname>GstStructure</classname>
internally. A <classname>GstCaps</classname> is nothing more than a small
provided set of caps. Types are stored in <ulink type="http"
url="../../gstreamer/html/gstreamer-GstStructure.html"><classname>GstStructure
</classname></ulink> internally. A <ulink
type="http" url="../../gstreamer/html/gstreamer-GstCaps.html"><classname>GstCaps
</classname></ulink> is nothing more than a small
wrapper for 0 or more structures/types. From the structure, you can also
retrieve properties, as is shown above with the function
<function>gst_structure_get_int ()</function>.

26
docs/pwg/building-state.xml
View file

@ -5,53 +5,53 @@
<para>
A state describes whether the element instance is initialized, whether it
is ready to transfer data and whether it is currently handling data. There
are four states defined in &GStreamer;: <classname>GST_STATE_NULL</classname>,
<classname>GST_STATE_READY</classname>, <classname>GST_STATE_PAUSED</classname>
and <classname>GST_STATE_PLAYING</classname>.
are four states defined in &GStreamer;: <symbol>GST_STATE_NULL</symbol>,
<symbol>GST_STATE_READY</symbol>, <symbol>GST_STATE_PAUSED</symbol>
and <symbol>GST_STATE_PLAYING</symbol>.
</para>
<para>
<classname>GST_STATE_NULL</classname> (from now on referred to as
<symbol>GST_STATE_NULL</symbol> (from now on referred to as
<quote>NULL</quote>) is the default state of an element. In this state, it
has not allocated any runtime resources, it has not loaded any runtime
libraries and it can obviously not handle data.
</para>
<para>
<classname>GST_STATE_READY</classname> (from now on referred to as
<symbol>GST_STATE_READY</symbol> (from now on referred to as
<quote>READY</quote>) is the next state that an element can be in. In the
READY state, an element has all default resources (runtime-libraries,
runtime-memory) allocated. However, it has not yet allocated or defined
anything that is stream-specific. When going from NULL to READY state
(<classname>GST_STATE_NULL_TO_READY</classname>), an element should
(<symbol>GST_STATE_NULL_TO_READY</symbol>), an element should
allocate any non-stream-specific resources and should load runtime-loadable
libraries (if any). When going the other way around (from READY to NULL,
<classname>GST_STATE_READY_TO_NULL</classname>), an element should unload
<symbol>GST_STATE_READY_TO_NULL</symbol>), an element should unload
these libraries and free all allocated resources. Examples of such
resources are hardware devices. Note that files are generally streams,
and these should thus be considered as stream-specific resources; therefore,
they should <emphasis>not</emphasis> be allocated in this state.
</para>
<para>
<classname>GST_STATE_PAUSED</classname> (from now on referred to as
<symbol>GST_STATE_PAUSED</symbol> (from now on referred to as
<quote>PAUSED</quote>) is a state in which an element is by all means able
to handle data; the only 'but' here is that it doesn't actually handle
any data. When going from the READY state into the PAUSED state
(<classname>GST_STATE_READY_TO_PAUSED</classname>), the element will
(<symbol>GST_STATE_READY_TO_PAUSED</symbol>), the element will
usually not do anything at all: all stream-specific info is generally
handled in the <function>_link ()</function>, which is called during caps
negotiation. Exceptions to this rule are, for example, files: these are
considered stream-specific data (since one file is one stream), and should
thus be opened in this state change. When going from the PAUSED back to
READY (<classname>GST_STATE_PAUSED_TO_READY</classname>), all
READY (<symbol>GST_STATE_PAUSED_TO_READY</symbol>), all
stream-specific data should be discarded.
</para>
<para>
<classname>GST_STATE_PLAYING</classname> (from now on referred to as
<symbol>GST_STATE_PLAYING</symbol> (from now on referred to as
<quote>PLAYING</quote>) is the highest state that an element can be in. It
is similar to PAUSED, except that now, data is actually passing over the
pipeline. The transition from PAUSED to PLAYING
(<classname>GST_STATE_PAUSED_TO_PLAYING</classname>) should be as small
(<symbol>GST_STATE_PAUSED_TO_PLAYING</symbol>) should be as small
as possible and would ideally cause no delay at all. The same goes for the
reverse transition (<classname>GST_STATE_PLAYING_TO_PAUSED</classname>).
reverse transition (<symbol>GST_STATE_PLAYING_TO_PAUSED</symbol>).
</para>
<sect1 id="section-statemanage-filters">

15
docs/pwg/intro-basics.xml
View file

@ -17,7 +17,8 @@
<para>
Elements are at the core of &GStreamer;. In the context of plugin
development, an <emphasis>element</emphasis> is an object derived from the
<classname>GstElement</classname> class. Elements provide some sort of
<ulink type="http" url="../../gstreamer/html/GstElement.html"><classname>
GstElement</classname></ulink> class. Elements provide some sort of
functionality when linked with other elements: For example, a source
element provides data to a stream, and a filter element acts on the data
in a stream. Without elements, &GStreamer; is just a bunch of conceptual
@ -56,9 +57,9 @@
<para>
See the &GstLibRef; for the current implementation details of <ulink
type="http"
url="../../gstreamer/gstelement.html"><classname>GstElement</classname></ulink>
url="../../gstreamer/html/GstElement.html"><classname>GstElement</classname></ulink>
and <ulink type="http"
url="../../gstreamer/gstreamer-gstplugin.html"><classname>GstPlugin</classname></ulink>.
url="../../gstreamer/html/gstreamer-GstPlugin.html"><classname>GstPlugin</classname></ulink>.
</para>
</sect1>
@ -97,7 +98,7 @@
<para>
See the &GstLibRef; for the current implementation details of a <ulink
type="http"
url="../../gstreamer/gstreamer-gstpad.html"><classname>GstPad</classname></ulink>.
url="../../gstreamer/html/GstPad.html"><classname>GstPad</classname></ulink>.
</para>
</sect1>
@ -192,9 +193,9 @@
<para>
See the &GstLibRef; for the current implementation details of a <ulink
type="http"
url="../../gstreamer/gstreamer-gstdata.html"><classname>GstData</classname></ulink>, <ulink type="http"
url="../../gstreamer/gstreamer-gstbuffer.html"><classname>GstBuffer</classname></ulink> and <ulink type="http"
url="../../gstreamer/gstreamer-gstevent.html"><classname>GstEvent</classname></ulink>.
url="../../gstreamer/html/gstreamer-GstData.html"><classname>GstData</classname></ulink>, <ulink type="http"
url="../../gstreamer/html/gstreamer-GstBuffer.html"><classname>GstBuffer</classname></ulink> and <ulink type="http"
url="../../gstreamer/html/gstreamer-GstEvent.html"><classname>GstEvent</classname></ulink>.
</para>
<sect2 id="sect2-buffer-allocation" xreflabel="Buffer Allocation">

5
docs/pwg/intro-preface.xml
View file

@ -67,7 +67,10 @@
url="http://developer.gnome.org/doc/API/2.0/gobject/index.html">GObject</ulink>
programming. There are several good introductions to the GObject library,
including the <emphasis><ulink type="http"
url="http://www.gtk.org/tutorial/">GTK+ Tutorial</ulink></emphasis>.
url="http://www.gtk.org/tutorial/">GTK+ Tutorial</ulink></emphasis> and
the <emphasis><ulink type="http"
url="http://www.le-hacker.org/papers/gobject/index.html">Glib Object
system</ulink></emphasis>.
</para>
</sect1>