Category Archives: GStreamer

Update on QtGStreamer

Due to personal issues I have not been able to be online much or work for the past two months. Things are starting to settle now, and while I am still not able to return to a full time work schedule just yet I would like to keep the blog minimally updated 🙂

QtGStreamer had its first stable release! Congratulations to George for taking the flag to the finish line: he is an amazing coder and we are very lucky to have it in the KDE community. It is specially nice for me to read articles like this one from Jonathan, which validates much of the reasoning for QtGStreamer’s design choices (elegant API and no hard dependency on GStreamer libs, to name two core ones.)

Last week in QtGStreamer – week 9

Well, this week’s report is brief, and more technical. But first I would like to congratulate the GStreamer community for making 0.10.31 available. This is the version we are tracking for our initial stable release of QtGStreamer as well.

After the move to last week we were kept busy with code. George merged his initial GGlib::Value reimplementation, with the goal of making it at the same time more powerful and easier to maintain and use. I spent some days working on the Structure API to hopefully make it simpler: the StructureBase class was removed and SharedStructure was made private. StructurePtr was implemented, so now users only have Structure and StructurePtr, which is consistent with the rest of the API. This opens the door for additional improvements as well. The commit history with a log of the activity from the past 7 days is available here. You will see there that other items from the TODO list in the QtGStreamer wiki were also addressed.

Speaking of TODO lists… why every time we start to maintain one, it seems to grow faster then our ability to tame it?

Last week in QtGStreamer – week 8

This was a very productive week for the project, with a lot of of activity moving us closer to a first stable release. I worked mostly on refactoring the mechanism that tracks reference counts for miniobjects and caps, while George has been busy with a redesign of the QGlib::Value system that makes it really convenient to use it from Qt, much like QVariant.

Also, we are happy to announce that QtGStreamer is now a project, with the repository living at

Bug reporting is already integrated as a GStreamer component in Bugzilla.

These moves makes me very happy. QtGStreamer was started last year by George Kiagiadakis as a personal project and were previously hosted at Gitorious. With this move we are now effectively the “official” Qt bindings for GStreamer, living in the same repository tree and using the same bug reporting system. This makes it easier for us to tap into the knowledge of the existing GStreamer developer community (including people that are using other bindings, like PyGst). And the visibility of the project is increased, which is good in general as we really want to have more people hacking on and using it.

Last week in QtGStreamer – week 7

This week George merged some of the patches I have been working on to the QtGStreamer master repository, including support for Events. (*) He also wrote and committed a bunch of bugfixes and some improvements to the build files.

I started to work on some refactoring for our refCounted object, with an eye on addressing two issues that are common to other GStreamer bindings as well. So far things are promising, but this effort will take a little more time before it is ready to be merged.

And finally, the Kamoso team announced that they have completed the intial port to QtGStreamer. It is still a work in progress, but it is good to be able to collaborate on real world applications instead of just hacking on an “ideal” library API. We have already some adjustments in our long and public TODO list thanks to the input from Alex, and I wish the Kamoso team good luck with the project.

(*) As a comment to that, I still need to adjust my workflow to git: I use to prototype things and commit frequently in the local directory to avoid losing work, but this produces a not-so-good history as things are added and deleted… and do not end up in the final patch, just in the commit history. To avoid this I was rebasing and squashing, but the side effect of this for big changes (like the TagList support I was working on) is that it tends to be a very long and not-so-manageable merge request, which takes more time to process. I promised George I will send smaller, atomic patches from now on :). But generally I think that I am now finally getting into the git mode of thinking: it requires a mental adjustment for people like me that were used to CVS and SVN and were afraid of branching… Once you adjust there is no going back, I am glad KDE is migrating to it.

Last week in QtGStreamer – a recap (and an overview of GStreamer)

This is inspired by the ‘Last week in Krita’ and ‘Last week in KOffice’ series. Boud, the author of these series, mentioned that this is a nice way to “keep everyone who is interested, developers, contributors, users — everyone — up to date on what is happening in the […] community.” I do not promise I will be able to keep up with weekly updates AND still work on development :), but I will do my best to summarize what is happening on a frequent basis.

I guess starting the series with a recap is good. I have worked in this project for a little more than 5 weeks now, so this is going to be the “Week 1-6” edition. Two weeks ago I posted an introduction to the project, and the reaction so far has been mostly positive. I know of at least one KDE project that is trying QtGStreamer already, and this is good because it lets us tweak the API to real-world applications easily, as no official release has been done and there is still flexibility to do so. And because it is important for us to get more people on board we are usually hanging out in the #gstreamer IRC channel on Freenode: please join us there if you have a question, want to help us with development or just need a hand trying QtGStreamer in your application.

