<?xml version="1.0"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
               "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY % version-entities SYSTEM "version.entities">
%version-entities;
]>
<refentry id="compiling" revision="17 Jan 2002">
<refmeta>
<refentrytitle>Compiling</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>GStreamer-Base Library</refmiscinfo>
</refmeta>

<refnamediv>
<refname>Compiling against the base plugins libraries</refname>
<refpurpose>
How to compile against the base plugins libraries
</refpurpose>
</refnamediv>

<refsect1>
<title>Compiling against the base plugins libraries</title>

<para>
To compile against these libraries, you need to tell the compiler where to 
find the header files and libraries. This is done with the
<application>pkg-config</application> utility.
</para>
<para>
The following interactive shell session demonstrates how
<application>pkg-config</application> is used:
<programlisting>
$ pkg-config --cflags gstreamer-plugins-base-&GST_API_VERSION;
-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -pthread -I/usr/include/gstreamer-&GST_API_VERSION; -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -I/usr/include/libxml2
$ pkg-config --libs gstreamer-plugins-base-&GST_API_VERSION;
-Wl,--export-dynamic -pthread -lgstreamer-&GST_API_VERSION; -lgobject-2.0 -lgmodule-2.0 -ldl -lgthread-2.0 -lxml2 -lpthread -lz -lm -lglib-2.0
</programlisting>
</para>

<para>
Note that, because of the number of libraries provided in this package,
the pkg-config information <emphasis>does not add -l flags</emphasis> itself
to choose the libraries to link to.  You must add these yourself to select
which of the libraries you want to use.
</para>
</refsect1>

</refentry>
