ENDE
Menu
← All news

TECHNICAL GUIDE / SRT

Building FFmpeg, VLC, GStreamer and OBS Studio with Robotweax SRT

A practical guide to source builds, isolated dependencies and verification of the SRT library in use

Robotweax SRT can be integrated through the SRT interfaces already present in FFmpeg, VLC, GStreamer and OBS Studio. The key is to build each application against the intended headers and library, then verify that it loads that library at runtime.

This guide brings the four build paths together using the documentation and helper scripts at the Robotweax SRT v0.2.5 source tag. It focuses on Linux, with Ubuntu 24.04 as the reference environment for the ecosystem recipes. The tag identifies the source baseline; it does not by itself establish publication or acceptance of release installers.

The examples build restricted evaluation profiles. They provide a starting point for testing an integration; they do not produce fully featured distributions of all four applications.

1. Prepare the Sources and Build Tools

Start with a C/C++ toolchain, Git, CMake, pkg-config, OpenSSL 3 development files and Python 3.10 or newer. Additional dependencies differ by application:

Project Additional preparation
FFmpeg The helper builds a minimal profile and disables x86 assembly dependencies.
VLC Autoconf, Automake, Libtool, Gettext, Autopoint, Flex, Bison, libmpeg2 and libdvbpsi development files.
GStreamer Meson 1.9.1, Ninja, GLib/GIO development files, Flex and Bison.
OBS Studio The dependencies listed in the OBS integration guide, including graphics and codec libraries, Xvfb and Mesa; Qt dependencies for the desktop profile.

Use the complete package lists in the application guides linked below. Install Meson in a dedicated Python environment and ensure it is on PATH for subsequent commands.

Create a workspace and check out Robotweax:

mkdir robotweax-media-build
cd robotweax-media-build
media_workspace="$PWD"

git clone --branch v0.2.5 https://github.com/Robotweax/srt.git robotweax-srt
robotweax_source="$media_workspace/robotweax-srt"

Clone the upstream repositories into separate writable directories. Check out the exact revisions used by these profiles:

Source Revision
FFmpeg 3acec0a1af2dda0a0838689b8b8649e7deb080a0
VLC 3.0.24-rc1 6de05adcbaf2e8b85fe86aad4169393098628119
GStreamer 1.28.7 070125524a8422e29d3b69a372ed4f62fd343ffa
OBS Studio 32.2.2 ba2f32bdf791005443988a4955e963663e16b1ed
Haivision SRT 1.5.7, test peer only 899348d8318eb9a3c5a5b6ec43c4a1114288773a

For each checkout, use git checkout --detach <revision> and verify it with git rev-parse HEAD. The /absolute/path/to/... values below are placeholders for those checkouts. Keep the same shell session so the workspace variables remain available. Use fresh build directories, and separate source checkouts wherever specified.

2. Build the Shared Robotweax Library

FFmpeg, VLC and GStreamer can use a common isolated Robotweax installation. Enable the optional srt.pc compatibility metadata:

robotweax_prefix="$media_workspace/stage/robotweax"

cmake -S "$robotweax_source" -B "$media_workspace/build-srt" \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_SHARED_LIBS=ON \
  -DROBOTWEAX_SRT_INSTALL_LAYOUT=namespaced \
  -DCMAKE_INSTALL_LIBDIR=lib \
  -DCMAKE_INSTALL_PREFIX="$robotweax_prefix" \
  -DROBOTWEAX_SRT_BUILD_BENCHMARKS=OFF \
  -DROBOTWEAX_SRT_BUILD_TOOLS=OFF \
  -DROBOTWEAX_SRT_INSTALL_LIBSRT_PKGCONFIG_COMPAT=ON
cmake --build "$media_workspace/build-srt" --parallel 4
cmake --install "$media_workspace/build-srt"

export PKG_CONFIG_PATH="$robotweax_prefix/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}"
pkg-config --variable=pcfiledir srt
pkg-config --modversion srt
pkg-config --variable=robotweax_release srt

The metadata directory should point to the isolated prefix. The compatible API version is 1.5.7; the Robotweax release variable is 0.2.5. These identify different things.

Keep this installation separate from any Haivision SRT prefix. The namespaced library is librobotweax-srt; the compatibility metadata lets existing build systems discover it using the conventional package name srt.

3. FFmpeg: Use the Existing SRT Protocol

FFmpeg already has an SRT adapter. For an initial evaluation, use the minimal build helper from the Robotweax repository:

ffmpeg_source=/absolute/path/to/ffmpeg-source

"$robotweax_source/tests/ffmpeg/configure.sh" \
  "$ffmpeg_source" "$robotweax_prefix"
make -C "$ffmpeg_source" -j4 ffmpeg
"$robotweax_source/tests/ffmpeg/run_smoke.sh" \
  "$ffmpeg_source/ffmpeg"

The helper validates the selected srt.pc, enables --enable-libsrt and sets the runtime library path. It deliberately disables unrelated FFmpeg components. A broader application build can enable its required codecs, filters and formats separately.

Check that ffmpeg -protocols lists SRT input and output. On Linux, inspect the built binary with ldd and confirm that its SRT dependency resolves to the intended Robotweax installation. The smoke procedure checks unencrypted and AES-128-CTR MPEG-TS transfer, including elementary-stream comparison.

Keep using srt:// URLs. No Robotweax-specific URL scheme is needed.

Full instructions: FFmpeg integration.

4. VLC: Build the Existing Input and Output Modules

Use a dedicated VLC checkout at the revision above. The helper modifies that checkout as part of its documented compatibility preparation.

