GStreamer Application Development Manual (0.10.14)

Wim Taymans

Steve Baker

Andy Wingo

Ronald S. Bultje

Stefan Kost

This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/opl.shtml).


Table of Contents
I. Introduction
1. Preface
1.1. What is GStreamer?
1.2. Who Should Read This Manual?
1.3. Preliminary Reading
1.4. Structure of this Manual
2. Motivation & Goals
2.1. Current problems
2.2. The design goals
3. Foundations
3.1. Elements
3.2. Bins and pipelines
3.3. Pads
II. Building an Application
4. Initializing GStreamer
4.1. Simple initialization
4.2. The GOption interface
5. Elements
5.1. What are elements?
5.2. Creating a GstElement
5.3. Using an element as a GObject
5.4. More about element factories
5.5. Linking elements
5.6. Element States
6. Bins
6.1. What are bins
6.2. Creating a bin
6.3. Custom bins
7. Bus
7.1. How to use a bus
7.2. Message types
8. Pads and capabilities
8.1. Pads
8.2. Capabilities of a pad
8.3. What capabilities are used for
8.4. Ghost pads
9. Buffers and Events
9.1. Buffers
9.2. Events
10. Your first application
10.1. Hello world
10.2. Compiling and Running helloworld.c
10.3. Conclusion
III. Advanced GStreamer concepts
11. Position tracking and seeking
11.1. Querying: getting the position or length of a stream
11.2. Events: seeking (and more)
12. Metadata
12.1. Metadata reading
12.2. Tag writing
13. Interfaces
13.1. The URI interface
13.2. The Mixer interface
13.3. The Tuner interface
13.4. The Color Balance interface
13.5. The Property Probe interface
13.6. The X Overlay interface
14. Clocks in GStreamer
14.1. Clock providers
14.2. Clock slaves
15. Dynamic Controllable Parameters
15.1. Getting Started
15.2. Setting up parameter control
16. Threads
16.1. When would you want to force a thread?
16.2. Scheduling in GStreamer
17. Autoplugging
17.1. MIME-types as a way to identity streams
17.2. Media stream type detection
17.3. Plugging together dynamic pipelines
18. Pipeline manipulation
18.1. Data probing
18.2. Manually adding or removing data from/to a pipeline
18.3. Embedding static elements in your application
IV. Higher-level interfaces for GStreamer applications
19. Components
19.1. Playbin
19.2. Decodebin
19.3. GstEditor
20. XML in GStreamer
20.1. Turning GstElements into XML
20.2. Loading a GstElement from an XML file
20.3. Adding custom XML tags into the core XML data
V. Appendices
21. Things to check when writing an application
21.1. Good programming habits
21.2. Debugging
21.3. Conversion plugins
21.4. Utility applications provided with GStreamer
22. Porting 0.8 applications to 0.10
22.1. List of changes
23. Integration
23.1. Linux and UNIX-like operating systems
23.2. GNOME desktop
23.3. KDE desktop
23.4. OS X
23.5. Windows
24. Licensing advisory
24.1. How to license the applications you build with GStreamer
25. Windows support
25.1. Building GStreamer under Win32
25.2. Installation on the system
26. Quotes from the Developers
List of Figures
5-1. Visualisation of a source element
5-2. Visualisation of a filter element
5-3. Visualisation of a filter element with more than one output pad
5-4. Visualisation of a sink element
5-5. Visualisation of three linked elements
6-1. Visualisation of a bin with some elements in it
8-1. Visualisation of a GstBin element without ghost pads
8-2. Visualisation of a GstBin element with a ghost pad
10-1. The "hello world" pipeline
16-1. a two-threaded decoder with a queue
17-1. The Hello world pipeline with MIME types
List of Examples
4-1. Initializing GStreamer
4-2. Initialisation using the GOption interface