Category: GStreamer

  • July 13, 2017 - Thibault Saunier

    GStreamer to Gain the First RTSP 2.0 Implementation!

    Real Time Stream Protocol 2.0 The RTSP 2.0 was proposed in December 2016 to replace the 1.0 version of the standard; this new version is not backward compatible with the previous one. RTSP 1.0 is almost 20 years old, and it’s done a good job at defining a standard protocol for real time media streaming signaling, but it has not evolved much since then and had some issues that were worth fixing. The new version of this standard aims to resolve inconsistencies, clean up the RFC, add missing definitions, and restructure the document to reach better interoperability between implementers. RTSP 2.0 also comes with a bunch of new features (such as pipelined setup request, to avoid round trip time on initialization) and removes some features that were considered not useful enough (such as the RECORD command). GStreamer’s RSTP 2.0 Implementation At Samsung, we decided it was the right time to […]

    Read More
  • The gst-validate utility allows for the detection of known issues in GStreamer pipelines, and it’s part of the developer tools the GStreamer community offers through the gst-devtols modules. In this guide, I will demonstrate how to create playback scenarios to test a pipeline’s reaction to a new set of controlling actions. There are a couple of common and not-so-common scenarios that are already included with the GStreamer validate suite. This set allows for the identification of known error conditions on a running pipeline subjected to the actions the provided scenarios express. Now, what if you want to inspect the reaction of your pipeline to a new set of actions? Then, you need a new scenario that describes it. What’s in a Scenario? Scenarios are built from serialized actions on a .scenario file. These actions and their parameters are expressed using a GstStructure-based text format, and includes the following core actions: […]

    Read More
  • As you might already know, many open source projects are moving away from autotools as a build system and are embracing Meson. GStreamer was one of the first projects to initiate this move as the community pushed for it to happen. Meson has many advantages over autotools, but one I would like to talk about in this post is the notion of subprojects, which Meson introduces. Basically, thanks to this it’s easy to build several projects as if it was one; GStreamer has many components that were formerly independent in the build system, meaning that if you wanted to build the latest version of, say, gst-plugins-bad, you also needed to build GStreamer core and GStreamer base one way or another. Previously, we had some scripts to help with this process, but it was still necessary to clone and build everything separately and handle interdependency between things manually. Today, things are different when using […]

    Read More
  • This article will explain how to use GStreamer to capture Digital Television (DTV) streams; it will focus on terrestrial DTV and ATSC broadcasts in the Silicon Valley area to provide examples, but the principles are the same for every other DTV standard or supported location. If you want to follow the examples, you will at the very least need a Linux machine with GStreamer and v4l-utils, and a DTV capture device. For my ATSC testing setup I use a WinTV-HVR 950Q USB stick (Hauppauge), connected to a Debian desktop computer that runs the latest code for GStreamer and dvbv5-scan from their respective git repositories, both uninstalled. This setup works well for me as a developer but if you simply want to play DTV streams on your machine, the version from your distribution’s binary packages should suffice. A Few Notes on Receiver Setup You’ll need to have your receiver setup properly to capture multi-media content from a radio […]

    Read More
  • December 29, 2016 - Arun Raghavan

    Playback Synchronization & Video Walls with GStreamer

    Hello again, and I hope you’re having a pleasant end of the year (if you are, you might want to consider avoiding the news until next year). In a previous post, I wrote about synchronized playback with GStreamer, and work on this has continued apace. Since I last wrote about it, a bunch of work has been completed: Added support for sending a playlist to clients (instead of a single URI), Added the ability to start/stop playback, Cleaned up the API considerably to improve the potential for it to be included upstream, Turned the control protocol implementation into an interface to remove the necessity to use the built-in TCP server (different use-cases might want different transports), Improved overall robustness of code and documentation, Introduced an API for clients to send the server information about themselves, and finally Added an API for the server to send video transformations for each specific client to apply before rendering. […]

    Read More
  • November 8, 2016 - Arun Raghavan

    GStreamer Media Synchronization Made Easy

    A lesser known, but particularly powerful feature of GStreamer is the ability to synchronize media playback across multiple devices with fairly good accuracy. However, with the way things stand right now, it requires some amount of fiddling and a reasonably thorough knowledge of GStreamer’s synchronization mechanisms. While we have had some excellent talks about these at previous GStreamer conferences, getting things to work is still a fair amount of effort for someone not well-versed with GStreamer. As part of my work with the Samsung OSG, I’ve been working on addressing this problem by wrapping all the complexity associated with this in a library. The intention is for anyone who wants to implement synchronized streaming between devices on the same network to be able to do so with a few lines of code and basic know-how of writing applications based on GStreamer. I’ve started work on this already, and you can […]

    Read More
  • October 25, 2016 - Reynaldo Verdejo

    The 2016 GStreamer Hackfest & Conference in Berlin

    A few days ago, while on my way back from the GStreamer hackfest and conference combo, I tried to come up with a list of pearls to share here and arrived at a pretty troubling conclusion: there was no easy way to do so. The Hackfest I met Luis (De Bethencourt) a kilometer away from my hotel on a cold Saturday morning on October 8th. By then, I had already figured the only exercise I’d be able to get during my short 4-day stay in Berlin was going to be related to my commute, so I decided to embrace walking. We headed for C-Base as soon as we meet at his hotel’s lobby and arrived 10 minutes later to meet the typical familiar faces from the GStreamer community. So did everything start. The GStreamer developer community, while quite compact, has a surprisingly large number of regulars; people tend to stay around. This is something you hardly […]

    Read More
  • October 18, 2016 - Thibault Saunier

    Improving Debugging in GStreamer Validate

    Debugging GStreamer is often a hard and time-consuming task; because of this, the community has been working to enhance debugging tools and make it simpler in the gst-devtools official module and its gst-validate component (you can find more information about this in my previous post). Lately, we’ve decided to take a step forward and enhance the GStreamer validate reports for specific and very common GStreamer issues. We started with the classic Not Negotiated Error which basically happens when the elements in the pipeline are not able to agree on a data format (Caps) in which to do the processing. This can happen for many reasons, and until recently, the only way to figure out what went wrong was to read verbose and sometimes hard to read GStreamer debug logs; this is time consuming, particularly for people who are not very familiar with GStreamer. Starting from the next 1.10 release, GstValidate will attempt to explain the precise reason and place in the pipeline […]

    Read More
  • September 6, 2016 - Reynaldo Verdejo

    Wayland Uninstalled, the Easy Way

    I recently had to start looking at some GStreamer & Wayland integration issues and, as everyone would, commenced by trying to setup a Wayland development environment. Before getting my feet wet though, I decided to have a chat about this with Derek Foreman: our resident Wayland expert. This isn’t surprising because on our team, pretty much every task starts by having a conversation (virtual or not) with one of the field specialists in the group. The idea is to save time, as you might have guessed. This time around I was looking for a fairly trivial piece of info: Me – “Hey Derek, I have Wayland installed on my distro for some reason – I don’t really want to take a look at now – and I would like to setup an upstream (development) Wayland environment without messing it up. Do you have some script like GStreamer’s gst-uninstalled so I can perform […]

    Read More
  • September 1, 2016 - Javier Martinez Canillas

    Video Decoding with the Exynos Multi-Format Codec & GStreamer

    Exynos SoCs have an IP block known as the Multi-Format Codec (MFC) that allows them to do hardware accelerated video encoding/decoding, and the mainline kernel has a s5p-mfc Video for Linux2 (V4L2) driver that supports the MFC. The s5p-mfc driver is a Memory-to-Memory (M2M) V4L2 driver, it’s called M2M because the kernel moves video buffers from an output queue to a capture queue. The user-space enqueues buffers into the output queue, then the kernel passes these buffers to the MFC where they are converted and put it in the capture queue so the user-space can dequeue them. The GStreamer (gst) multimedia framework supports V4L2 M2M devices, but only for decoders the v4l2videodec element supports. Randy Li is working to also support M2M encoders in GStreamer (v4l2videoenc), but this hasn’t landed in upstream GStreamer yet. This post will explain how to use GStreamer and the Linux mainline kernel to do hardware […]

    Read More