vlc_source=/absolute/path/to/vlc-source
vlc_build="$media_workspace/build-vlc"
vlc_prefix="$media_workspace/stage/vlc"

"$robotweax_source/tests/vlc/configure.sh" \
  "$vlc_source" "$vlc_build" "$robotweax_prefix" "$vlc_prefix"
make -C "$vlc_build" -j4
make -C "$vlc_build" install

At this VLC revision, an obsolete input-side payload-size registration conflicts with the active output option. The helper removes the obsolete registration after checking the source hash. This adjustment is part of the tested build and should not be bypassed when changing source revisions.

The resulting profile enables the SRT modules, MPEG-TS demuxing/muxing and MPEG-2 video decoding. It is headless: GUI, audio qualification and FFmpeg-backed VLC codecs are outside this profile. Disabling the latter also avoids indirectly loading a second SRT implementation through FFmpeg.

Use the guide’s complete qualification procedure to check decoded video, outgoing media and the library selected by the actual VLC modules. Connecting a standard VLC installation to a Robotweax endpoint is an interoperability test; it does not establish that VLC uses Robotweax internally.

Full instructions: VLC integration.

5. GStreamer: Rebuild the Plugin and Isolate Its Registry

GStreamer uses its existing, unmodified SRT plugin. With Meson 1.9.1 on PATH and the pinned source checkout ready:

gst_source=/absolute/path/to/gstreamer-source
gst_build="$media_workspace/build-gstreamer"
gst_prefix="$media_workspace/stage/gstreamer"

"$robotweax_source/tests/gstreamer/configure.sh" \
  "$gst_source" "$gst_build" "$robotweax_prefix" "$gst_prefix"
meson compile -C "$gst_build" -j 4
meson install -C "$gst_build" --no-rebuild

Select the installed plugins explicitly and use a separate registry:

export GST_PLUGIN_SYSTEM_PATH_1_0=""
export GST_PLUGIN_PATH_1_0="$gst_prefix/lib/gstreamer-1.0"
export GST_PLUGIN_SCANNER_1_0="$gst_prefix/libexec/gstreamer-1.0/gst-plugin-scanner"
export GST_REGISTRY_1_0="$gst_prefix/robotweax-registry.bin"

"$gst_prefix/bin/gst-inspect-1.0" srtsrc
"$gst_prefix/bin/gst-inspect-1.0" srtsink

Check the reported plugin filenames and inspect the selected libgstsrt.so with ldd. This distinguishes your rebuilt plugin from a system installation. The helper configures runtime paths as well as build-time discovery; PKG_CONFIG_PATH alone does not control runtime loading.

The installation is minimal. Add the encoders, muxers, parsers or device plugins required by your own pipeline. When adapting an FFmpeg example, also check option names and units: GStreamer uses milliseconds for latency, while FFmpeg’s SRT URL option uses microseconds.

Full instructions and media tests: GStreamer integration.

6. OBS Studio: Build Both SRT Paths Together

OBS requires particular care because its native SRT output calls the SRT API directly, while its media source receives through FFmpeg. Both paths must select the same Robotweax library within the process. The minimal FFmpeg build above is insufficient for OBS.

For this section, start a fresh shell and set the workspace variables again. This also avoids inheriting the GStreamer plugin overrides from the previous section:

media_workspace=/absolute/path/to/robotweax-media-build
robotweax_source="$media_workspace/robotweax-srt"

Install the dependencies from the OBS guide. Prepare clean, dedicated OBS, GStreamer, FFmpeg and Haivision SRT checkouts at the revisions in the table. From the Robotweax repository, run:

cd "$robotweax_source"
JOBS=4 tests/obs/build_and_test.sh \
  /absolute/path/to/obs-source \
  /absolute/path/to/gstreamer-obs-source \
  /absolute/path/to/ffmpeg-obs-source \
  /absolute/path/to/haivision-srt-source \
  "$media_workspace/obs-qualification"

This procedure builds its own isolated Robotweax installation, an OBS-specific shared FFmpeg profile, the OBS modules and a separately installed reference peer. It checks actual video and audio, including encrypted operation, and verifies the selected library through both media paths.

To add the Qt desktop frontend, install the additional desktop dependencies and prepare a second clean OBS checkout at the same pinned revision:

JOBS=4 tests/obs/build_desktop.sh \
  /absolute/path/to/clean-obs-desktop-source \
  "$media_workspace/obs-qualification/robotweax-srt" \
  "$media_workspace/obs-qualification/ffmpeg" \
  "$media_workspace/obs-desktop"

The final work directory must not already exist. The frontend is installed under obs-desktop/obs. Keep the dependency prefixes in place because runtime paths are absolute.

This desktop recipe selects a limited plugin set and applies a checked MPEG-TS lifecycle correction for the pinned OBS version. Use the desktop guide’s smoke and interactive acceptance procedures to verify the resulting application. A successful compile alone is not a media test.

Read the OBS integration guide and Linux desktop procedure. Separate desktop recipes cover Windows x64 and macOS on Apple Silicon; they use different dependencies and build steps.

From a Successful Build to Your Own Workflow

For all four projects, verify three things: the selected headers and metadata at build time, the library loaded at runtime, and media delivery in the intended application roles. Rebuild against matching headers and libraries rather than replacing a dependency underneath an existing binary.

The documented profiles have specific platform, codec and transport boundaries. They do not automatically qualify hardware capture, hardware encoding, arbitrary networks or long-duration operation. Robotweax SRT remains a pre-1.0 implementation, and third-party application and dependency licences continue to apply.

Use the ecosystem support matrix to choose a starting profile, then extend the tests to your own workflow.