Merge lp:~phablet-team/media-hub/video-support into lp:media-hub

[Jim Hodapp]

* Merged with EOS branch from tvoss
* Added on_frame_available listener and callback
* Create a decoding session and pass it to the hybris layer
* Allow playback to work again after a client quits or dies
* Added two new properties to see if the opened media is video or audio
* Background playlist support

* Merged with EOS branch from tvoss
* Added on_frame_available listener and callback
* Create a decoding session and pass it to the hybris layer
* Allow playback to work again after a client quits or dies
* Added two new properties to see if the opened media is video or audio
* Background playlist support

[lp:~phablet-team/media-hub/video-support]

37. By Jim Hodapp on 2014-03-27

Merged with Sergio's packaging changes. Added a copyright header to server.cpp. Removed any includes for decoding_service.h since it's not being used right now.

38. By Jim Hodapp on 2014-03-27

Didn't mean to #include <visibility.h> in previous commit, undo that.

39. By Jim Hodapp on 2014-03-27

Enable libhyris-dev as a build-dep

40. By Jim Hodapp on 2014-03-27

Get rid of the visibility attribute.

41. By Jim Hodapp on 2014-03-28

Add libproperties-cpp-dev as a Depends: for libmedia-hub-dev

42. By Jim Hodapp on 2014-03-28

Merged with upstream changes to disable all unit-tests

43. By Jim Hodapp on 2014-04-04

Made ricmm's change recommendations and enabled the tests that still work properly.

44. By Jim Hodapp on 2014-04-04

Snap to the preceeding key unit after doing a seek.

45. By Jim Hodapp on 2014-04-08

Mock decoding_service_set_client_death_cb so that the unittests don't crash when running on a non-target device.

46. By Jim Hodapp on 2014-04-09

Enable the seeked_to signal

47. By Jim Hodapp on 2014-04-09

Merged with ricmm's EOS fix branch

48. By Jim Hodapp on 2014-04-15

Initial version of apparmor security context arbitration for open_uri. This does not yet check the trust store

49. By Jim Hodapp on 2014-04-15

Refine the apparmor arbitration a bit. Whitelist music-app explicitly until the trust store lands.

50. By Jim Hodapp on 2014-04-15

Only start when dbus is started instead of preventing media-hub from being able to be stopped

51. By Jim Hodapp on 2014-04-16

Enable streaming sources to work with media-hub

52. By Jim Hodapp on 2014-04-16

Allow apps to access their own media files in /opt

53. By Jim Hodapp on 2014-04-17

Merged with jdstrand's changes to confine media-hub with apparmor

54. By Jim Hodapp on 2014-04-17

Slightly improve the get_position_duration_works unit test

55. By Jim Hodapp on 2014-04-17

Make sure the camer-app can play the click sound when a user captures a picture

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-02-14 07:19:31 +0000
+++ CMakeLists.txt	2014-03-26 17:18:55 +0000
@@ -25,6 +25,7 @@
 pkg_check_modules(DBUS dbus-1 REQUIRED)
 pkg_check_modules(DBUS_CPP dbus-cpp REQUIRED)
 pkg_check_modules(PROPERTIES_CPP properties-cpp REQUIRED)
+pkg_check_modules(GIO gio-2.0 REQUIRED)
 
 #####################################################################
 # Enable code coverage calculation with gcov/gcovr/lcov
 
=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2014-02-18 19:27:01 +0000
+++ include/core/media/player.h	2014-03-26 17:18:55 +0000
@@ -39,6 +39,11 @@
   public:
     typedef double PlaybackRate;
     typedef double Volume;
+    typedef void* GLConsumerWrapperHybris;
+
+    /** Used to set a callback function to be called when a frame is ready to be rendered **/
+    typedef void (*FrameAvailableCbHybris)(GLConsumerWrapperHybris wrapper, void *context);
+    typedef void (*FrameAvailableCb)(void *context);
 
     struct Configuration;
 
@@ -74,6 +79,8 @@
     virtual std::shared_ptr<TrackList> track_list() = 0;
 
     virtual bool open_uri(const Track::UriType& uri) = 0;
+    virtual void create_video_sink(uint32_t texture_id) = 0;
+    virtual GLConsumerWrapperHybris gl_consumer() const = 0;
     virtual void next() = 0;
     virtual void previous() = 0;
     virtual void play() = 0;
@@ -81,11 +88,16 @@
     virtual void stop() = 0;
     virtual void seek_to(const std::chrono::microseconds& offset) = 0;
 
+    // TODO: Convert this to be a signal
+    virtual void set_frame_available_callback(FrameAvailableCb cb, void *context) = 0;
+
     virtual const core::Property<bool>& can_play() const = 0;
     virtual const core::Property<bool>& can_pause() const = 0;
     virtual const core::Property<bool>& can_seek() const = 0;
     virtual const core::Property<bool>& can_go_previous() const = 0;
     virtual const core::Property<bool>& can_go_next() const = 0;
+    virtual const core::Property<bool>& is_video_source() const = 0;
+    virtual const core::Property<bool>& is_audio_source() const = 0;
     virtual const core::Property<PlaybackStatus>& playback_status() const = 0;
     virtual const core::Property<LoopStatus>& loop_status() const = 0;
     virtual const core::Property<PlaybackRate>& playback_rate() const = 0;
@@ -97,15 +109,13 @@
     virtual const core::Property<uint64_t>& position() const = 0;
     virtual const core::Property<uint64_t>& duration() const = 0;
 
-
     virtual core::Property<LoopStatus>& loop_status() = 0;
     virtual core::Property<PlaybackRate>& playback_rate() = 0;
     virtual core::Property<bool>& is_shuffle() = 0;
     virtual core::Property<Volume>& volume() = 0;
 
-
     virtual const core::Signal<uint64_t>& seeked_to() const = 0;
-
+    virtual const core::Signal<void>& end_of_stream() const = 0;
   protected:
     Player();
 
 
=== modified file 'src/core/media/CMakeLists.txt'
--- src/core/media/CMakeLists.txt	2014-02-26 14:58:36 +0000
+++ src/core/media/CMakeLists.txt	2014-03-26 17:18:55 +0000
@@ -1,6 +1,6 @@
 pkg_check_modules(PC_GSTREAMER_1_0 REQUIRED gstreamer-1.0)
 
