Chapter 2. Foundations

This chapter of the guide introduces the basic concepts of GStreamer.
Understanding these concepts will help you grok the issues involved in
extending GStreamer. Many of these concepts are explained in greater
detail in the GStreamer Application Development Manual; the basic concepts presented here serve mainly
to refresh your memory.

Elements and Plugins

Elements are at the core of GStreamer. In the context of plugin
development, an element is an object derived from the
GstElement 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
pipe fittings with nothing to link. A large number of elements ship
with GStreamer, but extra elements can also be written.

Just writing a new element is not entirely enough, however: You will need
to encapsulate your element in a plugin to enable
GStreamer to use it. A plugin is essentially a loadable block of code,
usually called a shared object file or a dynamically linked library. A
single plugin may contain the implementation of several elements, or just
a single one. For simplicity, this guide concentrates primarily on plugins
containing one element.

A filter is an important type of element that
processes a stream of data. Producers and consumers of data are called
source and sink elements,
respectively. Bin elements contain other elements.
One type of bin is responsible for synchronization of the elements that they
contain so that data flows smoothly. Another type of bin, called
autoplugger elements, automatically add other
elements to the bin and links them together so that they act as a
filter between two arbitrary stream types.

The plugin mechanism is used everywhere in GStreamer, even if only the
standard packages are being used. A few very basic functions reside in the
core library, and all others are implemented in plugins. A plugin registry
is used to store the details of the plugins in an binary registry file.
This way, a program using GStreamer does not have to load all plugins to
determine which are needed. Plugins are only loaded when their provided
elements are requested.

See the GStreamer Library Reference for the current implementation details of GstElement
and GstPlugin.