Dragon Player 3

Only a few minutes ago Ian Monroe, the creator of Dragon Player, announced at the Desktop Summit in Berlin that there will be a Dragon Player 3.


In 2004 a new video player named Codeine was presented by former Amarok rockstar Max Howell, later adopted by Ian and turned into Dragon Player 2, which has served the KDE workspace as default video player for almost 4 years now.

Today the KDE Multimedia community is proud to announce the next evolutionary stage of this simple but powerful player.

Dragon Player 3 is being created using the latest terrific technologies: Phonon’s currently evolving support for QML/Qt Quick and Qt Quick itself. The combination of these technologies allows for rapid creation of awesome looking graphical applications for media playback.

The estimated feature set of Dragon Player 3 is definitely something to long for.

  • As simple and easy to use as its predecessor
  • All the features of its predecessor
  • Smooth animations on startup
  • A more visual and more usable recently viewed display
  • On playback start both Video and Audio fade in, on stop they fade out
  • A revolutionary approach that will make it tons easier to watch a series of videos (yet to be unveiled ;))

Dragon Player 3 will earliest arrive with the KDE workspace 4.8 release, though 4.9 seems more likely.

The current development version of Dragon Player 3 is available in my scratch repository on git.kde.org. It depends on the qml branches of both Phonon and Phonon GStreamer as well as the Qt Quick Desktop Components.

Advertisements

GSoC: Details on Phonon in QML

Native Phonon QML Player

As mentioned in my previous blog post I am working on bringing Phonon, the best multimedia abstraction library from KDE, to QML and Qt Quick.

Now I’d like to go more into detail about what the point of all this is and how this is going to rock our world.

Before Qt Quick we had widgets (imagine them as boxes). These were easy to use for Phonon, because every box on just about every operating system has some way to draw video content on it. Therefore this was nicely implemented in the frameworks underneath Phonon, so only the high-level Qt integration had to be done. With Qt Quick we don’t have proper boxes anymore, not in the way the operating systems like them anyway. Consequently we need to do some work to get from where we are to Qt Quick.

How will this work you might ask. Really it is actually very simple. In Qt Quick rather than having a random box where you can draw your video frames on, you have declarative items, which in essence also are boxes but unknown to the operating system. In Qt Quick those boxes are rendered using Qt internal technology. Right now that would be a software rasterizing approach or similar magic supported by QPainter, in Qt 5 this will actually all be done using OpenGL to enable much more awesome and complex applications as essentially the whole user interface will be rendered using GL.

Even though Qt 5 will do this vastly different, the concept of making video playback happen with Qt Quick is the same in both cases. You get your video frame, hand it to your Qt Quick item and in there you draw the frame depending on available capabilities and what not.

Ok, clearly there is various degrees of complexity involved on both ends (video/audio sync? drawing speed? …). Some of the more interesting programming challenges I will blog about next week.

Anyhow, people who know me a bit will notice that this post is unusually long, and clearly I would not blog that much blah without offering something to try 😉 So, get the Phonon QML branch iteration1 and take it for a test drive if you want. There is an audio and video demo in demos/qml (just make sure you have audio.wav or vidoe.ogv in the demo folders).

Iteration1 actually uses only technology that is already available (namely stock Phonon QObjects for Media and Audio and VideoDataOutput from experimental for Video). Future iterations will get rid of the dependency on VideoDataOutput as the QML branch is moving parts of the magic in the Phonon backends to allow for more ways to optimize the entire drawing process. In fact my local branches already have something that draws without the overhead of VideoDataOutput 😉

If you want to watch development at large you might want to check out the main qml branch.

I’ll blog soon about the architecture (once I have figured it out better ^^), meanwhile you can take a look at this picture (for Phonon GStreamer).

GSoC: Phonon and QML

This summer the Phonominals have something particularly awesome for you in store: native QML elements.

Phonon is the multimedia abstraction layer for Qt brought to you by the KDE community. QML is the new and cool way to create snazzy computer applications with Qt.

Through Google Summer of CodeI will be working on bringing these two great technologies closer together.

Why is this good you ask? Well….

  • QML allows for more designer involved computer application development -> better designed user interfaces
  • QML gives more freedom with regards to what the user interface can look like -> more engaging and natural interfaces
  • Phonon allows for rapid creation of media applications -> more time for actual features

In conclusion: Phonon and QML together will bring us better designed, better looking and feature rich media applications such as video players. Of course it also allows non-media centered applications to easily emit audio or video.

Finally, if you are a developer you might want to look at this code sample, which might very well be how one will use Phonon in QML.

import Qt 4.7
import Phonon 1.0

Media {
    source: "video.webm"

    Audio {
        volume: 5
    }

    Video {
        width: 320
        height: 240
    }
}