-include_directories(${PC_GSTREAMER_1_0_INCLUDE_DIRS})
+include_directories(${PC_GSTREAMER_1_0_INCLUDE_DIRS} /usr/include/hybris)
 
 add_library(
   media-hub-common SHARED
@@ -52,6 +52,7 @@
   ${DBUS_LIBRARIES}
   ${DBUS_CPP_LDFLAGS}
   ${GLog_LIBRARY}
+  -lmedia
 )
 
 install(
@@ -82,9 +83,11 @@
   ${DBUS_CPP_LDFLAGS}
   ${GLog_LIBRARY}
   ${PC_GSTREAMER_1_0_LIBRARIES}
+  ${GIO_LIBRARIES}
+  -lmedia
 )
 
-include_directories(${PROJECT_SOURCE_DIR}/src/)
+include_directories(${PROJECT_SOURCE_DIR}/src/ /usr/include/hybris)
 
 add_executable(
   media-hub-server
@@ -102,6 +105,7 @@
   ${DBUS_CPP_LDFLAGS}
   ${GLog_LIBRARY}
   ${PC_GSTREAMER_1_0_LIBRARIES}
+  -lmedia
 )
 
 install(
 
=== modified file 'src/core/media/engine.h'
--- src/core/media/engine.h	2014-02-18 19:27:01 +0000
+++ src/core/media/engine.h	2014-03-26 17:18:55 +0000
@@ -97,12 +97,16 @@
     virtual const core::Property<State>& state() const = 0;
 
     virtual bool open_resource_for_uri(const Track::UriType& uri) = 0;
+    virtual void create_video_sink(uint32_t texture_id) = 0;
 
     virtual bool play() = 0;
     virtual bool stop()  = 0;
     virtual bool pause() = 0;
     virtual bool seek_to(const std::chrono::microseconds& ts) = 0;
 
+    virtual const core::Property<bool>& is_video_source() const = 0;
+    virtual const core::Property<bool>& is_audio_source() const = 0;
+
     virtual const core::Property<uint64_t>& position() const = 0;
     virtual const core::Property<uint64_t>& duration() const = 0;
 
@@ -110,6 +114,9 @@
     virtual core::Property<Volume>& volume() = 0;
 
     virtual const core::Property<std::tuple<Track::UriType, Track::MetaData>>& track_meta_data() const = 0;
+
+    virtual const core::Signal<void>& about_to_finish_signal() const = 0;
+    virtual const core::Signal<void>& end_of_stream_signal() const = 0;
 };
 }
 }
 
=== modified file 'src/core/media/gstreamer/engine.cpp'
--- src/core/media/gstreamer/engine.cpp	2014-02-20 19:05:17 +0000
+++ src/core/media/gstreamer/engine.cpp	2014-03-26 17:18:55 +0000
@@ -16,6 +16,9 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include <stdio.h>
+#include <stdlib.h>
+
 #include "bus.h"
 #include "engine.h"
 #include "meta_data_extractor.h"
@@ -43,14 +46,10 @@
 
 struct gstreamer::Engine::Private
 {
-    void about_to_finish()
-    {
-        state = Engine::State::ready;
-    }
-
     void on_playbin_state_changed(
-            const gstreamer::Bus::Message::Detail::StateChanged&)
+            const gstreamer::Bus::Message::Detail::StateChanged& state_change)
     {
+        (void) state_change;
     }
 
     void on_tag_available(const gstreamer::Bus::Message::Detail::Tag& tag)
@@ -163,13 +162,26 @@
         playbin.set_volume(new_volume.value);
     }
 
+    void on_about_to_finish()
+    {
+        state = Engine::State::ready;
+        about_to_finish();
+    }
+
+    void on_end_of_stream()
+    {
+        end_of_stream();
+    }
+
     Private()
         : meta_data_extractor(new gstreamer::MetaDataExtractor()),
           volume(media::Engine::Volume(1.)),
+          is_video_source(false),
+          is_audio_source(false),
           about_to_finish_connection(
               playbin.signals.about_to_finish.connect(
                   std::bind(
-                      &Private::about_to_finish,
+                      &Private::on_about_to_finish,
                       this))),
           on_state_changed_connection(
               playbin.signals.on_state_changed.connect(
@@ -188,7 +200,12 @@
                   std::bind(
                       &Private::on_volume_changed,
                       this,
-                      std::placeholders::_1)))
+                      std::placeholders::_1))),
+          on_end_of_stream_connection(
+              playbin.signals.on_end_of_stream.connect(
+                  std::bind(
+                      &Private::on_end_of_stream,
+                      this)))
     {
     }
 
@@ -198,11 +215,17 @@
     core::Property<uint64_t> position;
     core::Property<uint64_t> duration;
     core::Property<media::Engine::Volume> volume;
+    core::Property<bool> is_video_source;
+    core::Property<bool> is_audio_source;
     gstreamer::Playbin playbin;
     core::ScopedConnection about_to_finish_connection;
     core::ScopedConnection on_state_changed_connection;
     core::ScopedConnection on_tag_available_connection;
     core::ScopedConnection on_volume_changed_connection;
+    core::ScopedConnection on_end_of_stream_connection;
+
+    core::Signal<void> about_to_finish;
+    core::Signal<void> end_of_stream;
 };
 
 gstreamer::Engine::Engine() : d(new Private{})
@@ -231,6 +254,11 @@
     return true;
 }
 
