Category Archives: Meego

HTML5 apps on all platforms: can Qt help?

A couple of questions for my dear Qt friends: after a long winter, mostly devoted to building and deploying HTML5 games and educational apps, I find myself evaluating Qt again for a big project… It is an app to be used on schools: it must work online and partly offline as well. And it has to run on desktops (Linux/Win) and mobile (Android/iOS).

HTML5 apps have evolved a lot. We built very interesting collaborative things using it, and the team is already familiar with backbone.js and other goodies. But the requirement that part of the funcionality must be available offline is puzzling me for this particular project. HTML5 offline support will not cut it, as data to enable the features we need is not something that fits in the typical localstorage cache solution. So I was thinking about using something like Apache Cordova (previously phonegap) and its sqlite plugin. The thing is that I would very much wanted a single code base…

The research lead to interesting new projects, like node-webkit and chromium embedding framework. All have pros and cons, and none runs on all platforms we need to support.

And then yesterday I found that ICS was working on cordova-qt. So maybe it is possible to build such an app (HTML5 based with local fs support) and really deploy it worldwide from a single codebase? Apparently, not yet… the project appears to be a bit stale. Does anyone know why? Perhaps the announcement that Digia will work on native iOS and Android versions of Qt has made this a lower priority? It would be nice to use a C++ app with QtWebKit, but IIUIC this does not work for iOS and Android, so back to square one, right? Comments are welcome!

Elop is after me

Back in 2005, my small company had an active customer base of more than 15,000 developers using our plugins. These were extensions (Xtras) for Macromedia Director, at the time the number one tool for authoring of CD-ROM and online games published via Shockwave. The global Director developers community was composed of 300,000+ professionals, not counting the illegal copies. Sure, Flash (also from Macromedia) was starting to become a powerhouse and was competing strongly with its older brother. But development of both software continued at a healthy pace, and the collaboration between both teams resulted in the opportunity to use Director as a container for Flash media, with a bright outlook for both. Director was still the tool of choice for 3D games, kiosks, CD-ROMS and lots of projects where the ability to extend the environment with C++ code was required, with embedded Flash elements providing the eye candy and an army of designers that were used to the platform.
Then Elop was elected CEO of Macromedia. And some months later, the company was sold to Adobe. A nice and stable transition was assured at the time. Director was not to be killed, like Freehand and some others. And it fact it wasn’t. The Director product team had a good channel of communication with the community at the time, and from them we were told that several options were being considered for the future, we just had to wait a bit for the dust to settle.
Looking back, it would have been better if the product was sold to another company, or it Adobe management had clearly stated from the start that no significant updates were planned. Instead, Director remained alive at Adobe as a cash cow, with a reduced team that was strangled slowly, always waiting for better news “in the near future”. It was planned obsolescence, and it continues until today: there were sporadic releases (to reap the upgrade fees) and this helped keep some content created in Director still alive. Nowadays the developer community consists mostly of old timers who are maintaining their legacy projects, and struggling against an aging code base that is minimally supported. There were more than 40 companies producing Xtras for Director circa 2002, and from these only 1 or 2 (including ours) is still active. This is mostly out of respect to the existing customers and the investment they have made on the “ecosystem”, as keeping this business alive (support and minimal maintenance costs) is something that has not generated a profit for me in the last two years.

So I was not happy to see Elop (after graduating from Adobe and Microsoft, which surely increased his business “skills”) took over the role of Nokia CEO. Oh, oh… spider sense ticked off. Luckily, the other shoe dropped almost as quickly, also in a matter of months, as we all know by now.

There is, however, a significant distinction between both scenarios. Director was never free software. There was no option: some from the community even tried the only possible route, which was to acquire the product, but Adobe did not want to let it go, probably out of fear that it will compete strongly again with Flash. So the “strangling” of the community succeeded. Qt, on the other hand, is free software. And KDE has also secured the FreeQt agreement. So, thanks to the L(GPL) and the efforts of the community, there is a way out.

I read several blogs asking for restrain and calling a fork “premature”. I respect those opinions, but having lived through a previous elopcalypse, I beg to differ. A small part of me hopes I am wrong, but I believe a fork is not only necessary, but inevitable. And I think KDE is the place where this fork should live, with kdelibs and qt forming an unified platform where truly free (in license, cost and development direction) software can be built. Everyone knows the problems KDE developers and the community have with their patches being integrated in Qt.: with a Qt tree living inside KDE we would be free to apply true open source principles to the development, and let it thrive in the way our software has. I understand Qt Software inside Nokia is implementing open governance and all, and I trust the people in charge of this initiative. But again, their power is limited. I respectfully must say that any initiative led by Nokia or their employees will never be truly open in the sense KDE is. And the axe might fall again in a couple of months, and then again. And the good people will be gone. Qt developers would have migrated to another environments. And the opportunity will be lost.

Some will say: but then we will loose the Nokia-sponsored development. This is true. But these are already gone, or will be gone soon, IMHO.

Well, we can check this in 2 years, and I will certainly buy a round of beer to everyone at the 2013 Desktop Summit if I am wrong. In fact, I will be happy to do so, and I would be happy to be wrong as it would mean less work for KDE. But I got tired of the “calm down” posts. Putting it in blunt words, we can no longer trust Nokia or depend on it for the core framework KDE needs. Even if most Nokians are very good guys, brilliant engineers and a joy to work with, the new management has shown its true face. Two months ago they were drafting developers in Dublin for Meego, and some people dedicated their time and resources to support the Qt-everywhere promise. This commitment has been broken, and it will not be the first one. Reading the join press release (Elop and Ballmer, come on) feels like an April’s Fool joke, honestly. Just stare at the photo for a while. We can not expect any FLOSS love from these guys, sorry. Like KDE, Meego is hurt, but it can also recover if Qt moves to a truly open upstream repository. Qt, imho, can no longer be controlled by Nokia: development has to happen in the open and be governed like a true community project, like KDE. I can imagine that such a move would make other Meego players happier as well.

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 freedesktop.org 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 Freedesktop.org project, with the repository living at

http://cgit.freedesktop.org/gstreamer/qt-gstreamer/

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
m_pipeline->add(src);
m_pipeline->add(m_sink);
//Link the source to the sink
src->link(m_sink);
//Tell the sink to use one widget defined in our UI file
m_ui.videoWidget->setVideoSink(m_sink);
//Start the pipeline
m_pipeline->setState(QGst::StatePlaying);

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!