Since that last update we have added some of the basic blocks from the GStreamer API that were still missing, including support for Events, Buffers and TagLists. Some of these are already in the master repository and some are still in review, but we are generally in good shape and ready for prototyping. The plan is to work on the next two weeks on stabilizing what is already added and refactoring some of the code that deals with the bridge between Glib/GObject and Qt. George and I have some interesting ideas on how to deal with some of the challenges that face every GStreamer-binding project, as there are a lot of special cases and design choices in the framework that require authors of bindings to be creative and decide where to draw the line: we can give users full access to the engine at expense of making the API complex, or we can hand-hold the developer and maybe limit the inherent flexibility of the engine. It is a tenuous line, but by now we *think* we have a pretty good overview of the main use cases, and are in a good position to try some things.

I realized after reading the paragraph above that it might not make more sense to people not familiarized with how GStreamer is designed, so I will write a “5 minute overview” of the technology. If you have more time I recommend reading the first chapter of the online docs instead. But, in short, the GStreamer framework is pipeline based. The pipeline is composed of different elements, which are GStreamer’s building blocks. See the image below for the pipeline that can be assembled for a simple ogg player:

Simple Player
A simple GStreamer pipeline

In this example each block is a GStreamer element. An element in its simplest form is a box that generates, processes or outputs data: it can have one or more “pads”, which are the ports that make the connections so data can flow from one element to the other. Pads can be source pads (produce data) or sink pads (consume data). There are over 1000 elements in a typical GStreamer installation, dealing with everything from getting data from cameras (a v4l2 element with a single source pad) to decoding VP8 streams (a vp8 decoder element) to displaying data on the screen (several specialized elements that only have one sink pad, including for example the xvvideosink one).

The pipeline concept is what makes GStreamer so flexible. It is not that different from Unix pipelines in design: the idea is that you build complex solutions starting from simple and discrete elements. As this is supposed to be a 5-minute introduction I will not get into much more detail, but it is important to mention that in GStreamer communication events between elements can flow upstream and downstream, and there are facilities that let the elements communicate back to the application and vice-versa using messages and queries, as well for assembling pipelines dynamically.

So in QtGStreamer we give you all the power to link these GStreamer elements as you wish. A real world example might help: let us say you want to display the image of your webcam in a Qt application window. In Linux you can do this by linking the v4l2src to a qwidgetsink, which as the name implies is a QtGStreamer element that can display images and inherits from QWidget.. Actual code for this is something like:

//Creates the pipeline
m_pipeline = QGst::Pipeline::create();
//Construct the source Video for Linux element
QGst::ElementPtr src = QGst::ElementFactory::make(“v4l2src”);
//Construct the QWidget sink element
m_sink = QGst::ElementFactory::make(“qwidgetvideosink”);
//Add both to the pipeline
//Link the source to the sink
//Tell the sink to use one widget defined in our UI file
//Start the pipeline

That’s it: video should now be flowing from your v4l2 drivers directly to your screen. The example above can be expanded: it is typical to include an element called “ffmpegcolorspace” in between the v4l2src and the qwidgetvideosink, to handle color space conversion if necessary. You could also add an element that duplicates the data before it reaches the qwidget, followed by a VP8 encoder element, a Matroska muxer and an element that writes data to a file, and your application would already compress and record WebM video. But this is a quick tutorial, so we will not expand on that right now. The idea is to show that you have a lot of flexibility and QtGStreamer already lets you construct any pipeline you wish using the make and link functions.

But constructing pipelines manually can be complex. This is where higher-level objects come handy: next week I plan to continue this series with an update on the progress of the project and at the same time will write about how GStreamer’s pre-made bins (which are complex elements that internally have their own collection of elements) can be used to easily play/decode/capture almost any kind of media on several platform, as they auto-discover the elements that need to be used and connect them automatically for you.

Disclaimer: the above description of GStreamer’s design is extremely simplified of course, so I recommend checking the documentation if you are really interested in finding out more about its internals.

Embedded Linux Conference Europe and GStreamer Conference

This week I am in Cambridge getting to know my colleagues at Collabora Multimedia and attending both the ELC and the GStreamer Conference, which were co-locating.
ELC was interesting. There were a lot of talks dealing with user interface and multimedia issues, and I was pleasantly surprised to find out several presenters mentioning Qt, usually in conjunction with MeeGo. I remember that four or five years ago Qt was relatively unknown, at least in the free software events I used to attend. Nowadays this is clearly not the case: a presenter from Alcatel had a lecture where he compared the available solutions for embedded Linux products. It was a nice presentation, covering all the different SoC architectures as well as the frameworks and toolkits. When he reached the toolkit section there was a big chart with 7 or 8 different solutions, and Qt was clearly a contender for the top position.

The GStreamer conference was a pleasant surprise for me as well, as I was not expecting that many developers. There were at least 150 people there from different projects and companies, and the quality of the presentations was great. I was very pleased to meet another Brazilian developer, Luciana Fujii from Holoscopio. She presented about Landell, a GStreamer-based recording and streaming solution that was used for the last FISL conference in Brazil. It looks very interesting and could possibly help us solve some of the challenges related to recording and streaming content for the next Desktop Summit. On-the-fly camera switching and titling are possible, as well as recording and streaming using different settings. It is Python-based and seems very simple to operate.