+void gstreamer::Engine::create_video_sink(uint32_t texture_id)
+{
+    d->playbin.create_video_sink(texture_id);
+}
+
 bool gstreamer::Engine::play()
 {
     auto result = d->playbin.set_state_and_wait(GST_STATE_PLAYING);
@@ -256,7 +284,7 @@
 bool gstreamer::Engine::pause()
 {
     auto result = d->playbin.set_state_and_wait(GST_STATE_PAUSED);
-
+    
     if (result)
         d->state = media::Engine::State::paused;
 
@@ -268,6 +296,28 @@
     return d->playbin.seek(ts);
 }
 
+const core::Property<bool>& gstreamer::Engine::is_video_source() const
+{
+    gstreamer::Playbin::MediaFileType type = d->playbin.media_file_type();
+    if (type == gstreamer::Playbin::MediaFileType::MEDIA_FILE_TYPE_VIDEO)
+        d->is_video_source.set(true);
+    else
+        d->is_video_source.set(false);
+
+    return d->is_video_source;
+}
+
+const core::Property<bool>& gstreamer::Engine::is_audio_source() const
+{
+    gstreamer::Playbin::MediaFileType type = d->playbin.media_file_type();
+    if (type == gstreamer::Playbin::MediaFileType::MEDIA_FILE_TYPE_AUDIO)
+        d->is_audio_source.set(true);
+    else
+        d->is_audio_source.set(false);
+
+    return d->is_audio_source;
+}
+
 const core::Property<uint64_t>& gstreamer::Engine::position() const
 {
     d->position.set(d->playbin.position());
@@ -295,3 +345,13 @@
 {
     return d->track_meta_data;
 }
+
+const core::Signal<void>& gstreamer::Engine::about_to_finish_signal() const
+{
+    return d->about_to_finish;
+}
+
+const core::Signal<void>& gstreamer::Engine::end_of_stream_signal() const
+{
+    return d->end_of_stream;
+}
 
=== modified file 'src/core/media/gstreamer/engine.h'
--- src/core/media/gstreamer/engine.h	2014-02-18 19:27:01 +0000
+++ src/core/media/gstreamer/engine.h	2014-03-26 17:18:55 +0000
@@ -33,12 +33,16 @@
     const core::Property<State>& state() const;
 
     bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri);
+    void create_video_sink(uint32_t texture_id);
 
     bool play();
     bool stop();
     bool pause();
     bool seek_to(const std::chrono::microseconds& ts);
 
+    const core::Property<bool>& is_video_source() const;
+    const core::Property<bool>& is_audio_source() const;
+
     const core::Property<uint64_t>& position() const;
     const core::Property<uint64_t>& duration() const;
 
@@ -47,6 +51,9 @@
 
     const core::Property<std::tuple<core::ubuntu::media::Track::UriType, core::ubuntu::media::Track::MetaData>>& track_meta_data() const;
 
+    const core::Signal<void>& about_to_finish_signal() const;
+    const core::Signal<void>& end_of_stream_signal() const;
+
 private:
     struct Private;
     std::unique_ptr<Private> d;
 
=== modified file 'src/core/media/gstreamer/playbin.h'
--- src/core/media/gstreamer/playbin.h	2014-02-20 19:05:17 +0000
+++ src/core/media/gstreamer/playbin.h	2014-03-26 17:18:55 +0000
@@ -21,6 +21,11 @@
 
 #include "bus.h"
 
+#include <media/decoding_service.h>
+#include <media/media_codec_layer.h>
+#include <media/surface_texture_client_hybris.h>
+
+#include <gio/gio.h>
 #include <gst/gst.h>
 
 #include <chrono>
@@ -37,6 +42,13 @@
         GST_PLAY_FLAG_TEXT = (1 << 2)
     };
 
+    enum MediaFileType
+    {
+        MEDIA_FILE_TYPE_NONE,
+        MEDIA_FILE_TYPE_AUDIO,
+        MEDIA_FILE_TYPE_VIDEO
+    };
+
     static const std::string& pipeline_name()
     {
         static const std::string s{"playbin"};
@@ -45,14 +57,15 @@
 
     static void about_to_finish(GstElement*,
                                 gpointer user_data)
-    {        auto thiz = static_cast<Playbin*>(user_data);
-
+    {
+        auto thiz = static_cast<Playbin*>(user_data);
         thiz->signals.about_to_finish();
     }
 
     Playbin()
         : pipeline(gst_element_factory_make("playbin", pipeline_name().c_str())),
           bus{gst_element_get_bus(pipeline)},
+          file_type(MEDIA_FILE_TYPE_NONE),
           on_new_message_connection(
               bus.on_new_message.connect(
                   std::bind(
@@ -74,6 +87,8 @@
                     this
                     );
 
+        // When a client of media-hub dies, call on_client_died
+        decoding_service_set_client_death_cb(&Playbin::on_client_died_cb, static_cast<void*>(this));
     }
 
     ~Playbin()
@@ -82,6 +97,43 @@
             gst_object_unref(pipeline);
     }
 
+    static void on_client_died_cb(void *context)
+    {
+        if (context)
+        {
+            Playbin *pb = static_cast<Playbin*>(context);
+            pb->on_client_died();
+        }
+    }
+
+    void on_client_died()
+    {
+        std::cout << "Client died, resetting pipeline" << std::endl;
+        // When the client dies, tear down the current pipeline and get it
+        // in a state that is ready for the next client that connects to the
+        // service
+        reset_pipeline();
+    }
+
+    void reset_pipeline()
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        auto ret = gst_element_set_state(pipeline, GST_STATE_NULL);
+        switch(ret)
+        {
+        case GST_STATE_CHANGE_FAILURE:
+            std::cout << "Failed to reset the pipeline state. Client reconnect may not function properly." << std::endl;
+            break;
+        case GST_STATE_CHANGE_NO_PREROLL:
+        case GST_STATE_CHANGE_SUCCESS:
+        case GST_STATE_CHANGE_ASYNC:
+            break;
+        default:
+            std::cout << "Failed to reset the pipeline state. Client reconnect may not function properly." << std::endl;
+        }
+        file_type = MEDIA_FILE_TYPE_NONE;
+    }
+
     void on_new_message(const Bus::Message& message)
     {
         switch(message.type)
@@ -101,6 +153,9 @@
         case GST_MESSAGE_STATE_CHANGED:
             signals.on_state_changed(message.detail.state_changed);
             break;
+        case GST_MESSAGE_EOS:
+            std::cout << "EOS detected" << std::endl;
+            signals.on_end_of_stream();
         default:
             break;
         }
@@ -126,6 +181,8 @@
                         ::getenv("CORE_UBUNTU_MEDIA_SERVICE_AUDIO_SINK_NAME"),
                         "audio-sink");
 
