# gst-build
-GStreamer [meson](http://mesonbuild.com/) based repositories aggregrator
+GStreamer [meson](http://mesonbuild.com/) based repositories aggregrator.
-You can build GStreamer and all its modules at once using
-meson and its [subproject](https://github.com/mesonbuild/meson/wiki/Subprojects) feature.
+Check out this module and run meson on it, and it will git clone the other
+GStreamer modules as [meson subprojects](http://mesonbuild.com/Subprojects.html)
+and build everything in one go. Once that is done you can switch into an
+development environment which allows you to easily develop and test the latest
+version of GStreamer without the need to install anything or touch an existing
+GStreamer system installation.
## Getting started
### Install meson and ninja
-Meson 0.48 or newer is required.
+Meson 0.52 or newer is required.
+
+For cross-compilation Meson 0.54 or newer is required.
On Linux and macOS you can get meson through your package manager or using:
You can get all GStreamer built running:
```
-meson build/
-ninja -C build/
+meson builddir
+ninja -C builddir
```
This will automatically create the `build` directory and build everything
inside it.
-NOTE: On Windows, you *must* run this from inside the Visual Studio command
-prompt of the appropriate architecture and version.
+NOTE: On Windows, you *must* run this from [inside the Visual Studio command
+prompt](#running-meson-on-windows) of the appropriate architecture and version.
-# Development environment
+### External dependencies
+
+All mandatory dependencies of GStreamer are included as [meson subprojects](https://mesonbuild.com/Subprojects.html):
+libintl, zlib, libffi, glib. Some optional dependencies are also included as
+subprojects, such as ffmpeg, x264, json-glib, graphene, openh264, orc, etc.
+
+Mandatory dependencies will be automatically built if meson cannot find them on
+your system using pkg-config. The same is true for optional dependencies that
+are included as subprojects. You can find a full list by looking at the
+`subprojects` directory.
+
+Plugins that need optional dependencies that aren't included can only be built
+if they are provided by the system. Instructions on how to build some common
+ones such as Qt5/QML are listed below. If you do not know how to provide an
+optional dependency needed by a plugin, you should use [Cerbero](https://gitlab.freedesktop.org/gstreamer/cerbero/#description)
+which handles this for you automatically.
+
+Plugins will be automatically enabled if possible, but you can ensure that
+a particular plugin (especially if it has external dependencies) is built by
+enabling the gstreamer repository that ships it and the plugin inside it. For
+example, to enable the Qt5 plugin in the gst-plugins-good repository, you need
+to run meson as follows:
+
+```
+meson -Dgood=enabled -Dgst-plugins-good:qt5=enabled builddir
+```
-## Building the Qt5 QML plugin
+This will cause Meson to error out if the plugin could not be enabled. You can
+also flip the default and disable all plugins except those explicitly enabled
+like so:
+
+```
+meson -Dauto_features=disabled -Dgstreamer:tools=enabled -Dbad=enabled -Dgst-plugins-bad:openh264=enabled
+```
+
+This will disable all optional features and then enable the `openh264` plugin
+and the tools that ship with the core gstreamer repository: `gst-inspect-1.0`,
+`gst-launch-1.0`, etc. As usual, you can change these values on a builddir that
+has already been setup with `meson configure -Doption=value`.
+
+### Building the Qt5 QML plugin
If `qmake` is not in `PATH` and pkgconfig files are not available, you can
point the `QMAKE` env var to the Qt5 installation of your choosing before
running `meson` as shown above.
The plugin will be automatically enabled if possible, but you can ensure that
-it is built by passing `-Dgst-plugins-good:qt5=enabled` to `meson`. This will
-cause Meson to error out if the plugin could not be enabled. This also works
-for all plugins in all GStreamer repositories.
+it is built by passing `-Dgood=enabled -Dgst-plugins-good:qt5=enabled` to `meson`.
+
+### Building the Intel MSDK plugin
+
+On Linux, you need to have development files for `libmfx` installed. On
+Windows, if you have the [Intel Media SDK](https://software.intel.com/en-us/media-sdk),
+it will set the `INTELMEDIASDKROOT` environment variable, which will be used by
+the build files to find `libmfx`.
+
+The plugin will be automatically enabled if possible, but you can ensure it by
+passing `-Dbad=enabled -Dgst-plugins-bad:msdk=enabled` to `meson`.
+
+# Development environment
-## Uninstalled environment
+## Development environment target
-gst-build also contains a special `uninstalled` target that lets you enter an
-uninstalled development environment where you will be able to work on GStreamer
+gst-build also contains a special `devenv` target that lets you enter an
+development environment where you will be able to work on GStreamer
easily. You can get into that environment running:
```
-ninja -C build/ uninstalled
+ninja -C builddir devenv
```
If your operating system handles symlinks, built modules source code will be
available at the root of `gst-build/` for example GStreamer core will be in
`gstreamer/`. Otherwise they will be present in `subprojects/`. You can simply
-hack in there and to rebuild you just need to rerun `ninja -C build/`.
+hack in there and to rebuild you just need to rerun `ninja -C builddir`.
-NOTE: In the uninstalled environment, a fully usable prefix is also configured
+NOTE: In the development environment, a fully usable prefix is also configured
in `gst-build/prefix` where you can install any extra dependency/project.
+An external script can be run in development environment with:
+
+```
+./gst-env.py external_script.sh
+```
+
## Update git subprojects
We added a special `update` target to update subprojects (it uses `git pull
Update all GStreamer modules and rebuild:
```
-ninja -C build/ update
+ninja -C builddir update
```
Update all GStreamer modules without rebuilding:
```
-ninja -C build/ git-update
+ninja -C builddir git-update
```
## Custom subprojects
To list all available tests:
```
-meson test -C build --list
+meson test -C builddir --list
```
To run all the tests of a specific component:
```
-meson test -C build --suite gst-plugins-base
+meson test -C builddir --suite gst-plugins-base
```
Or to run a specific test file:
```
-meson test -C build/ --suite gstreamer gst_gstbuffer
+meson test -C builddir --suite gstreamer gst_gstbuffer
```
Run a specific test from a specific test file:
```
-GST_CHECKS=test_subbuffer meson test -C build/ --suite gstreamer gst_gstbuffer
+GST_CHECKS=test_subbuffer meson test -C builddir --suite gstreamer gst_gstbuffer
```
## Optional Installation
-`gst-build` has been created primarily for [uninstalled usage](#uninstalled-environment),
+`gst-build` has been created primarily for [development usage](#development-environment-target),
but you can also install everything that is built into a predetermined prefix like so:
```
-meson --prefix=/path/to/install/prefix build/
-ninja -C build/
-meson install -C build/
+meson --prefix=/path/to/install/prefix builddir
+ninja -C builddir
+meson install -C builddir
```
Note that the installed files have `RPATH` stripped, so you will need to set
## Checkout another branch using worktrees
-If you need to have several versions of GStreamer coexisting (eg. `master` and `1.14`),
-you can use the `checkout-branch-worktree` script provided by `gst-build`. It allows you
+If you need to have several versions of GStreamer coexisting (eg. `master` and `1.16`),
+you can use the `gst-worktree.py` script provided by `gst-build`. It allows you
to create a new `gst-build` environment with new checkout of all the GStreamer modules as
[git worktrees](https://git-scm.com/docs/git-worktree).
-For example to get a fresh checkout of `gst-1.14` from a `gst-build` in master already
-built in a `build` directory you can simply run:
+For example to get a fresh checkout of `gst-1.16` from a `gst-build` repository
+that is checked out at master, you can run:
```
-./checkout-branch-worktree ../gst-1.14 1.14 -C build/
+./gst-worktree.py add gst-build-1.16 origin/1.16
```
+This will create a new ``gst-build-1.16`` directory pointing to the given branch `1.16`
+for all the subprojects (gstreamer, gst-plugins-base, etc.)
+
+
## Add information about GStreamer development environment in your prompt line
### Bash prompt
PS1+="[ ${GST_ENV} ]"
fi
...
-
-```
-
-### Zsh prompt
-
-In your `.zshrc`, you should add something like:
-
-```
-export PROMPT="$GST_ENV-$PROMPT"
-```
-
-### Fish prompt
-
-In your `~/.config/fish/functions/fish_prompt.fish`, you should add something like this at the end of the fish_prompt function body:
-
-```
-if set -q GST_ENV
- echo -n -s (set_color -b blue white) "(" (basename "$GST_ENV") ")" (set_color normal) " "
-end
```
### Using powerline
Note that Meson is written entirely in Python, so you can also run it as-is
from the [git repository](https://github.com/mesonbuild/meson/) if you want to
use the latest master branch for some reason.
+
+**ARM64 native only**: You might need
+[native upstream ARM64 support fix](https://github.com/mesonbuild/meson/pull/7432)
+which is expected to be a part of Meson 0.55.1.
+If your Meson package version which was installed via `pip3` is lower than 0.55.1,
+then you need to use [the latest master branch](https://github.com/mesonbuild/meson/).
+
+### Running Meson on Windows
+
+At present, to build with Visual Studio, you need to run Meson from inside the
+VS 2019 command prompt. Press `Start`, and search for `VS 2019`, and click on
+`x64 Native Tools Command Prompt for VS 2019`, or a prompt named similar to
+that:
+
+
+
+**ARM64 native only**: Since Visual Studio might not install dedicated command
+prompt for native ARM64 build, you might need to run `vcvarsx86_arm64.bat` on CMD.
+Please refer to [this document](https://docs.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=vs-2019#developer_command_file_locations)
+
+### Setup a mingw/wine based development environment on linux
+
+#### Install wine and mingw
+
+##### On fedora x64
+
+``` sh
+sudo dnf install mingw64-gcc mingw64-gcc-c++ mingw64-pkg-config mingw64-winpthreads wine
+```
+
+FIXME: Figure out what needs to be installed on other distros
+
+#### Get meson from git
+
+This simplifies the process and allows us to use the cross files
+defined in meson itself.
+
+``` sh
+git clone https://github.com/mesonbuild/meson.git
+```
+
+#### Build and install
+
+```
+BUILDDIR=$PWD/winebuild/
+export WINEPREFIX=$BUILDDIR/wine-prefix/ && mkdir -p $WINEPREFIX
+# Setting the prefix is mandatory as it is used to setup symlinks during uninstalled development
+meson/meson.py $BUILDDIR --cross-file meson/cross/linux-mingw-w64-64bit.txt -Dgst-plugins-bad:vulkan=disabled -Dorc:gtk_doc=disabled --prefix=$BUILDDIR/wininstall/ -Djson-glib:gtk_doc=disabled
+meson/meson.py install -C $BUILDDIR/
+```
+
+> __NOTE__: You should use `meson install -C $BUILDDIR` each time you make a change
+> instead of the usual `ninja -C build` as the environment is not uninstalled.
+
+#### The development environment
+
+You can get into the development environment the usual way:
+
+```
+ninja -C $BUILDDIR/ devenv
+```
+
+Alternatively, if you'd rather not start a shell in your workflow, you
+can mutate the current environment into a suitable state like so:
+
+```
+gst-env.py --only-environment
+```
+
+This will print output suitable for an sh-compatible `eval` function,
+just like `ssh-agent -s`.
+
+After setting up [binfmt] to use wine for windows binaries,
+you can run GStreamer tools under wine by running:
+
+```
+gst-launch-1.0.exe videotestsrc ! glimagesink
+```
+
+[binfmt]: http://man7.org/linux/man-pages/man5/binfmt.d.5.html
projects / platform / upstream / gstreamer.git / blobdiff