Stream logo
Start Coding Free

Using GStreamer with Go for Advanced Streaming Solutions

Engineering
Go
7 min read
Jeroen L.
Jeroen L.
Published August 27, 2024

GStreamer is a powerful and versatile framework for video streaming and media processing. It's used widely in various applications due to its extensive capabilities for handling multimedia content. When combined with Go (Golang), a language known for its efficiency and ease of use, GStreamer can be employed to create robust streaming solutions. This article will delve into using GStreamer in the context of Stream's projects, focusing on HLS (HTTP Live Streaming), RTMP (Real-Time Messaging Protocol), and SFU (Selective Forwarding Unit) tasks.

Introduction to GStreamer and Go

What is GStreamer?

GStreamer is a comprehensive and versatile multimedia framework that handles many audio and video processing tasks. Its modular and flexible architecture enables the construction of complex media processing pipelines. Users can build pipelines by chaining together a series of elements, each responsible for a specific function, such as decoding, encoding, or streaming media. This approach allows GStreamer to handle tasks ranging from simple media playback to advanced streaming and real-time processing, making it a popular choice in desktop and embedded systems.

Written primarily in C, GStreamer is renowned for its performance and efficiency. Its core components are developed in C, providing a solid foundation for its high-speed media processing capabilities. The framework also offers bindings for multiple programming languages, including Python, C++, and Go, which enable developers to integrate GStreamer’s functionalities into applications written in those languages. This multilingual support makes GStreamer highly accessible and versatile, accommodating many development environments and use cases.

GStreamer’s architecture is based on a plugin system, allowing for the dynamic loading and unloading of media processing components. This design facilitates extending GStreamer’s capabilities with additional plugins, which can handle new media formats, codecs, and protocols. The flexibility provided by this plugin-based approach means that GStreamer can be tailored to meet the specific needs of various applications, from simple video players to complex broadcasting systems. Its robust framework and extensive library of plugins have established GStreamer as a critical tool in multimedia processing.

At Stream we use GStreamer in several ways:

  • For HLS (HTTP Live Streaming) and call recording in video egress
  • In RTMP (Real-Time Messaging Protocol) output implementations
  • For thumbnail generation in SFU (Selective Forwarding Unit) tasks

What is Go?

Go, also known as Golang, is a statically typed, compiled language designed by Google. It's known for its simplicity, efficiency, and strong concurrency support, which make it well-suited for developing scalable networked services and applications, including those that involve multimedia processing.

Combining GStreamer and Go

GStreamer has native support for various programming languages, but for Go developers, working with GStreamer involves using Go bindings. These bindings allow Go applications to interact with GStreamer’s functionality, providing a way to leverage GStreamer’s capabilities while writing code in Go.

Setting Up GStreamer with Go

Before diving into specific use cases, let’s get our environment ready. Here’s how you can set up GStreamer and its Go bindings:

Installing GStreamer

  1. On Linux:

    sudo apt-get update
sudo apt-get install gstreamer1.0-tools gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-ugly gstreamer1.0-plugins-bad

  2. On macOS:

    brew install gst-plugins-base gst-plugins-good gst-plugins-ugly gst-plugins-bad

  3. On Windows:
    Download the GStreamer binaries from the official GStreamer website.

Installing Go Bindings for GStreamer

The Go bindings for GStreamer can be installed via go get. However, since Go bindings might not always be up-to-date or actively maintained, you may need to build them from source or use pre-built packages from repositories.

shell
1
go get github.com/ziutek/gst

Ensure you have the GStreamer development files installed, as these are required to build the bindings.

Implementing GStreamer for HLS and Call Recording

HTTP Live Streaming (HLS)

HLS is a popular protocol for delivering video content over HTTP. GStreamer’s flexibility allows it to handle HLS streams effectively. Below is an example of how you can use GStreamer with Go to create an HLS stream.

Sample Code for HLS Streaming

go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package main

import (
    "fmt"
    "github.com/ziutek/gst"
    "os"
)