+            std::cout << "audio_sink: " << ::getenv("CORE_UBUNTU_MEDIA_SERVICE_AUDIO_SINK_NAME") << std::endl;
+
             g_object_set (
                         pipeline,
                         "audio-sink",
@@ -136,26 +193,43 @@
         if (::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME") != nullptr)
         {
             auto video_sink = gst_element_factory_make (
-                        ::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME"),
-                        "video-sink");
+                    ::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME"),
+                    "video-sink");
 
             std::cout << "video_sink: " << ::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME") << std::endl;
 
             g_object_set (
-                        pipeline,
-                        "video-sink",
-                        video_sink,
-                        NULL);
+                    pipeline,
+                    "video-sink",
+                    video_sink,
+                    NULL);
+        }
+    }
+
+    void create_video_sink(uint32_t texture_id)
+    {
+        std::cout << "Creating video sink for texture_id: " << texture_id << std::endl;
+
+        if (::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME") != nullptr)
+        {
+            GstElement *video_sink = NULL;
+            g_object_get (pipeline, "video_sink", &video_sink, NULL);
+
+            // Get the service-side BufferQueue (IGraphicBufferProducer) and associate it with
+            // the SurfaceTextureClientHybris instance
+            IGBPWrapperHybris igbp = decoding_service_get_igraphicbufferproducer();
+            std::cout << "IGBPWrapperHybris: " << igbp << std::endl;
+            SurfaceTextureClientHybris stc = surface_texture_client_create_by_igbp(igbp);
+            std::cout << "SurfaceTextureClientHybris: " << stc << std::endl;
+            // Because mirsink is being loaded, we are definitely doing * hardware rendering.
+            surface_texture_client_set_hardware_rendering (stc, TRUE);
+            g_object_set (G_OBJECT (video_sink), "surface", static_cast<gpointer>(stc), static_cast<char*>(NULL));
         }
     }
 
     void set_volume(double new_volume)
     {
-        g_object_set(
-                    pipeline,
-                    "volume",
-                    new_volume,
-                    NULL);
+        g_object_set(pipeline, "volume", new_volume, NULL);
     }
 
     uint64_t position() const
@@ -178,11 +252,11 @@
 
     void set_uri(const std::string& uri)
     {
-        g_object_set(
-                    pipeline,
-                    "uri",
-                    uri.c_str(),
-                    NULL);
+        g_object_set(pipeline, "uri", uri.c_str(), NULL);
+        if (is_video_file(uri))
+            file_type = MEDIA_FILE_TYPE_VIDEO;
+        else if (is_audio_file(uri))
+            file_type = MEDIA_FILE_TYPE_AUDIO;
     }
 
     std::string uri() const
@@ -236,8 +310,80 @@
                     ms.count() * 1000);
     }
 
+    std::string get_file_content_type(const std::string& uri) const
+    {
+        if (uri.empty())
+            return std::string();
+
+        std::string filename(uri);
+        size_t pos = uri.find("file://") + 7;
+        if (pos)
+            filename = uri.substr(pos, std::string::npos);
+
+        std::cout << "filename: " << filename << std::endl;
+
+        GError *error = nullptr;
+        std::unique_ptr<GFile, void(*)(void *)> file(
+                g_file_new_for_path(filename.c_str()), g_object_unref);
+        std::unique_ptr<GFileInfo, void(*)(void *)> info(
+                g_file_query_info(
+                    file.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE ","
+                    G_FILE_ATTRIBUTE_ETAG_VALUE, G_FILE_QUERY_INFO_NONE,
+                    /* cancellable */ NULL, &error),
+                g_object_unref);
+        if (!info)
+        {
+            std::string error_str(error->message);
+            g_error_free(error);
+
+            std::cout << "Failed to query the URI for the presence of video content: "
+                << error_str << std::endl;
+            return std::string();
+        }
+
+        std::string content_type(g_file_info_get_attribute_string(
+                    info.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE));
+
+        return content_type;
+    }
+
+    bool is_audio_file(const std::string& uri) const
+    {
+        if (uri.empty())
+            return false;
+
+        if (get_file_content_type(uri).find("audio/") == 0)
+        {
+            std::cout << "Found audio content" << std::endl;
+            return true;
+        }
+
+        return false;
+    }
+
+    bool is_video_file(const std::string& uri) const
+    {
+        if (uri.empty())
+            return false;
+
+        if (get_file_content_type(uri).find("video/") == 0)
+        {
+            std::cout << "Found video content" << std::endl;
+            return true;
+        }
+
+        return false;
+    }
+
+    MediaFileType media_file_type() const
+    {
+        return file_type;
+    }
+
     GstElement* pipeline;
     gstreamer::Bus bus;
+    MediaFileType file_type;
+    SurfaceTextureClientHybris stc_hybris;
     core::Connection on_new_message_connection;
     struct
     {
@@ -247,6 +393,7 @@
         core::Signal<Bus::Message::Detail::ErrorWarningInfo> on_info;
         core::Signal<Bus::Message::Detail::Tag> on_tag_available;
         core::Signal<Bus::Message::Detail::StateChanged> on_state_changed;
+        core::Signal<void> on_end_of_stream;
     } signals;
 };
 }
 
=== modified file 'src/core/media/mpris/player.h'
--- src/core/media/mpris/player.h	2014-02-18 19:27:01 +0000
+++ src/core/media/mpris/player.h	2014-03-26 17:18:55 +0000
@@ -54,11 +54,13 @@
     METHOD(Play, Player, std::chrono::seconds(1))
     METHOD(Seek, Player, std::chrono::seconds(1))
     METHOD(SetPosition, Player, std::chrono::seconds(1))
+    METHOD(CreateVideoSink, Player, std::chrono::seconds(1))
     METHOD(OpenUri, Player, std::chrono::seconds(1))
 
     struct Signals
     {
         SIGNAL(Seeked, Player, uint64_t)
+        SIGNAL(EndOfStream, Player, void)
     };
 
     struct Properties
@@ -74,6 +76,8 @@
         READABLE_PROPERTY(Duration, Player, uint64_t)
         READABLE_PROPERTY(MinimumRate, Player, double)
         READABLE_PROPERTY(MaximumRate, Player, double)
+        READABLE_PROPERTY(IsVideoSource, Player, bool)
+        READABLE_PROPERTY(IsAudioSource, Player, bool)
         READABLE_PROPERTY(CanGoNext, Player, bool)
         READABLE_PROPERTY(CanGoPrevious, Player, bool)
         READABLE_PROPERTY(CanPlay, Player, bool)
 
=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2014-02-18 20:25:21 +0000
+++ src/core/media/player_implementation.cpp	2014-03-26 17:18:55 +0000
@@ -17,9 +17,13 @@
 
 #include "player_implementation.h"
 
+#include <unistd.h>
+
 #include "engine.h"
 #include "track_list_implementation.h"
 
