size from the surface itself, so we do not need to bother about it
here. We need to call `gst_video_overlay_expose()` twice because of the way
the surface changes propagate down the OpenGL ES / EGL pipeline (The
-only video sink available for Android in the GStreamer SDK uses OpenGL
+only video sink available for Android in GStreamer uses OpenGL
ES). By the time we call the first expose, the surface that the sink
will pick up still contains the old size.
LOCAL_LDLIBS := -llog -landroid
include $(BUILD_SHARED_LIBRARY)
-ifndef GSTREAMER_SDK_ROOT
-ifndef GSTREAMER_SDK_ROOT_ANDROID
-$(error GSTREAMER_SDK_ROOT_ANDROID is not defined!)
+ifndef GSTREAMER_ROOT
+ifndef GSTREAMER_ROOT_ANDROID
+$(error GSTREAMER_ROOT_ANDROID is not defined!)
endif
-GSTREAMER_SDK_ROOT := $(GSTREAMER_SDK_ROOT_ANDROID)
+GSTREAMER_ROOT := $(GSTREAMER_ROOT_ANDROID)
endif
-GSTREAMER_NDK_BUILD_PATH := $(GSTREAMER_SDK_ROOT)/share/gst-android/ndk-build/
+GSTREAMER_NDK_BUILD_PATH := $(GSTREAMER_ROOT)/share/gst-android/ndk-build/
include $(GSTREAMER_NDK_BUILD_PATH)/plugins.mk
GSTREAMER_PLUGINS := $(GSTREAMER_PLUGINS_CORE) $(GSTREAMER_PLUGINS_SYS) $(GSTREAMER_PLUGINS_EFFECTS)
GSTREAMER_EXTRA_DEPS := gstreamer-video-1.0
# Android tutorials
-## Welcome to the GStreamer SDK Android tutorials
+## Welcome to the GStreamer Android tutorials
These tutorials describe Android-specific topics. General GStreamer
concepts will not be explained in these tutorials, so the
## Introduction
-These tools are available in the bin directory of the SDK. You need to
-move to this directory to execute them, because it is not added to the
-system’s `PATH` environment variable (to avoid polluting it too much).
+These tools are available in the bin directory of the GStreamer
+binaries. You need to move to this directory to execute them, because
+it is not added to the system’s `PATH` environment variable (to avoid
+polluting it too much).
Just open a terminal (or console window) and go to the `bin` directory
-of your GStreamer SDK installation (Read again the [Installing the
-SDK](sdk-installing.html) section to find our where this is),
+of your GStreamer installation (Read again the [Installing
+GStreamer](sdk-installing.html) section to find our where this is),
and you are ready to start typing the commands given in this tutorial.
In order to allow for multiple versions of GStreamer to coexists in the
same system, these tools are versioned, this is, a GStreamer version
-number is appended to their name. This version of the SDK is based on
+number is appended to their name. This version is based on
GStreamer 1.0, so the tools are called `gst-launch-1.0`,
`gst-inspect-1.0` and `gst-discoverer-1.0`
# Basic tutorials
These tutorials describe general topics required to understand the rest
-of tutorials in the GStreamer SDK.
+of tutorials.
## Build requirements
-The GStreamer SDK build system provides bootstrapping facilities for all
+The GStreamer build system provides bootstrapping facilities for all
platforms, but it still needs a minimum base to bootstrap:
-- python >= 2.6 and python's `argparse` module, which is already
+- python > 2.6 and python's `argparse` module, which is already
included in python2.7.
- git
### iOS developers
-If you want to build the GStreamer-SDK for iOS, you also need the iOS
+If you want to build GStreamer for iOS, you also need the iOS
SDK. The minimum required iOS SDK version is 6.0 and is included in
[XCode] since version 4.
## Download the sources
-To build the GStreamer SDK, you first need to download **Cerbero**.
+To build GStreamer, you first need to download **Cerbero**.
Cerbero is a multi-platform build system for Open Source projects that
builds and creates native packages for different platforms,
architectures and distributions.
Enter the superuser/root password when prompted.
The bootstrap process will then install all packages required to build
-the GStreamer SDK.
+GStreamer.
-## Build the SDK
+## Build GSTreamer
-To generate the SDK, use the following command:
+To generate GStreamer binaries, use the following command:
cerbero package gstreamer-1.0
-This should build all required SDK components and create packages for
+This should build all required GStreamer components and create packages for
your distribution at the Cerbero source directory.
A list of supported packages to build can be retrieved using:
defined in the Cerbero configuration file `$HOME/.cerbero/cerbero.cbc`
or at `$HOME/cerbero/dist` if no prefix is defined.
-### Build a single project with the SDK
+### Build a single project with GStreamer
-Rebuilding the whole SDK is relatively fast on Linux and OS X, but it
+Rebuilding the whole GStreamer is relatively fast on Linux and OS X, but it
can be very slow on Windows, so if you only need to rebuild a single
project (eg: gst-plugins-good to patch qtdemux) there is a much faster
way of doing it. You will need to follow the steps detailed in this
-page, but skipping the step "**Build the SDK**", and installing the
-SDK's development files as explained in [Installing the SDK].
+page, but skipping the step "**Build GStreamer**", and installing the
+GStreamer's development files as explained in [Installing GStreamer].
By default, Cerbero uses as prefix a folder in the user directory with
-the following schema \~/cerbero/dist/$platform\_$arch, but for the SDK
+the following schema \~/cerbero/dist/$platform\_$arch, but for GStreamer
we must change this prefix to use its installation directory. This can
be done with a custom configuration file named *custom.cbc*:
$ sudo chown -R <username> /Library/Frameworks/GStreamer.framework/
Cerbero has a shell command that starts a new shell with all the
-environment set up to target the SDK. You can start a new shell using
+environment set up to target GStreamer. You can start a new shell using
the installation prefix defined in *custom.cbc *with the following
command:
$ cerbero -c custom.cbc shell
Once you are in Cerbero's shell you can compile new projects targeting
-the SDK using the regular build process:
+GStreamer using the regular build process:
- $ git clone -b sdk-1.0.31 git://anongit.freedesktop.org/gstreamer-sdk/gst-plugins-good; cd gst-plugins-good
+ $ git clone git://anongit.freedesktop.org/gstreamer/gst-plugins-good; cd gst-plugins-good
$ sh autogen.sh --disable-gtk-doc --prefix=<prefix>
$ make -C gst/isomp4
-### Cross-compilation of the SDK
+### Cross-compilation of GStreamer
-Cerbero can be used to cross-compile the SDK to other platforms like
+Cerbero can be used to cross-compile GStreamer to other platforms like
Android or Windows. You only need to use a configuration file that sets
the target platform, but we also provide a set of of pre-defined
configuration files for the supported platforms (you will find them in
#### Android
-You can cross-compile the SDK for Android from a Linux host using the
+You can cross-compile GStreamer for Android from a Linux host using the
configuration file `config/cross-android.cbc`. Replace all the previous
commands with:
#### Windows
-The SDK can also be cross-compiled to Windows from Linux, but you should
+GStreamer can also be cross-compiled to Windows from Linux, but you should
only use it for testing purpose. The DirectShow plugins cannot be
cross-compiled yet and WiX can't be used with Wine yet, so packages can
only be created from Windows.
[Windows Driver Kit 7.1.0]: http://msdn.microsoft.com/en-us/windows/hardware/hh852365
[XCode]: https://developer.apple.com/devcenter/ios/index.action#downloads
[here]: http://www.freedesktop.org/software/gstreamer-sdk/cerbero.cbc.template
- [Installing the SDK]: sdk-installing.md
+ [Installing GStreamer]: sdk-installing.md
- The latest version of the [Android SDK]
- The latest version of the [Android NDK]
-- The GStreamer SDK for Android is targeted at API version 9 (Android
+- GStreamer for Android is targeted at API version 9 (Android
2.3.1, Gingerbread) or higher. Use the SDK Manager tool to make sure
you have at least one Android SDK platform installed with API
version 9 or higher.
[Android NDK] documentation, you can find some useful [Android JNI tips
here].
-## Download and install the SDK
+## Download and install GStreamer binaries
The GStreamer project provides [prebuilt binaries] you should download
the latest version and unzip it into any folder of your choice.
-In the process of building GStreamer-enabled Android applications, some
-tools will need to know where you installed the SDK. You must define an
-environment variable called `GSTREAMER_SDK_ROOT_ANDROID` and point it to
-the folder where you extracted the SDK. This environment variable must
-be available at build time, so maybe you want to make it available
-system-wide by adding it to your `~/.profile` file (on Linux and Mac) or
-to the Environment Variables in the System Properties dialog (on
-Windows).
+In the process of building GStreamer-enabled Android applications,
+some tools will need to know where you installed the GStreamer
+binaries. You must define an environment variable called
+`GSTREAMER_ROOT_ANDROID` and point it to the folder where you
+extracted the GStreamer binaries. This environment variable must be available at
+build time, so maybe you want to make it available system-wide by
+adding it to your `~/.profile` file (on Linux and Mac) or to the
+Environment Variables in the System Properties dialog (on Windows).
-Point `GSTREAMER_SDK_ROOT_ANDROID` to the folder where you unzipped the
-SDK.
+Point `GSTREAMER_ROOT_ANDROID` to the folder where you unzipped the binaries.
> ![information] If you plan to use Android Studio and do not want to define this
> environment variable globally, you can set it inside Eclipse. Go to
> Window → Preferences → C/C++ → Build → Build Variables and define
-> `GSTREAMER_SDK_ROOT_ANDROID` there.
+> `GSTREAMER_ROOT_ANDROID` there.
## Configure your development environment
### Building the tutorials
There are a few Android-specific tutorials in the
-`$GSTREAMER_SDK_ROOT_ANDROID\share\gst-sdk\tutorials` folder. Each
+`$GSTREAMER_ROOT_ANDROID\share\gst-sdk\tutorials` folder. Each
tutorial is a folder containing source code (in Java and C) and the
resource files required to build a complete Android application.
-The rest of the GStreamer SDK tutorials (basic and playback tutorials)
+The rest of the GStreamer tutorials (basic and playback tutorials)
cannot be run on Android without modification.
Android projects with GStreamer support are built like conventional
project is now ready to run. Hit Run → Run.
A new application called “Android tutorial 1” should now be available on
-your device, with the GStreamer SDK logo. If you want to run the
+your device, with the GStreamer logo. If you want to run the
tutorial in an Android Virtual Device (AVD), make sure to create the
device with support for audio playback and GPU Emulation (to enable
OpenGL ES).
application.
A new application called “Android tutorial 1” should now be available on
-your device, with the GStreamer SDK logo. If you want to run the
+your device, with the GStreamer logo. If you want to run the
tutorial in an Android Virtual Device (AVD), make sure to create the
device with support for audio playback and GPU Emulation (to enable
OpenGL ES).
include $(BUILD_SHARED_LIBRARY)
- GSTREAMER_SDK_ROOT := $(GSTREAMER_SDK_ROOT_ANDROID)
- GSTREAMER_NDK_BUILD_PATH := $(GSTREAMER_SDK_ROOT)/share/gst-android/ndk-build/
+ GSTREAMER_ROOT := $(GSTREAMER__ROOT_ANDROID)
+ GSTREAMER_NDK_BUILD_PATH := $(GSTREAMER_ROOT)/share/gst-android/ndk-build/
GSTREAMER_PLUGINS := coreelements ogg theora vorbis ffmpegcolorspace playback eglglessink soup opensles
G_IO_MODULES := gnutls
GSTREAMER_EXTRA_DEPS := gstreamer-interfaces-1.0 gstreamer-video-1.0
website.
[This](http://developer.apple.com/library/ios/#DOCUMENTATION/iPhone/Conceptual/iPhone101/Articles/00_Introduction.html) can be a good starting point.
-# Download and install the SDK
+# Download and install GStreamer binaries
-The GStreamer SDK installer can be found at:
+GStreamer binary installer can be found at:
-**FIXME: Add links**
-
->  Due to the size of these files, usage of a [Download Manager](http://en.wikipedia.org/wiki/Download_manager) is **highly recommended**. Take a look at [this list](http://en.wikipedia.org/wiki/Comparison_of_download_managers) if you do not have one installed. If, after downloading, the installer reports itself as corrupt, chances are that the connection ended before the file was complete. A Download Manager will typically re-start the process and fetch the missing parts.
+[https://gstreamer.freedesktop.org/data/pkg/ios/](https://gstreamer.freedesktop.org/data/pkg/ios/)
Double click the package file and follow the instructions presented by
the install wizard. In case the system complains about the package not
> 
> On Mac OS X 10.6 (Snow Leopard) you have to install Python 2.7 manually. It is included in later versions of OS X already. You can get it from [here](http://www.python.org/getit).
-> 
-> Due to the size of these files, usage of a [Download Manager](http://en.wikipedia.org/wiki/Download_manager) is **highly recommended**. Take a look at [this list](http://en.wikipedia.org/wiki/Comparison_of_download_managers) if you do not have one installed. If, after downloading, the installer reports itself as corrupt, chances are that the connection ended before the file was complete. A Download Manager will typically re-start the process and fetch the missing parts.
-
The downloads are [Apple Disk Images
(.dmg)](http://en.wikipedia.org/wiki/Apple_Disk_Image) containing an
[Installer Package
### Creating new projects
-The GStreamer SDK provides a
+The GStreamer binaries provides a
[framework](https://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPFrameworks/Tasks/IncludingFrameworks.html)
that you can drag and drop to XCode to start using it, or using the
linker option ***-framework GStreamer****.*
## Prerequisites
-To develop applications using the GStreamer SDK for Windows you will
+To develop applications using GStreamer for Windows you will
need [Windows
XP](http://windows.microsoft.com/en-US/windows/products/windows-xp) or
later.
-The GStreamer SDK includes C headers (`.h`) and library files (`.lib`)
+GStreamer binaries includes C headers (`.h`) and library files (`.lib`)
valid for any version of [Microsoft Visual
Studio](http://www.microsoft.com/visualstudio). For convenience,
property pages (`.props`) are also included which extremely simplify
a look at its [system
requirements](http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express)).
-Installing the SDK for 32-bits platforms requires approximately 286MB of
+Installing GStreamer for 32-bits platforms requires approximately 286MB of
free disk space for the runtime and 207MB for the development files.
-Installing the SDK for 64-bits platforms requires approximately 340MB of
+Installing GStreamer for 64-bits platforms requires approximately 340MB of
free disk space for the runtime and 216MB for the development files.
-## Download and install the SDK
+## Download and install GStreamer binaries
-There are 3 sets of files in the SDK:
+There are 3 sets of files in GStreamer binaries:
- The runtime files are needed to run GStreamer applications. You
probably want to distribute these files with your application (or
GStreamer applications.
- The [Merge
Modules](http://msdn.microsoft.com/en-us/library/windows/desktop/aa369820%28v=vs.85%29.aspx)
- files are **additional** files you can use to deploy the GStreamer
- SDK alongside your application (see [Windows
+ files are **additional** files you can use to deploy GStreamer binaries
+ alongside your application (see [Windows
deployment](Windows%2Bdeployment.html)).
Get **the Runtime and Development files** installers appropriate for
**FIXME: Add links **
-> 
-> Due to the size of these files, usage of a [Download Manager](http://en.wikipedia.org/wiki/Download_manager) is **highly recommended**. Take a look at [this list](http://en.wikipedia.org/wiki/Comparison_of_download_managers) if you do not have one installed. If, after downloading, the installer reports itself as corrupt, chances are that the connection ended before the file was complete. A Download Manager will typically re-start the process and fetch the missing parts.
-
Execute the installers and choose an installation folder. The suggested
default is usually OK.
> 
->`If you plan to use Visual Studio, **close it before installing the GStreamer SDK**. The installer will define new environment variables which will not be picked up by Visual Studio if it is open.
+>`If you plan to use Visual Studio, **close it before installing GStreamer**. The installer will define new environment variables which will not be picked up by Visual Studio if it is open.
> On **Windows 8** and **Windows 10**, it might be necessary to log out and log back in to your account after the installation for the newly defined environment variables to be picked up by Visual Studio.
It is the application's responsibility to ensure that, at runtime,
GStreamer can access its libraries and plugins. It can be done by adding
-`%GSTREAMER_SDK_ROOT_X86%\bin` to the `%PATH%` environment variable, or
+`%GSTREAMER_ROOT_X86%\bin` to the `%PATH%` environment variable, or
by running the application from this same folder.
At runtime, GStreamer will look for its plugins in the following
structure is unmodified. If you do change this structure in your
application, then you can use the `%GST_PLUGIN_PATH%` environment
variable to point GStreamer to its plugins. The plugins are initially
-found at `%GSTREAMER_SDK_ROOT_X86%\lib\gstreamer-1.0`.
+found at `%GSTREAMER_ROOT_X86%\lib\gstreamer-1.0`.
Additionally, if you want to prevent GStreamer from looking in all the
default folders listed above, you can set the
### Building the tutorials
The tutorial's code, along with project files and a solution file for
-Visual Studio 2010 are all included in the SDK, in
-the `%GSTREAMER_SDK_ROOT_X86%``\share\gst-sdk\tutorials` folder.
+Visual Studio 2010 are all included in the GStreamer binaries, in
+the `%GSTREAMER_ROOT_X86%``\share\gst-sdk\tutorials` folder.
-`%GSTREAMER_SDK_ROOT_X86%` is an environment variable that the installer
-defined for you, and points to the installation folder of the SDK.
+`%GSTREAMER_ROOT_X86%` is an environment variable that the installer
+defined for you, and points to the installation folder of GStreamer binaries.
In order to prevent accidental modification of the original code, and to
make sure Visual Studio has the necessary permissions to write the
> 
> **64-bit Users**
>
->Use `%GSTREAMER_SDK_ROOT_X86_64%` if you have installed the SDK for 64-bit platforms. Both SDKs (32 and 64-bit) can be installed simultaneously, and hence the separate environment variables.
+>Use `%GSTREAMER_ROOT_X86_64%` if you have installed GStreamer binaries for 64-bit platforms. Both GStreamer binariess (32 and 64-bit) can be installed simultaneously, and hence the separate environment variables.
>
->Make sure you select the Solution Configuration that matches the GStreamer SDK that you have installed: `Win32` for 32 bits or `x64` for 64 bits.
+>Make sure you select the Solution Configuration that matches GStreamer that you have installed: `Win32` for 32 bits or `x64` for 64 bits.
>
> 
### Running the tutorials
In order to run the tutorials, we will set the current working directory
-to `%GSTREAMER_SDK_ROOT_X86%`\\`bin` in the Debugging section of the
+to `%GSTREAMER_ROOT_X86%`\\`bin` in the Debugging section of the
project properties. **This property is not stored in the project files,
so you will need to manually add it to every tutorial you want to run
from within Visual Studio**. Right click on a project in the Solution
Explorer, Properties → Debugging → Working Directory, and type
-`$(GSTREAMER_SDK_ROOT_X86)`\\`bin`
+`$(GSTREAMER_ROOT_X86)`\\`bin`
(The `$(...)` notation is required to access environment variables
from within Visual Studio. You use the `%...%` notation from Windows
Solution and Project configurations as
explained [here](http://msdn.microsoft.com/en-us/library/9yb4317s\(v=vs.100\).aspx).**
-#### Include the necessary SDK Property Sheet
+#### Include the necessary GStreamer Property Sheet
The included property sheets make creating new projects extremely easy.
In Visual Studio 2010 create a new project (Normally a `Win32
Console` or `Win32 Application`). Then go to the Property Manager
(View→Property Manager), right-click on your project and select “Add
Existing Property Sheet...”. Navigate to
-`%GSTREAMER_SDK_ROOT_X86%`\\`share\vs\2010\libs` and
+`%GSTREAMER_ROOT_X86%`\\`share\vs\2010\libs` and
load `gstreamer-1.0.props `
This property sheet contains the directories where the headers and
understands the ISO format).
Then, add the `x86.props` or `x86_64.props` (for 32 or 64 bits) property
-sheet found in `%GSTREAMER_SDK_ROOT_X86%``\``share\vs\2010\msvc` to your
+sheet found in `%GSTREAMER_ROOT_X86%``\``share\vs\2010\msvc` to your
project. This will make your application use the ubiquitous
`MSVCRT.DLL` saving you some troubles in the future.
### Creating new projects using the wizard
Go to File → New → Project… and you should find a template
-named **GStreamer SDK Project**. It takes no parameters, and sets all
+named **GStreamer Project**. It takes no parameters, and sets all
necessary project settings, both for 32 and 64 bits architectures.
The generated project file includes the two required Property Sheets
short-description: Download and install GStreamer
...
-# Installing the SDK
+# Installing GStreamer
## Choose your platform by clicking on the corresponding logo
## Linux
-The GStreamer community does not provide the SDK for GNU/Linux platforms
-as it will always be available through package managers on all
-distribution. It is also always installed by default on desktop
+The GStreamer community does not provide binaries for GNU/Linux
+platforms as it will always be available through package managers on
+all distribution. It is also always installed by default on desktop
environments, you will just need to make sure you have the development
packages installed (refer to your distribution documentation for more
-information). If you really want to run the Sdk on Linux, you can
-always follow the instructions to
-[build from source using cerbero](sdk-building-from-source-using-cerbero.md).
+information). If you really want to run upstream style binaries on
+Linux, you can always follow the instructions to [build from source
+using cerbero](sdk-building-from-source-using-cerbero.md).
# iOS tutorials
-## Welcome to the GStreamer SDK iOS tutorials
+## Welcome to the GStreamer iOS tutorials
These tutorials describe iOS-specific topics. General GStreamer
concepts will not be explained in these tutorials, so the
might want to take. All downloads are from the
[gstreamer.freedesktop.org](http://gstreamer.freedesktop.org) website.
-# Licensing of SDK
+# Licensing of GStreamer
-GStreamer SDK minimal default installation only contains packages which
+GStreamer minimal default installation only contains packages which
are licensed under the [GNU LGPL license
v2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html). This
license gives you the Freedom to use, modify, make copies of the
software under whichever license. In other words, it is a weak copyleft
license.
-Therefore, it is possible to use the SDK to build applications that are
+Therefore, it is possible to use GStreamer to build applications that are
then distributed under a different license, including a proprietary one,
provided that reverse engineering is not prohibited for debugging
-modifications purposes. Only the pieces of the SDK that are under the
+modifications purposes. Only the pieces of GStreamer that are under the
LGPL need to be kept under the LGPL, and the corresponding source code
must be distributed along with the application (or an irrevocable offer
to do so for at least three years from distribution). Please consult
solutions are formally prohibited, but granted (this is the case in many
European countries), and in others again are neither allowed nor granted.
-It is up to you to make sure that in the countries where the SDK is
+It is up to you to make sure that in the countries where GStreamer is
used, products are made using it and product are distributed, a license
-from the applicable patent holders is required or not. Receiving the SDK
+from the applicable patent holders is required or not. Receiving GStreamer
– or links to other downloadable software – does not provide any license
expressed or implied over these patents, except in very limited
conditions where the license so provides. No representation is made.
# Software is as-is
-All software and the entire GStreamer SDK is provided as-is, without any
+All software and the entire GStreamer binaries areprovided as-is, without any
warranty whatsoever. The individual licenses have particular language
disclaiming liability: we invite you to read all of them. Should you
need a warranty on the fact that software works as intended or have any
#### What licenses are there?
-The SDK containst software under various licenses. See above.
+GStreamer binaries containst software under various licenses. See above.
#### How does this relate to the packaging system?
and downloading the same packages for your own platform. So it is
entirely up to you to decide what to do.
-Also, we note that SDK elements are divided into different packages,
+Also, we note that GStreamer elements are divided into different packages,
roughly following the licensing conditions attached to the same. For
instance, the codecs-gpl package contains GPL licensed codecs. All the
packages installed by default, conversely, are licensed under the LGPL
or a more liberal license. This division is provided only for ease of
reference, but we cannot guarantee that our selection is 100% correct,
so it is up to the user to verify the actual licensing conditions before
-distributing works that utilize the SDK.
+distributing works that utilize GStreamer.
-#### Can I / must I distribute the SDK along with my application?
+#### Can I / must I distribute GStreamer along with my application?
You surely can. All software is Free/Open Source software, and can be
distributed freely. You are not **required** to distribute it. Only,
also distribute the complete source code of the original code (or of
the modified code, if you have modified it). There are alternative
ways to comply with this obligation, some of them do not require any
-actual distribution of source code, but since the SDK contains the
+actual distribution of source code, but since GStreamer contains the
entire source code, you might want to include it (or the directories
containing the source code) with your application as a safe way to
comply with this requirement of the license.
-#### What happens when I modify the GStreamer SDK's source code?
+#### What happens when I modify the GStreamer's source code?
You are invited to do so, as the licenses (unless you are dealing with
proprietary bits, but in that case you will not find the corresponding
API, requires permission by the copyright holder of the library when
the two pieces are distributed together.
-In all cases, since most of the software we include in the SDK is under
+In all cases, since most of the software we include in GStreamer is under
the LGPL, this permission is granted once for all, subject to compliance
with the conditions set out by it. Therefore, the problem only arises
when you want to use GPL libraries to make non-GPL applications, and you
## Adding a package for you software
-To distribute your software with the SDK it is necessary to put it into
+To distribute your software with GStreamer it is necessary to put it into
a package or installer, depending on the target platform. This is done
by selecting the files that should be included. To add a package you
have to create a package file in `cerbero/packages`. The package files
At this point you have two main options: you could either have a single
package that contains everything your software needs, or depend on a
-shared version of the SDK.
+shared version of GStreamer.
-### Having a private version of the SDK
+### Having a private version of GStreamer
-To have a private version of the SDK included in a single package you
+To have a private version of GStreamer included in a single package you
don't have to add the `deps` variable to the package file but instead
list all files you need in the `files` variables. If you decide to go
-this road you must make sure that you use a different prefix than the
-GStreamer SDK in the Cerbero configuration file, otherwise your package
+this road you must make sure that you use a different prefix than
+GStreamer in the Cerbero configuration file, otherwise your package
will have file conflicts with GStreamer.
-### Having a shared version of the SDK
+### Having a shared version of GStreamer
-If you decide to use a shared version of the SDK you can create a
+If you decide to use a shared version of GStreamer you can create a
package file like the other package files in GStreamer. Just
list all packages you need in the `deps` variable and put the files your
software needs inside the `files` variables. When building a package
## The multilingual player
Copy this code into a text file named `playback-tutorial-1.c` (or find
-it in the SDK installation).
+it in the GStreamer installation).
**playback-tutorial-1.c**
## The multilingual player with subtitles
Copy this code into a text file named `playback-tutorial-2.c` (or find
-it in the SDK installation).
+it in the GStreamer installation).
**playback-tutorial-2.c**
---
-short-description: Learn how to use the GStreamer SDK
+short-description: Learn how to use GStreamer
...
# Tutorials
-## Welcome to the GStreamer SDK Tutorials!
+## Welcome to the GStreamer Tutorials!
The following sections introduce a series of tutorials designed to help
you learn how to use GStreamer, the multi-platform, modular,
Before following these tutorials, you need to set up your development
environment according to your platform. If you have not done so yet, go
-to the [installing the SDK] page and come back here afterwards.
+to the [installing GStreamer] page and come back here afterwards.
The tutorials are currently written only in the C programming language,
so you need to be comfortable with it. Even though C is not an
### Source code
Every tutorial represents a self-contained project, with full source
-code in C (and eventually in other languages too). Source code snippets
-are introduced alongside the text, and the full code (with any other
-required files like makefiles or project files) is distributed with the
-SDK, as explained in the installation instructions.
+code in C (and eventually in other languages too). Source code
+snippets are introduced alongside the text, and the full code (with
+any other required files like makefiles or project files) is
+distributed with GStreamer, as explained in the installation
+instructions.
### A short note on GObject and GLib
The tutorials are organized in sections, revolving about a common theme:
- [Basic tutorials]: Describe general topics required to understand
- the rest of tutorials in the GStreamer SDK.
+ the rest of tutorials in GStreamer.
- [Playback tutorials]: Explain everything you need to know to produce
a media playback application using GStreamer.
- [Android tutorials]: Tutorials dealing with the few Android-specific
- [Sintel, the Durian Open Movie Project]
- [installing the SDK]: sdk-installing.md
+ [installing GStreamer]: sdk-installing.md
[GStreamer documentation]: http://gstreamer.freedesktop.org/documentation/
[Basic tutorials]: sdk-basic-tutorials.md
[Playback tutorials]: sdk-playback-tutorials.md
projects / platform / upstream / gstreamer.git / commitdiff