func main() {
    // Initialize GStreamer
    gst.Init(nil)

    // Create a GStreamer pipeline
    pipeline := gst.NewPipeline("pipeline")

    // Create elements
    src := gst.NewElement("videotestsrc", "source")
    enc := gst.NewElement("x264enc", "encoder")
    mux := gst.NewElement("hlsmux", "muxer")
    sink := gst.NewElement("filesink", "sink")

    // Set properties
    sink.SetProperty("location", "output.m3u8")

    // Add elements to the pipeline
    pipeline.Add(src, enc, mux, sink)

    // Link elements
    src.Link(enc)
    enc.Link(mux)
    mux.Link(sink)

    // Start playing the pipeline
    pipeline.SetState(gst.StatePlaying)

    // Wait until the pipeline finishes
    bus := pipeline.GetBus()
    for {
        msg := bus.TimedPopFiltered(gst.CLOCK_TIME_NONE, gst.MESSAGE_EOS|gst.MESSAGE_ERROR)
        if msg != nil {
            switch msg.Type {
            case gst.MESSAGE_EOS:
                fmt.Println("End of Stream")
                pipeline.SetState(gst.StateNull)
                return
            case gst.MESSAGE_ERROR:
                err := msg.ParseError()
                fmt.Printf("Error: %s\\\\n", err)
                pipeline.SetState(gst.StateNull)
                return
            }
        }
    }
}

This Go program sets up a GStreamer pipeline to generate an HLS stream using a video test source. It encodes the video using x264 and muxes it into an HLS stream, saving it as output.m3u8.

Call Recording

You typically need to capture and save streams in a suitable format for call recording. Using GStreamer, you can create a pipeline to capture video and audio from a call and save it to a file.

Sample Code for Call Recording

go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package main

import (
    "fmt"
    "github.com/ziutek/gst"
    "os"
)

func main() {
    // Initialize GStreamer
    gst.Init(nil)

    // Create a GStreamer pipeline
    pipeline := gst.NewPipeline("pipeline")

    // Create elements
    src := gst.NewElement("audiotestsrc", "audio_source")
    videoSrc := gst.NewElement("videotestsrc", "video_source")
    enc := gst.NewElement("x264enc", "encoder")
    mux := gst.NewElement("matroskamux", "muxer")
    sink := gst.NewElement("filesink", "sink")

    // Set properties
    sink.SetProperty("location", "call_recording.mkv")

    // Add elements to the pipeline
    pipeline.Add(src, videoSrc, enc, mux, sink)

    // Link elements
    videoSrc.Link(enc)
    enc.Link(mux)
    src.Link(mux)
    mux.Link(sink)

    // Start playing the pipeline
    pipeline.SetState(gst.StatePlaying)

    // Wait until the pipeline finishes
    bus := pipeline.GetBus()
    for {
        msg := bus.TimedPopFiltered(gst.CLOCK_TIME_NONE, gst.MESSAGE_EOS|gst.MESSAGE_ERROR)
        if msg != nil {
            switch msg.Type {
            case gst.MESSAGE_EOS:
                fmt.Println("End of Stream")
                pipeline.SetState(gst.StateNull)
                return
            case gst.MESSAGE_ERROR:
                err := msg.ParseError()
                fmt.Printf("Error: %s\\\\n", err)
                pipeline.SetState(gst.StateNull)
                return
            }
        }
    }
}

In this example, the GStreamer pipeline captures audio and video using test sources and saves them to an MKV file. For real call recording, replace the test sources with actual audio and video capture elements suitable for your environment.

Implementing RTMP Output

RTMP is a protocol used for streaming audio, video, and data over the internet. GStreamer can handle RTMP output, which is essential for live-streaming applications.

Sample Code for RTMP Output

go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package main

import (
    "fmt"
    "github.com/ziutek/gst"
    "os"
)

func main() {
    // Initialize GStreamer
    gst.Init(nil)

    // Create a GStreamer pipeline
    pipeline := gst.NewPipeline("pipeline")

    // Create elements
    src := gst.NewElement("videotestsrc", "source")
    enc := gst.NewElement("x264enc", "encoder")
    mux := gst.NewElement("flvmux", "muxer")
    sink := gst.NewElement("rtmpsink", "sink")

    // Set properties
    sink.SetProperty("location", "rtmp://localhost/live/stream")

    // Add elements to the pipeline
    pipeline.Add(src, enc, mux, sink)

    // Link elements
    src.Link(enc)
    enc.Link(mux)
    mux.Link(sink)

    // Start playing the pipeline
    pipeline.SetState(gst.StatePlaying)

    // Wait until the pipeline finishes
    bus := pipeline.GetBus()
    for {
        msg := bus.TimedPopFiltered(gst.CLOCK_TIME_NONE, gst.MESSAGE_EOS|gst.MESSAGE_ERROR)
        if msg != nil {
            switch msg.Type {
            case gst.MESSAGE_EOS:
                fmt.Println("End of Stream")
                pipeline.SetState(gst.StateNull)
                return
            case gst.MESSAGE_ERROR:
                err := msg.ParseError()
                fmt.Printf("Error: %s\\\\n", err)
                pipeline.SetState(gst.StateNull)
                return
            }
        }
    }
}