+#define UNUSED __attribute__((unused))
+
 namespace media = core::ubuntu::media;
 
 struct media::PlayerImplementation::Private
@@ -39,7 +43,7 @@
     {
         engine->state().changed().connect(
                     [parent](const Engine::State& state)
-                    {
+        {
             switch(state)
             {
             case Engine::State::ready: parent->playback_status().set(media::Player::ready); break;
@@ -49,7 +53,8 @@
             default:
                 break;
             };
-                    });
+        });
+
     }
 
     PlayerImplementation* parent;
@@ -76,6 +81,8 @@
     can_seek().set(true);
     can_go_previous().set(true);
     can_go_next().set(true);
+    is_video_source().set(false);
+    is_audio_source().set(false);
     is_shuffle().set(true);
     playback_rate().set(1.f);
     playback_status().set(Player::PlaybackStatus::null);
@@ -98,6 +105,33 @@
         return d->engine->duration().get();
     };
     duration().install(duration_getter);
+    
+    std::function<bool()> video_type_getter = [this]()
+    {
+        return d->engine->is_video_source().get();
+    };
+    is_video_source().install(video_type_getter);
+
+    std::function<bool()> audio_type_getter = [this]()
+    {
+        return d->engine->is_audio_source().get();
+    };
+    is_audio_source().install(audio_type_getter);
+
+    engine->about_to_finish_signal().connect([this]()
+    {
+        if (d->track_list->has_next())
+        {
+            Track::UriType uri = d->track_list->query_uri_for_track(d->track_list->next());
+            if (!uri.empty())
+                d->parent->open_uri(uri);
+        }
+    });
+
+    engine->end_of_stream_signal().connect([this]()
+    {
+        end_of_stream()();
+    });
 }
 
 media::PlayerImplementation::~PlayerImplementation()
@@ -114,6 +148,17 @@
     return d->engine->open_resource_for_uri(uri);
 }
 
+void media::PlayerImplementation::create_video_sink(uint32_t texture_id)
+{
+    d->engine->create_video_sink(texture_id);
+}
+
+media::Player::GLConsumerWrapperHybris media::PlayerImplementation::gl_consumer() const
+{
+    // This method is client-side only and is simply a no-op for the service side
+    return NULL;
+}
+
 void media::PlayerImplementation::next()
 {
 }
@@ -124,11 +169,6 @@
 
 void media::PlayerImplementation::play()
 {
-    /*if (playback_status() == media::Player::null)
-    {
-        if (d->track_list->has_next())
-            if (open_uri(d->track_list->next()->))
-    }*/
     d->engine->play();
 }
 
@@ -142,6 +182,12 @@
     d->engine->stop();
 }
 
+void media::PlayerImplementation::set_frame_available_callback(
+    UNUSED FrameAvailableCb cb, UNUSED void *context)
+{
+    // This method is client-side only and is simply a no-op for the service side
+}
+
 void media::PlayerImplementation::seek_to(const std::chrono::microseconds& ms)
 {
     d->engine->seek_to(ms);
 
=== modified file 'src/core/media/player_implementation.h'
--- src/core/media/player_implementation.h	2014-02-18 20:25:21 +0000
+++ src/core/media/player_implementation.h	2014-03-26 17:18:55 +0000
@@ -43,11 +43,14 @@
     virtual std::shared_ptr<TrackList> track_list();
 
     virtual bool open_uri(const Track::UriType& uri);
+    virtual void create_video_sink(uint32_t texture_id);
+    virtual GLConsumerWrapperHybris gl_consumer() const;
     virtual void next();
     virtual void previous();
     virtual void play();
     virtual void pause();
     virtual void stop();
+    virtual void set_frame_available_callback(FrameAvailableCb cb, void *context);
     virtual void seek_to(const std::chrono::microseconds& offset);
 
 private:
 
=== modified file 'src/core/media/player_skeleton.cpp'
--- src/core/media/player_skeleton.cpp	2014-02-20 19:05:17 +0000
+++ src/core/media/player_skeleton.cpp	2014-03-26 17:18:55 +0000
@@ -44,6 +44,8 @@
               object->get_property<mpris::Player::Properties::CanControl>(),
               object->get_property<mpris::Player::Properties::CanGoNext>(),
               object->get_property<mpris::Player::Properties::CanGoPrevious>(),
+              object->get_property<mpris::Player::Properties::IsVideoSource>(),
+              object->get_property<mpris::Player::Properties::IsAudioSource>(),
               object->get_property<mpris::Player::Properties::PlaybackStatus>(),
               object->get_property<mpris::Player::Properties::LoopStatus>(),
               object->get_property<mpris::Player::Properties::PlaybackRate>(),
@@ -54,6 +56,11 @@
               object->get_property<mpris::Player::Properties::Duration>(),
               object->get_property<mpris::Player::Properties::MinimumRate>(),
               object->get_property<mpris::Player::Properties::MaximumRate>()
+          },
+          signals
+          {
+              object->get_signal<mpris::Player::Signals::Seeked>(),
+              object->get_signal<mpris::Player::Signals::EndOfStream>()
           }
     {
     }
@@ -111,6 +118,16 @@
     {
     }
 
+    void handle_create_video_sink(const core::dbus::Message::Ptr& in)
+    {
+        uint32_t texture_id;
+        in->reader() >> texture_id;
+        impl->create_video_sink(texture_id);
+
+        auto reply = dbus::Message::make_method_return(in);
+        impl->access_bus()->send(reply);
+    }
+
     void handle_open_uri(const core::dbus::Message::Ptr& in)
     {
         Track::UriType uri;
@@ -131,6 +148,8 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanControl>> can_control;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoNext>> can_go_next;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoPrevious>> can_go_previous;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsVideoSource>> is_video_source;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsAudioSource>> is_audio_source;
 
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackStatus>> playback_status;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::LoopStatus>> loop_status;
@@ -144,10 +163,41 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MaximumRate>> maximum_playback_rate;
     } properties;
 
