In other news, GStreamer is now almost buzzword-compliant! The next blog post on our list: blockchains and smart contracts in GStreamer.
Late last year, we at Centricular announced a new implementation of WebRTC in GStreamer. Today we’re happy to announce that after community review, that work has been merged into GStreamer itself! The plugin is called webrtcbin, and the library is, naturally, called gstwebrtc.
The implementation has all the basic features, is transparently compatible with other WebRTC stacks (particularly in browsers), and has been well-tested with both Firefox and Chrome.
How do I use it?
Currently, the easiest way to use webrtcbin is to build GStreamer using either gst-uninstalled(Linux and macOS) or Cerbero (Windows, iOS, Android). If you’re a patient person, you can follow @gstreamer and wait for GStreamer 1.14 to be released which will include Windows, macOS, iOS, and Android binaries.
The API currently lacks documentation, so the best way to learn it is to dive into the source-tree examples. Help on this will be most appreciated! To see how to use GStreamer to do WebRTC with a browser, checkout the bidirectional audio-video demos that I wrote.
Show me the code! [skip]
Here’s a quick highlight of the important bits that should get you started if you already know how GStreamer works. This example is in C, but GStreamer also has bindings for Rust, Python, Java, C#, Vala, and so on.
Let’s say you want to capture video from V4L2, stream it to a webrtc peer, and receive video back from it. The first step is the streaming pipeline, which will look something like this:
v4l2src ! queue ! vp8enc ! rtpvp8pay !
As a short-cut, let’s parse the string description to create the pipeline.
Next, we get a reference to the webrtcbin element and attach some callbacks to it.
When the pipeline goes to PLAYING, the on_negotiation_needed() callback will be called, and we will ask webrtcbin to create an offer which will match the pipeline above.
When webrtcbin has created the offer, it will call on_offer_created()
Similarly, when we have the SDP answer from the remote, we must call "set-remote-description" on webrtcbin.
ICE handling is very similar; when the "on-ice-candidate" signal is emitted, we get a local ICE candidate which we must send to the remote. When we have an ICE candidate from the remote, we must call "add-ice-candidate" on webrtcbin.
There’s just one piece left now; handling incoming streams that are sent by the remote. For that, we have on_incoming_stream() attached to the "pad-added" signal on webrtcbin.
That’s it! This is what a basic webrtc workflow looks like. Those of you that have used the PeerConnection API before will be happy to see that this maps to that quite closely.
The aforementioned demos also include a Websocket signalling server and JS browser components, and I will be doing an in-depth application newbie developer’s guide at a later time, so you can follow me @nirbheek to hear when it comes out!
Tell me more!
The code is already being used in production in a number of places, such as EasyMile‘s autonomous vehicles, and we’re excited to see where else the community can take it.
If you’re wondering why we decided a new implementation was needed, read on! For a more detailed discussion into that, you should watch Matthew Waters’ talk from the GStreamer conference last year. It’s a great companion for this article!
But before we can dig into details, we need to lay some foundations first.
What is GStreamer, and what is WebRTC? [skip]
Everything is great, let’s build amazing apps! [skip]
WebRTC in GStreamer — webrtcbin and gstwebrtc
This combined with the SRTP and DTLS plugins that were written during OWRTC’s development meant that our implementation is built upon a solid and well-tested base, and that implementing WebRTC features is not as difficult as one might presume. However, WebRTC is a large collection of standards, and reaching feature-parity with libwebrtc is an ongoing task.
Lucky for us, Matthew made some excellent decisions while architecting the internals of webrtcbin, and we follow the PeerConnection specification quite closely, so almost all the missing features involve writing code that would plug into clearly-defined sockets.
We believe what we’ve been building here is the most flexible, versatile, and easy to use WebRTC implementation out there, and it can only get better as time goes by. Bringing the power of pipeline-based multimedia manipulation to WebRTC opens new doors for interesting, unique, and highly efficient applications.
To demonstrate this, in the near future we will be publishing articles that dive into how to use the PeerConnection-inspired API exposed by webrtcbin to build various kinds of applications—starting with a CPU-efficient multi-party bidirectional conferencing solution with a mesh topology that can work with any webrtc stack.