This example shows how to set up a GStreamer pipeline to stream video data to an RTMP server. The pipeline uses a video test source, encodes it with x264, and sends the stream to the RTMP sink.

Generating Thumbnails in SFU Tasks

Generating thumbnails or snapshots from video streams can be useful for previews and monitoring in a Selective Forwarding Unit (SFU) setup. GStreamer can extract frames from video streams and generate thumbnails.

Sample Code for Thumbnail Generation

go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package main

import (
    "fmt"
    "github.com/ziutek/gst"
    "image/jpeg"
    "os"
)

func main() {
    // Initialize GStreamer
    gst.Init(nil)

    // Create a GStreamer pipeline
    pipeline := gst.NewPipeline("pipeline")

    // Create elements
    src := gst.NewElement("videotestsrc", "source")
    convert := gst.NewElement("vide

oconvert", "converter")
    caps := gst.NewElement("capsfilter", "filter")
    sink := gst.NewElement("appsink", "sink")

    // Set caps to get a specific format for thumbnail
    caps.SetProperty("caps", gst.NewCapsFromString("video/x-raw,format=RGB"))

    // Add elements to the pipeline
    pipeline.Add(src, convert, caps, sink)

    // Link elements
    src.Link(convert)
    convert.Link(caps)
    caps.Link(sink)

    // Set appsink to emit signals
    sink.SetProperty("emit-signals", true)
    sink.Connect("new-sample", func(sink *gst.Element) gst.FlowReturn {
        sample := sink.GetProperty("sample").(*gst.Sample)
        buffer := sample.GetBuffer()
        // Extract image from buffer (assuming RGB format)
        // Save as thumbnail (this is a simplified example)
        file, _ := os.Create("thumbnail.jpg")
        defer file.Close()
        jpeg.Encode(file, buffer.GetData(), nil)
        return gst.FlowOk
    })

    // Start playing the pipeline
    pipeline.SetState(gst.StatePlaying)

    // Wait until the pipeline finishes
    bus := pipeline.GetBus()
    for {
        msg := bus.TimedPopFiltered(gst.CLOCK_TIME_NONE, gst.MESSAGE_EOS|gst.MESSAGE_ERROR)
        if msg != nil {
            switch msg.Type {
            case gst.MESSAGE_EOS:
                fmt.Println("End of Stream")
                pipeline.SetState(gst.StateNull)
                return
            case gst.MESSAGE_ERROR:
                err := msg.ParseError()
                fmt.Printf("Error: %s\\\\n", err)
                pipeline.SetState(gst.StateNull)
                return
            }
        }
    }
}

In this example, a GStreamer pipeline captures video frames and extracts an image in RGB format, saving it as a JPEG file. For a real implementation, buffer data and image encoding might need to be handled more robustly.

Conclusion

Using GStreamer with Go provides a powerful way to build advanced streaming solutions. Whether you're implementing HLS streaming, RTMP output, or thumbnail generation in SFUtasks, GStreamer’s flexibility and Go’s concurrency make a compelling combination.

This guide provides a high-level overview and sample code to get you started. For more advanced use cases and optimizations, refer to the GStreamer and Go bindings documentation.

As you integrate GStreamer into your Go projects, remember that its complexity can require a deep understanding of its capabilities and the nuances of multimedia processing. But with careful implementation and testing, you can harness the full power of GStreamer to deliver exceptional multimedia experiences. And remember, Stream Video does all these things and much more, without you having to roll your own implementations.

Recommended posts
Using GStreamer with Go for Advanced Streaming SolutionsIs Go The Right Choice for Building a Backend?Go 10 Week Backend Engineering OnboardingStream Is Deprecating Virtual Go – It’s Time to Move to Go ModulesHow a Go Program Compiles down to Machine CodeGo 1.11 Rocket TutorialFixing the billion dollar mistake in Go by borrowing from RustGo Client Now Available