-    /*struct
+    struct Signals
     {
-        std::shared_ptr<dbus::Signal<mpris::Player::Signals::Seeked, uint64_t>> seeked;
-        } signals;*/
+        typedef core::dbus::Signal<mpris::Player::Signals::Seeked, mpris::Player::Signals::Seeked::ArgumentType> DBusSeekedToSignal;
+        typedef core::dbus::Signal<mpris::Player::Signals::EndOfStream, mpris::Player::Signals::EndOfStream::ArgumentType> DBusEndOfStreamSignal;
+
+        Signals(const std::shared_ptr<DBusSeekedToSignal>& seeked,
+                const std::shared_ptr<DBusEndOfStreamSignal>& eos)
+            : dbus
+              {
+                  seeked,
+                  eos
+              },
+              seeked_to(),
+              end_of_stream()
+        {
+            seeked_to.connect([this](std::uint64_t value)
+            {
+                std::cout << "value: " << value << std::endl;
+                //dbus.seeked_to->emit(value);
+            });
+
+            end_of_stream.connect([this]()
+            {
+                dbus.end_of_stream->emit();
+            });
+        }
+
+        struct DBus
+        {
+            std::shared_ptr<DBusSeekedToSignal> seeked_to;
+            std::shared_ptr<DBusEndOfStreamSignal> end_of_stream;
+        } dbus;
+        core::Signal<uint64_t> seeked_to;
+        core::Signal<void> end_of_stream;
+    } signals;
 
 };
 
@@ -184,6 +234,10 @@
         std::bind(&Private::handle_set_position,
                   std::ref(d),
                   std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::CreateVideoSink>(
+        std::bind(&Private::handle_create_video_sink,
+                  std::ref(d),
+                  std::placeholders::_1));
     d->object->install_method_handler<mpris::Player::OpenUri>(
         std::bind(&Private::handle_open_uri,
                   std::ref(d),
@@ -219,6 +273,16 @@
     return *d->properties.can_go_next;
 }
 
+const core::Property<bool>& media::PlayerSkeleton::is_video_source() const
+{
+    return *d->properties.is_video_source;
+}
+
+const core::Property<bool>& media::PlayerSkeleton::is_audio_source() const
+{
+    return *d->properties.is_audio_source;
+}
+
 const core::Property<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status() const
 {
     return *d->properties.playback_status;
@@ -329,6 +393,17 @@
     return *d->properties.can_go_next;
 }
 
+core::Property<bool>& media::PlayerSkeleton::is_video_source()
+{
+    return *d->properties.is_video_source;
+}
+
+core::Property<bool>& media::PlayerSkeleton::is_audio_source()
+{
+    return *d->properties.is_audio_source;
+}
+
+
 core::Property<media::Track::MetaData>& media::PlayerSkeleton::meta_data_for_current_track()
 {
     return *d->properties.meta_data_for_current_track;
@@ -346,6 +421,20 @@
 
 const core::Signal<uint64_t>& media::PlayerSkeleton::seeked_to() const
 {
-    static const core::Signal<uint64_t> signal;
-    return signal;
+    return d->signals.seeked_to;
+}
+
+core::Signal<uint64_t>& media::PlayerSkeleton::seeked_to()
+{
+    return d->signals.seeked_to;
+}
+
+const core::Signal<void>& media::PlayerSkeleton::end_of_stream() const
+{
+    return d->signals.end_of_stream;
+}
+
+core::Signal<void>& media::PlayerSkeleton::end_of_stream()
+{
+    return d->signals.end_of_stream;
 }
 
=== modified file 'src/core/media/player_skeleton.h'
--- src/core/media/player_skeleton.h	2014-02-18 19:27:01 +0000
+++ src/core/media/player_skeleton.h	2014-03-26 17:18:55 +0000
@@ -46,6 +46,8 @@
     virtual const core::Property<bool>& can_seek() const;
     virtual const core::Property<bool>& can_go_previous() const;
     virtual const core::Property<bool>& can_go_next() const;
+    virtual const core::Property<bool>& is_video_source() const;
+    virtual const core::Property<bool>& is_audio_source() const;
     virtual const core::Property<PlaybackStatus>& playback_status() const;
     virtual const core::Property<LoopStatus>& loop_status() const;
     virtual const core::Property<PlaybackRate>& playback_rate() const;
@@ -63,6 +65,7 @@
     virtual core::Property<Volume>& volume();
 
     virtual const core::Signal<uint64_t>& seeked_to() const;
+    virtual const core::Signal<void>& end_of_stream() const;
 
   protected:
     PlayerSkeleton(const core::dbus::types::ObjectPath& session_path);
@@ -73,12 +76,17 @@
     virtual core::Property<bool>& can_seek();
     virtual core::Property<bool>& can_go_previous();
     virtual core::Property<bool>& can_go_next();
+    virtual core::Property<bool>& is_video_source();
+    virtual core::Property<bool>& is_audio_source();
     virtual core::Property<Track::MetaData>& meta_data_for_current_track();
     virtual core::Property<PlaybackRate>& minimum_playback_rate();
     virtual core::Property<PlaybackRate>& maximum_playback_rate();
     virtual core::Property<uint64_t>& position();
     virtual core::Property<uint64_t>& duration();
 
+    virtual core::Signal<uint64_t>& seeked_to();
+    virtual core::Signal<void>& end_of_stream();
+
   private:
     struct Private;
     std::unique_ptr<Private> d;
 
=== modified file 'src/core/media/player_stub.cpp'
--- src/core/media/player_stub.cpp	2014-02-20 19:05:17 +0000
+++ src/core/media/player_stub.cpp	2014-03-26 17:18:55 +0000
@@ -31,8 +31,15 @@
 #include <core/dbus/property.h>
 #include <core/dbus/types/object_path.h>
 
+// Hybris
+#include <media/decoding_service.h>
+#include <media/media_codec_layer.h>
+#include <media/surface_texture_client_hybris.h>
+
 #include <limits>
 
+#define UNUSED __attribute__((unused))
+
 namespace dbus = core::dbus;
 namespace media = core::ubuntu::media;
 
@@ -42,6 +49,12 @@
             const std::shared_ptr<dbus::Service>& remote,
             const dbus::types::ObjectPath& path
             ) : parent(parent),
+                texture_id(0),
+                igbc_wrapper(nullptr),
+                glc_wrapper(nullptr),
+                decoding_session(decoding_service_create_session()),
+                frame_available_cb(nullptr),
+                frame_available_context(nullptr),
                 path(path),
                 object(remote->object_for_path(path)),
                 properties
@@ -52,6 +65,8 @@
                     object->get_property<mpris::Player::Properties::CanControl>(),
                     object->get_property<mpris::Player::Properties::CanGoNext>(),
                     object->get_property<mpris::Player::Properties::CanGoPrevious>(),
+                    object->get_property<mpris::Player::Properties::IsVideoSource>(),
+                    object->get_property<mpris::Player::Properties::IsAudioSource>(),
                     object->get_property<mpris::Player::Properties::PlaybackStatus>(),
                     object->get_property<mpris::Player::Properties::LoopStatus>(),
                     object->get_property<mpris::Player::Properties::PlaybackRate>(),
@@ -62,13 +77,67 @@
                     object->get_property<mpris::Player::Properties::Duration>(),
                     object->get_property<mpris::Player::Properties::MinimumRate>(),
                     object->get_property<mpris::Player::Properties::MaximumRate>()
+                },
+                signals
+                {
+                    object->get_signal<mpris::Player::Signals::Seeked>(),
+                    object->get_signal<mpris::Player::Signals::EndOfStream>()
                 }
     {
     }
 
+    ~Private()
+    {
+    }
+
+    static void on_frame_available_cb(UNUSED GLConsumerWrapperHybris wrapper, void *context)
+    {
+        if (context != nullptr) {
+            Private *p = static_cast<Private*>(context);
+            p->on_frame_available();
+        }
+        else
+            std::cout << "context is nullptr, can't call on_frame_available()" << std::endl;
+    }
+
+    void on_frame_available()
+    {
+        if (frame_available_cb != nullptr) {
+            frame_available_cb(frame_available_context);
+        }
+        else
+            std::cout << "frame_available_cb is nullptr, can't call frame_available_cb()" << std::endl;
+    }
+
+    void set_frame_available_cb(FrameAvailableCb cb, void *context)
+    {
+        frame_available_cb = cb;
+        frame_available_context = context;
+
+        gl_consumer_set_frame_available_cb(glc_wrapper, &Private::on_frame_available_cb, static_cast<void*>(this));
+    }
+
+    /** We need a GLConsumerHybris instance for doing texture streaming over the
+     * process boundary **/
+    void get_gl_consumer()
+    {
+        igbc_wrapper = decoding_service_get_igraphicbufferconsumer();
+        glc_wrapper = gl_consumer_create_by_id_with_igbc(texture_id, igbc_wrapper);
+
+    }
+
     std::shared_ptr<Service> parent;
     std::shared_ptr<TrackList> track_list;
 
+    uint32_t texture_id;
+    IGBCWrapperHybris igbc_wrapper;
+    GLConsumerWrapperHybris glc_wrapper;
+
+    DSSessionWrapperHybris decoding_session;
+
+    FrameAvailableCb frame_available_cb;
+    void *frame_available_context;
+
     dbus::Bus::Ptr bus;
     dbus::types::ObjectPath path;
     dbus::Object::Ptr object;
@@ -81,6 +150,8 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanControl>> can_control;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoNext>> can_go_next;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoPrevious>> can_go_previous;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsVideoSource>> is_video_source;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsAudioSource>> is_audio_source;
 
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackStatus>> playback_status;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::LoopStatus>> loop_status;
@@ -93,6 +164,42 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MinimumRate>> minimum_playback_rate;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MaximumRate>> maximum_playback_rate;
     } properties;