I also met several other developers working with GStreamer either professionally or in their pet projects. One I found particularly interesting to watch in action was Stefan Kost’s Buzztard: a pretty impressive music composition environment. I recommend a visit to the site: it can work with both samples and generated sounds, has a built-in sequencer/tracker and can even work with legacy Buzz Windows plugins. For some songs Stefan told me that the internal GStreamer pipeline created by Buzz uses up to 500 elements! (mixers, effects, sound generators…) And it all runs at real time: in his machine this was using 25% of the CPU, but of these only 5% were really being used to play the track, as the rest was mostly consumed by the GUI.

Finally, I collected some initial feedback about the current QtGStreamer implementation and possible use cases. I think we are in the right track so far, and I hope we can see the results of this work pretty soon in the form of applications as cool as the ones I have seen in this conference.

QtGStreamer – an introduction

For the past couple of weeks I have been working on a very cool project, one started and lead by one of our brilliant KDE hackers-that-came-from-GSoC, George Kiagiadakis (gkiagia). I remember that the project got my attention when it was first announced. But I was very busy at that time, and could only follow it from a distance, until now.

As the title of this post reveals, I am talking about QtGStreamer, the Qt-style bindings for the GStreamer multimedia framework.

The project has been progressing during the past year, mostly because it is used in George’s kcall. The structure of the bindings is very flexible, as it follows the powerful pipeline model that is the strength of GStreamer’s design without falling into the trap of trying to map the GStreamer API 1:1. This gives us something that is friendly to the Qt/KDE developer, but at the same time allows things that are very difficult (or impossible) to do with the multimedia APIs we have currently, like displaying a webcam and transcoding the video at the same time with a few lines of code, or streaming audio/video from a remote location transparently.

Even if QtGStreamer is already functional for simple applications it is of course not complete. There is still a lot of work to be done. So as part of my job with Collabora Multimedia I have been assigned to help it reach a feature-complete status. This does not mean the whole GStreamer API will be wrapped: we are aiming for something that is directed specifically to application developers, and I hope it will allow us to help developers code better multimedia experiences for both Qt, MeeGo and KDE users.

My work on the project started recently, and there is still much I have to learn. Luckily George has been around to mentor me, and Collabora Multimedia has a LOT of expertise in GStreamer, of course. I spent the first few weeks doing a full review of the existing GStreamer bindings for all languages, and identifying the missing pieces that we needed to provide. Oh, and making stupid mistakes as well 🙂 You can follow the development of course at the current QGStreamer repository, and don’t be shy if you think you can help, or have a specific request. At this time it is important for us to identify the use cases we have not envisioned for QtGStreamer and do our best to provide an easy API to make them possible, so your input is much appreciated.

I plan to blog regularly about the status of this project. For now, I will already answer the inevitable initial questions:

a) No, it is not meant to replace Phonon. Different use cases, different priorities.
b) No, we could not make this work as part of the Phonon-gstreamer backend. Although the Phonon-gstreamer backend could possibly be ported to QtGStreamer in the future, if there is interest in doing it.
c) No, this does not conflict with the QtMobility/MultimediaKit API. Again, the use case is different, and they might interoperate in the future.

My work on this project is being sponsored by Nokia/MeeGo. As you might know, GStreamer is the official media framework for the MeeGo project, much like Qt is the official developer API. So this project aims to provide the link between those two powerful elements in the MeeGo ecosystem. I will keep you posted about our development, and thanks for reading so far!

Collabora Multimedia

For the past 6 years I have been working on several open source projects as a volunteer. But it has been difficult to find the time to continue to do so on a regular basis after my son was born, in August 2009. There are only 24 hours in a day, and these are not enough to care for the baby, continue my work on Tabuleiro (my small commercial software development company), keep in touch with my friends and family and still make meaningful contributions to KDE and other projects.

During my years with Tabuleiro I accumulated a good deal of experience working with multimedia technology for Windows/OSX, and recently I even managed to convince the bulk of my multimedia customers to do LGPL or GPL projects using Qt as well. But a full transition from closed source to the open source development model was always at my mind. At last Akademy I could witness the number of new companies working strictly with open source projects, most of them leveraging Qt as the main development toolkit, and being able to generate revenue for its developers and maintain a healthy relationship with the community.

And then I realized that I really wanted to work full time on open-source development, after 15 years doing commercial software. This was an easy realization: I did not want to cut on the time spent with my son or with my friends, so changing my work was the only other possible solution 🙂

A few weeks ago the opportunity arrived. I am happy to say that I am now working for Collabora Multimedia on a Qt-based project that I hope will be very useful to Meego and KDE. It is really, really cool. But this is the subject of another post…. For now I just want to say that I am loving the opportunity to work with some of my KDE friends at the same company on a daily basis, as well as having the chance to meet several new developers with different backgrounds.