+
+    struct Signals
+    {
+        typedef core::dbus::Signal<mpris::Player::Signals::Seeked, mpris::Player::Signals::Seeked::ArgumentType> DBusSeekedToSignal;
+        typedef core::dbus::Signal<mpris::Player::Signals::EndOfStream, mpris::Player::Signals::EndOfStream::ArgumentType> DBusEndOfStreamSignal;
+
+        Signals(const std::shared_ptr<DBusSeekedToSignal>& seeked,
+                const std::shared_ptr<DBusEndOfStreamSignal>& eos)
+            : dbus
+              {
+                  seeked,
+                  eos
+              },
+              seeked_to(),
+              end_of_stream()
+        {
+            dbus.seeked_to->connect([this](std::uint64_t value)
+            {
+                seeked_to(value);
+            });
+
+            dbus.end_of_stream->connect([this]()
+            {
+                std::cout << "EndOfStream signal arrived via the bus." << std::endl;
+                end_of_stream();
+            });
+        }
+
+        struct DBus
+        {
+            std::shared_ptr<DBusSeekedToSignal> seeked_to;
+            std::shared_ptr<DBusEndOfStreamSignal> end_of_stream;
+        } dbus;
+        core::Signal<uint64_t> seeked_to;
+        core::Signal<void> end_of_stream;
+    } signals;
 };
 
 media::PlayerStub::PlayerStub(
@@ -125,6 +232,21 @@
     return op.value();
 }
 
+void media::PlayerStub::create_video_sink(uint32_t texture_id)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::CreateVideoSink, void>(texture_id);
+    d->texture_id = texture_id;
+    d->get_gl_consumer();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem switching to next track on remote object");
+}
+
+GLConsumerWrapperHybris media::PlayerStub::gl_consumer() const
+{
+    return d->glc_wrapper;
+}
+
 void media::PlayerStub::next()
 {
     auto op = d->object->invoke_method_synchronously<mpris::Player::Next, void>();
@@ -173,6 +295,11 @@
         throw std::runtime_error("Problem stopping playback on remote object");
 }
 
+void media::PlayerStub::set_frame_available_callback(FrameAvailableCb cb, void *context)
+{
+    d->set_frame_available_cb(cb, context);
+}
+
 const core::Property<bool>& media::PlayerStub::can_play() const
 {
     return *d->properties.can_play;
@@ -198,6 +325,16 @@
     return *d->properties.can_go_next;
 }
 
+const core::Property<bool>& media::PlayerStub::is_video_source() const
+{
+    return *d->properties.is_video_source;
+}
+
+const core::Property<bool>& media::PlayerStub::is_audio_source() const
+{
+    return *d->properties.is_audio_source;
+}
+
 const core::Property<media::Player::PlaybackStatus>& media::PlayerStub::playback_status() const
 {
     return *d->properties.playback_status;
@@ -270,6 +407,10 @@
 
 const core::Signal<uint64_t>& media::PlayerStub::seeked_to() const
 {
-    static core::Signal<uint64_t> signal;
-    return signal;
+    return d->signals.seeked_to;
+}
+
+const core::Signal<void>& media::PlayerStub::end_of_stream() const
+{
+    return d->signals.end_of_stream;
 }
 
=== modified file 'src/core/media/player_stub.h'
--- src/core/media/player_stub.h	2014-02-18 19:27:01 +0000
+++ src/core/media/player_stub.h	2014-03-26 17:18:55 +0000
@@ -45,6 +45,8 @@
     virtual std::shared_ptr<TrackList> track_list();
 
     virtual bool open_uri(const Track::UriType& uri);
+    virtual void create_video_sink(uint32_t texture_id);
+    virtual GLConsumerWrapperHybris gl_consumer() const;
     virtual void next();
     virtual void previous();
     virtual void play();
@@ -52,11 +54,15 @@
     virtual void seek_to(const std::chrono::microseconds& offset);
     virtual void stop();
 
+    virtual void set_frame_available_callback(FrameAvailableCb cb, void *context);
+
     virtual const core::Property<bool>& can_play() const;
     virtual const core::Property<bool>& can_pause() const;
     virtual const core::Property<bool>& can_seek() const;
     virtual const core::Property<bool>& can_go_previous() const;
     virtual const core::Property<bool>& can_go_next() const;
+    virtual const core::Property<bool>& is_video_source() const;
+    virtual const core::Property<bool>& is_audio_source() const;
     virtual const core::Property<PlaybackStatus>& playback_status() const;
     virtual const core::Property<LoopStatus>& loop_status() const;
     virtual const core::Property<PlaybackRate>& playback_rate() const;
@@ -74,6 +80,7 @@
     virtual core::Property<Volume>& volume();
 
     virtual const core::Signal<uint64_t>& seeked_to() const;
+    virtual const core::Signal<void>& end_of_stream() const;
 
   private:
     struct Private;
 
=== modified file 'src/core/media/server/server.cpp'
--- src/core/media/server/server.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/server/server.cpp	2014-03-26 17:18:55 +0000
@@ -2,12 +2,23 @@
 #include <core/media/player.h>
 #include <core/media/track_list.h>
 
+#include <media/decoding_service.h>
+#include <media/media_codec_layer.h>
+
 #include "core/media/service_implementation.h"
 
+#include <iostream>
+
 namespace media = core::ubuntu::media;
 
+using namespace std;
+
 int main()
 {
+    // Init hybris-level DecodingService
+    decoding_service_init();
+    cout << "Starting DecodingService..." << endl;
+
     auto service = std::make_shared<media::ServiceImplementation>();
     service->run();
 
 
=== modified file 'src/core/media/track_list_implementation.cpp'
--- src/core/media/track_list_implementation.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_implementation.cpp	2014-03-26 17:18:55 +0000
@@ -16,6 +16,9 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include <stdio.h>
+#include <stdlib.h>
+
 #include "track_list_implementation.h"
 
 #include "engine.h"
@@ -45,6 +48,16 @@
 {
 }
 
+media::Track::UriType media::TrackListImplementation::query_uri_for_track(const media::Track::Id& id)
+{
+    auto it = d->meta_data_cache.find(id);
+
+    if (it == d->meta_data_cache.end())
+        return Track::UriType{};
+
+    return std::get<0>(it->second);
+}
+
 media::Track::MetaData media::TrackListImplementation::query_meta_data_for_track(const media::Track::Id& id)
 {
     auto it = d->meta_data_cache.find(id);
 
=== modified file 'src/core/media/track_list_implementation.h'
--- src/core/media/track_list_implementation.h	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_implementation.h	2014-03-26 17:18:55 +0000
@@ -36,6 +36,7 @@
             const std::shared_ptr<Engine::MetaDataExtractor>& extractor);
     ~TrackListImplementation();
 
+    Track::UriType query_uri_for_track(const Track::Id& id);
     Track::MetaData query_meta_data_for_track(const Track::Id& id);
 
     void add_track_with_uri_at(const Track::UriType& uri, const Track::Id& position, bool make_current);
 
=== modified file 'src/core/media/track_list_skeleton.cpp'
--- src/core/media/track_list_skeleton.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_skeleton.cpp	2014-03-26 17:18:55 +0000
@@ -48,7 +48,8 @@
           object(object),
           can_edit_tracks(object->get_property<mpris::TrackList::Properties::CanEditTracks>()),
           tracks(object->get_property<mpris::TrackList::Properties::Tracks>()),
-          current_track(tracks->get().begin())
+          current_track(tracks->get().begin()),
+          empty_iterator(tracks->get().begin())
     {
     }
 
@@ -103,6 +104,7 @@
     std::shared_ptr<core::dbus::Property<mpris::TrackList::Properties::CanEditTracks>> can_edit_tracks;
     std::shared_ptr<core::dbus::Property<mpris::TrackList::Properties::Tracks>> tracks;
     TrackList::ConstIterator current_track;
+    TrackList::ConstIterator empty_iterator;
 
     core::Signal<void> on_track_list_replaced;
     core::Signal<Track::Id> on_track_added;
@@ -142,12 +144,22 @@
 
 bool media::TrackListSkeleton::has_next() const
 {
-    return std::next(d->current_track) != d->tracks->get().end();
+    return d->current_track != d->tracks->get().end();
 }
 
 const media::Track::Id& media::TrackListSkeleton::next()
 {
-    return *(d->current_track = std::next(d->current_track));
+    if (d->tracks->get().empty())
+        return *(d->current_track);
+
+    if (d->tracks->get().size() && (d->current_track == d->empty_iterator))
+    {        
+        d->current_track = d->tracks->get().begin();
+        return *(d->current_track = std::next(d->current_track));
+    }
+
+    d->current_track = std::next(d->current_track);
+    return *(d->current_track);
 }
 
 const core::Property<bool>& media::TrackListSkeleton::can_edit_tracks() const
 
=== modified file 'src/core/media/track_list_skeleton.h'
--- src/core/media/track_list_skeleton.h	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_skeleton.h	2014-03-26 17:18:55 +0000
@@ -48,9 +48,10 @@
     const core::Signal<Track::Id>& on_track_removed() const;
     const core::Signal<Track::Id>& on_track_changed() const;
 
+    core::Property<Container>& tracks();
+
 protected:
     core::Property<bool>& can_edit_tracks();
-    core::Property<Container>& tracks();
 
     core::Signal<void>& on_track_list_replaced();
     core::Signal<Track::Id>& on_track_added();